Difference between revisions of "Vulcan/SystemPrototype/OutputExamples"

From Knowitall
Jump to: navigation, search
(Q2)
 
(6 intermediate revisions by the same user not shown)
Line 1: Line 1:
== Q1 ==
+
== Example ==  
 
 
; Propositions + Output scores
 
 
 
; Evidence
 
 
 
; Newly inferred facts
 
 
 
; Relevant clauses (reachable from the input proposition)
 
 
 
== Q2 ==  
 
  
 
; Propositions + Output scores
 
; Propositions + Output scores
Line 15: Line 5:
 
<pre>
 
<pre>
  
P21 = (growth, causes, (leaves of a plant, to become large))
+
P1 = (growth, causes, (leaves of a plant, to become large))
 
      
 
      
  0.017 (id=1, growth, causes, "")
+
  0.017 Top(id=1, growth, causes, "")
  0.222 (id=1, leaves of a plant, become large, "")
+
  0.222 Nested(id=1, leaves of a plant, become large, "")
  
  
P22 = (germination, causes, (leaves of a plant, to become large))
+
P2 = (germination, causes, (leaves of a plant, to become large))
  
  0.049 (id=2, germination, causes, "")
+
  0.049 Top(id=2, germination, causes, "")
  0.055 (id=2, leaves of a plant, become large, "")
+
  0.055 Nested(id=2, leaves of a plant, become large, "")
  
 
</pre>
 
</pre>
  
; Evidence  
+
; Evidence for P21
 
<pre>
 
<pre>
0.9 (id = 1, Noun growth, is the process of, "")
+
0.9 Top(id = 1, Noun growth, is the process of, "")
0.9 (id = 1, something, becoming bigger, "")
+
0.9 Nested(id = 1, something, becoming bigger, "")
  
 
0.9 Head(Noun growth, growth)
 
0.9 Head(Noun growth, growth)
Line 37: Line 27:
  
 
0.9 Syn(become big, become large)
 
0.9 Syn(become big, become large)
 +
</pre>
 +
 +
; Evidence for P22
 +
<pre>
 +
//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", "")
 +
 
</pre>
 
</pre>
  
Line 46: Line 52:
 
0.33 SameAs("become big", "become large")
 
0.33 SameAs("become big", "become large")
  
0.42 (1, noun growth, causes, "")
+
0.42 Top(id=1, noun growth, causes, "")
0.06 (1, growth, is the process of, "")
+
0.06 Top(id=1, growth, is the process of, "")
  
0.017 (1, something, become big)
+
0.017 Nested(id=1, something, become big)
0.015 (1, something, become large)
+
0.015 Nested(id=1, something, become large)
 +
 
 +
0.17 Nested(2, "seed", "become large", "")
  
 
</pre>
 
</pre>
  
; Relevant clauses (reachable from the input proposition)
+
; # Relevant clauses (reachable from the input proposition) = 24.
 +
 
 +
== Rules ==
 +
<pre>
 +
 
 +
************************
 +
Logical inference rules
 +
************************
 +
 
 +
//Type transitivity.
 +
0.9 Type(x, y), Type(y, z) => Type(x, z)
 +
0.9 SameAs(x, y), SameAs(y, z) => SameAs(x, z)
 +
 
 +
 
 +
//Deductive: If a type of actors does something then a single actor of the type also does it.
 +
0.9 BinaryTuple(t, a1, r, a2), Type(x, a1) => BinaryTuple(t, x, r, a2)
 +
0.9 Nested(t, a1, r, a2), Type(x, a1) => Nested(t, x, r, a2)
 +
 
 +
//Abductive: If an actor does something then it is possible that other actors of the type also do it.
 +
0.1 BinaryTuple(t, a1, r, a2), Type(a1, x) => BinaryTuple(t, x, r, a2)
 +
0.1 Nested(t, a1, r, a2), Type(a1, x) => Nested(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)
  
== Q3 ==
 
  
; Propositions + Output scores
+
************************
 +
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 -- Not a good rule x => something coupled with above rule something => anything leads to arbitrary matches.
 +
//0.0001 Arg(t, p, l1), [l1 != "something"] => Arg(t, p, "something")
 +
 
  
; Evidence
+
************************
 +
Textual entailment rules
 +
-- Stemming, Synonyms.
 +
************************
 +
Syn(x, y) => SameAs(x, y) .
 +
Syn(y, x) => SameAs(x, y) .
  
; Newly inferred facts
+
0.8 ModifierDropped(x, y) => SameAs(x, y)
 +
0.8 Stem(x,y) => SameAs(x, y)
 +
0.7 Head(x,y) => SameAs(x, y)
  
; Relevant clauses (reachable from the input proposition)
+
0.8 Rel(t, p, "is necessary for") => Rel(t, p, "helps")
 +
</pre>

Latest revision as of 14:24, 6 September 2013

Example

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.
0.9 Type(x, y), Type(y, z) => Type(x, z)
0.9 SameAs(x, y), SameAs(y, z) => SameAs(x, z)


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

//Abductive: If an actor does something then it is possible that other actors of the type also do it.
0.1 BinaryTuple(t, a1, r, a2), Type(a1, x) => BinaryTuple(t, x, r, a2)
0.1 Nested(t, a1, r, a2), Type(a1, x) => Nested(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 -- Not a good rule x => something coupled with above rule something => anything leads to arbitrary matches.
//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.8 Stem(x,y) => SameAs(x, y)
0.7 Head(x,y) => SameAs(x, y)

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