Some sort of Swamp trick.
Fire Sessions.
See what breaking the 50% public approval mark will do for you...
This could be lawyer talk. For constitutional reasons, a President cannot be indicted for criminal misconduct while he is in office, so Trump cannot be a criminal target. Meuller though could report on criminal misconduct by Trump so that impeachment can be pursued.
it’s a trap
Well then Mueller can resign and go back out to pasture.
a cya to avoid the fact that his mandate does not specify a crime
Bracing for the Horowitz report release, perhaps?
~W
Trump said he was told this many months ago. Mueller just sucking up money and air space.
bookmark
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. Not a criminal target and should stay that way by refusing to talk to Mueller!
President Mueller is Obstructing the Nation. Indict him.
He is a clear danger to Americans.