RuleTransformation

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 prohibitively large possibilities during inference. Therefore, we break up the predicate into predicates with smaller arity tied by a tuple id.

NEEDS to be fixed

//Predicate definitions
Arg(tupleid, position, phrase)
Rel(tupleid, position, phrase)
BinaryRelationTuple(tupleid, position, phrase, phrase, phrase)
NestedTuple(BinaryTuple, BinaryTuple)

//Rules to construct predicates of larger arity.
Arg(t, 1, a1), Rel(t, 1, r), Arg(t, 2, a2) => BinaryRelationTuple(t, a1, rel, a2)

BinaryRelationTuple(t, p, a1, rel, a2) => Arg(t, p.1, a1)
BinaryRelationTuple(t, p, a1, rel, a2) => Rel(t, p.1, rel)
BinaryRelationTuple(t, p, a1, rel, a2) => Arg(t, p.2, a2)

BinaryRelationTuple(t1, a11, r1, a12), BinaryRelationTuple(t2, a21, r2, a22) => NestedTuple(t,

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