Difference between revisions of "RuleTransformation"
(→Overview) |
(→Overview) |
||
Line 11: | Line 11: | ||
<div style="background-color:yellow" width="50%"> | <div style="background-color:yellow" width="50%"> | ||
− | Having predicates with large arity leads to intractable inference. | + | Having predicates with large arity leads to intractable inference. We break up the predicate into smaller predicates tied by a tuple id. |
</div> | </div> | ||
+ | |||
+ | <pre> | ||
+ | Arg(tupleid, position, phrase) | ||
+ | Rel(tupleid, position, phrase) | ||
+ | |||
+ | Arg(t, 1, a1), Rel(t, 1, r), Arg(t, 1, a2) => BinaryRelationTuple(t, a1, rel, a2) | ||
+ | BinaryRelationTuple(t, a1, rel, a2) => Arg(t, 1, a1) | ||
+ | BinaryRelationTuple(t, a1, rel, a2) => Rel(t, 1, rel) | ||
+ | BinaryRelationTuple(t, a1, rel, a2) => Arg(t, 2, a2) | ||
+ | </pre> | ||
+ | |||
+ | |||
+ | |||
Rules that specify when two arguments match (e.g., under synonymy, stemming, and/or dropping of modifiers) need to be enumerated out for each argument position. | Rules that specify when two arguments match (e.g., under synonymy, stemming, and/or dropping of modifiers) need to be enumerated out for each argument position. |
Revision as of 07:39, 23 August 2013
Overview
Inference rules are represented in human-readable format. This page describes the transformation of these rules into Tuffy's MLN syntax.
We first define a general purpose tuple predicates that can represent n-ary and nested tuples.
T(a1, r, a2, a3, n1, nr, n2)
Having predicates with large arity leads to intractable inference. We break up the predicate into smaller predicates tied by a tuple id.
Arg(tupleid, position, phrase) Rel(tupleid, position, phrase) Arg(t, 1, a1), Rel(t, 1, r), Arg(t, 1, a2) => BinaryRelationTuple(t, a1, rel, a2) BinaryRelationTuple(t, a1, rel, a2) => Arg(t, 1, a1) BinaryRelationTuple(t, a1, rel, a2) => Rel(t, 1, rel) BinaryRelationTuple(t, a1, rel, a2) => Arg(t, 2, a2)
Rules that specify when two arguments match (e.g., under synonymy, stemming, and/or dropping of modifiers) need to be enumerated out for each argument position.
Types of transformations
Equality under stemming will be covered by the following rules: T(a1, rel, a2, a3, na1, arel, na2), stem(a1, x) => T(x, rel, a2, a3, na1, nrel, na2) T(a1, rel, a2, a3, na1, arel, na2), stem(rel, x) => T(a1, x, a2, a3, na1, nrel, na2) T(a1, rel, a2, a3, na1, arel, na2), stem(a2, x) => T(a1, rel, x, a3, na1, nrel, na2) ... ... Equality under head word transformations will be covered by the following rules: T(a1, rel, a2, a3, na1, arel, na2) [headword(a1) == x || headword(x) == a1] => T(x, rel, a2, a3, na1, nrel, na2) ... ... Allowing the argument with "something" to match any value. T(a1, rel, "something", a3, na1, nrel, na2) => T(a1, rel, x, na1, nrel, na2) ...
Examples
- Question to demonstrate
“Growth causes leaves of a plant to become large”.
(growth, cause, (leaves of a plant, become large)) [nested, with intransitive arg2] (growth, cause, (leaves of a plant, become, large)) [nested, with binary rel for arg2]
- Evidence from definition
“The noun growth is the process of something becoming bigger”
(growth, is process of, (something, become bigger) (growth, is process of, (something, become, bigger))
- Rules needed
Id | Rule | Tuffy Format | Description |
---|---|---|---|
1. | Rel: X => Rel: is process of | T(a1, x, a2, a3, n1, nr, n2) => T(a1, "is process of", a2, a3, n1, nr, n2) |
Generalize any action to “is process of”. Note this rule seems appropriate only for the top level action in a nested relation i.e., (a1, X, (n1, nr, n2) => (a1, "is process of", (n1, nr, n2)) |
1a. | Rel: cause => Rel: is process of | T(a1, "cause", a2, a3, n1, nr, n2) => T(a1, "is process of", a3, n1, nr, n2) | More particular version of rule 1. Again, this appears to be appropriate for the top level action in a nested relation. |
2. | Rel: is process of => Rel: X | T(a1, "is process of", a2, a3, n1, nr, n2) => T(a1, x, a2, a3, n1, nr, n2) |
Abductive inverse of rule 1. |
2a. | Rel: is process of => Rel: cause | T(a1, "is process of", a3, n1, nr, n2) => T(a1, "cause", a2, a3, n1, nr, n2) | [abductive rule, inverse of rule 1a] |
3. | Arg: X => Arg: something | T(x, r, a2, n1, nr, n2) => T("something", r, a2, n1, nr, n2) T(a1, r, x, n1, nr, n2) => T(a1, r, "something", n1, nr, n2) ... |
Generalize any arg value to “something” |
4. | Arg: something => Arg: X | T("something", r, a2, n1, nr, n2) => T(x, r, a2, n1, nr, n2) T(a1, r, "something", n1, nr, n2) => T(a1, r, x, n1, nr, n2) ... |
Abductive rule, inverse of rule 3. |
5. | Rel: become bigger => Rel: become big | T(a1, r, a2, n1, nr, n2), stem(r, x) => T(a1, x, a2, n1, nr, n2) T(a1, r, a2, n1, nr, n2), stem(a1, x) => T(a1, x, a2, n1, nr, n2) ... |
Lexical substitution from verb stemmer. |
6. | Rel: become big => Rel: become large | T(a1, r, a2, n1, nr, n2), syn(r, x) => T(a1, x, a2, n1, nr, n2) T(a1, r, a2, n1, nr, n2), syn(a1, x) => T(a1, x, a2, n1, nr, n2) ... |
Lexical substitution from WN synonym. |
Notes on rules:
We can derive abductive inverses automatically with a meta-rule. Lexical substitution rules are generated on the fly as needed.
- Derivation
Evidence: (growth, is process of, (something, become bigger)) Rel: become bigger => Rel: become big (growth, is process of, (something, become big)) Rel: become big => Rel: become large (growth, is process of, (something, become large)) Arg: something => Arg: X (growth, is process of, (leaves of a plant, become large)) Rel: is process of => Rel: X (growth, cause, (leaves of a plant, become large)) QED