Clearly we can express the meaning in natural language. Why is this not satisfactory for analyzing the meaning? The components (the words) are ambiguous; even sentences in isolation are ambiguous. Resolving these ambiguities can be difficult. Even though syntactic analysis has made some relationships explicit, others are still implicit; for example, it does not indicate the quantificational structure of a sentence. Furthermore, the rules for inferring new facts from given facts in natural language may be very complicated.

- is
*unambiguous* - has simple rules of interpretation and inference, and in particular
- has a logical structure determined by its form
- is sufficiently
*expressive*to capture the range of natural language meanings we shall require for our applications

These are the properties of the languages of *logic*.
Actual
systems may use different representations, but they are generally
equivalent
to the formal language (extensions of predicate calculus) we will use
for
presentation.

- terms (constants, variables, and functions)
- atomic formulas (predicate + arguments)
- logical connectives (not, and, or, implies)
- quantifiers

We can address this problem by reification -- treating events as objects (J&M p. 566).

- generalized quantifiers (for ‘some’, ‘most’, …)
- tense and aspect
- modality and belief (need to allow formulas as arguments: “John believes Fred likes Mary” = believe(John,like(Fred,Mary)) )
- presupposition (“All the men on Mars drink Coca-Cola.”)
- fuzziness (“The milk is warm.”)

We want to compute the semantic representation of a sentence from
the
parse tree. Because the parse tree provides a structural
framework,
we will use a compositional, *syntax-driven translation process*.
This
means
that we will associate a (partial) semantic interpretation with
some or all of the nodes of the parse tree, to be computed (using a
rule)
from the interpretations of its children.

We could embed this translation in a procedure associated with each type of node. Alternatively, one can formalize this by a set of rules associated with the productions of the grammar (J&M sec. 18.1 and 2). The grammar will be extended to add a SEM feature, representing the semantic interpretation of a node. Each production will then incorporate the rule for computing its SEM value, and the SEM of the root will be the interpretation of the sentence.

The semantics of a verb phrase is essentially the semantics of a
clause,
with one argument (the subject) missing … a predicate with one unbound
argument. We can represent this by a lambda expression (p.
587). Lambda expressions are commonly used to capture the rules
for composing the semantics. (See p. 559 for a presentation of lambda
notation.)

(forall x: C(x))These do not add any power to predicate calculus; they can be rewritten

(exists x: C(x))

(forall x: C(x)) P(x) = (forall x) (C(x) => P(x))Roughly speaking, a noun phrase can be translated to a constant or a restricted quantifier.

(exists x: C(x)) P(x) = (exists x) (C(x) & P(x))

A woman gives birth in the United States every five minutes.We can represent the two readings in conventional predicate calculus using different quantifier scopes. If we explicitly represent all the semantic ambiguities in a sentence in this way, we may have very many readings. It is therefore practical to initially produce (from the parse) a representation which captures multiple readings … which encodes (some of) the ambiguity. (And hope that this ambiguity can be resolved at a later stage of semantic analysis.)

In particular, we can use complex terms (J&M First edition p. 555)

<Quantifier x: C(x)>with the understanding that

P(<Quantifier x: C(x)>) = (Quantifier x: C(x)) P(x)If an expression contains several complex terms, the scope of the quantifiers is indeterminate. Semantic analysis will generate such

One such procedure, described by Sergei Brin, discovers patterns for
binary
relations. It works as follows

- start with a few pairs of names involved in the relation of interest, and a set of patterns (initially empty)
- collect (from a large corpus) examples of patterns which connect several of these pairs
- add best pattern(s) to set
- collect additional pairs matching these patterns
- repeat

Sergei Brin. Extracting Patterns and Relations from the World Wide Web. (Also available in PDF) In Proc. World Wide Web and Databases International Workshop, pages 172-183. Number 1590 in LNCS, Springer, March 1998.