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 and makes it harder to write/maintain rules. Further, since most rules can be specified as transformations over individual arguments (or the relation phrase), we will use the following representation for tuples.

//Predicate definitions

Arg(tupleid, position, phrase)
Rel(tupleid, position, phrase)

BinaryRelationTuple(tupleid, phrase, phrase, phrase)
NestedTuple(tupleid, phrase, phrase, phrase, phrase, phrase)

//A binary relation tuple can be constructed from these smaller predicates.
Arg(t, 1, a1), Rel(t, 1, r), Arg(t, 2, a2) => BinaryRelationTuple(t, a1, rel, a2)

//A binary relation can be broken down.
BinaryRelationTuple(t, p, a1, rel, a2) => Arg(t, 1, a1)
BinaryRelationTuple(t, p, a1, rel, a2) => Rel(t, 1, rel)
BinaryRelationTuple(t, p, a1, rel, a2) => Arg(t, 2, a2)

Arg(t, 1, a1), Rel(t, 1, r1), Arg(t, 3, a3), Rel(t, 2, r2), Arg(t, 4, a4) => NestedTuple(t, a1, r1, a3, r2, a4)

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.The example transformations below need to be updated using the smaller predicates.

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.