Vulcan/SystemPrototype/OutputExamples

Q1

Propositions + Output scores

P1 = (growth, causes, (leaves of a plant, to become large))
    
 0.017 Top(id=1, growth, causes, "")
 0.222 Nested(id=1, leaves of a plant, become large, "")


P2 = (germination, causes, (leaves of a plant, to become large))

 0.049 Top(id=2, germination, causes, "")
 0.055 Nested(id=2, leaves of a plant, become large, "")

Evidence for P21

0.9 Top(id = 1, Noun growth, is the process of, "")
0.9 Nested(id = 1, something, becoming bigger, "")

0.9 Head(Noun growth, growth)
0.9 Stem(becoming bigger, become big)

0.9 Syn(become big, become large)

Evidence for P22

//Germination is the process whereby seeds or spores sprout and begin to grow

0.9 Stem("seeds", "seed")
0.9 Syn("sprout", "shoot")
0.9 Syn("sprout", "spud")
0.9 ModifierDropped("begin to grow", "grow")
0.9 Syn("grow", "become larger")
0.9 Stem("become larger", "become large")

Top(2, "germination", "is process of", "")
Nested(2, "seeds", "sprout", "")

Newly inferred facts

0.53 SameAs("becoming bigger", "become big")
0.42 SameAs("becoming bigger", "become large")
0.33 SameAs("become big", "become large")

0.42 Top(id=1, noun growth, causes, "")
0.06 Top(id=1, growth, is the process of, "")

0.017 Nested(id=1, something, become big)
0.015 Nested(id=1, something, become large)

0.17 Nested(2, "seed", "become large", "")

# Relevant clauses (reachable from the input proposition) = 24.

Rules

//************************
//Logical inference rules
//************************

//Type transitivity.
//ISA(x, y) => Type(x, y) .
0.9 Type(x, y), Type(y, z) => Type(x, z)
0.9 SameAs(x, y), SameAs(y, z) => SameAs(x, z)


//Deductive: e.g. If a type of actors does something then a single actor of the type also does it.
//0.9 Arg(t, p, a1), Type(x, a1) => Arg(t, p, x)
0.9 BinaryTuple(t, a1, r, a2), Type(x, a1) => BinaryTuple(t, x, r, a2)

//Abductive: e.g. If an actor does something then it is possible that other actors of the type also do it.
//0.1 Arg(t, p, a1), Type(a1, x) => Arg(t, p, x)
0.1 BinaryTuple(t, a1, r, a2), Type(a1, x) => BinaryTuple(t, x, r, a2)

0.9 Arg(t, p, a), SameAs(a, b) => Arg(t, p, b)
0.9 Rel(t, p, a), SameAs(a, b) => Rel(t, p, b)


//************************
// Domain rules
//************************
//iron nail specific rule
0.9 BinaryTuple(t, a1, "composed of", x), BinaryTuple(t1, x, r, a4) => BinaryTuple(t1, a1, r, a4)


//Growth specific rule
0.8 Rel(t, 1, x), Rel(t, 2, y) => Rel(t, 1, "causes")
0.8 BinaryTuple(t, a1, r1, a2), Nested(t, a2, r2, a3) => BinaryTuple(t, a1, "causes", "")

//Fox specific rules
0.9 Arg(t, p, l1), [l1 = "something"] => Arg(t, p, l2)

//Deductive inverse.
//0.0001 Arg(t, p, l1), [l1 != "something"] => Arg(t, p, "something")

//************************
// Textual entailment rules
// -- Stemming, Synonyms.
//************************
Syn(x, y) => SameAs(x, y) .
Syn(y, x) => SameAs(x, y) .

0.8 ModifierDropped(x, y) => SameAs(x, y)
//0.05 ModifierDropped(x, y) => SameAs(y, x)

0.8 Stem(x,y) => SameAs(x, y)
//0.05 Stem(x,y) => SameAs(y, x)

0.7 Head(x,y) => SameAs(x, y)

0.8 Rel(t, p, "is necessary for") => Rel(t, p, "helps")