Abstract:
Flattened representations are standard fare in computational systems that attempt to reason with logical formulae. A textbook example is the skolemization and conversion to clausal form of first-order formulas, facilitating various forms of resolution theorem proving. Flat representations simplify the control for the reasoning engine but potentially at the expense of expressive power.
Semantic analyses for natural language tend to be framed in some kind of higher-order and/or intensional logic that is both expressive and intractable. To what extent can such representations be flattened into something more tractable so that reasoning can be performed on the output of semantic analysis? The process of flattening itself must be tractable and preserve key entailments of the original NL input.
In this talk we propose a systematic way of deriving flattened representations from linguistically motivated logical forms and discuss some of the questions it raises.
There are two principal motivations for flattening. First, structures assembled by compositional semantics must be transformed to structures that are well-suited for making successive small, automated inference steps. This transformation requires that important globally represented information, such as scopes of operators, be made locally accessible.
The second motivation is to bring about a reduction in expressive power of the formalism, while as far as possible preserving the meaning of what is represented. This typically involves replacing expressions with complex internal structure (e.g., propositional arguments, verbal complexes) with atomic first order terms (e.g., skolems for Davidsonian events, context names), and then making first order statements about these terms in order to recapitulate their internal structure.
For purposes of illustration, consider a simplified semantic representation for (1), which abstracts away from such things as tense, the proper representation of gradable predicates, etc, but which follows the proposal that object arguments to "prevent" should be concept denoting ("Preventing existence", FOIS 2001).
(1) Removing a sleeve made the cable flexible, preventing breakage.
(2) exists(c, cable(c)
exists(s, sleeve(s),
prevent( make( remove(s), flexible(c)), ^breakage)))
How can (2) be transformed into a flat, clausal representation, and what would be achieved by doing so? We propose (3) as a flattened representation.
(3) (ctx t (sleeve sleeve100))
(ctx t (cable cable220))
(ctx t (breakage breakage250_type))
(ctx t (remove *remove_ev700* nullAgent221 sleeve100))
(ctx t (prevent *make_context105* breakage250_type))
(ctx *make_context105*
(make *remove_ev700* *flexible_context123*))
(ctx *flexible_context123* (flexible cable220))
In (3) the transformation from global to local dependencies and the reduction to atomic first order terms (highlighted with *'s) is achieved by