********** variable unification
<<$x --> bird> ==> <$x --> flyer>>.
// If something is a bird, then it is a flyer.
<<$y --> bird> ==> <$y --> flyer>>. %0.00;0.70% 
// If something is a bird, then it is not a flyer. 
1
 OUT: <<$1 --> bird> ==> <$1 --> flyer>>. %0.79;0.92% 
// If something is a bird, then usually, it is a flyer. 

********** variable unification
<<$x --> bird> ==> <$x --> animal>>. 
// If something is a bird, then it is a animal. 
<<$y --> robin> ==> <$y --> bird>>. 
// If something is a robin, then it is a bird. 
5
 OUT: <<$1 --> robin> ==> <$1 --> animal>>. %1.00;0.81% 
// If something is a robin, then it is a animal. 
 OUT: <<$1 --> animal> ==> <$1 --> robin>>. %1.00;0.45% 
 // I guess that if something is a animal, then it is a robin. 

********** variable unification
<<$x --> swan> ==> <$x --> bird>>. %1.00;0.80%  
// If something is a swan, then it is a bird.
<<$y --> swan> ==> <$y --> swimmer>>. %0.80% 
// If something is a swan, then it is a swimmer.
5
 OUT: <<$1 --> swan> ==> (||,<$1 --> bird>,<$1 --> swimmer>)>. %1.00;0.72% 
// I believe that if something is a swan, then it is a bird or a swimmer.
 OUT: <<$1 --> swan> ==> (&&,<$1 --> bird>,<$1 --> swimmer>)>. %0.80;0.72% 
//I believe that if something is a swan, then usually, it is both a bird and a swimmer.
 OUT: <<$1 --> swimmer> ==> <$1 --> bird>>. %1.00;0.37% 
// I guess if something is a swimmer, then it is a bird. 
 OUT: <<$1 --> bird> ==> <$1 --> swimmer>>. %0.80;0.42% 
// I guess if something is a bird, then it is a swimmer. 
 OUT: <<$1 --> bird> <=> <$1 --> swimmer>>. %0.80;0.42% 
// I guess something is a bird, if and only if it is a swimmer. 

********** variable unification
<<bird --> $x> ==> <robin --> $x>>.
// What can be said about bird can also be said about robin.
<<swimmer --> $y> ==> <robin --> $y>>. %0.70;0.90%  
// What can be said about swimmer usually can also be said about robin.
5
 OUT: <(&&,<bird --> $1>,<swimmer --> $1>) ==> <robin --> $1>>. %1.00;0.81%
// What can be said about bird and swimmer can also be said about robin.
 OUT: <(||,<bird --> $1>,<swimmer --> $1>) ==> <robin --> $1>>. %0.70;0.81% 
// What can be said about bird or swimmer can also be said about robin.
 OUT: <<bird --> $1> ==> <swimmer --> $1>>. %1.00;0.36%
// I guess what can be said about bird can also be said about swimmer.
 OUT: <<swimmer --> $1> ==> <bird --> $1>>. %0.70;0.45%
// I guess what can be said about swimmer can also be said about bird.
 OUT: <<bird --> $1> <=> <swimmer --> $1>>. %0.70;0.45%
// I guess bird and swimmer share most properties.

********** variable unification
<(&&,<$x --> flyer>,<$x --> [chirping]>) ==> <$x --> bird>>. 
// If something can fly and chirp, then it is a bird.
<<$y --> [with-wings]> ==> <$y --> flyer>>. 
// If something has wings, then it can fly.
1
 OUT: <(&&,<$1 --> [chirping]>,<$1 --> [with-wings]>) ==> <$1 --> bird>>. %1.00;0.81% 
// If something can chirp and has wings, then it is a bird.

********** variable unification
<(&&,<$x --> flyer>,<$x --> [chirping]>, <(*, $x, worms) --> food>) ==> <$x --> bird>>. 
// If something can fly, chirp, and eats worms, then it is a bird.
<(&&,<$y --> [chirping]>,<$y --> [with-wings]>) ==> <$y --> bird>>.
// If something can chirp and has wings, then it is a bird.
4
 OUT: <(&&,<$1 --> flyer>,<(*,$1,worms) --> food>) ==> <$1 --> [with-wings]>>. %1.00;0.45%  
// If something can fly and eats worms, then I guess it has wings.
 OUT: <<$1 --> [with-wings]> ==> (&&,<$1 --> flyer>,<(*,$1,worms) --> food>)>. %1.00;0.45% 
// I guess if something has wings, then it can fly and eats worms.

********** variable unification
<(&&,<$x --> flyer>,<(*,$x,worms) --> food>) ==> <$x --> bird>>.
// If something can fly and eats worms, then it is a bird.
<<$y --> flyer> ==> <$y --> [with-wings]>>.
// If something can fly, then it has wings.
4
 OUT: <(&&,<$1 --> [with-wings]>,<(*,$1,worms) --> food>) ==> <$1 --> bird>>. %1.00;0.45% 
// If something has wings and eats worms, then I guess it is a bird.

****** variable elimination
<<$x --> bird> ==> <$x --> animal>>.
// If something is a bird, then it is an animal.
<robin --> bird>. 
// A robin is a bird.
5
 OUT: <robin --> animal>. %1.00;0.81%  
// A robin is an animal.

********** variable elimination
<<$x --> bird> ==> <$x --> animal>>. 
// If something is a bird, then it is an animal.
<tiger --> animal>. 
// A tiger is an animal.
5
 OUT: <tiger --> bird>. %1.00;0.45%  
// I guess that a tiger is a bird.

********** variable elimination
<<$x --> animal> <=> <$x --> bird>>. 
// Something is a animal if and only if it is a bird.
<robin --> bird>.
// A robin is a bird.
5
 OUT: <robin --> animal>. %1.00;0.81%  
// A robin is a animal.

********** variable elimination
(&&,<#x --> bird>,<#x --> swimmer>). 
// Some bird can swim.
<swan --> bird>. %0.90%
// Swan is a type of bird.
5
 OUT: <swan --> swimmer>. %0.90;0.43%  
// I guess swan can swim.

********** variable elimination
<{Tweety} --> [with-wings]>.
// Tweety has wings.
<(&&,<$x --> [chirping]>,<$x --> [with-wings]>) ==> <$x --> bird>>.
// If something can chirp and has wings, then it is a bird.
18
 OUT: <<{Tweety} --> [chirping]> ==> <{Tweety} --> bird>>. %1.00;0.81%
// If Tweety can chirp, then it is a bird.

********** variable elimination
<(&&,<$x --> flyer>,<$x --> [chirping]>, <(*, $x, worms) --> food>) ==> <$x --> bird>>. 
// If something can fly, chirp, and eats worms, then it is a bird.
<{Tweety} --> flyer>.
// Tweety can fly.
3
 OUT: <(&&,<(*,{Tweety},worms) --> food>,<{Tweety} --> [chirping]>) ==> <{Tweety} --> bird>>. %1.00;0.81%
// If Tweety can chirp and eats worms, then it is a bird.

********** multiple variable elimination
<(&&,<$x --> key>,<$y --> lock>) ==> <$y --> (/,open,$x,_)>>.  
// Every lock can be opened by every key.
<{lock1} --> lock>. 
// Lock-1 is a lock.
8
 OUT: <<$1 --> key> ==> <{lock1} --> (/,open,$1,_)>>. %1.00;0.81%
// Lock-1 can be opened by every key.

********** multiple variable elimination
<<$x --> lock> ==> (&&,<#y --> key>,<$x --> (/,open,#y,_)>)>.  
// Every lock can be opened by some key.
<{lock1} --> lock>. 
// Lock-1 is a lock.
3
 OUT: (&&,<#1 --> key>,<{lock1} --> (/,open,#1,_)>). %1.00;0.81% 
// Some key can open Lock-1.

********** multiple variable elimination
(&&,<#x --> lock>,<<$y --> key> ==> <#x --> (/,open,$y,_)>>).  
// There is a lock that can be opened by every key.
<{lock1} --> lock>.
// Lock-1 is a lock.
3
 OUT: <<$1 --> key> ==> <{lock1} --> (/,open,$1,_)>>. %1.00;0.43% 
// I guess Lock-1 can be opened by every key.

********** multiple variable elimination
(&&,<#x --> (/,open,#y,_)>,<#x --> lock>,<#y --> key>).  
// There is a key that can open some lock.
<{lock1} --> lock>.
// Lock-1 is a lock.
1
 OUT: (&&,<#1 --> key>,<{lock1} --> (/,open,#1,_)>). %1.00;0.43%
// I guess there is a key that can open Lock-1.

********** variable introduction
<swan --> bird>.  
// A swan is a bird.
<swan --> swimmer>. %0.80% 
// A swan is usually a swimmer.
5
 OUT: <<$1 --> bird> ==> <$1 --> swimmer>>. %0.80;0.45% 
// I guess a bird is usually a swimmer.
 OUT: <<$1 --> swimmer> ==> <$1 --> bird>>. %1.00;0.39% 
// I guess a swimmer is a bird.
 OUT: <<$1 --> bird> <=> <$1 --> swimmer>>. %0.80;0.45% 
// I guess a bird is usually a swimmer, and the other way around.
 OUT: (&&,<#1 --> bird>,<#1 --> swimmer>). %0.80;0.81% 
// Some bird can swim.

********** variable introduction
<gull --> swimmer>. 
//A gull is a swimmer.
<swan --> swimmer>. %0.80% 
//Usually, a swan is a swimmer.
5
 OUT: <<gull --> $1> ==> <swan --> $1>>. %0.80;0.45% 
// I guess what can be said about gull usually can also be said about swan.
 OUT: <<swan --> $1> ==> <gull --> $1>>. %1.00;0.39%  
// I guess what can be said about swan can also be said about gull.
 OUT: <<gull --> $1> <=> <swan --> $1>>. %0.80;0.45%
// I guess gull and swan share most properties.
 OUT: (&&,<gull --> #1>,<swan --> #1>). %0.80;0.81%
// Gull and swan have some common property.

********** variables introduction
<{key1} --> (/,open,_,{lock1})>. 
// Key-1 opens Lock-1.
<{key1} --> key>.
// Key-1 is a key.
3
 OUT: <<$1 --> key> ==> <$1 --> (/,open,_,{lock1})>>. %1.00;0.45%
// I guess every key can open Lock-1.
 OUT: (&&,<#1 --> (/,open,_,{lock1})>,<#1 --> key>). %1.00;0.81%
// Some key can open Lock-1.

********** multiple variables introduction
<<$x --> key> ==> <{lock1} --> (/,open,$x,_)>>. 
// Lock-1 can be opened by every key.
<{lock1} --> lock>. 
// Lock-1 is a lock.
1
 OUT: (&&,<#1 --> lock>,<<$2 --> key> ==> <#1 --> (/,open,$2,_)>>). %1.00;0.81%
// There is a lock that can be opened by every key.
 OUT: <(&&,<$1 --> key>,<$2 --> lock>) ==> <$2 --> (/,open,$1,_)>>. %1.00;0.45%
// I guess every lock can be opened by every key.

********** multiple variables introduction
(&&,<#x --> key>,<{lock1} --> (/,open,#x,_)>).  
// Lock-1 can be opened by some key.
<{lock1} --> lock>. 
// Lock-1 is a lock.
1
 OUT: (&&,<#1 --> key>,<#2 --> lock>,<#2 --> (/,open,#1,_)>). %1.00;0.81%
// There is a key that can open some lock.
 OUT: <<$1 --> lock> ==> (&&,<#2 --> key>,<$1 --> (/,open,#2,_)>)>. %1.00;0.45% 
// I guess every lock can be opened by some key.