Posted on 04/03/2018 5:44:29 PM PDT by Duke C.
Predict what?
The key words in what Mulehead said is “at this point”.
I don’t understand why folks here are getting so excited.
When Mulehead disbands his group of con men,
That is the time to celebrate.
He is still digging for dirt.
I vote for this explanation.
“The Dems don’t have enough votes to impeach.”
People are not getting this at all. The republicans want Trump gone as much or more than the demoncrats. That’s why almost all of them have backed mueller’s ‘mission’. They’re awaiting a fig leaf.
“If true, could it be a way to prevent him from taking the Fifth in an “interview” about someone else as a perjury trap?”
Exactly. This smells like a trap in the making. Mueller wants to try to get Trump off guard so that he will make some kind of mistake or misstatement that he can use against him in the future.
bookmark
Common misperception that you have to do something or not do something to get impeached.
Impeachment is a political process. Impeachment happens outside the justice system and inside the Senate deliberative process.
CJSCOTUS only attends the impeachment to maintain regular order and not introduce any judicial processes.
The world and the listener The literal listener simply infers likely worlds assuming the meaning is true in the world:
var literalListener = function(utterance) {
Infer({
model() {
var world = worldPrior()
var m = meaning(utterance, world)
factor(m?0:-Infinity)
return world
}
})
}
run▼
The world is some named objects with random (binary) properties:
var makeObj = function(name) {
return {name: name, blond: flip(0.5), nice: flip(0.5)}
}
var worldPrior = function(objs) {
return [makeObj("Bob"), makeObj("Bill"), makeObj("Alice")]
}
run▼ The parser Notice that we have written the meaning function as taking the utterance and world and returning a (model-theoretic) denotation – a truth value when the utterance is a sentence. The motivation for doing things this way, rather than breaking it up into a meaning function that builds an ‘LF’ form which is then separately applied to the world, is well described by the introduction to Jacobson (1999): The point of departure for this paper is the hypothesis of “direct compositionality” (see, e.g., Montague 1974): the syntax and the model-theoretic semantics work in tandem. Thus the syntax “builds” (i.e. proves the well-formedness of) expressions, where each syntactic rule supplies the proof of the well-formedness of an output expression in terms of the well-formedness of one or more input expressions. (These rules might, of course, be stated in highly general and schematic terms as in, e.g., Categorial Grammar.) The semantics works in tandem with this - each output expression is directly assigned a meaning (a model-theoretic interpretation) in terms of the meaning(s) of the input expressions(s). There is thus no need to for any kind of abstract level like LF mediating between the surface syntax and the model-theoretic interpretation, and hence no need for an additional set of rules mapping one “level” of syntactic representation into another. For our system, the meaning function is a stochastic map from utterances to truth values, with the different return values corresponding (non-uniquely) to different parses or lexical choices. First we get a lexical meaning for each word and filter out the undefined meanings, then we recursively apply meaning fragments to each other until only one meaning fragment is left.
// Split the string into words, lookup lexical meanings,
// delete words with vacuous meaning, then call combineMeanings..
var meaning = function(utterance, world) {
return combineMeanings(
filter(map(utterance.split(" "),
function(w){return lexicalMeaning(w, world)}),
function(m){return !(m.sem==undefined)}))
}
run▼
The lexicon is captured in a function lexicalMeaning which looks up the meaning of a word. A meaning is an object with semantics and syntax.
var lexicalMeaning = function(word, world) {
var wordMeanings = {
"blond" : {
sem: function(obj){return obj.blond},
syn: {dir:'L', int:'NP', out:'S'} },
"nice" : {
sem: function(obj){return obj.nice},
syn: {dir:'L', int:'NP', out:'S'} },
"Bob" : {
sem: find(function(obj){return obj.name=="Bob"}, world),
syn: 'NP' },
"some" : {
sem: function(P){
return function(Q){return filter(Q, filter(P, world)).length>0}},
syn: {dir:'R',
int:{dir:'L', int:'NP', out:'S'},
out:{dir:'R',
int:{dir:'L', int:'NP', out:'S'},
out:'S'}} },
"all" : {
sem: function(P){
return function(Q){return filter(neg(Q), filter(P, world)).length==0}},
syn: {dir:'R',
int:{dir:'L', int:'NP', out:'S'},
out:{dir:'R',
int:{dir:'L', int:'NP', out:'S'},
out:'S'}} }
}
var meaning = wordMeanings[word];
return meaning == undefined?{sem: undefined, syn: ''}:meaning;
}
// We use this helper function to negate a predicate above:
var neg = function(Q){
return function(x){return !Q(x)}
}
run▼
Note that the lexicalMeaning mapping could be stochastic, allowing us to capture polysemy. It can also depend on auxiliary elements of the world that play the role of semantically-free context variables. To make a parsing step, we randomly choose a word such that the syntactic rules claim an application is possible, and do this application (reducing the set of meaning fragments). We do this until only one meaning fragment is left.
var combineMeaning = function(meanings) {
var possibleComb = canApply(meanings,0)
display(possibleComb)
var i = possibleComb[randomInteger(possibleComb.length)]
var s = meanings[i].syn
if (s.dir == 'L') {
var f = meanings[i].sem
var a = meanings[i-1].sem
var newmeaning = {sem: f(a), syn: s.out}
return meanings.slice(0,i-1).concat([newmeaning]).concat(meanings.slice(i+1))
}
if (s.dir == 'R') {
var f = meanings[i].sem
var a = meanings[i+1].sem
var newmeaning = {sem: f(a), syn: s.out}
return meanings.slice(0,i).concat([newmeaning]).concat(meanings.slice(i+2))
}
}
//make a list of the indexes that can (syntactically) apply.
var canApply = function(meanings,i) {
if(i==meanings.length){
return []
}
var s = meanings[i].syn
if (s.hasOwnProperty('dir')){ //a functor
var a = ((s.dir == 'L')?syntaxMatch(s.int, meanings[i-1].syn):false) |
((s.dir == 'R')?syntaxMatch(s.int, meanings[i+1].syn):false)
if(a){return [i].concat(canApply(meanings,i+1))}
}
return canApply(meanings,i+1)
}
// The syntaxMatch function is a simple recursion to
// check if two syntactic types are equal.
var syntaxMatch = function(s,t) {
return !s.hasOwnProperty('dir') ? s==t :
s.dir==t.dir & syntaxMatch(s.int,t.int) & syntaxMatch(s.out,t.out)
}
// Recursively do the above until only one meaning is
// left, return it's semantics.
var combineMeanings = function(meanings){
return meanings.length==1 ? meanings[0].sem : combineMeanings(combineMeaning(meanings))
}
run▼
To allow fancy movement and binding we would mix this with type-shifting operators, following, for example, Barker (2002) (who extends Jacobson, 1999).
///fold:
...
//literalListener("Bob is nice")
//literalListener("some blond are nice")
//literalListener("some blond people are nice")
viz.table(literalListener("all blond people are nice"))
run▼
Incremental world building The above version of semantic parsing constructs an entire world and an entire meaning before trying to enforce that the meaning is true of the world. We would like to make either the world construction or the parsing more incremental… Below we give a version that uses the canceling heuristic factors trick to encourage the world to be one in which the constructed meaning is true, incrementally as we add objects to the world. Two changes are involved. First we adapt the worldPrior to allow canceling factors. Second, this version constructs a function from world to truth value, which can then be used several times while the world is constructed. That is, we depart from direct compositionality, in building ‘delayed’ denotations that await the world.
Oh, I get what you’re saying. Which is why I never reply to you about anything. LOL
lol ;)
You do have a good sense of humor I’ll give you that! :)
“Was Trump ever officially a target of a criminal investigation?”
Good question.
Was Flynn? Was Manafort?
A Special Counsel is supposed to be investigating a specific identified crime. But I’ve never heard what specific crime Mueller is investigating, he’s all over the place.
I think you mean misconception.
Btw, in a sadistic sort of way, I'd like to see these lying leftist stooges attempt it. After everything that is now know, I'd pay to see that.
Not a criminal target and should stay that way by refusing to talk to Mueller!
They got zip. They got the T-bone with no meat. What do they have, several platoons of attorneys/investigators with unlimited resources, working round the clock for how long now?
Ya think if these corrupt collusive azzholes had anything they wouldn't have used it by now? Come on.
Ya think they're going to get rid of Trump over some insignificant error or typo from some obscure dated unrelated biz deal? Think again. Not going to happen.
The fig leaf is likely a Mueller report that boils down to “President Trump did nothing that legally crossed any lines but he did shady things and surrounded himself with shady individuals who are criminals (since I’ve charged them).
Don’t think it will work, but it’s what they’ve got.
Yet and they will have R votes
Anything the Dems can spin.
Ping me when these stooges try to overthrow Trump over some stupid unrelated insignificant issue. Like I said, I’d pay to see that.
“The special counsel also told Trump’s lawyers that he is preparing a report about the president’s actions while in office and potential obstruction of justice”
The fig leaf is coming. Mueller was tasked by ‘our’ corrupt state to take down Trump(impeachment material or make him resign) Barring that, de-legitimize him and destroy his administration. That’s exactly what he’s doing.
Didn’t I post the special counsel’s reason for being up thread?
Disclaimer: Opinions posted on Free Republic are those of the individual posters and do not necessarily represent the opinion of Free Republic or its management. All materials posted herein are protected by copyright law and the exemption for fair use of copyrighted works.