From d6da425850778fd221d034739647d1e3a240277e Mon Sep 17 00:00:00 2001
From: TonyLo1 <tony_lofthouse@btinternet.com>
Date: Thu, 14 Feb 2019 22:32:29 +0000
Subject: [PATCH] Added new tests, support for additional belief category
 (generalised) in event store, and added ui support for the latter

---
 ALANNStreams/ALANNStreams.fsproj              |    4 +-
 ALANNStreams/Commands/CommandProcessor.fs     |    8 +
 ALANNStreams/Containers/Store.fs              |   16 +-
 .../Inference/HigherOrderInference.fs         |   74 +-
 ALANNStreams/Parser/CommandParser.fs          |    3 +
 .../Inference/FirstOrderInfernceTests.fs      |  633 ++++++
 .../Inference/HigherOrderInferenceTests.fs    | 1267 ++++++++++++
 .../Tests/Inference/InferenceTests.fs         | 1842 -----------------
 ALANNStreams/Tests/Parser/ParserTests.fs      |  345 +++
 ALANNStreams/Tests/Unify/UniifyTests.fs       |    7 +
 ALANNStreams/TypesPlus/Types.fs               |    2 +
 11 files changed, 2320 insertions(+), 1881 deletions(-)
 create mode 100644 ALANNStreams/Tests/Inference/FirstOrderInfernceTests.fs
 create mode 100644 ALANNStreams/Tests/Inference/HigherOrderInferenceTests.fs
 delete mode 100644 ALANNStreams/Tests/Inference/InferenceTests.fs
 create mode 100644 ALANNStreams/Tests/Parser/ParserTests.fs

diff --git a/ALANNStreams/ALANNStreams.fsproj b/ALANNStreams/ALANNStreams.fsproj
index 16a3302..9d666f6 100644
--- a/ALANNStreams/ALANNStreams.fsproj
+++ b/ALANNStreams/ALANNStreams.fsproj
@@ -101,9 +101,11 @@
     <Compile Include="System\Controller.fs" />
     <Compile Include="Tests\TermFormatters\TermFormattersTests.fs" />
     <Compile Include="Tests\Unify\UniifyTests.fs" />
-    <Compile Include="Tests\Inference\InferenceTests.fs" />
+    <Compile Include="Tests\Inference\FirstOrderInfernceTests.fs" />
+    <Compile Include="Tests\Inference\HigherOrderInferenceTests.fs" />
     <Compile Include="Tests\Evidence\EvidenceTests.fs" />
     <Compile Include="Tests\TermUtils\TermUtilsTests.fs" />
+    <Compile Include="Tests\Parser\ParserTests.fs" />
     <Compile Include="Program.fs" />
   </ItemGroup>
   <ItemGroup>
diff --git a/ALANNStreams/Commands/CommandProcessor.fs b/ALANNStreams/Commands/CommandProcessor.fs
index 06d1ce8..5734fcd 100644
--- a/ALANNStreams/Commands/CommandProcessor.fs
+++ b/ALANNStreams/Commands/CommandProcessor.fs
@@ -55,6 +55,13 @@ let showSuperBeliefs term =
         showBeliefs (List.sortBy (fun b -> -exp(b.TV)) [for b in node.Beliefs.GetSuperBeliefs() -> b])
     | _ -> printCommand "ERROR *** TERM DOES NOT EXIST ***"
 
+let showVariableBeliefs term =
+    match getNodeFromTerm term with
+    | (true, node) ->
+        printCommandWithString "SHOW_VARIABLE_BELIEFS FOR TERM" (ft term)
+        showBeliefs (List.sortBy (fun b -> -exp(b.TV)) [for b in node.Beliefs.GetVariableBeliefs() -> b])
+    | _ -> printCommand "ERROR *** TERM DOES NOT EXIST ***"
+
 let showNode term =
     match getNodeFromTerm term with
     | (true, node) ->
@@ -141,6 +148,7 @@ let processCommand (cmd : string) =
     | Show_General_Beliefs(term) -> showGeneralBeliefs term
     | Show_Temporal_Beliefs(term) -> showTemporalBeliefs term
     | Show_Super_Beliefs(term) -> showSuperBeliefs term
+    | Show_Variable_Beliefs(term) -> showVariableBeliefs term
     | Show_Node(term) -> showNode(term)
     | Node_Count -> nodeCount()
     | Enable_Trace(term) -> enableTrace term
diff --git a/ALANNStreams/Containers/Store.fs b/ALANNStreams/Containers/Store.fs
index eb81d5a..cc35905 100644
--- a/ALANNStreams/Containers/Store.fs
+++ b/ALANNStreams/Containers/Store.fs
@@ -33,11 +33,14 @@ type Store(hostTerm, generalCapacity, temporalCapacity, superCapacity ) =
     let temporalStore = new SubStore(temporalCapacity) :> ISubStore
     let GeneralStore = new SubStore(generalCapacity) :> ISubStore
     let superStore = new SubStore(superCapacity) :> ISubStore
+    let variableStore = new SubStore(superCapacity) :> ISubStore
 
     interface IStore with
         member x.Contains(key) = 
             if key |> isSuperTerm hostTerm then
                 superStore.Contains key
+            else if key |> containsVars then
+                variableStore.Contains key
             else if key |> isTemporal then
                 temporalStore.Contains key
             else 
@@ -46,6 +49,8 @@ type Store(hostTerm, generalCapacity, temporalCapacity, superCapacity ) =
         member x.Insert(key, belief) =
             if key |> isSuperTerm hostTerm then
                 superStore.Insert(key, belief)
+            else if key |> containsVars then
+                variableStore.Insert(key, belief)
             else if key |> isTemporal then
                 temporalStore.Insert(key, belief)
             else
@@ -54,6 +59,8 @@ type Store(hostTerm, generalCapacity, temporalCapacity, superCapacity ) =
         member x.Update(key, belief) =
             if key |> isSuperTerm hostTerm then
                 superStore.Update(key, belief)
+            else if key |> containsVars then
+                variableStore.Update(key, belief)
             else if key |> isTemporal then
                 temporalStore.Update(key, belief)
             else
@@ -62,6 +69,8 @@ type Store(hostTerm, generalCapacity, temporalCapacity, superCapacity ) =
         member x.TryGetValue key = 
             if key |> isSuperTerm hostTerm then
                 superStore.TryGetValue key
+            else if key |> containsVars then
+                variableStore.TryGetValue key
             else if key |> isTemporal then
                 temporalStore.TryGetValue key
             else
@@ -71,8 +80,9 @@ type Store(hostTerm, generalCapacity, temporalCapacity, superCapacity ) =
             superStore.Clear()
             temporalStore.Clear()
             GeneralStore.Clear()
+            variableStore.Clear()
 
-        member x.Count = temporalStore.Count + GeneralStore.Count
+        member x.Count = temporalStore.Count + GeneralStore.Count + superStore.Count + variableStore.Count
 
         member x.GetBeliefs() =           
             Seq.append
@@ -80,6 +90,8 @@ type Store(hostTerm, generalCapacity, temporalCapacity, superCapacity ) =
                 (temporalStore.GetBeliefs())
             |> Seq.append
                 (GeneralStore.GetBeliefs())
+            |> Seq.append
+                (variableStore.GetBeliefs())
 
         member x.GetSuperBeliefs() = superStore.GetBeliefs()
 
@@ -87,3 +99,5 @@ type Store(hostTerm, generalCapacity, temporalCapacity, superCapacity ) =
            
         member x.GetGeneralBeliefs() = GeneralStore.GetBeliefs() 
 
+        member x.GetVariableBeliefs() = variableStore.GetBeliefs()
+
diff --git a/ALANNStreams/Inference/HigherOrderInference.fs b/ALANNStreams/Inference/HigherOrderInference.fs
index 3b171d7..8977ac6 100644
--- a/ALANNStreams/Inference/HigherOrderInference.fs
+++ b/ALANNStreams/Inference/HigherOrderInference.fs
@@ -339,64 +339,64 @@ let nal5_multi_conditional_syllogism : InferenceFunction = function
     | _ -> []
 
 let nal6_variable_introduction = function
-    | Inh(s, m1), Inh(p, m2) when m1 = m2 && s <> p -> [(Term(Imp, [Term(Inh, [p; Var(IVar, "X")]); Term(Inh, [s; Var(IVar, "X")])]), abd, None, [BeliefOnly])
-                                                        (Term(Imp, [Term(Inh, [s; Var(IVar, "X")]); Term(Inh, [p; Var(IVar, "X")])]), ind, None, [BeliefOnly])
-                                                        (Term(Equ, [Term(Inh, [p; Var(IVar, "X")]); Term(Inh, [s; Var(IVar, "X")])]), com, None, [BeliefOnly])
-                                                        (Term(And, [Term(Inh, [p; Var(DVar, "Y")]); Term(Inh, [s; Var(DVar, "Y")])]), int, None, [BeliefOnly])
+    | Inh(s, m1), Inh(p, m2) when m1 = m2 && s <> p -> [(Term(Imp, [Term(Inh, [p; Var(IVar, "1")]); Term(Inh, [s; Var(IVar, "1")])]), abd, None, [BeliefOnly])
+                                                        (Term(Imp, [Term(Inh, [s; Var(IVar, "1")]); Term(Inh, [p; Var(IVar, "1")])]), ind, None, [BeliefOnly])
+                                                        (Term(Equ, [Term(Inh, [p; Var(IVar, "1")]); Term(Inh, [s; Var(IVar, "1")])]), com, None, [BeliefOnly])
+                                                        (Term(And, [Term(Inh, [p; Var(DVar, "1")]); Term(Inh, [s; Var(DVar, "1")])]), int, None, [BeliefOnly])
                                                         
-                                                        (Term(ConImp, [Term(Inh, [p; Var(IVar, "X")]); Term(Inh, [s; Var(IVar, "X")])]), abd, None, [BeliefOnly; IsConcurrent])
-                                                        (Term(ConImp, [Term(Inh, [s; Var(IVar, "X")]); Term(Inh, [p; Var(IVar, "X")])]), ind, None, [BeliefOnly; IsConcurrent])
-                                                        (Term(ConImp, [Term(Inh, [p; Var(IVar, "X")]); Term(Inh, [s; Var(IVar, "X")])]), ind, None, [BeliefOnly; IsConcurrent])
-                                                        (Term(Par, [Term(Inh, [p; Var(DVar, "Y")]); Term(Inh, [s; Var(DVar, "Y")])]), int, None, [BeliefOnly; IsConcurrent])
+                                                        (Term(ConImp, [Term(Inh, [p; Var(IVar, "1")]); Term(Inh, [s; Var(IVar, "1")])]), abd, None, [BeliefOnly; IsConcurrent])
+                                                        (Term(ConImp, [Term(Inh, [s; Var(IVar, "1")]); Term(Inh, [p; Var(IVar, "1")])]), ind, None, [BeliefOnly; IsConcurrent])
+                                                        (Term(ConImp, [Term(Inh, [p; Var(IVar, "1")]); Term(Inh, [s; Var(IVar, "1")])]), ind, None, [BeliefOnly; IsConcurrent])
+                                                        (Term(Par, [Term(Inh, [p; Var(DVar, "1")]); Term(Inh, [s; Var(DVar, "")])]), int, None, [BeliefOnly; IsConcurrent])
 
-                                                        (Term(PreImp, [Term(Inh, [s; Var(IVar, "X")]); Term(Inh, [p; Var(IVar, "X")])]), abd, None, [BeliefOnly; IsBefore])
-                                                        (Term(RetImp, [Term(Inh, [p; Var(IVar, "X")]); Term(Inh, [s; Var(IVar, "X")])]), ind, None, [BeliefOnly; IsBefore])
-                                                        (Term(Seq, [Term(Inh, [s; Var(DVar, "Y")]); Term(Inh, [p; Var(DVar, "Y")])]), int, None, [BeliefOnly; IsBefore])
+                                                        (Term(PreImp, [Term(Inh, [s; Var(IVar, "1")]); Term(Inh, [p; Var(IVar, "1")])]), abd, None, [BeliefOnly; IsBefore])
+                                                        (Term(RetImp, [Term(Inh, [p; Var(IVar, "1")]); Term(Inh, [s; Var(IVar, "1")])]), ind, None, [BeliefOnly; IsBefore])
+                                                        (Term(Seq, [Term(Inh, [s; Var(DVar, "1")]); Term(Inh, [p; Var(DVar, "1")])]), int, None, [BeliefOnly; IsBefore])
 
-                                                        (Term(PreImp, [Term(Inh, [s; Var(IVar, "X")]); Term(Inh, [p; Var(IVar, "X")])]), abd, None, [BeliefOnly; IsAfter])
-                                                        (Term(RetImp, [Term(Inh, [p; Var(IVar, "X")]); Term(Inh, [s; Var(IVar, "X")])]), ind, None, [BeliefOnly; IsAfter])
-                                                        (Term(Seq, [Term(Inh, [s; Var(DVar, "Y")]); Term(Inh, [p; Var(DVar, "Y")])]), int, None, [BeliefOnly; IsAfter])]
+                                                        (Term(PreImp, [Term(Inh, [s; Var(IVar, "1")]); Term(Inh, [p; Var(IVar, "1")])]), abd, None, [BeliefOnly; IsAfter])
+                                                        (Term(RetImp, [Term(Inh, [p; Var(IVar, "1")]); Term(Inh, [s; Var(IVar, "1")])]), ind, None, [BeliefOnly; IsAfter])
+                                                        (Term(Seq, [Term(Inh, [s; Var(DVar, "1")]); Term(Inh, [p; Var(DVar, "1")])]), int, None, [BeliefOnly; IsAfter])]
 
 
 
                                                         // interval variants ommitted here as not required
 
-    | Inh(m1, s), Inh(m2, p) when m1 = m2 && s <> p -> [(Term(Imp, [Term(Inh, [Var(IVar, "X"); s]); Term(Inh, [Var(IVar, "X"); p])]), ind, None, [BeliefOnly])
-                                                        (Term(Imp, [Term(Inh, [Var(IVar, "X"); p]); Term(Inh, [Var(IVar, "X"); s])]), abd, None, [BeliefOnly])
-                                                        (Term(Equ, [Term(Inh, [Var(IVar, "X"); s]); Term(Inh, [Var(IVar, "X"); p])]), com, None, [BeliefOnly])
-                                                        (Term(And, [Term(Inh, [Var(DVar, "Y"); s]); Term(Inh, [Var(DVar, "Y"); p])]), int, None, [BeliefOnly])
+    | Inh(m1, s), Inh(m2, p) when m1 = m2 && s <> p -> [(Term(Imp, [Term(Inh, [Var(IVar, "1"); s]); Term(Inh, [Var(IVar, "1"); p])]), ind, None, [BeliefOnly])
+                                                        (Term(Imp, [Term(Inh, [Var(IVar, "1"); p]); Term(Inh, [Var(IVar, "1"); s])]), abd, None, [BeliefOnly])
+                                                        (Term(Equ, [Term(Inh, [Var(IVar, "1"); s]); Term(Inh, [Var(IVar, "1"); p])]), com, None, [BeliefOnly])
+                                                        (Term(And, [Term(Inh, [Var(DVar, "1"); s]); Term(Inh, [Var(DVar, "1"); p])]), int, None, [BeliefOnly])
                                                         
-                                                        (Term(ConImp, [Term(Inh, [Var(IVar, "X"); s]); Term(Inh, [Var(IVar, "X"); p])]), ind, None, [BeliefOnly; IsConcurrent])
-                                                        (Term(ConImp, [Term(Inh, [Var(IVar, "X"); p]); Term(Inh, [Var(IVar, "X"); s])]), abd, None, [BeliefOnly; IsConcurrent])
-                                                        (Term(ConImp, [Term(Inh, [Var(IVar, "X"); s]); Term(Inh, [Var(IVar, "X"); p])]), ind, None, [BeliefOnly; IsConcurrent])
-                                                        (Term(ConEqu, [Term(Inh, [Var(IVar, "X"); s]); Term(Inh, [Var(IVar, "X"); p])]), com, None, [BeliefOnly; IsConcurrent])
-                                                        (Term(Par, [Term(Inh, [Var(DVar, "Y"); s]); Term(Inh, [Var(DVar, "Y"); p])]), int, None, [BeliefOnly; IsConcurrent])
+                                                        (Term(ConImp, [Term(Inh, [Var(IVar, "1"); s]); Term(Inh, [Var(IVar, "1"); p])]), ind, None, [BeliefOnly; IsConcurrent])
+                                                        (Term(ConImp, [Term(Inh, [Var(IVar, "1"); p]); Term(Inh, [Var(IVar, "1"); s])]), abd, None, [BeliefOnly; IsConcurrent])
+                                                        (Term(ConImp, [Term(Inh, [Var(IVar, "1"); s]); Term(Inh, [Var(IVar, "1"); p])]), ind, None, [BeliefOnly; IsConcurrent])
+                                                        (Term(ConEqu, [Term(Inh, [Var(IVar, "1"); s]); Term(Inh, [Var(IVar, "1"); p])]), com, None, [BeliefOnly; IsConcurrent])
+                                                        (Term(Par, [Term(Inh, [Var(DVar, "1"); s]); Term(Inh, [Var(DVar, "1"); p])]), int, None, [BeliefOnly; IsConcurrent])
 
-                                                        (Term(PreImp, [Term(Inh, [Var(IVar, "X"); s]); Term(Inh, [Var(IVar, "X"); p])]), ind, None, [BeliefOnly; IsBefore])
-                                                        (Term(RetImp, [Term(Inh, [Var(IVar, "X"); p]); Term(Inh, [Var(IVar, "X"); s])]), abd, None, [BeliefOnly; IsBefore])
-                                                        (Term(Seq, [Term(Inh, [Var(IVar, "X"); s]); Term(Inh, [Var(IVar, "X"); p])]), ind, None, [BeliefOnly; IsBefore])
+                                                        (Term(PreImp, [Term(Inh, [Var(IVar, "1"); s]); Term(Inh, [Var(IVar, "1"); p])]), ind, None, [BeliefOnly; IsBefore])
+                                                        (Term(RetImp, [Term(Inh, [Var(IVar, "1"); p]); Term(Inh, [Var(IVar, "1"); s])]), abd, None, [BeliefOnly; IsBefore])
+                                                        (Term(Seq, [Term(Inh, [Var(IVar, "1"); s]); Term(Inh, [Var(IVar, "1"); p])]), ind, None, [BeliefOnly; IsBefore])
 
-                                                        (Term(PreImp, [Term(Inh, [Var(IVar, "X"); s]); Term(Inh, [Var(IVar, "X"); p])]), ind, None, [BeliefOnly; IsAfter])
-                                                        (Term(RetImp, [Term(Inh, [Var(IVar, "X"); p]); Term(Inh, [Var(IVar, "X"); s])]), abd, None, [BeliefOnly; IsAfter])
-                                                        (Term(Seq, [Term(Inh, [Var(IVar, "X"); s]); Term(Inh, [Var(IVar, "X"); p])]), ind, None, [BeliefOnly; IsAfter])]
+                                                        (Term(PreImp, [Term(Inh, [Var(IVar, "1"); s]); Term(Inh, [Var(IVar, "1"); p])]), ind, None, [BeliefOnly; IsAfter])
+                                                        (Term(RetImp, [Term(Inh, [Var(IVar, "1"); p]); Term(Inh, [Var(IVar, "1"); s])]), abd, None, [BeliefOnly; IsAfter])
+                                                        (Term(Seq, [Term(Inh, [Var(IVar, "1"); s]); Term(Inh, [Var(IVar, "1"); p])]), ind, None, [BeliefOnly; IsAfter])]
 
 
     | _ -> []
 
 let nal6_variable_syllogisms = function
-    | Imp(Inh(a, r1), z1), Imp(And([Inh(Var(DVar, "Y"), b); Inh(Var(DVar, "Y"), r2)]), z2) when r1 = r2 && z1 = z2 && a <> b -> [Term(Inh, [a; b]), abd, None, []]  
-    | Imp(Inh(a, r1), z1), Imp(And([Inh(Var(DVar, "Y"), r2); Inh(Var(DVar, "Y"), b)]), z2) when r1 = r2 && z1 = z2 && a <> b -> [Term(Inh, [a; b]), abd, None, []]  
+    | Imp(Inh(a, r1), z1), Imp(And([Inh(Var(DVar, "1"), b); Inh(Var(DVar, "1"), r2)]), z2) when r1 = r2 && z1 = z2 && a <> b -> [Term(Inh, [a; b]), abd, None, []]  
+    | Imp(Inh(a, r1), z1), Imp(And([Inh(Var(DVar, "1"), r2); Inh(Var(DVar, "1"), b)]), z2) when r1 = r2 && z1 = z2 && a <> b -> [Term(Inh, [a; b]), abd, None, []]  
 
-    | Inh(u, l1), Imp(And([Inh(Var(DVar, "Y"), l2); Inh(Var(DVar, "Y"), r)]), z) when l1 = l2 && u <> z && z <> l1 -> [(Term(Imp, [Term(Inh, [u; r]); z]), ded, None, [])]
-    | Inh(u, l1), Imp(And([Inh(Var(DVar, "Y"), r); Inh(Var(DVar, "Y"), l2)]), z) when l1 = l2 && u <> z && z <> l1 -> [(Term(Imp, [Term(Inh, [u; r]); z]), ded, None, [])]
+    | Inh(u, l1), Imp(And([Inh(Var(DVar, "1"), l2); Inh(Var(DVar, "1"), r)]), z) when l1 = l2 && u <> z && z <> l1 -> [(Term(Imp, [Term(Inh, [u; r]); z]), ded, None, [])]
+    | Inh(u, l1), Imp(And([Inh(Var(DVar, "1"), r); Inh(Var(DVar, "1"), l2)]), z) when l1 = l2 && u <> z && z <> l1 -> [(Term(Imp, [Term(Inh, [u; r]); z]), ded, None, [])]
 
     | _ -> []
 
 let nal6_multiple_variable_introduction = function
-    | Imp(a, Inh(m1, p)), Inh(m2, s) when m1 = m2 && s <> p && a <> Term(Inh, [m1; s]) -> [(Term(Imp, [Term(And, [a; Term(Inh, [Var(IVar, "X"); s])]); Term(Inh, [Var(IVar, "X"); p])]), ind, None, [])
-                                                                                           (Term(And, [Term(Imp, [a; Term(Inh, [Var(DVar, "Y"); p])]); Term(Inh, [Var(DVar, "Y"); s])]), int, None, [])]
-    | And(Inh(m1, p)::lst), Inh(m2, s) when m1 = m2 && s <> p -> [(Term(Imp, [Term(Inh, [Var(IVar, "Y"); s]); Term(And, Term(Inh, [Var(IVar, "Y"); p])::lst)]), ind, None, [])
-                                                                  (Term(And, Term(Inh, [Var(DVar, "Y"); s])::Term(Inh, [Var(DVar, "Y"); p])::lst), ind, None, [])]
+    | Imp(a, Inh(m1, p)), Inh(m2, s) when m1 = m2 && s <> p && a <> Term(Inh, [m1; s]) -> [(Term(Imp, [Term(And, [a; Term(Inh, [Var(IVar, "1"); s])]); Term(Inh, [Var(IVar, "1"); p])]), ind, None, [])
+                                                                                           (Term(And, [Term(Imp, [a; Term(Inh, [Var(DVar, "1"); p])]); Term(Inh, [Var(DVar, "1"); s])]), int, None, [])]
+    | And(Inh(m1, p)::lst), Inh(m2, s) when m1 = m2 && s <> p -> [(Term(Imp, [Term(Inh, [Var(IVar, "1"); s]); Term(And, Term(Inh, [Var(IVar, "1"); p])::lst)]), ind, None, [])
+                                                                  (Term(And, Term(Inh, [Var(DVar, "1"); s])::Term(Inh, [Var(DVar, "1"); p])::lst), ind, None, [])]
     | _ -> []
 
 let nal6_variable_elimination = function
diff --git a/ALANNStreams/Parser/CommandParser.fs b/ALANNStreams/Parser/CommandParser.fs
index 80e7f44..d84b0ba 100644
--- a/ALANNStreams/Parser/CommandParser.fs
+++ b/ALANNStreams/Parser/CommandParser.fs
@@ -36,8 +36,10 @@ let term_ws = temporal_term <|> pterm
 let show_general_beliefs = (str_ws "SHOW_GENERAL_BELIEFS" <|> str_ws "SGB") >>. term_ws |>> fun t -> Show_General_Beliefs(t)
 let show_temporal_beliefs = (str_ws "SHOW_TEMPORAL_BELIEFS" <|> str_ws "STB") >>. term_ws |>> fun t -> Show_Temporal_Beliefs(t)
 let show_super_beliefs = (str_ws "SHOW_SUPER_BELIEFS" <|> str_ws "SSB") >>. term_ws |>> fun t -> Show_Super_Beliefs(t)
+let show_variable_beliefs = (str_ws "SHOW_VARIABLE_BELIEFS" <|> str_ws "SVB") >>. term_ws |>> fun t -> Show_Variable_Beliefs(t)
 let show_node = (str_ws "SHOW_NODE" <|> str_ws "SN") >>. term_ws |>> fun t -> Show_Node(t)
 
+
 let node_count = (str_ws "NODE_COUNT" <|> str_ws "NC") |>> fun _ -> Node_Count
 let enable_trace = (str_ws "ENABLE_TRACE" <|> str_ws "ET") >>. term_ws |>> fun t -> Enable_Trace(t)
 let disable_trace = (str_ws "DISABLE_TRACE" <|> str_ws "DT") >>. term_ws  |>> fun t -> Disable_Trace(t)
@@ -50,6 +52,7 @@ let reset = (str_ws "RESET" <|> str_ws "R") |>> fun _ -> Reset
 let pcmd = show_general_beliefs 
            <|> show_temporal_beliefs 
            <|> show_super_beliefs
+           <|> show_variable_beliefs
            <|> show_node 
            <|> node_count 
            <|> enable_trace 
diff --git a/ALANNStreams/Tests/Inference/FirstOrderInfernceTests.fs b/ALANNStreams/Tests/Inference/FirstOrderInfernceTests.fs
new file mode 100644
index 0000000..4a2e56c
--- /dev/null
+++ b/ALANNStreams/Tests/Inference/FirstOrderInfernceTests.fs
@@ -0,0 +1,633 @@
+ (*
+ * The MIT License
+ *
+ * Copyright 2018 The ALANN2018 authors.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *)
+
+module FirstOrderInferenceTests
+
+open System
+open Types
+open Parser
+open InferenceUtils
+open FirstOrderInference
+open HigherOrderInference
+open Expecto
+open TermFormatters
+open Factories
+open TruthFunctions
+open System.Threading
+
+let parseTerm str = 
+    match testp pterm str with
+    | Some x -> x
+    | None -> failwith "Parsing Term error"
+
+let parseEvent str = 
+    match testp pevent_ws str with
+    | Some x -> x
+    | None -> failwith "Parsing Term error"
+
+let makeTestEventBelief e b =
+    {Attention = 1.0f; Depth = SearchDepth.Deep; Answer = false; Event = e; Belief = makeBeliefFromEvent b}
+
+let testInfFunc (f : InferenceFunction) (e1 : Event) (e2 : Event) =
+    let matcher = function
+        | {Event.Term = t1; TV = Some tv1} -> (ft t1, Some tv1)
+        | {Event.Term = t1; TV = None} -> (ft t1, None)
+
+    List.map matcher (inf (f, NoSwap) (makeTestEventBelief e1 e2))
+
+//let testTemporalInfFunc t1 t2 =
+//    let matcher = function
+//        | {Event.Term = t1; TV = Some tv1} -> (ft t1, Some tv1)
+//        | {Event.Term = t1; TV = None} -> (ft t1, None)
+
+//    List.map matcher (temporalInf t1 t2)
+
+[<Tests>]
+let test1 =
+    testList "FirstOrderInference" [
+        testCase "FirstOrderSyllogistic: Ded" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <| "<a --> b>." + truth tv1
+            let t2 = parseEvent <| "<b --> c>." + truth tv2
+            let expected = [("<a --> c>", Some <| ded(tv1, tv2))
+                            ("<c --> a>", Some <| exe(tv1, tv2))]
+            Expect.equal (testInfFunc firstOrderSyllogisitic t1 t2) expected "FirstOrderSyllogistic: ded failed"
+
+        testCase "FirstOrderSyllogistic: Ded?" <| fun () ->   
+            let t1 = parseEvent <| "<a --> b>?"
+            let t2 = parseEvent <| "<b --> c>."
+            let expected = [("<a --> c>", None)
+                            ("<c --> a>", None)]
+            Expect.equal (testInfFunc firstOrderSyllogisitic t1 t2) expected "FirstOrderSyllogistic: ded? failed"
+
+        testCase "FirstOrderSyllogistic: abd" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<a --> b>." + truth tv1
+            let t2 = parseEvent <|  "<a --> c>." + truth tv1
+            let expected = [("<c --> b>", Some <| abd(tv1, tv2))]
+            Expect.equal (testInfFunc firstOrderSyllogisitic t1 t2) expected "FirstOrderSyllogistic: abd failed"
+
+        testCase "FirstOrderSyllogistic: abd?" <| fun () ->   
+            let t1 = parseEvent <|  "<a --> b>?"
+            let t2 = parseEvent <|  "<a --> c>."
+            let expected = [("<c --> b>", None)]
+            Expect.equal (testInfFunc firstOrderSyllogisitic t1 t2) expected "FirstOrderSyllogistic: abd? failed"
+
+        testCase "FirstOrderSyllogistic: ind" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<a --> c>." + truth tv1
+            let t2 = parseEvent <|  "<b --> c>." + truth tv1
+            let expected = [("<b --> a>", Some <| ind(tv1, tv2))]
+            Expect.equal (testInfFunc firstOrderSyllogisitic t1 t2) expected "FirstOrderSyllogistic: ind failed"
+
+        testCase "Immediate: cnv" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<s --> p>." + truth tv1
+            let t2 = parseEvent <|  "<z --> z>." + truth tv1 
+            let expected = [("<p --> s>", Some <| cnv(tv1, tv2))]
+            Expect.equal (testInfFunc immediate t1 t2) expected "Immediate: cnv failed"
+      
+        testCase "similaritySyllogisitic: com1" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<p --> m>." + truth tv1
+            let t2 = parseEvent <|  "<s --> m>." + truth tv1
+            let expected = [("<s <-> p>", Some <| com(tv1, tv2))]
+            Expect.equal (testInfFunc similaritySyllogisitic t1 t2) expected "similaritySyllogisitic: com1 failed"
+
+        testCase "similaritySyllogisitic: com2" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<m --> p>." + truth tv1
+            let t2 = parseEvent <|  "<m --> s>." + truth tv1
+            let expected = [("<s <-> p>", Some <| com(tv1, tv2))]
+            Expect.equal (testInfFunc similaritySyllogisitic t1 t2) expected "similaritySyllogisitic: com2 failed"
+
+        testCase "similaritySyllogisitic: ana1" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<m --> p>." + truth tv1
+            let t2 = parseEvent <|  "<a_s <-> m>." + truth tv1
+            let expected = [("<a_s --> p>", Some <| ana(tv1, tv2))]
+            Expect.equal (testInfFunc similaritySyllogisitic t1 t2)  expected "similaritySyllogisitic: ana1 failed"
+
+        testCase "similaritySyllogisitic: ana2" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<p --> m>." + truth tv1
+            let t2 = parseEvent <|  "<a_s <-> m>." + truth tv1
+            let expected = [("<p --> a_s>", Some <| ana(tv1, tv2))]
+            Expect.equal (testInfFunc similaritySyllogisitic t1 t2)  expected "similaritySyllogisitic: ana2 failed"
+
+        testCase "similarityFromInheritance: int" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<s --> p>." + truth tv1
+            let t2 = parseEvent <|  "<p --> s>." + truth tv1
+            let expected = [("<s <-> p>", Some <| int(tv1, tv2))]
+            Expect.equal (testInfFunc similarityFromInheritance t1 t2)  expected "similarityFromInheritance: int failed"
+
+        testCase "setIntersectionComprehension: ExtInt" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<c --> {a b}>." + truth tv1
+            let t2 = parseEvent <|  "<c --> {b c}>." + truth tv1
+            let expected = [("<c --> {b}>", Some <| int(tv1, tv2))]
+            Expect.equal (testInfFunc setIntersectionComprehension t1 t2)  expected "setIntersectionComprehension: ExtInt failed"
+
+        testCase "setIntersectionComprehension: ExtInt2" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<{a b} --> c>." + truth tv1
+            let t2 = parseEvent <|  "<{b c} --> c>." + truth tv1
+            let expected = [("<{b} --> c>", Some <| uni(tv1, tv2))]
+            Expect.equal (testInfFunc setIntersectionComprehension t1 t2)  expected "setIntersectionComprehension: ExtInt2 failed"
+
+        testCase "setIntersectionComprehension: IntInt" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<c --> [a b]>." + truth tv1
+            let t2 = parseEvent <|  "<c --> [b c]>." + truth tv1 
+            let expected = [("<c --> [b]>", Some <| uni(tv1, tv2))]
+            Expect.equal (testInfFunc setIntersectionComprehension t1 t2)  expected "setIntersectionComprehension: IntInt failed"
+
+        testCase "setIntersectionComprehension: IntInt2" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<[a b] --> c>." + truth tv1 
+            let t2 = parseEvent <|  "<[b c] --> c>." + truth tv1 
+            let expected = [("<[b] --> c>", Some <| int(tv1, tv2))]
+            Expect.equal (testInfFunc setIntersectionComprehension t1 t2)  expected "setIntersectionComprehension: IntInt2 failed"
+
+        testCase "setUnionComprehension: ExtUni" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<c --> {a b}>." + truth tv1 
+            let t2 = parseEvent <|  "<c --> {b c}>." + truth tv1 
+            let expected = [("<c --> {a b c}>", Some <| uni(tv1, tv2))]
+            Expect.equal (testInfFunc setUnionComprehension t1 t2)  expected "setUnionComprehension: ExtUni failed"
+
+        testCase "setUnionComprehension: IntUni" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<c --> [a b]>." + truth tv1 
+            let t2 = parseEvent <|  "<c --> [b c]>." + truth tv1 
+            let expected = [("<c --> [a b c]>", Some <| int(tv1, tv2))]
+            Expect.equal (testInfFunc setUnionComprehension t1 t2)  expected "setUnionComprehension: IntUni failed"
+    
+        testCase "setUnionComprehension: ExtUni2" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<{a b} --> c>." + truth tv1 
+            let t2 = parseEvent <|  "<{b c} --> c>." + truth tv1 
+            let expected = [("<{a b c} --> c>", Some <| int(tv1, tv2))]
+            Expect.equal (testInfFunc setUnionComprehension t1 t2)  expected "setUnionComprehension: ExtUni2 failed"
+
+        testCase "setUnionComprehension: IntUni2" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<[a b] --> c>." + truth tv1 
+            let t2 = parseEvent <|  "<[b c] --> c>." + truth tv1 
+            let expected = [("<[a b c] --> c>", Some <| uni(tv1, tv2))]
+            Expect.equal (testInfFunc setUnionComprehension t1 t2)  expected "setUnionComprehension: IntUni2 failed"
+
+        testCase "setDifferenceComprehension: ExtDif" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<c --> {a b}>." + truth tv1 
+            let t2 = parseEvent <|  "<c --> {b c}>." + truth tv1 
+            let expected = [("<c --> {a}>", Some <| dif(tv1, tv2))]
+            Expect.equal (testInfFunc setDifferenceComprehension t1 t2)  expected "setDifferenceComprehension: ExtDif failed"
+
+        testCase "setDifferenceComprehension: IntDif" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<c --> [a b]>." + truth tv1 
+            let t2 = parseEvent <|  "<c --> [b c]>." + truth tv1 
+            let expected = [("<c --> [a]>", Some <| dif(tv1, tv2))]
+            Expect.equal (testInfFunc setDifferenceComprehension t1 t2)  expected "setDifferenceComprehension: IntDif failed"
+    
+        testCase "setDifferenceComprehension: ExtDif2" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<{a b} --> c>." + truth tv1 
+            let t2 = parseEvent <|  "<{b c} --> c>." + truth tv1 
+            let expected = [("<{a} --> c>", Some <| dif(tv1, tv2))]
+            Expect.equal (testInfFunc setDifferenceComprehension t1 t2)  expected "setDifferenceComprehension: ExtDif2 failed"
+
+        testCase "setDifferenceComprehension: IntDif2" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<[a b] --> c>." + truth tv1 
+            let t2 = parseEvent <|  "<[b c] --> c>." + truth tv1 
+            let expected = [("<[a] --> c>", Some <| dif(tv1, tv2))]
+            Expect.equal (testInfFunc setDifferenceComprehension t1 t2)  expected "setDifferenceComprehension: IntDif2 failed"
+
+        testCase "setDecomposition: pnn1" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<s --> m>." + truth tv1 
+            let t2 = parseEvent <|  "<(a | s) --> m>." + truth tv1 
+            let expected = [("<a --> m>", Some <| pnn(tv1, tv2))]
+            Expect.equal (testInfFunc setDecomposition t1 t2)  expected "setDecomposition: pnn1 failed"
+
+        testCase "setDecomposition: npp1" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<s --> m>." + truth tv1 
+            let t2 = parseEvent <|  "<(a & s) --> m>." + truth tv1 
+            let expected = [("<a --> m>", Some <| npp(tv1, tv2))]
+            Expect.equal (testInfFunc setDecomposition t1 t2)  expected "setDecomposition: npp1 failed"
+
+        testCase "setDecomposition: pnp1" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<s --> m>." + truth tv1 
+            let t2 = parseEvent <|  "<(s ~ p) --> m>." + truth tv1 
+            let expected = [("<p --> m>", Some <| pnp(tv1, tv2))]
+            Expect.equal (testInfFunc setDecomposition t1 t2)  expected "setDecomposition: pnp1 failed"
+
+        testCase "setDecomposition: nnn1" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<s --> m>." + truth tv1 
+            let t2 = parseEvent <|  "<(p ~ s) --> m>." + truth tv1 
+            let expected = [("<p --> m>", Some <| nnn(tv1, tv2))]
+            Expect.equal (testInfFunc setDecomposition t1 t2)  expected "setDecomposition: nnn1 failed"
+
+        testCase "setDecomposition: pnn2" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<m --> s>." + truth tv1 
+            let t2 = parseEvent <|  "<m --> (p & s)>." + truth tv1 
+            let expected = [("<m --> p>", Some <| pnn(tv1, tv2))]
+            Expect.equal (testInfFunc setDecomposition t1 t2)  expected "setDecomposition: pnn2 failed"
+
+        testCase "setDecomposition: npp2" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<m --> s>." + truth tv1 
+            let t2 = parseEvent <|  "<m --> (p | s)>." + truth tv1 
+            let expected = [("<m --> p>", Some <| npp(tv1, tv2))]
+            Expect.equal (testInfFunc setDecomposition t1 t2)  expected "setDecomposition: npp2 failed"
+
+        testCase "setDecomposition: pnp2" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<m --> s>." + truth tv1 
+            let t2 = parseEvent <|  "<m --> (s - p)>." + truth tv1 
+            let expected = [("<m --> p>", Some <| pnp(tv1, tv2))]
+            Expect.equal (testInfFunc setDecomposition t1 t2)  expected "setDecomposition: pnp2 failed"
+
+        testCase "setDecomposition: nnn2" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<m --> s>." + truth tv1 
+            let t2 = parseEvent <|  "<m --> (p - s)>." + truth tv1 
+            let expected = [("<m --> p>", Some <| nnn(tv1, tv2))]
+            Expect.equal (testInfFunc setDecomposition t1 t2)  expected "setDecomposition: nnn2 failed"
+
+        testCase "InheritanceSetComprehension: Int" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<p --> m>." + truth tv1 
+            let t2 = parseEvent <|  "<s --> m>." + truth tv1 
+            let expected = [("<(p | s) --> m>", Some <| int(tv1, tv2))
+                            ("<(p & s) --> m>", Some <| uni(tv1, tv2))
+                            ("<(p ~ s) --> m>", Some <| dif(tv1, tv2))]
+            Expect.equal (testInfFunc InheritanceSetComprehension t1 t2)  expected "InheritanceSetComprehension: Int failed"
+
+        testCase "InheritanceSetComprehension: Ext" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<m --> p>." + truth tv1 
+            let t2 = parseEvent <|  "<m --> s>." + truth tv1 
+            let expected = [("<m --> (p & s)>", Some <| int(tv1, tv2))
+                            ("<m --> (p | s)>", Some <| uni(tv1, tv2))
+                            ("<m --> (p - s)>", Some <| dif(tv1, tv2))]
+            Expect.equal (testInfFunc InheritanceSetComprehension t1 t2)  expected "InheritanceSetComprehension: Ext failed"
+
+        testCase "Nal1_3_EquivalenceAndImplication: 1a" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<s --> p>." + truth tv1 
+            let t2 = parseEvent <|  "<s <-> p>." + truth tv1 
+            let expected = [("<s --> p>", Some <| structuralInt(tv1, tv2))]
+            Expect.equal (testInfFunc Nal1_3_EquivalenceAndImplication t1 t2)  expected "Nal1_3_EquivalenceAndImplication: 1a failed"
+
+        testCase "Nal1_3_EquivalenceAndImplication: 1b" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<s <-> p>." + truth tv1 
+            let t2 = parseEvent <|  "<s --> p>." + truth tv1 
+            let expected = [("<s <-> p>", Some <| structuralInt(tv1, tv2))]
+            Expect.equal (testInfFunc Nal1_3_EquivalenceAndImplication t1 t2)  expected "Nal1_3_EquivalenceAndImplication: 1b failed"
+
+        testCase "Nal1_3_EquivalenceAndImplication: 1" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<s <-> {p}>." + truth tv1 
+            let t2 = parseEvent <|  "s ." + truth tv1 
+            let expected = [("<s --> {p}>", Some <| identity(tv1, tv2))]
+            Expect.equal (testInfFunc Nal1_3_EquivalenceAndImplication t1 t2)  expected "Nal1_3_EquivalenceAndImplication: 1 failed"
+
+        testCase "Nal1_3_EquivalenceAndImplication: 2" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<s <-> {p}>." + truth tv1 
+            let t2 = parseEvent <|  "{p}." + truth tv1 
+            let expected = [("<s --> {p}>", Some <| identity(tv1, tv2))]
+            Expect.equal (testInfFunc Nal1_3_EquivalenceAndImplication t1 t2)  expected "Nal1_3_EquivalenceAndImplication: 2 failed"
+
+        testCase "Nal1_3_EquivalenceAndImplication: 3" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<[s] <-> p>." + truth tv1 
+            let t2 = parseEvent <| "[s]." + truth tv1 
+            let expected = [("<[s] --> p>", Some <| identity(tv1, tv2))]
+            Expect.equal (testInfFunc Nal1_3_EquivalenceAndImplication t1 t2)  expected "Nal1_3_EquivalenceAndImplication: 3 failed"
+
+        testCase "Nal1_3_EquivalenceAndImplication: 4" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<[s] <-> p>." + truth tv1 
+            let t2 = parseEvent <|  "p . " + truth tv1 
+            let expected = [("<[s] --> p>", Some <| identity(tv1, tv2))]
+            Expect.equal (testInfFunc Nal1_3_EquivalenceAndImplication t1 t2)  expected "Nal1_3_EquivalenceAndImplication: 4 failed"
+
+        testCase "Nal1_3_EquivalenceAndImplication: 5" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<{s} <-> {p}>." + truth tv1 
+            let t2 = parseEvent <|  "{s} ." + truth tv1 
+            let expected = [("<{s} --> {p}>", Some <| identity(tv1, tv2))]
+            Expect.equal (testInfFunc Nal1_3_EquivalenceAndImplication t1 t2)  expected "Nal1_3_EquivalenceAndImplication: 5 failed"
+
+        testCase "Nal1_3_EquivalenceAndImplication: 6" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<{s} <-> {p}>." + truth tv1 
+            let t2 = parseEvent <|  "{p} ." + truth tv1 
+            let expected = [("<{s} --> {p}>", Some <| identity(tv1, tv2))]
+            Expect.equal (testInfFunc Nal1_3_EquivalenceAndImplication t1 t2)  expected "Nal1_3_EquivalenceAndImplication: 6 failed"
+
+        testCase "Nal1_3_EquivalenceAndImplication: 7" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<[s] <-> [p]>." + truth tv1 
+            let t2 = parseEvent <| "[s] ." + truth tv1 
+            let expected = [("<[s] --> [p]>", Some <| identity(tv1, tv2))]
+            Expect.equal (testInfFunc Nal1_3_EquivalenceAndImplication t1 t2)  expected "Nal1_3_EquivalenceAndImplication: 7 failed"
+
+        testCase "Nal1_3_EquivalenceAndImplication: 8" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<[s] <-> [p]>." + truth tv1 
+            let t2 = parseEvent <|  "[p] ." + truth tv1          
+            let expected = [("<[s] --> [p]>", Some <| identity(tv1, tv2))]
+            Expect.equal (testInfFunc Nal1_3_EquivalenceAndImplication t1 t2)  expected "Nal1_3_EquivalenceAndImplication: 8 failed"
+
+        testCase "setDefinitionUnwrap: 1" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<{s} <-> {p}>." + truth tv1 
+            let t2 = parseEvent <|  "{s}." + truth tv1          
+            let expected = [("<s <-> p>", Some <| identity(tv1, tv2))]
+            Expect.equal (testInfFunc setDefinitionUnwrap t1 t2)  expected "setDefinitionUnwrap: 1 failed"
+
+        testCase "setDefinitionUnwrap: 2" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<{s} <-> {p}>." + truth tv1 
+            let t2 = parseEvent <|  "{p}." + truth tv1          
+            let expected = [("<s <-> p>", Some <| identity(tv1, tv2))]
+            Expect.equal (testInfFunc setDefinitionUnwrap t1 t2)  expected "setDefinitionUnwrap: 2 failed"
+
+        testCase "setDefinitionUnwrap: 3" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<[s] <-> [p]>." + truth tv1 
+            let t2 = parseEvent <| "[s]. " + truth tv1          
+            let expected = [("<s <-> p>", Some <| identity(tv1, tv2))]
+            Expect.equal (testInfFunc setDefinitionUnwrap t1 t2)  expected "setDefinitionUnwrap: 3 failed"
+
+        testCase "setDefinitionUnwrap: 4" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<[s] <-> [p]>." + truth tv1 
+            let t2 = parseEvent <|  "[p]." + truth tv1          
+            let expected = [("<s <-> p>", Some <| identity(tv1, tv2))]
+            Expect.equal (testInfFunc setDefinitionUnwrap t1 t2)  expected "setDefinitionUnwrap: 4 failed"
+
+        testCase "setDefinitionUnwrap: 5" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<s --> {p}>." + truth tv1 
+            let t2 = parseEvent <|  "s ." + truth tv1          
+            let expected = [("<s <-> {p}>", Some <| identity(tv1, tv2))]
+            Expect.equal (testInfFunc setDefinitionUnwrap t1 t2)  expected "setDefinitionUnwrap: 5 failed"
+
+        testCase "setDefinitionUnwrap: 6" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<s --> {p}>." + truth tv1 
+            let t2 = parseEvent <|  "{p} ." + truth tv1          
+            let expected = [("<s <-> {p}>", Some <| identity(tv1, tv2))]
+            Expect.equal (testInfFunc setDefinitionUnwrap t1 t2)  expected "setDefinitionUnwrap: 6 failed"
+
+        testCase "setDefinitionUnwrap: 7" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<[s] --> p>." + truth tv1 
+            let t2 = parseEvent <| "[s] ." + truth tv1          
+            let expected = [("<[s] <-> p>", Some <| identity(tv1, tv2))]
+            Expect.equal (testInfFunc setDefinitionUnwrap t1 t2)  expected "setDefinitionUnwrap: 7 failed"
+
+        testCase "setDefinitionUnwrap: 8" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<[s] --> p>." + truth tv1 
+            let t2 = parseEvent <|  "p . " + truth tv1          
+            let expected = [("<[s] <-> p>", Some <| identity(tv1, tv2))]
+            Expect.equal (testInfFunc setDefinitionUnwrap t1 t2)  expected "setDefinitionUnwrap: 8 failed"
+
+        testCase "structuralInference: 1" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<(a * b) --> m>." + truth tv1 
+            let t2 = parseEvent <|  "<z --> z>." + truth tv1          
+            let expected = [("<a --> (m / _ b)>", Some <| identity(tv1, tv2))
+                            ("<b --> (m / a _)>", Some <| identity(tv1, tv2))]
+            Expect.equal (testInfFunc structuralInference t1 t2)  expected "structuralInference: 1 failed"
+
+        testCase "structuralInference: 2" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<m --> (a * b)>." + truth tv1 
+            let t2 = parseEvent <|  "<z --> z>." + truth tv1 
+            let expected = [("<(m \\ _ b) --> a>", Some <| identity(tv1, tv2))
+                            ("<(m \\ a _) --> b>", Some <| identity(tv1, tv2))]
+            Expect.equal (testInfFunc structuralInference t1 t2)  expected "structuralInference: 2 failed"
+
+        testCase "structuralInference: 3" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<ai --> (m / a _)>." + truth tv1
+            let t2 = parseEvent <|  "_ ." + truth tv1          
+            let expected = (("<(a * ai) --> m>", Some <| identity(tv1, tv2)))
+            Expect.contains (testInfFunc structuralInference t1 t2)  expected "structuralInference: 3 failed"
+
+        testCase "structuralInference: 4" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<ai --> (m / _ b)>." + truth tv1
+            let t2 = parseEvent <|  "_ ." + truth tv1          
+            let expected = (("<(ai * b) --> m>", Some <| identity(tv1, tv2)))
+            Expect.contains (testInfFunc structuralInference t1 t2)  expected "structuralInference: 4 failed"
+
+        testCase "structuralInference: 5" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<(m \ a _) --> ai>." + truth tv1
+            let t2 = parseEvent <|  "_ ." + truth tv1          
+            let expected = (("<m --> (a * ai)>", Some <| identity(tv1, tv2)))
+            Expect.contains (testInfFunc structuralInference t1 t2)  expected "structuralInference: 5 failed"
+
+        testCase "structuralInference: 6" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<(m \ _ b) --> ai>." + truth tv1
+            let t2 = parseEvent <|  "_ ." + truth tv1          
+            let expected = (("<m --> (ai * b)>", Some <| identity(tv1, tv2)))
+            Expect.contains (testInfFunc structuralInference t1 t2) expected "structuralInference: 6 failed"
+
+        testCase "structuralInference2: 1" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<a --> c>." + truth tv1
+            let t2 = parseEvent <|  "<a --> d>." + truth tv1         
+            let expected = [("<(a * a) --> (c * d)>", Some <| int(tv1, tv2))]
+            Expect.equal (testInfFunc structuralInference2 t1 t2)  expected "structuralInference2: 1 failed"
+
+        testCase "structuralInference2: 2" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<a --> c>." + truth tv1
+            let t2 = parseEvent <|  "<b --> c>." + truth tv1         
+            let expected = [("<(a * b) --> (c * c)>", Some <| int(tv1, tv2))]
+            Expect.equal (testInfFunc structuralInference2 t1 t2)  expected "structuralInference2: 2 failed"
+
+        testCase "structuralInference2: 3" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<{a} --> c>." + truth tv1
+            let t2 = parseEvent <|  "<a --> d>." + truth tv1         
+            let expected = [("<({a} * a) --> (c * d)>", Some <| int(tv1, tv2))]
+            Expect.equal (testInfFunc structuralInference2 t1 t2)  expected "structuralInference2: 3 failed"
+
+        testCase "structuralInference2: 4" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<a --> c>." + truth tv1
+            let t2 = parseEvent <|  "<{a} --> d>." + truth tv1         
+            let expected = [("<(a * {a}) --> (c * d)>", Some <| int(tv1, tv2))]
+            Expect.equal (testInfFunc structuralInference2 t1 t2)  expected "structuralInference2: 4 failed"
+
+        testCase "structuralInference2: 5" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<a --> [c]>." + truth tv1
+            let t2 = parseEvent <|  "<b --> c>." + truth tv1         
+            let expected = [("<(a * b) --> ([c] * c)>", Some <| int(tv1, tv2))]
+            Expect.equal (testInfFunc structuralInference2 t1 t2)  expected "structuralInference2: 5 failed"
+
+        testCase "structuralInference2: 6" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<a --> c>." + truth tv1
+            let t2 = parseEvent <|  "<b --> [c]>." + truth tv1         
+            let expected = [("<(a * b) --> (c * [c])>", Some <| int(tv1, tv2))]
+            Expect.equal (testInfFunc structuralInference2 t1 t2)  expected "structuralInference2: 6 failed"
+
+        testCase "backwardDrivenForwardInference: 1" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<(b * p) --> z>?" + truth tv1
+            let t2 = parseEvent <|  "<b --> a>." + truth tv1         
+            let expected = [("<(b * p) --> (a * p)>", Some <| beliefStructuralDed(tv1, tv2))]
+            Expect.equal (testInfFunc backwardDrivenForwardInference t1 t2)  expected "backwardDrivenForwardInference: 1 failed"
+
+        testCase "backwardDrivenForwardInference: 2" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<(p * b) --> z>?" + truth tv1
+            let t2 = parseEvent <|  "<b --> a>." + truth tv1         
+            let expected = [("<(p * b) --> (p * a)>", Some <| beliefStructuralDed(tv1, tv2))]
+            Expect.equal (testInfFunc backwardDrivenForwardInference t1 t2)  expected "backwardDrivenForwardInference: 2 failed"
+
+        testCase "backwardDrivenForwardInference: 3" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<(b * p) <-> z>?" + truth tv1
+            let t2 = parseEvent <|  "<b <-> a>." + truth tv1         
+            let expected = [("<(b * p) <-> (a * p)>", Some <| beliefStructuralDed(tv1, tv2))]
+            Expect.equal (testInfFunc backwardDrivenForwardInference t1 t2)  expected "backwardDrivenForwardInference: 3 failed"
+
+        testCase "backwardDrivenForwardInference: 4" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<(p * b) <-> z>?" + truth tv1
+            let t2 = parseEvent <|  "<b <-> a>." + truth tv1         
+            let expected = [("<(p * b) <-> (p * a)>", Some <| beliefStructuralDed(tv1, tv2))]
+            Expect.equal (testInfFunc backwardDrivenForwardInference t1 t2)  expected "backwardDrivenForwardInference: 4 failed"
+
+        testCase "backwardDrivenForwardInference: 5" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<(n \ a _) --> z>?" + truth tv1
+            let t2 = parseEvent <|  "<n --> r>." + truth tv1         
+            let expected = [("<(n \\ a _) --> (r \\ a _)>", Some <| beliefStructuralDed(tv1, tv2))]
+            Expect.equal (testInfFunc backwardDrivenForwardInference t1 t2)  expected "backwardDrivenForwardInference: 5 failed"
+
+        testCase "backwardDrivenForwardInference: 6" <| fun () ->   
+            let tv1 = {F = 1.0f; C = 0.9f}
+            let tv2 = {F = 1.0f; C = 0.9f}
+            let t1 = parseEvent <|  "<(n / _ b) --> z>?" + truth tv1
+            let t2 = parseEvent <|  "<s --> b>." + truth tv1         
+            let expected = [("<(n / _ b) --> (n / _ s)>", Some <| beliefStructuralDed(tv1, tv2))]
+            Expect.equal (testInfFunc backwardDrivenForwardInference t1 t2)  expected "backwardDrivenForwardInference: 6 failed"
+
+        testCase "backwardOnlyInference: 6" <| fun () ->   
+            let tv1 = {F = 0.0f; C = 0.0f}
+            let t1 = parseEvent <|  "<a --> s>?"
+            let t2 = parseEvent <|  "<b --> s>." + truth tv1         
+            let expected = [("<a --> b>", None)
+                            ("<b --> a>", None)
+                            ("<a <-> b>", None)]
+            Expect.equal (testInfFunc backwardOnlyInference t1 t2)  expected "backwardOnlyInference: 6 failed"
+]
diff --git a/ALANNStreams/Tests/Inference/HigherOrderInferenceTests.fs b/ALANNStreams/Tests/Inference/HigherOrderInferenceTests.fs
new file mode 100644
index 0000000..00dbe8b
--- /dev/null
+++ b/ALANNStreams/Tests/Inference/HigherOrderInferenceTests.fs
@@ -0,0 +1,1267 @@
+ (*
+ * The MIT License
+ *
+ * Copyright 2018 The ALANN2018 authors.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *)
+
+module InferenceTests
+
+//open Types
+//open Parser
+//open InferenceUtils
+//open FirstOrderInference
+//open HigherOrderInference
+//open Expecto
+//open TermFormatters
+//open Factories
+//open TruthFunctions
+//open System.Threading
+
+//let parseTerm str = 
+//    match testp pterm str with
+//    | Some x -> x
+//    | None -> failwith "Parsing Term error"
+
+//let parseEvent str = 
+//    match testp pevent str with
+//    | Some x -> x
+//    | None -> failwith "Parsing Term error"
+
+//let makeTestEventBelief e b =
+//    {Attention = 1.0f; Depth = SearchDepth.Deep; Answer = false; Event = e; Belief = makeBeliefFromEvent b}
+
+//let testInfFunc (f : InferenceFunction) (e1 : Event) (e2 : Event) =
+//    let matcher = function
+//        | {Event.Term = t1; TV = Some tv1} -> (ft t1, Some tv1)
+//        | {Event.Term = t1; TV = None} -> (ft t1, None)
+
+//    List.map matcher (inf (f, NoSwap) (makeTestEventBelief e1 e2))
+
+////let testTemporalInfFunc t1 t2 =
+////    let matcher = function
+////        | {Event.Term = t1; TV = Some tv1} -> (ft t1, Some tv1)
+////        | {Event.Term = t1; TV = None} -> (ft t1, None)
+
+////    List.map matcher (temporalInf t1 t2)
+
+//let TemporalDistance = int32(Params.CONCURRENCY_DURATION + 10L)
+
+//[<Tests>]
+//let test1 =
+//    testList "Inference" [
+//        testCase "Nal1_5_conversion_contrapostion_negation: conversion1" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<p --> s>." + truth tv1
+//            let t2 = parseEvent <|  "<s --> p>." + truth tv1         
+//            let expected = [("<p --> s>", Some <| cnv(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal1_4_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: conversion1 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: conversion2" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<p ==> s>." + truth tv1
+//            let t2 = parseEvent <|  "<s ==> p>." + truth tv1         
+//            let expected = [("<p ==> s>", Some <| cnv(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: conversion2 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: conversion3" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<p =|> s>." + truth tv1
+//            let t2 = parseEvent <|  "<s =|> p>." + truth tv1         
+//            let expected = [("<p =|> s>", Some <| cnv(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: conversion3 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: conversion4" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<p =-> s>." + truth tv1
+//            let t2 = parseEvent <|  "<s =+> p>." + truth tv1         
+//            let expected = [("<p =-> s>", Some <| cnv(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: conversion4 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: conversion5" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<p =+> s>." + truth tv1
+//            let t2 = parseEvent <|  "<s =-> p>." + truth tv1         
+//            let expected = [("<p =+> s>", Some <| cnv(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: conversion5 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: contrapostion1" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<--s ==> p>." + truth tv1
+//            let t2 = parseEvent <|  "p . " + truth tv1          
+//            let expected = [("<--p ==> s>", Some <| cnt(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: contrapostion1 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: contrapostion2" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<--s ==> p>." + truth tv1
+//            let t2 = parseEvent <|  "--s ." + truth tv1          
+//            let expected = [("<--p ==> s>", Some <| cnt(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: contrapostion2 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: contrapostion3" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<--s =|> p>." + truth tv1
+//            let t2 = parseEvent <|  "p . " + truth tv1          
+//            let expected = [("<--p =|> s>", Some <| cnt(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: contrapostion3 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: contrapostion4" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<--s =|> p>." + truth tv1
+//            let t2 = parseEvent <|  "--s ." + truth tv1          
+//            let expected = [("<--p =|> s>", Some <| cnt(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: contrapostion4 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: contrapostion5" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<--s =+> p>." + truth tv1
+//            let t2 = parseEvent <|  "p . " + truth tv1          
+//            let expected = [("<--p =-> s>", Some <| cnt(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: contrapostion5 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: contrapostion6" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<--s =+> p>." + truth tv1
+//            let t2 = parseEvent <|  "--s ." + truth tv1          
+//            let expected = [("<--p =-> s>", Some <| cnt(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: contrapostion6 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: contrapostion7" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<--s =-> p>." + truth tv1
+//            let t2 = parseEvent <|  "p . " + truth tv1          
+//            let expected = [("<--p =+> s>", Some <| cnt(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: contrapostion7 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: contrapostion8" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<--s =-> p>." + truth tv1
+//            let t2 = parseEvent <|  "--s ." + truth tv1           
+//            let expected = [("<--p =+> s>", Some <| cnt(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: contrapostion8 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: negation1" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<a --> b>." + truth tv1
+//            let t2 = parseEvent <|  "a ." + truth tv1       
+//            let expected = [("--<a --> b>", Some <| neg(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal1_4_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation1 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: negation2" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<a --> b>." + truth tv1
+//            let t2 = parseEvent <|  "b ." + truth tv1         
+//            let expected = [("--<a --> b>", Some <| neg(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal1_4_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation2 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: negation3" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "--<a --> b>." + truth tv1
+//            let t2 = parseEvent <|  "a ." + truth tv1        
+//            let expected = [("<a --> b>", Some <| neg(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation3 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: negation4" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "--<a --> b>." + truth tv1
+//            let t2 = parseEvent <|  "b ." + truth tv1         
+//            let expected = [("<a --> b>", Some <| neg(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation4 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: negation5" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<a <-> b>." + truth tv1
+//            let t2 = parseEvent <|  "a ." + truth tv1        
+//            let expected = [("--<a <-> b>", Some <| neg(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal1_4_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation5 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: negation6" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<a <-> b>." + truth tv1
+//            let t2 = parseEvent <|  "b ." + truth tv1        
+//            let expected = [("--<a <-> b>", Some <| neg(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal1_4_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation6 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: negation7" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "--<a <-> b>." + truth tv1
+//            let t2 = parseEvent <|  "a ." + truth tv1        
+//            let expected = [("<a <-> b>", Some <| neg(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation7 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: negation8" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "--<a <-> b>." + truth tv1
+//            let t2 = parseEvent <|  "b ." + truth tv1         
+//            let expected = [("<a <-> b>", Some <| neg(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation8 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: negation9" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<a ==> b>." + truth tv1
+//            let t2 = parseEvent <|  "a ." + truth tv1        
+//            let expected = [("--<a ==> b>", Some <| neg(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation9 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: negation10" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<a ==> b>." + truth tv1
+//            let t2 = parseEvent <|  "b ." + truth tv1         
+//            let expected = [("--<a ==> b>", Some <| neg(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation10 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: negation11" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "--<a ==> b>." + truth tv1
+//            let t2 = parseEvent <|  "a ." + truth tv1         
+//            let expected = [("<a ==> b>", Some <| neg(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation11 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: negation12" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "--<a ==> b>." + truth tv1
+//            let t2 = parseEvent <|  "b ." + truth tv1         
+//            let expected = [("<a ==> b>", Some <| neg(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation12 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: negation13" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<a <=> b>." + truth tv1
+//            let t2 = parseEvent <|  "a ." + truth tv1          
+//            let expected = [("--<a <=> b>", Some <| neg(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation13 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: negation14" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<a <=> b>." + truth tv1
+//            let t2 = parseEvent <|  "b ." + truth tv1          
+//            let expected = [("--<a <=> b>", Some <| neg(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation14 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: negation15" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "--<a <=> b>." + truth tv1
+//            let t2 = parseEvent <|  "a ." + truth tv1    
+//            let expected = [("<a <=> b>", Some <| neg(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation15 failed"
+
+//        testCase "Nal1_5_conversion_contrapostion_negation: negation16" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "--<a <=> b>." + truth tv1
+//            let t2 = parseEvent <|  "b . " + truth tv1
+//            let expected = [("<a <=> b>", Some <| neg(tv1, tv2))]
+//            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation16 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Imp: 1" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m ==> p>." + truth tv1
+//            let t2 = parseEvent <|  "<s ==> m>." + truth tv1
+//            let expected = [("<s ==> p>", Some <| ded(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 1 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Imp: 2" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m =|> p>." + truth tv1
+//            let t2 = parseEvent <|  "<s =|> m>." + truth tv1
+//            let expected = [("<s =|> p>", Some <| ded(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 2 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Imp: 3" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t2 = parseEvent <|  "<s =-> m>." + truth tv1
+//            Thread.Sleep(TemporalDistance)
+//            let t1 = parseEvent <|  "<m =-> p>." + truth tv1
+//            let expected = [("<s =-> p>", Some <| ded(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 3 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Imp: 4" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m =+> p>." + truth tv1
+//            Thread.Sleep(TemporalDistance)
+//            let t2 = parseEvent <|  "<s =+> m>." + truth tv1
+//            let expected = [("<s =+> p>", Some <| ded(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 4 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Imp: 5" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<p ==> m>." + truth tv1
+//            let t2 = parseEvent <|  "<s ==> m>." + truth tv1
+//            let expected = [("<s ==> p>", Some <| ind(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 5 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Imp: 6" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<p =|> m>." + truth tv1
+//            let t2 = parseEvent <|  "<s =|> m>." + truth tv1
+//            let expected = [("<s =|> p>", Some <| ind(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 6 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Imp: 7" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<p =+> m>." + truth tv1
+//            Thread.Sleep(TemporalDistance)
+//            let t2 = parseEvent <|  "<s =+> m>." + truth tv1
+//            let expected = [("<s =|> p>", Some <| ind(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 7 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Imp: 8" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t2 = parseEvent <|  "<s =-> m>." + truth tv1
+//            Thread.Sleep(TemporalDistance)
+//            let t1 = parseEvent <|  "<p =-> m>." + truth tv1
+//            let expected = [("<s =|> p>", Some <| ind(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 8 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Imp: 9" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m ==> p>." + truth tv1
+//            let t2 = parseEvent <|  "<m ==> s>." + truth tv1
+//            let expected = [("<s ==> p>", Some <| abd(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 9 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Imp: 10" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m =+> p>." + truth tv1
+//            Thread.Sleep(TemporalDistance)
+//            let t2 = parseEvent <|  "<m =+> s>." + truth tv1
+//            let expected = [("<s =|> p>", Some <| abd(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 10 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Imp: 11" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m =|> p>." + truth tv1
+//            let t2 = parseEvent <|  "<m =|> s>." + truth tv1
+//            let expected = [("<s =|> p>", Some <| abd(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 11 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Imp: 12" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t2 = parseEvent <|  "<m =-> s>." + truth tv1
+//            Thread.Sleep(TemporalDistance)
+//            let t1 = parseEvent <|  "<m =-> p>." + truth tv1
+//            let expected = [("<s =|> p>", Some <| abd(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 12 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Imp: 13" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<p ==> m>." + truth tv1
+//            let t2 = parseEvent <|  "<m ==> s>." + truth tv1
+//            let expected = [("<s ==> p>", Some <| exe(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 13 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Imp: 14" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<p =+> m>." + truth tv1
+//            Thread.Sleep(TemporalDistance)
+//            let t2 = parseEvent <|  "<m =+> s>." + truth tv1
+//            let expected = [("<s =-> p>", Some <| exe(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 14 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Imp: 15" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t2 = parseEvent <|  "<m =-> s>." + truth tv1
+//            Thread.Sleep(TemporalDistance)
+//            let t1 = parseEvent <|  "<p =-> m>." + truth tv1
+//            let expected = [("<s =+> p>", Some <| exe(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 15 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Imp: 16" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<p =|> m>." + truth tv1
+//            let t2 = parseEvent <|  "<m =|> s>." + truth tv1
+//            let expected = [("<s =|> p>", Some <| exe(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 16 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Equ1: 1" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<s ==> p>." + truth tv1
+//            let t2 = parseEvent <|  "<p ==> s>." + truth tv1
+//            let expected = [("<s <=> p>", Some <| int(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ1 t1 t2)  expected "nal_5_implication_based_syllogism_Equ1: 1 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Equ1: 2" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<s =|> p>." + truth tv1
+//            let t2 = parseEvent <|  "<p =|> s>." + truth tv1
+//            let expected = [("<s <|> p>", Some <| int(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ1 t1 t2)  expected "nal_5_implication_based_syllogism_Equ1: 2 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Equ1: 3" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<s =+> p>." + truth tv1
+//            Thread.Sleep(TemporalDistance)
+//            let t2 = parseEvent <|  "<p =-> s>." + truth tv1
+//            let expected = [("<s <+> p>", Some <| int(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ1 t1 t2)  expected "nal_5_implication_based_syllogism_Equ1: 3 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Equ1: 4" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<s =-> p>." + truth tv1
+//            let t2 = parseEvent <|  "<p =+> s>." + truth tv1
+//            let expected = [("<p <+> s>", Some <| int(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ1 t1 t2)  expected "nal_5_implication_based_syllogism_Equ1: 4 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Equ1: 5" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<p ==> m>." + truth tv1
+//            let t2 = parseEvent <|  "<s ==> m>." + truth tv1
+//            let expected = [("<s <=> p>", Some <| ind(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ1 t1 t2)  expected "nal_5_implication_based_syllogism_Equ1: 5 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Equ1: 6" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<p =+> m>." + truth tv1
+//            Thread.Sleep(TemporalDistance)
+//            let t2 = parseEvent <|  "<s =+> m>." + truth tv1
+//            let expected = [("<s <|> p>", Some <| ind(tv1, tv2))
+//                            ("<s <+> p>", Some <| ind(tv1, tv2))
+//                            ("<p <+> s>", Some <| ind(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ1 t1 t2)  expected "nal_5_implication_based_syllogism_Equ1: 6 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Equ1: 7" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<p =|> m>." + truth tv1
+//            let t2 = parseEvent <|  "<s =|> m>." + truth tv1
+//            let expected = [("<s <|> p>", Some <| ind(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ1 t1 t2)  expected "nal_5_implication_based_syllogism_Equ1: 7 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Equ1: 8" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t2 = parseEvent <|  "<s =-> m>." + truth tv1
+//            Thread.Sleep(TemporalDistance)
+//            let t1 = parseEvent <|  "<p =-> m>." + truth tv1
+//            let expected = [("<s <|> p>", Some <| com(tv1, tv2))
+//                            ("<s <+> p>", Some <| com(tv1, tv2))
+//                            ("<p <+> s>", Some <| com(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ1 t1 t2)  expected "nal_5_implication_based_syllogism_Equ1: 8 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Equ1: 9" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m ==> p>." + truth tv1
+//            let t2 = parseEvent <|  "<m ==> s>." + truth tv1
+//            let expected = [("<s <=> p>", Some <| com(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ1 t1 t2)  expected "nal_5_implication_based_syllogism_Equ1: 9 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Equ1: 10" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m =+> p>." + truth tv1
+//            Thread.Sleep(TemporalDistance)
+//            let t2 = parseEvent <|  "<m =+> s>." + truth tv1
+//            let expected = [("<s <|> p>", Some <| com(tv1, tv2))
+//                            ("<s <+> p>", Some <| com(tv1, tv2))
+//                            ("<p <+> s>", Some <| com(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ1 t1 t2)  expected "nal_5_implication_based_syllogism_Equ1: 10 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Equ1: 11" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m =|> p>." + truth tv1
+//            let t2 = parseEvent <|  "<m =|> s>." + truth tv1
+//            let expected = [("<s <|> p>", Some <| com(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ1 t1 t2)  expected "nal_5_implication_based_syllogism_Equ1: 11 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Equ2: 1" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m ==> p>." + truth tv1
+//            let t2 = parseEvent <|  "<s <=> m>." + truth tv1
+//            let expected = [("<s ==> p>", Some <| ana(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ2 t1 t2)  expected "nal_5_implication_based_syllogism_Equ2: 1 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Equ2: 2" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m =+> p>." + truth tv1
+//            Thread.Sleep(TemporalDistance)
+//            let t2 = parseEvent <|  "<s <+> m>." + truth tv1
+//            let expected = [("<s =+> p>", Some <| ana(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ2 t1 t2)  expected "nal_5_implication_based_syllogism_Equ2: 2 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Equ2: 3" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m =+> p>." + truth tv1
+//            let t2 = parseEvent <|  "<s <|> m>." + truth tv1
+//            let expected = [("<s =+> p>", Some <| ana(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ2 t1 t2)  expected "nal_5_implication_based_syllogism_Equ2: 3 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Equ2: 4" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m =|> p>." + truth tv1
+//            let t2 = parseEvent <|  "<s <|> m>." + truth tv1
+//            let expected = [("<s =|> p>", Some <| ana(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ2 t1 t2)  expected "nal_5_implication_based_syllogism_Equ2: 4 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Equ2: 5" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m =-> p>." + truth tv1
+//            let t2 = parseEvent <|  "<s <+> m>." + truth tv1
+//            let expected = [("<s =-> p>", Some <| ana(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ2 t1 t2)  expected "nal_5_implication_based_syllogism_Equ2: 5 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Equ2: 6" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m =-> p>." + truth tv1
+//            let t2 = parseEvent <|  "<s <|> m>." + truth tv1
+//            let expected = [("<s =-> p>", Some <| ana(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ2 t1 t2)  expected "nal_5_implication_based_syllogism_Equ2: 6 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Equ2: 7" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<p ==> m>." + truth tv1
+//            let t2 = parseEvent <|  "<s <=> m>." + truth tv1
+//            let expected = [("<s ==> p>", Some <| ana(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ2 t1 t2)  expected "nal_5_implication_based_syllogism_Equ2: 7 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Equ2: 8" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<p =+> m>." + truth tv1
+//            let t2 = parseEvent <|  "<s <|> m>." + truth tv1
+//            let expected = [("<p =-> s>", Some <| ana(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ2 t1 t2)  expected "nal_5_implication_based_syllogism_Equ2: 8 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Equ2: 9" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<p =|> m>." + truth tv1
+//            let t2 = parseEvent <|  "<s <|> m>." + truth tv1
+//            let expected = [("<p =|> s>", Some <| ana(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ2 t1 t2)  expected "nal_5_implication_based_syllogism_Equ2: 9 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Equ2: 10" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<p =-> m>." + truth tv1
+//            let t2 = parseEvent <|  "<s <+> m>." + truth tv1
+//            let expected = [("<p =-> s>", Some <| ana(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ2 t1 t2)  expected "nal_5_implication_based_syllogism_Equ2: 10 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Equ2: 11" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<p =-> m>." + truth tv1
+//            let t2 = parseEvent <|  "<s <|> m>." + truth tv1
+//            let expected = [("<p =-> s>", Some <| ana(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ2 t1 t2)  expected "nal_5_implication_based_syllogism_Equ2: 11 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Equ2: 12" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m <+> p>." + truth tv1
+//            let t2 = parseEvent <|  "<s <|> m>." + truth tv1
+//            let expected = [("<s <+> p>", Some <| res(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ2 t1 t2)  expected "nal_5_implication_based_syllogism_Equ2: 12 failed"
+
+//        testCase "nal_5_implication_based_syllogism_Equ2: 13" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m <|> p>." + truth tv1
+//            let t2 = parseEvent <|  "<s <+> m>." + truth tv1
+//            let expected = [("<s <+> p>", Some <| res(tv1, tv2))]
+//            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ2 t1 t2)  expected "nal_5_implication_based_syllogism_Equ2: 13 failed"
+
+//        testCase "nal5_implication_based_composition: 1" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<p ==> m>." + truth tv1
+//            let t2 = parseEvent <|  "<s ==> m>." + truth tv1
+//            let expected = [("<(p || s) ==> m>", Some <| int(tv1, tv2))
+//                            ("<(p && s) ==> m>", Some <| uni(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_implication_based_composition t1 t2)  expected "nal5_implication_based_composition: 1 failed"
+
+//        testCase "nal5_implication_based_composition: 2" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<p =|> m>." + truth tv1
+//            let t2 = parseEvent <|  "<s =|> m>." + truth tv1
+//            let expected = [("<(p || s) =|> m>", Some <| int(tv1, tv2))
+//                            ("<(p ; s) =|> m>", Some <| uni(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_implication_based_composition t1 t2)  expected "nal5_implication_based_composition: 2 failed"
+
+//        testCase "nal5_implication_based_composition: 3" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<p =+> m>." + truth tv1
+//            Thread.Sleep(TemporalDistance)
+//            let t2 = parseEvent <|  "<s =+> m>." + truth tv1
+//            let expected = [("<(p || s) =+> m>", Some <| int(tv1, tv2))
+//                            ("<(p ; s) =+> m>", Some <| uni(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_implication_based_composition t1 t2)  expected "nal5_implication_based_composition: 3 failed"
+
+//        testCase "nal5_implication_based_composition: 4" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t2 = parseEvent <|  "<s =-> m>." + truth tv1
+//            Thread.Sleep(TemporalDistance)
+//            let t1 = parseEvent <|  "<p =-> m>." + truth tv1
+//            let expected = [("<(p || s) =-> m>", Some <| int(tv1, tv2))
+//                            ("<(p ; s) =-> m>", Some <| uni(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_implication_based_composition t1 t2)  expected "nal5_implication_based_composition: 4 failed"
+
+//        testCase "nal5_implication_based_composition: 5" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m ==> p>." + truth tv1
+//            let t2 = parseEvent <|  "<m ==> s>." + truth tv1
+//            let expected = [("<m ==> (p && s)>", Some <| int(tv1, tv2))
+//                            ("<m ==> (p || s)>", Some <| uni(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_implication_based_composition t1 t2)  expected "nal5_implication_based_composition: 5 failed"
+
+//        testCase "nal5_implication_based_composition: 6" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m =+> p>." + truth tv1
+//            Thread.Sleep(TemporalDistance)
+//            let t2 = parseEvent <|  "<m =+> s>." + truth tv1
+//            let expected = [("<m =+> (p ; s)>", Some <| int(tv1, tv2))
+//                            ("<m =+> (p || s)>", Some <| uni(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_implication_based_composition t1 t2)  expected "nal5_implication_based_composition: 6 failed"
+
+//        testCase "nal5_implication_based_composition: 7" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m =|> p>." + truth tv1
+//            let t2 = parseEvent <|  "<m =|> s>." + truth tv1
+//            let expected = [("<m =|> (p ; s)>", Some <| int(tv1, tv2))
+//                            ("<m =|> (p || s)>", Some <| uni(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_implication_based_composition t1 t2)  expected "nal5_implication_based_composition: 7 failed"
+
+//        testCase "nal5_implication_based_composition: 8" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t2 = parseEvent <|  "<m =-> s>." + truth tv1
+//            Thread.Sleep(TemporalDistance)
+//            let t1 = parseEvent <|  "<m =-> p>." + truth tv1
+//            let expected = [("<m =-> (p ; s)>", Some <| int(tv1, tv2))
+//                            ("<m =-> (p || s)>", Some <| uni(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_implication_based_composition t1 t2)  expected "nal5_implication_based_composition: 8 failed"
+
+//        testCase "nal5_implication_based_composition: 9" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<d =+> r>." + truth tv1
+//            let t2 = parseEvent <|  "<d =-> k>." + truth tv1
+//            let expected = [("<k =+> r>", Some <| abd(tv1, tv2))
+//                            ("<k =-> r>", Some <| ind(tv1, tv2))
+//                            ("<k <+> r>", Some <| com(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_implication_based_composition t1 t2)  expected "nal5_implication_based_composition: 9 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition1: 1" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<s ==> m>." + truth tv1
+//            let t2 = parseEvent <|  "<(s || (r || t)) ==> m>." + truth tv1
+//            let expected = [("<(r || t) ==> m>", Some <| pnn(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition1 t1 t2)  expected "nal5_nal8_implication_based_decomposition1: 1 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition1: 2" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<s =+> m>." + truth tv1
+//            let t2 = parseEvent <|  "<(s || (r || t)) ==> m>." + truth tv1
+//            let expected = [("<(r || t) =+> m>", Some <| pnn(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition1 t1 t2)  expected "nal5_nal8_implication_based_decomposition1: 2 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition1: 3" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<s =|> m>." + truth tv1
+//            let t2 = parseEvent <|  "<(s || (r || t)) ==> m>." + truth tv1
+//            let expected = [("<(r || t) =|> m>", Some <| pnn(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition1 t1 t2)  expected "nal5_nal8_implication_based_decomposition1: 3 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition1: 4" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<s =-> m>." + truth tv1
+//            let t2 = parseEvent <|  "<(s || (r || t)) ==> m>." + truth tv1
+//            let expected = [("<(r || t) =-> m>", Some <| pnn(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition1 t1 t2)  expected "nal5_nal8_implication_based_decomposition1: 4 failed"
+
+
+//        testCase "nal5_nal8_implication_based_decomposition2: 1" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<s ==> m>." + truth tv1
+//            let t2 = parseEvent <|  "<(s && (r && t)) ==> m>." + truth tv1
+//            let expected = [("<(r && t) ==> m>", Some <| npp(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition2 t1 t2)  expected "nal5_nal8_implication_based_decomposition2: 1 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition2: 2" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<s =+> m>." + truth tv1
+//            let t2 = parseEvent <|  "<(s && (r && t)) =+> m>." + truth tv1
+//            let expected = [("<(r && t) =+> m>", Some <| npp(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition2 t1 t2)  expected "nal5_nal8_implication_based_decomposition2: 2 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition2: 3" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<s =|> m>." + truth tv1
+//            let t2 = parseEvent <|  "<(s && (r && t)) =|> m>." + truth tv1
+//            let expected = [("<(r && t) =|> m>", Some <| npp(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition2 t1 t2)  expected "nal5_nal8_implication_based_decomposition2: 3 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition2: 4" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<s =-> m>." + truth tv1
+//            let t2 = parseEvent <|  "<(s && (r && t)) =-> m>." + truth tv1
+//            let expected = [("<(r && t) =-> m>", Some <| npp(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition2 t1 t2)  expected "nal5_nal8_implication_based_decomposition2: 4 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition3: 1" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m ==> s>." + truth tv1
+//            let t2 = parseEvent <|  "<m ==> (s && (r && t))>." + truth tv1
+//            let expected = [("<m ==> (r && t)>", Some <| pnn(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition3 t1 t2)  expected "nal5_nal8_implication_based_decomposition3: 1 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition3: 2" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m =+> s>." + truth tv1
+//            let t2 = parseEvent <|  "<m =+> (s && (r && t))>." + truth tv1
+//            let expected = [("<m =+> (r && t)>", Some <| pnn(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition3 t1 t2)  expected "nal5_nal8_implication_based_decomposition3: 2 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition3: 3" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m =|> s>." + truth tv1
+//            let t2 = parseEvent <|  "<m =|> (s && (r && t))>." + truth tv1
+//            let expected = [("<m =|> (r && t)>", Some <| pnn(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition3 t1 t2)  expected "nal5_nal8_implication_based_decomposition3: 3 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition3: 4" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m =-> s>." + truth tv1
+//            let t2 = parseEvent <|  "<m =-> (s && (r && t))>." + truth tv1
+//            let expected = [("<m =-> (r && t)>", Some <| pnn(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition3 t1 t2)  expected "nal5_nal8_implication_based_decomposition3: 4 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition4: 1" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m ==> s>." + truth tv1
+//            let t2 = parseEvent <|  "<m ==> (s || (r || t))>." + truth tv1
+//            let expected = [("<m ==> (r || t)>", Some <| npp(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition4 t1 t2)  expected "nal5_nal8_implication_based_decomposition4: 1 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition4: 2" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m =+> s>." + truth tv1
+//            let t2 = parseEvent <|  "<m =+> (s || (r || t))>." + truth tv1
+//            let expected = [("<m =+> (r || t)>", Some <| npp(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition4 t1 t2)  expected "nal5_nal8_implication_based_decomposition4: 2 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition4: 3" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m =|> s>." + truth tv1
+//            let t2 = parseEvent <|  "<m =|> (s || (r || t))>." + truth tv1
+//            let expected = [("<m =|> (r || t)>", Some <| npp(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition4 t1 t2)  expected "nal5_nal8_implication_based_decomposition4: 3 failed"
+
+           
+//        testCase "nal5_nal8_implication_based_decomposition5: 1" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "m ." + truth tv1
+//            let t2 = parseEvent <|  "<m ==> p>." + truth tv1
+//            let expected = [("p", Some <| ind(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 1 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition5: 2" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "m ." + truth tv1
+//            let t2 = parseEvent <|  "<m =+> p>." + truth tv1
+//            let expected = [("p", Some <| ind(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 2 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition5: 3" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "m ." + truth tv1
+//            let t2 = parseEvent <|  "<m =|> p>." + truth tv1
+//            let expected = [("p", Some <| ind(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 3 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition5: 4" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "m ." + truth tv1
+//            let t2 = parseEvent <|  "<m =-> p>." + truth tv1
+//            let expected = [("p", Some <| ind(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 4 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition5: 5" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "m ." + truth tv1
+//            let t2 = parseEvent <|  "<p ==> m>." + truth tv1
+//            let expected = [("p", Some <| ind(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 5 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition5: 6" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "m ." + truth tv1
+//            let t2 = parseEvent <|  "<p =+> m>." + truth tv1
+//            let expected = [("p", Some <| ind(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 6 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition5: 7" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "m ." + truth tv1
+//            let t2 = parseEvent <|  "<p =|> m>." + truth tv1
+//            let expected = [("p", Some <| ind(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 7 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition5: 8" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "m ." + truth tv1
+//            let t2 = parseEvent <|  "<p =-> m>." + truth tv1
+//            let expected = [("p", Some <| ind(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 8 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition5: 9" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "m ." + truth tv1
+//            let t2 = parseEvent <|  "<s <=> m>." + truth tv1
+//            let expected = [("s", Some <| ana(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 9 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition5: 10" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "m ." + truth tv1
+//            let t2 = parseEvent <|  "<s <|> m>." + truth tv1
+//            let expected = [("s", Some <| ana(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 10 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition5: 11" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "m ." + truth tv1
+//            let t2 = parseEvent <|  "<s <+> m>." + truth tv1
+//            let expected = [("s", Some <| ana(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 11 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition5: 12" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "m ." + truth tv1
+//            let t2 = parseEvent <|  "<m <=> s>." + truth tv1
+//            let expected = [("s", Some <| ana(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 12 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition5: 13" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "m ." + truth tv1
+//            let t2 = parseEvent <|  "<m <|> s>." + truth tv1
+//            let expected = [("s", Some <| ana(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 13 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition5: 14" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "m ." + truth tv1
+//            let t2 = parseEvent <|  "<m <+> s>." + truth tv1
+//            let expected = [("s", Some <| ana(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 14 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition6: 1" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "(s && t)." + truth tv1
+//            let t2 = parseEvent <|  "s ." + truth tv1
+//            let expected = [("t", Some <| ded(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition6 t1 t2)  expected "nal5_nal8_implication_based_decomposition6: 1 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition6: 2" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "(s , t)." + truth tv1
+//            let t2 = parseEvent <|  "s ." + truth tv1
+//            let expected = [("t", Some <| ded(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition6 t1 t2)  expected "nal5_nal8_implication_based_decomposition6: 2 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition6: 3" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "(s ; t)." + truth tv1
+//            let t2 = parseEvent <|  "s ." + truth tv1
+//            let expected = [("t", Some <| ded(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition6 t1 t2)  expected "nal5_nal8_implication_based_decomposition6: 3 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition7: 1" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "s ." + truth tv1
+//            let t2 = parseEvent <|  "(s , (r , t))." + truth tv1
+//            let expected = [("(r , t)", Some <| pnn(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition7 t1 t2)  expected "nal5_nal8_implication_based_decomposition7: 1 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition7: 2" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "s ." + truth tv1
+//            let t2 = parseEvent <|  "(s ; (r ; t))." + truth tv1
+//            let expected = [("(r ; t)", Some <| pnn(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition7 t1 t2)  expected "nal5_nal8_implication_based_decomposition7: 2 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition7: 3" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "s ." + truth tv1
+//            let t2 = parseEvent <|  "(s && (r && t))." + truth tv1
+//            let expected = [("(r && t)", Some <| pnn(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition7 t1 t2)  expected "nal5_nal8_implication_based_decomposition7: 3 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition7: 4" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "s ." + truth tv1
+//            let t2 = parseEvent <|  "(s || (r || t))." + truth tv1
+//            let expected = [("(r || t)", Some <| pnn(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition7 t1 t2)  expected "nal5_nal8_implication_based_decomposition7: 4 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition8: 1" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "s ." + truth tv1
+//            let t2 = parseEvent <|  "(--s , (r , t))." + truth tv1
+//            let expected = [("(r , t)", Some <| nnn(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition8 t1 t2)  expected "nal5_nal8_implication_based_decomposition8: 1 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition8: 2" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "s ." + truth tv1
+//            let t2 = parseEvent <|  "(--s ; (r ; t))." + truth tv2
+//            let expected = [("(r ; t)", Some <| nnn(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition8 t1 t2)  expected "nal5_nal8_implication_based_decomposition8: 2 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition8: 3" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "s ." + truth tv1
+//            let t2 = parseEvent <|  "(--s && (r && t))." + truth tv2
+//            let expected = [("(r && t)", Some <| nnn(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition8 t1 t2)  expected "nal5_nal8_implication_based_decomposition8: 3 failed"
+
+//        testCase "nal5_nal8_implication_based_decomposition8: 4" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "s ." + truth tv1
+//            let t2 = parseEvent <|  "(--s || (r || t))." + truth tv2
+//            let expected = [("(r || t)", Some <| nnn(tv1, tv2))]
+//            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition8 t1 t2)  expected "nal5_nal8_implication_based_decomposition8: 4 failed"
+
+//        testCase "nal6_variable_introduction: 1" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<s --> m>." + truth tv1
+//            let t2 = parseEvent <|  "<p --> m>." + truth tv2
+//            let expected = [("<<p --> $X> ==> <s --> $X>>", Some <| abd(tv1, tv2))
+//                            ("<<s --> $X> ==> <p --> $X>>", Some <| ind(tv1, tv2))
+//                            ("<<p --> $X> <=> <s --> $X>>", Some <| com(tv1, tv2))
+//                            ("(<p --> #Y> && <s --> #Y>)", Some <| int(tv1, tv2))
+
+//                            ("<<p --> $X> =|> <s --> $X>>", Some <| abd(tv1, tv2))
+//                            ("<<s --> $X> =|> <p --> $X>>", Some <| ind(tv1, tv2))
+//                            ("<<p --> $X> =|> <s --> $X>>", Some <| ind(tv1, tv2))
+//                            ("(<p --> #Y> ; <s --> #Y>)", Some <| int(tv1, tv2))]
+//            Expect.equal (testInfFunc nal6_variable_introduction t1 t2)  expected "nal6_variable_introduction: 1 failed"
+
+//        testCase "nal6_variable_introduction: 2" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<m --> s>." + truth tv1
+//            let t2 = parseEvent <|  "<m --> p>." + truth tv2
+//            let expected = [("<<$X --> s> ==> <$X --> p>>", Some <| ind(tv1, tv2))
+//                            ("<<$X --> p> ==> <$X --> s>>", Some <| abd(tv1, tv2))
+//                            ("<<$X --> s> <=> <$X --> p>>", Some <| com(tv1, tv2))
+//                            ("(<#Y --> s> && <#Y --> p>)", Some <| int(tv1, tv2))
+
+//                            ("<<$X --> s> =|> <$X --> p>>", Some <| ind(tv1, tv2))
+//                            ("<<$X --> p> =|> <$X --> s>>", Some <| abd(tv1, tv2))
+//                            ("<<$X --> s> =|> <$X --> p>>", Some <| ind(tv1, tv2))
+//                            ("<<$X --> s> <|> <$X --> p>>", Some <| com(tv1, tv2))
+//                            ("(<#Y --> s> ; <#Y --> p>)", Some <| int(tv1, tv2))]
+//            Expect.equal (testInfFunc nal6_variable_introduction t1 t2)  expected "nal6_variable_introduction: 2 failed"
+
+//        testCase "nal6_variable_syllogisms: 1" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<<a --> r> ==> z>." + truth tv1
+//            let t2 = parseEvent <|  "<(<#Y --> b> && <#Y --> r>) ==> z>." + truth tv2
+//            let expected = [("<a --> b>", Some <| abd(tv1, tv2))]
+//            Expect.equal (testInfFunc nal6_variable_syllogisms t1 t2)  expected "nal6_variable_syllogisms: 1 failed"
+
+//        testCase "nal6_variable_syllogisms: 1a" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<<a --> r> ==> z>." + truth tv1
+//            let t2 = parseEvent <|  "<(<#Y --> r> && <#Y --> b>) ==> z>." + truth tv2
+//            let expected = [("<a --> b>", Some <| abd(tv1, tv2))]
+//            Expect.equal (testInfFunc nal6_variable_syllogisms t1 t2)  expected "nal6_variable_syllogisms: 1a failed"
+
+//        testCase "nal6_variable_syllogisms: 2" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<u --> l>." + truth tv1
+//            let t2 = parseEvent <|  "<(<#Y --> l> && <#Y --> r>) ==> z>." + truth tv2
+//            let expected = [("<<u --> r> ==> z>", Some <| ded(tv1, tv2))]
+//            Expect.equal (testInfFunc nal6_variable_syllogisms t1 t2)  expected "nal6_variable_syllogisms: 2 failed"
+
+//        testCase "nal6_variable_syllogisms: 2a" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<u --> l>." + truth tv1
+//            let t2 = parseEvent <|  "<(<#Y --> r> && <#Y --> l>) ==> z>." + truth tv2
+//            let expected = [("<<u --> r> ==> z>", Some <| ded(tv1, tv2))]
+//            Expect.equal (testInfFunc nal6_variable_syllogisms t1 t2)  expected "nal6_variable_syllogisms: 2a failed"
+
+//        testCase "nal6_variable_elimination: 1" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
+//            let t2 = parseEvent <|  "(<($x * $y) --> larger> && <($y * $x) --> smaller>)." + truth tv2
+//            let expected = [("<(apple * earth) --> smaller>", Some <| anon_ana(tv1, tv2))]
+//            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 1 failed"
+
+//        testCase "nal6_variable_elimination: 2" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
+//            let t2 = parseEvent <|  "(<($x * $y) --> smaller> && <($y * $x) --> larger>)." + truth tv2
+//            let expected = [("<(apple * earth) --> smaller>", Some <| anon_ana(tv1, tv2))]
+//            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 2 failed"
+
+//        testCase "nal6_variable_elimination: 3" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "(<($x * $y) --> smaller> && <($y * $x) --> larger>)." + truth tv2
+//            let t2 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1            
+//            let expected = [("<(apple * earth) --> smaller>", Some <| ded(tv1, tv2))]
+//            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 3 failed"
+
+//        testCase "nal6_variable_elimination: 4" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "(<($x * $y) --> smaller> && <($y * $x) --> larger>)." + truth tv2
+//            let t2 = parseEvent <|  "<(earth * apple) --> smaller>." + truth tv1            
+//            let expected = [("<(apple * earth) --> larger>", Some <| ded(tv1, tv2))]
+//            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 4 failed"
+
+//        testCase "nal6_variable_elimination: 5" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
+//            let t2 = parseEvent <|  "<<($x * $y) --> larger> ==> <($y * $x) --> smaller>>." + truth tv2
+//            let expected = [("<(apple * earth) --> smaller>", Some <| ded(tv1, tv2))]
+//            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 1 failed"
+
+//        testCase "nal6_variable_elimination: 6" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
+//            let t2 = parseEvent <|  "<<($x * $y) --> larger> =+> <($y * $x) --> smaller>>." + truth tv2
+//            let expected = [("<(apple * earth) --> smaller>", Some <| ded(tv1, tv2))]
+//            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 2 failed"
+
+//        testCase "nal6_variable_elimination: 7" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
+//            let t2 = parseEvent <|  "<<($x * $y) --> larger> =|> <($y * $x) --> smaller>>." + truth tv2
+//            let expected = [("<(apple * earth) --> smaller>", Some <| ded(tv1, tv2))]
+//            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 7 failed"
+        
+//        testCase "nal6_variable_elimination: 8" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
+//            let t2 = parseEvent <|  "<<($x * $y) --> larger> =-> <($y * $x) --> smaller>>." + truth tv2
+//            let expected = [("<(apple * earth) --> smaller>", Some <| ded(tv1, tv2))]
+//            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 8 failed"
+
+//        testCase "nal6_variable_elimination: 9" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
+//            let t2 = parseEvent <|  "<<($x * $y) --> smaller> ==> <($y * $x) --> larger>>." + truth tv2
+//            let expected = [("<(apple * earth) --> smaller>", Some <| abd(tv1, tv2))]
+//            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 9 failed"
+
+//        testCase "nal6_variable_elimination: 10" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
+//            let t2 = parseEvent <|  "<<($x * $y) --> smaller> =+> <($y * $x) --> larger>>." + truth tv2
+//            let expected = [("<(apple * earth) --> smaller>", Some <| abd(tv1, tv2))]
+//            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 10 failed"
+
+//        testCase "nal6_variable_elimination: 11" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
+//            let t2 = parseEvent <|  "<<($x * $y) --> smaller> =|> <($y * $x) --> larger>>." + truth tv2
+//            let expected = [("<(apple * earth) --> smaller>", Some <| abd(tv1, tv2))]
+//            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 11 failed"
+
+//        testCase "nal6_variable_elimination: 12" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
+//            let t2 = parseEvent <|  "<<($x * $y) --> smaller> =-> <($y * $x) --> larger>>." + truth tv2
+//            let expected = [("<(apple * earth) --> smaller>", Some <| abd(tv1, tv2))]
+//            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 12 failed"
+
+//        testCase "nal6_variable_elimination: 13" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
+//            let t2 = parseEvent <|  "<<($x * $y) --> larger> <=> <($y * $x) --> smaller>>." + truth tv2
+//            let expected = [("<(apple * earth) --> smaller>", Some <| ana(tv1, tv2))]
+//            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 13 failed"
+        
+//        testCase "nal6_variable_elimination: 14" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
+//            let t2 = parseEvent <|  "<<($x * $y) --> larger> <|> <($y * $x) --> smaller>>." + truth tv2
+//            let expected = [("<(apple * earth) --> smaller>", Some <| ana(tv1, tv2))]
+//            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 14 failed"
+
+//        testCase "nal6_variable_elimination: 14a" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "(<rabbit --> animal> ; <PETER --> word>)." + truth tv1
+//            let t2 = parseEvent <|  "<($1 ; <$2 --> word>) <|> <(REPRESENT / $2 _) <-> $1>>." + truth tv2
+//            let expected = [("<(REPRESENT / PETER _) <-> <rabbit --> animal>>", Some <| ana(tv1, tv2))]
+//            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 14a failed"
+
+
+//        testCase "nal6_variable_elimination: 15" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
+//            let t2 = parseEvent <|  "<<($x * $y) --> larger> <+> <($y * $x) --> smaller>>." + truth tv2
+//            let expected = [("<(apple * earth) --> smaller>", Some <| ana(tv1, tv2))]
+//            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 15 failed"
+
+//        testCase "nal6_variable_elimination: 16" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
+//            let t2 = parseEvent <|  "<<($x * $y) --> smaller> <=> <($y * $x) --> larger>>." + truth tv2
+//            let expected = [("<(apple * earth) --> smaller>", Some <| ana(tv1, tv2))]
+//            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 16 failed"
+
+//        testCase "nal6_variable_elimination: 17" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
+//            let t2 = parseEvent <|  "<<($x * $y) --> smaller> <|> <($y * $x) --> larger>>." + truth tv2
+//            let expected = [("<(apple * earth) --> smaller>", Some <| ana(tv1, tv2))]
+//            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 17 failed"
+
+//        testCase "nal6_variable_elimination: 18" <| fun () ->   
+//            let tv1 = {F = 1.0f; C = 0.9f}
+//            let tv2 = {F = 1.0f; C = 0.9f}
+//            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
+//            let t2 = parseEvent <|  "<<($x * $y) --> smaller> <+> <($y * $x) --> larger>>." + truth tv2
+//            let expected = [("<(apple * earth) --> smaller>", Some <| ana(tv1, tv2))]
+//            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 18 failed"       
+//]
+
diff --git a/ALANNStreams/Tests/Inference/InferenceTests.fs b/ALANNStreams/Tests/Inference/InferenceTests.fs
deleted file mode 100644
index 5b8f2af..0000000
--- a/ALANNStreams/Tests/Inference/InferenceTests.fs
+++ /dev/null
@@ -1,1842 +0,0 @@
- (*
- * The MIT License
- *
- * Copyright 2018 The ALANN2018 authors.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- *)
-
-module InferenceTests
-
-open System
-open Types
-open Parser
-open InferenceUtils
-open FirstOrderInference
-open HigherOrderInference
-open Expecto
-open TermFormatters
-open Factories
-open TruthFunctions
-open System.Threading
-
-let parseTerm str = 
-    match testp pterm str with
-    | Some x -> x
-    | None -> failwith "Parsing Term error"
-
-let parseEvent str = 
-    match testp pevent str with
-    | Some x -> x
-    | None -> failwith "Parsing Term error"
-
-let makeTestEventBelief e b =
-    {Attention = 1.0f; Depth = SearchDepth.Deep; Answer = false; Event = e; Belief = makeBeliefFromEvent b}
-
-let testInfFunc (f : InferenceFunction) (e1 : Event) (e2 : Event) =
-    let matcher = function
-        | {Event.Term = t1; TV = Some tv1} -> (ft t1, Some tv1)
-        | {Event.Term = t1; TV = None} -> (ft t1, None)
-
-    List.map matcher (inf (f, NoSwap) (makeTestEventBelief e1 e2))
-
-//let testTemporalInfFunc t1 t2 =
-//    let matcher = function
-//        | {Event.Term = t1; TV = Some tv1} -> (ft t1, Some tv1)
-//        | {Event.Term = t1; TV = None} -> (ft t1, None)
-
-//    List.map matcher (temporalInf t1 t2)
-
-[<Tests>]
-let test1 =
-    testList "Inference" [
-        testCase "FirstOrderSyllogistic: Ded" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <| "<a --> b>." + truth tv1
-            let t2 = parseEvent <| "<b --> c>." + truth tv2
-            let expected = [("<a --> c>", Some <| ded(tv1, tv2))
-                            ("<c --> a>", Some <| exe(tv1, tv2))]
-            Expect.equal (testInfFunc firstOrderSyllogisitic t1 t2) expected "FirstOrderSyllogistic: ded failed"
-
-        testCase "FirstOrderSyllogistic: Ded?" <| fun () ->   
-            let t1 = parseEvent <| "<a --> b>?"
-            let t2 = parseEvent <| "<b --> c>."
-            let expected = [("<a --> c>", None)
-                            ("<c --> a>", None)]
-            Expect.equal (testInfFunc firstOrderSyllogisitic t1 t2) expected "FirstOrderSyllogistic: ded? failed"
-
-        testCase "FirstOrderSyllogistic: abd" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<a --> b>." + truth tv1
-            let t2 = parseEvent <|  "<a --> c>." + truth tv1
-            let expected = [("<c --> b>", Some <| abd(tv1, tv2))]
-            Expect.equal (testInfFunc firstOrderSyllogisitic t1 t2) expected "FirstOrderSyllogistic: abd failed"
-
-        testCase "FirstOrderSyllogistic: abd?" <| fun () ->   
-            let t1 = parseEvent <|  "<a --> b>?"
-            let t2 = parseEvent <|  "<a --> c>."
-            let expected = [("<c --> b>", None)]
-            Expect.equal (testInfFunc firstOrderSyllogisitic t1 t2) expected "FirstOrderSyllogistic: abd? failed"
-
-        testCase "FirstOrderSyllogistic: ind" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<a --> c>." + truth tv1
-            let t2 = parseEvent <|  "<b --> c>." + truth tv1
-            let expected = [("<b --> a>", Some <| ind(tv1, tv2))]
-            Expect.equal (testInfFunc firstOrderSyllogisitic t1 t2) expected "FirstOrderSyllogistic: ind failed"
-
-        testCase "Immediate: cnv" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<s --> p>." + truth tv1
-            let t2 = parseEvent <|  "<_ --> _>." + truth tv1 
-            let expected = [("<p --> s>", Some <| cnv(tv1, tv2))]
-            Expect.equal (testInfFunc immediate t1 t2) expected "Immediate: cnv failed"
-      
-        testCase "similaritySyllogisitic: com1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p --> m>." + truth tv1
-            let t2 = parseEvent <|  "<s --> m>." + truth tv1
-            let expected = [("<s <-> p>", Some <| com(tv1, tv2))]
-            Expect.equal (testInfFunc similaritySyllogisitic t1 t2) expected "similaritySyllogisitic: com1 failed"
-
-        testCase "similaritySyllogisitic: com2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m --> p>." + truth tv1
-            let t2 = parseEvent <|  "<m --> s>." + truth tv1
-            let expected = [("<s <-> p>", Some <| com(tv1, tv2))]
-            Expect.equal (testInfFunc similaritySyllogisitic t1 t2) expected "similaritySyllogisitic: com2 failed"
-
-        testCase "similaritySyllogisitic: ana1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m --> p>." + truth tv1
-            let t2 = parseEvent <|  "<a_s <-> m>." + truth tv1
-            let expected = [("<a_s --> p>", Some <| ana(tv1, tv2))]
-            Expect.equal (testInfFunc similaritySyllogisitic t1 t2)  expected "similaritySyllogisitic: ana1 failed"
-
-        testCase "similaritySyllogisitic: ana2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p --> m>." + truth tv1
-            let t2 = parseEvent <|  "<a_s <-> m>." + truth tv1
-            let expected = [("<p --> a_s>", Some <| ana(tv1, tv2))]
-            Expect.equal (testInfFunc similaritySyllogisitic t1 t2)  expected "similaritySyllogisitic: ana2 failed"
-
-        testCase "similarityFromInheritance: int" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<s --> p>." + truth tv1
-            let t2 = parseEvent <|  "<p --> s>." + truth tv1
-            let expected = [("<s <-> p>", Some <| int(tv1, tv2))]
-            Expect.equal (testInfFunc similarityFromInheritance t1 t2)  expected "similarityFromInheritance: int failed"
-
-        testCase "setIntersectionComprehension: ExtInt" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<c --> {a b}>." + truth tv1
-            let t2 = parseEvent <|  "<c --> {b c}>." + truth tv1
-            let expected = [("<c --> {b}>", Some <| int(tv1, tv2))]
-            Expect.equal (testInfFunc setIntersectionComprehension t1 t2)  expected "setIntersectionComprehension: ExtInt failed"
-
-        testCase "setIntersectionComprehension: ExtInt2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<{a b} --> c>." + truth tv1
-            let t2 = parseEvent <|  "<{b c} --> c>." + truth tv1
-            let expected = [("<{b} --> c>", Some <| uni(tv1, tv2))]
-            Expect.equal (testInfFunc setIntersectionComprehension t1 t2)  expected "setIntersectionComprehension: ExtInt2 failed"
-
-        testCase "setIntersectionComprehension: IntInt" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<c --> [a b]>." + truth tv1
-            let t2 = parseEvent <|  "<c --> [b c]>." + truth tv1 
-            let expected = [("<c --> [b]>", Some <| uni(tv1, tv2))]
-            Expect.equal (testInfFunc setIntersectionComprehension t1 t2)  expected "setIntersectionComprehension: IntInt failed"
-
-        testCase "setIntersectionComprehension: IntInt2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<[a b] --> c>." + truth tv1 
-            let t2 = parseEvent <|  "<[b c] --> c>." + truth tv1 
-            let expected = [("<[b] --> c>", Some <| int(tv1, tv2))]
-            Expect.equal (testInfFunc setIntersectionComprehension t1 t2)  expected "setIntersectionComprehension: IntInt2 failed"
-
-        testCase "setUnionComprehension: ExtUni" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<c --> {a b}>." + truth tv1 
-            let t2 = parseEvent <|  "<c --> {b c}>." + truth tv1 
-            let expected = [("<c --> {a b c}>", Some <| uni(tv1, tv2))]
-            Expect.equal (testInfFunc setUnionComprehension t1 t2)  expected "setUnionComprehension: ExtUni failed"
-
-        testCase "setUnionComprehension: IntUni" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<c --> [a b]>." + truth tv1 
-            let t2 = parseEvent <|  "<c --> [b c]>." + truth tv1 
-            let expected = [("<c --> [a b c]>", Some <| int(tv1, tv2))]
-            Expect.equal (testInfFunc setUnionComprehension t1 t2)  expected "setUnionComprehension: IntUni failed"
-    
-        testCase "setUnionComprehension: ExtUni2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<{a b} --> c>." + truth tv1 
-            let t2 = parseEvent <|  "<{b c} --> c>." + truth tv1 
-            let expected = [("<{a b c} --> c>", Some <| int(tv1, tv2))]
-            Expect.equal (testInfFunc setUnionComprehension t1 t2)  expected "setUnionComprehension: ExtUni2 failed"
-
-        testCase "setUnionComprehension: IntUni2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<[a b] --> c>." + truth tv1 
-            let t2 = parseEvent <|  "<[b c] --> c>." + truth tv1 
-            let expected = [("<[a b c] --> c>", Some <| uni(tv1, tv2))]
-            Expect.equal (testInfFunc setUnionComprehension t1 t2)  expected "setUnionComprehension: IntUni2 failed"
-
-        testCase "setDifferenceComprehension: ExtDif" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<c --> {a b}>." + truth tv1 
-            let t2 = parseEvent <|  "<c --> {b c}>." + truth tv1 
-            let expected = [("<c --> {a}>", Some <| dif(tv1, tv2))]
-            Expect.equal (testInfFunc setDifferenceComprehension t1 t2)  expected "setDifferenceComprehension: ExtDif failed"
-
-        testCase "setDifferenceComprehension: IntDif" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<c --> [a b]>." + truth tv1 
-            let t2 = parseEvent <|  "<c --> [b c]>." + truth tv1 
-            let expected = [("<c --> [a]>", Some <| dif(tv1, tv2))]
-            Expect.equal (testInfFunc setDifferenceComprehension t1 t2)  expected "setDifferenceComprehension: IntDif failed"
-    
-        testCase "setDifferenceComprehension: ExtDif2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<{a b} --> c>." + truth tv1 
-            let t2 = parseEvent <|  "<{b c} --> c>." + truth tv1 
-            let expected = [("<{a} --> c>", Some <| dif(tv1, tv2))]
-            Expect.equal (testInfFunc setDifferenceComprehension t1 t2)  expected "setDifferenceComprehension: ExtDif2 failed"
-
-        testCase "setDifferenceComprehension: IntDif2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<[a b] --> c>." + truth tv1 
-            let t2 = parseEvent <|  "<[b c] --> c>." + truth tv1 
-            let expected = [("<[a] --> c>", Some <| dif(tv1, tv2))]
-            Expect.equal (testInfFunc setDifferenceComprehension t1 t2)  expected "setDifferenceComprehension: IntDif2 failed"
-
-        testCase "setDecomposition: pnn1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<s --> m>." + truth tv1 
-            let t2 = parseEvent <|  "<(a | s) --> m>." + truth tv1 
-            let expected = [("<a --> m>", Some <| pnn(tv1, tv2))]
-            Expect.equal (testInfFunc setDecomposition t1 t2)  expected "setDecomposition: pnn1 failed"
-
-        testCase "setDecomposition: npp1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<s --> m>." + truth tv1 
-            let t2 = parseEvent <|  "<(a & s) --> m>." + truth tv1 
-            let expected = [("<a --> m>", Some <| npp(tv1, tv2))]
-            Expect.equal (testInfFunc setDecomposition t1 t2)  expected "setDecomposition: npp1 failed"
-
-        testCase "setDecomposition: pnp1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<s --> m>." + truth tv1 
-            let t2 = parseEvent <|  "<(s ~ p) --> m>." + truth tv1 
-            let expected = [("<p --> m>", Some <| pnp(tv1, tv2))]
-            Expect.equal (testInfFunc setDecomposition t1 t2)  expected "setDecomposition: pnp1 failed"
-
-        testCase "setDecomposition: nnn1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<s --> m>." + truth tv1 
-            let t2 = parseEvent <|  "<(p ~ s) --> m>." + truth tv1 
-            let expected = [("<p --> m>", Some <| nnn(tv1, tv2))]
-            Expect.equal (testInfFunc setDecomposition t1 t2)  expected "setDecomposition: nnn1 failed"
-
-        testCase "setDecomposition: pnn2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m --> s>." + truth tv1 
-            let t2 = parseEvent <|  "<m --> (p & s)>." + truth tv1 
-            let expected = [("<m --> p>", Some <| pnn(tv1, tv2))]
-            Expect.equal (testInfFunc setDecomposition t1 t2)  expected "setDecomposition: pnn2 failed"
-
-        testCase "setDecomposition: npp2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m --> s>." + truth tv1 
-            let t2 = parseEvent <|  "<m --> (p | s)>." + truth tv1 
-            let expected = [("<m --> p>", Some <| npp(tv1, tv2))]
-            Expect.equal (testInfFunc setDecomposition t1 t2)  expected "setDecomposition: npp2 failed"
-
-        testCase "setDecomposition: pnp2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m --> s>." + truth tv1 
-            let t2 = parseEvent <|  "<m --> (s - p)>." + truth tv1 
-            let expected = [("<m --> p>", Some <| pnp(tv1, tv2))]
-            Expect.equal (testInfFunc setDecomposition t1 t2)  expected "setDecomposition: pnp2 failed"
-
-        testCase "setDecomposition: nnn2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m --> s>." + truth tv1 
-            let t2 = parseEvent <|  "<m --> (p - s)>." + truth tv1 
-            let expected = [("<m --> p>", Some <| nnn(tv1, tv2))]
-            Expect.equal (testInfFunc setDecomposition t1 t2)  expected "setDecomposition: nnn2 failed"
-
-        testCase "InheritanceSetComprehension: Int" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p --> m>." + truth tv1 
-            let t2 = parseEvent <|  "<s --> m>." + truth tv1 
-            let expected = [("<(p | s) --> m>", Some <| int(tv1, tv2))
-                            ("<(p & s) --> m>", Some <| uni(tv1, tv2))
-                            ("<(p ~ s) --> m>", Some <| dif(tv1, tv2))]
-            Expect.equal (testInfFunc InheritanceSetComprehension t1 t2)  expected "InheritanceSetComprehension: Int failed"
-
-        testCase "InheritanceSetComprehension: Ext" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m --> p>." + truth tv1 
-            let t2 = parseEvent <|  "<m --> s>." + truth tv1 
-            let expected = [("<m --> (p & s)>", Some <| int(tv1, tv2))
-                            ("<m --> (p | s)>", Some <| uni(tv1, tv2))
-                            ("<m --> (p - s)>", Some <| dif(tv1, tv2))]
-            Expect.equal (testInfFunc InheritanceSetComprehension t1 t2)  expected "InheritanceSetComprehension: Ext failed"
-
-        testCase "Nal1_3_EquivalenceAndImplication: 1a" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<s --> p>." + truth tv1 
-            let t2 = parseEvent <|  "<s <-> p>." + truth tv1 
-            let expected = [("<s --> p>", Some <| structuralInt(tv1, tv2))]
-            Expect.equal (testInfFunc Nal1_3_EquivalenceAndImplication t1 t2)  expected "Nal1_3_EquivalenceAndImplication: 1a failed"
-
-        testCase "Nal1_3_EquivalenceAndImplication: 1b" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<s <-> p>." + truth tv1 
-            let t2 = parseEvent <|  "<s --> p>." + truth tv1 
-            let expected = [("<s <-> p>", Some <| structuralInt(tv1, tv2))]
-            Expect.equal (testInfFunc Nal1_3_EquivalenceAndImplication t1 t2)  expected "Nal1_3_EquivalenceAndImplication: 1b failed"
-
-        testCase "Nal1_3_EquivalenceAndImplication: 1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<s <-> {p}>." + truth tv1 
-            let t2 = parseEvent <|  "s." + truth tv1 
-            let expected = [("<s --> {p}>", Some <| identity(tv1, tv2))]
-            Expect.equal (testInfFunc Nal1_3_EquivalenceAndImplication t1 t2)  expected "Nal1_3_EquivalenceAndImplication: 1 failed"
-
-        testCase "Nal1_3_EquivalenceAndImplication: 2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<s <-> {p}>." + truth tv1 
-            let t2 = parseEvent <|  "{p}." + truth tv1 
-            let expected = [("<s --> {p}>", Some <| identity(tv1, tv2))]
-            Expect.equal (testInfFunc Nal1_3_EquivalenceAndImplication t1 t2)  expected "Nal1_3_EquivalenceAndImplication: 2 failed"
-
-        testCase "Nal1_3_EquivalenceAndImplication: 3" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<[s] <-> p>." + truth tv1 
-            let t2 = parseEvent <| "[s]." + truth tv1 
-            let expected = [("<[s] --> p>", Some <| identity(tv1, tv2))]
-            Expect.equal (testInfFunc Nal1_3_EquivalenceAndImplication t1 t2)  expected "Nal1_3_EquivalenceAndImplication: 3 failed"
-
-        testCase "Nal1_3_EquivalenceAndImplication: 4" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<[s] <-> p>." + truth tv1 
-            let t2 = parseEvent <|  "p. " + truth tv1 
-            let expected = [("<[s] --> p>", Some <| identity(tv1, tv2))]
-            Expect.equal (testInfFunc Nal1_3_EquivalenceAndImplication t1 t2)  expected "Nal1_3_EquivalenceAndImplication: 4 failed"
-
-        testCase "Nal1_3_EquivalenceAndImplication: 5" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<{s} <-> {p}>." + truth tv1 
-            let t2 = parseEvent <|  "{s}." + truth tv1 
-            let expected = [("<{s} --> {p}>", Some <| identity(tv1, tv2))]
-            Expect.equal (testInfFunc Nal1_3_EquivalenceAndImplication t1 t2)  expected "Nal1_3_EquivalenceAndImplication: 5 failed"
-
-        testCase "Nal1_3_EquivalenceAndImplication: 6" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<{s} <-> {p}>." + truth tv1 
-            let t2 = parseEvent <|  "{p}." + truth tv1 
-            let expected = [("<{s} --> {p}>", Some <| identity(tv1, tv2))]
-            Expect.equal (testInfFunc Nal1_3_EquivalenceAndImplication t1 t2)  expected "Nal1_3_EquivalenceAndImplication: 6 failed"
-
-        testCase "Nal1_3_EquivalenceAndImplication: 7" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<[s] <-> [p]>." + truth tv1 
-            let t2 = parseEvent <| "[s]." + truth tv1 
-            let expected = [("<[s] --> [p]>", Some <| identity(tv1, tv2))]
-            Expect.equal (testInfFunc Nal1_3_EquivalenceAndImplication t1 t2)  expected "Nal1_3_EquivalenceAndImplication: 7 failed"
-
-        testCase "Nal1_3_EquivalenceAndImplication: 8" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<[s] <-> [p]>." + truth tv1 
-            let t2 = parseEvent <|  "[p]." + truth tv1          
-            let expected = [("<[s] --> [p]>", Some <| identity(tv1, tv2))]
-            Expect.equal (testInfFunc Nal1_3_EquivalenceAndImplication t1 t2)  expected "Nal1_3_EquivalenceAndImplication: 8 failed"
-
-        testCase "setDefinitionUnwrap: 1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<{s} <-> {p}>." + truth tv1 
-            let t2 = parseEvent <|  "{s}." + truth tv1          
-            let expected = [("<s <-> p>", Some <| identity(tv1, tv2))]
-            Expect.equal (testInfFunc setDefinitionUnwrap t1 t2)  expected "setDefinitionUnwrap: 1 failed"
-
-        testCase "setDefinitionUnwrap: 2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<{s} <-> {p}>." + truth tv1 
-            let t2 = parseEvent <|  "{p}." + truth tv1          
-            let expected = [("<s <-> p>", Some <| identity(tv1, tv2))]
-            Expect.equal (testInfFunc setDefinitionUnwrap t1 t2)  expected "setDefinitionUnwrap: 2 failed"
-
-        testCase "setDefinitionUnwrap: 3" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<[s] <-> [p]>." + truth tv1 
-            let t2 = parseEvent <| "[s]. " + truth tv1          
-            let expected = [("<s <-> p>", Some <| identity(tv1, tv2))]
-            Expect.equal (testInfFunc setDefinitionUnwrap t1 t2)  expected "setDefinitionUnwrap: 3 failed"
-
-        testCase "setDefinitionUnwrap: 4" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<[s] <-> [p]>." + truth tv1 
-            let t2 = parseEvent <|  "[p]." + truth tv1          
-            let expected = [("<s <-> p>", Some <| identity(tv1, tv2))]
-            Expect.equal (testInfFunc setDefinitionUnwrap t1 t2)  expected "setDefinitionUnwrap: 4 failed"
-
-        testCase "setDefinitionUnwrap: 5" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<s --> {p}>." + truth tv1 
-            let t2 = parseEvent <|  "s." + truth tv1          
-            let expected = [("<s <-> {p}>", Some <| identity(tv1, tv2))]
-            Expect.equal (testInfFunc setDefinitionUnwrap t1 t2)  expected "setDefinitionUnwrap: 5 failed"
-
-        testCase "setDefinitionUnwrap: 6" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<s --> {p}>." + truth tv1 
-            let t2 = parseEvent <|  "{p}." + truth tv1          
-            let expected = [("<s <-> {p}>", Some <| identity(tv1, tv2))]
-            Expect.equal (testInfFunc setDefinitionUnwrap t1 t2)  expected "setDefinitionUnwrap: 6 failed"
-
-        testCase "setDefinitionUnwrap: 7" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<[s] --> p>." + truth tv1 
-            let t2 = parseEvent <| "[s]." + truth tv1          
-            let expected = [("<[s] <-> p>", Some <| identity(tv1, tv2))]
-            Expect.equal (testInfFunc setDefinitionUnwrap t1 t2)  expected "setDefinitionUnwrap: 7 failed"
-
-        testCase "setDefinitionUnwrap: 8" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<[s] --> p>." + truth tv1 
-            let t2 = parseEvent <|  "p. " + truth tv1          
-            let expected = [("<[s] <-> p>", Some <| identity(tv1, tv2))]
-            Expect.equal (testInfFunc setDefinitionUnwrap t1 t2)  expected "setDefinitionUnwrap: 8 failed"
-
-        testCase "structuralInference: 1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<(a * b) --> m>." + truth tv1 
-            let t2 = parseEvent <|  "_." + truth tv1          
-            let expected = [("<a --> (m / _ b)>", Some <| identity(tv1, tv2))
-                            ("<b --> (m / a _)>", Some <| identity(tv1, tv2))]
-            Expect.equal (testInfFunc structuralInference t1 t2)  expected "structuralInference: 1 failed"
-
-        testCase "structuralInference: 2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m --> (a * b)>." + truth tv1 
-            let t2 = parseEvent <|  "_." + truth tv1 
-            let expected = [("<(m \\ _ b) --> a>", Some <| identity(tv1, tv2))
-                            ("<(m \\ a _) --> b>", Some <| identity(tv1, tv2))]
-            Expect.equal (testInfFunc structuralInference t1 t2)  expected "structuralInference: 2 failed"
-
-        testCase "structuralInference: 3" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<ai --> (m / a _)>." + truth tv1
-            let t2 = parseEvent <|  "_." + truth tv1          
-            let expected = [("<(a * ai) --> m>", Some <| identity(tv1, tv2))]
-            Expect.equal (testInfFunc structuralInference t1 t2)  expected "structuralInference: 3 failed"
-
-        testCase "structuralInference: 4" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<ai --> (m / _ b)>." + truth tv1
-            let t2 = parseEvent <|  "_." + truth tv1          
-            let expected = [("<(ai * b) --> m>", Some <| identity(tv1, tv2))]
-            Expect.equal (testInfFunc structuralInference t1 t2)  expected "structuralInference: 4 failed"
-
-        testCase "structuralInference: 5" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<(m \ a _) --> ai>." + truth tv1
-            let t2 = parseEvent <|  "_." + truth tv1          
-            let expected = [("<m --> (a * ai)>", Some <| identity(tv1, tv2))]
-            Expect.equal (testInfFunc structuralInference t1 t2)  expected "structuralInference: 5 failed"
-
-        testCase "structuralInference: 6" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<(m \ _ b) --> ai>." + truth tv1
-            let t2 = parseEvent <|  "_." + truth tv1          
-            let expected = [("<m --> (ai * b)>", Some <| identity(tv1, tv2))]
-            Expect.equal (testInfFunc structuralInference t1 t2)  expected "structuralInference: 6 failed"
-
-        testCase "structuralInference2: 1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<a --> c>." + truth tv1
-            let t2 = parseEvent <|  "<a --> d>." + truth tv1         
-            let expected = [("<(a * a) --> (c * d)>", Some <| int(tv1, tv2))]
-            Expect.equal (testInfFunc structuralInference2 t1 t2)  expected "structuralInference2: 1 failed"
-
-        testCase "structuralInference2: 2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<a --> c>." + truth tv1
-            let t2 = parseEvent <|  "<b --> c>." + truth tv1         
-            let expected = [("<(a * b) --> (c * c)>", Some <| int(tv1, tv2))]
-            Expect.equal (testInfFunc structuralInference2 t1 t2)  expected "structuralInference2: 2 failed"
-
-        testCase "structuralInference2: 3" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<{a} --> c>." + truth tv1
-            let t2 = parseEvent <|  "<a --> d>." + truth tv1         
-            let expected = [("<({a} * a) --> (c * d)>", Some <| int(tv1, tv2))]
-            Expect.equal (testInfFunc structuralInference2 t1 t2)  expected "structuralInference2: 3 failed"
-
-        testCase "structuralInference2: 4" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<a --> c>." + truth tv1
-            let t2 = parseEvent <|  "<{a} --> d>." + truth tv1         
-            let expected = [("<(a * {a}) --> (c * d)>", Some <| int(tv1, tv2))]
-            Expect.equal (testInfFunc structuralInference2 t1 t2)  expected "structuralInference2: 4 failed"
-
-        testCase "structuralInference2: 5" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<a --> [c]>." + truth tv1
-            let t2 = parseEvent <|  "<b --> c>." + truth tv1         
-            let expected = [("<(a * b) --> ([c] * c)>", Some <| int(tv1, tv2))]
-            Expect.equal (testInfFunc structuralInference2 t1 t2)  expected "structuralInference2: 5 failed"
-
-        testCase "structuralInference2: 6" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<a --> c>." + truth tv1
-            let t2 = parseEvent <|  "<b --> [c]>." + truth tv1         
-            let expected = [("<(a * b) --> (c * [c])>", Some <| int(tv1, tv2))]
-            Expect.equal (testInfFunc structuralInference2 t1 t2)  expected "structuralInference2: 6 failed"
-
-        testCase "backwardDrivenForwardInference: 1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<(b * p) --> z>?" + truth tv1
-            let t2 = parseEvent <|  "<b --> a>." + truth tv1         
-            let expected = [("<(b * p) --> (a * p)>", Some <| beliefStructuralDed(tv1, tv2))]
-            Expect.equal (testInfFunc backwardDrivenForwardInference t1 t2)  expected "backwardDrivenForwardInference: 1 failed"
-
-        testCase "backwardDrivenForwardInference: 2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<(p * b) --> z>?" + truth tv1
-            let t2 = parseEvent <|  "<b --> a>." + truth tv1         
-            let expected = [("<(p * b) --> (p * a)>", Some <| beliefStructuralDed(tv1, tv2))]
-            Expect.equal (testInfFunc backwardDrivenForwardInference t1 t2)  expected "backwardDrivenForwardInference: 2 failed"
-
-        testCase "backwardDrivenForwardInference: 3" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<(b * p) <-> z>?" + truth tv1
-            let t2 = parseEvent <|  "<b <-> a>." + truth tv1         
-            let expected = [("<(b * p) <-> (a * p)>", Some <| beliefStructuralDed(tv1, tv2))]
-            Expect.equal (testInfFunc backwardDrivenForwardInference t1 t2)  expected "backwardDrivenForwardInference: 3 failed"
-
-        testCase "backwardDrivenForwardInference: 4" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<(p * b) <-> z>?" + truth tv1
-            let t2 = parseEvent <|  "<b <-> a>." + truth tv1         
-            let expected = [("<(p * b) <-> (p * a)>", Some <| beliefStructuralDed(tv1, tv2))]
-            Expect.equal (testInfFunc backwardDrivenForwardInference t1 t2)  expected "backwardDrivenForwardInference: 4 failed"
-
-        testCase "backwardDrivenForwardInference: 5" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<(n \ a _) --> z>?" + truth tv1
-            let t2 = parseEvent <|  "<n --> r>." + truth tv1         
-            let expected = [("<(n \\ a _) --> (r \\ a _)>", Some <| beliefStructuralDed(tv1, tv2))]
-            Expect.equal (testInfFunc backwardDrivenForwardInference t1 t2)  expected "backwardDrivenForwardInference: 5 failed"
-
-        testCase "backwardDrivenForwardInference: 6" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<(n / _ b) --> z>?" + truth tv1
-            let t2 = parseEvent <|  "<s --> b>." + truth tv1         
-            let expected = [("<(n / _ b) --> (n / _ s)>", Some <| beliefStructuralDed(tv1, tv2))]
-            Expect.equal (testInfFunc backwardDrivenForwardInference t1 t2)  expected "backwardDrivenForwardInference: 6 failed"
-
-        testCase "backwardOnlyInference: 6" <| fun () ->   
-            let tv1 = {F = 0.0f; C = 0.0f}
-            let t1 = parseEvent <|  "<a --> s>?"
-            let t2 = parseEvent <|  "<b --> s>." + truth tv1         
-            let expected = [("<a --> b>", None)
-                            ("<b --> a>", None)
-                            ("<a <-> b>", None)]
-            Expect.equal (testInfFunc backwardOnlyInference t1 t2)  expected "backwardOnlyInference: 6 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: conversion1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p --> s>." + truth tv1
-            let t2 = parseEvent <|  "<s --> p>." + truth tv1         
-            let expected = [("<p --> s>", Some <| cnv(tv1, tv2))]
-            Expect.equal (testInfFunc Nal1_4_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: conversion1 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: conversion2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p ==> s>." + truth tv1
-            let t2 = parseEvent <|  "<s ==> p>." + truth tv1         
-            let expected = [("<p ==> s>", Some <| cnv(tv1, tv2))]
-            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: conversion2 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: conversion3" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p =|> s>." + truth tv1
-            let t2 = parseEvent <|  "<s =|> p>." + truth tv1         
-            let expected = [("<p =|> s>", Some <| cnv(tv1, tv2))]
-            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: conversion3 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: conversion4" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p =-> s>." + truth tv1
-            let t2 = parseEvent <|  "<s =+> p>." + truth tv1         
-            let expected = [("<p =-> s>", Some <| cnv(tv1, tv2))]
-            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: conversion4 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: conversion5" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p =+> s>." + truth tv1
-            let t2 = parseEvent <|  "<s =-> p>." + truth tv1         
-            let expected = [("<p =+> s>", Some <| cnv(tv1, tv2))]
-            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: conversion5 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: contrapostion1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<--s ==> p>." + truth tv1
-            let t2 = parseEvent <|  "p. " + truth tv1          
-            let expected = [("<--p ==> s>", Some <| cnt(tv1, tv2))]
-            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: contrapostion1 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: contrapostion2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<--s ==> p>." + truth tv1
-            let t2 = parseEvent <|  "--s." + truth tv1          
-            let expected = [("<--p ==> s>", Some <| cnt(tv1, tv2))]
-            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: contrapostion2 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: contrapostion3" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<--s =|> p>." + truth tv1
-            let t2 = parseEvent <|  "p. " + truth tv1          
-            let expected = [("<--p =|> s>", Some <| cnt(tv1, tv2))]
-            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: contrapostion3 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: contrapostion4" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<--s =|> p>." + truth tv1
-            let t2 = parseEvent <|  "--s." + truth tv1          
-            let expected = [("<--p =|> s>", Some <| cnt(tv1, tv2))]
-            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: contrapostion4 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: contrapostion5" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<--s =+> p>." + truth tv1
-            let t2 = parseEvent <|  "p. " + truth tv1          
-            let expected = [("<--p =-> s>", Some <| cnt(tv1, tv2))]
-            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: contrapostion5 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: contrapostion6" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<--s =+> p>." + truth tv1
-            let t2 = parseEvent <|  "--s." + truth tv1          
-            let expected = [("<--p =-> s>", Some <| cnt(tv1, tv2))]
-            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: contrapostion6 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: contrapostion7" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<--s =-> p>." + truth tv1
-            let t2 = parseEvent <|  "p. " + truth tv1          
-            let expected = [("<--p =+> s>", Some <| cnt(tv1, tv2))]
-            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: contrapostion7 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: contrapostion8" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<--s =-> p>." + truth tv1
-            let t2 = parseEvent <|  "--s." + truth tv1           
-            let expected = [("<--p =+> s>", Some <| cnt(tv1, tv2))]
-            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: contrapostion8 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: negation1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<a --> b>." + truth tv1
-            let t2 = parseEvent <|  "a." + truth tv1       
-            let expected = [("--<a --> b>", Some <| neg(tv1, tv2))]
-            Expect.equal (testInfFunc Nal1_4_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation1 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: negation2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<a --> b>." + truth tv1
-            let t2 = parseEvent <|  "b." + truth tv1         
-            let expected = [("--<a --> b>", Some <| neg(tv1, tv2))]
-            Expect.equal (testInfFunc Nal1_4_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation2 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: negation3" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "--<a --> b>." + truth tv1
-            let t2 = parseEvent <|  "a." + truth tv1        
-            let expected = [("<a --> b>", Some <| neg(tv1, tv2))]
-            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation3 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: negation4" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "--<a --> b>." + truth tv1
-            let t2 = parseEvent <|  "b." + truth tv1         
-            let expected = [("<a --> b>", Some <| neg(tv1, tv2))]
-            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation4 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: negation5" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<a <-> b>." + truth tv1
-            let t2 = parseEvent <|  "a." + truth tv1        
-            let expected = [("--<a <-> b>", Some <| neg(tv1, tv2))]
-            Expect.equal (testInfFunc Nal1_4_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation5 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: negation6" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<a <-> b>." + truth tv1
-            let t2 = parseEvent <|  "b." + truth tv1        
-            let expected = [("--<a <-> b>", Some <| neg(tv1, tv2))]
-            Expect.equal (testInfFunc Nal1_4_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation6 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: negation7" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "--<a <-> b>." + truth tv1
-            let t2 = parseEvent <|  "a." + truth tv1        
-            let expected = [("<a <-> b>", Some <| neg(tv1, tv2))]
-            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation7 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: negation8" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "--<a <-> b>." + truth tv1
-            let t2 = parseEvent <|  "b." + truth tv1         
-            let expected = [("<a <-> b>", Some <| neg(tv1, tv2))]
-            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation8 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: negation9" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<a ==> b>." + truth tv1
-            let t2 = parseEvent <|  "a." + truth tv1        
-            let expected = [("--<a ==> b>", Some <| neg(tv1, tv2))]
-            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation9 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: negation10" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<a ==> b>." + truth tv1
-            let t2 = parseEvent <|  "b." + truth tv1         
-            let expected = [("--<a ==> b>", Some <| neg(tv1, tv2))]
-            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation10 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: negation11" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "--<a ==> b>." + truth tv1
-            let t2 = parseEvent <|  "a." + truth tv1         
-            let expected = [("<a ==> b>", Some <| neg(tv1, tv2))]
-            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation11 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: negation12" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "--<a ==> b>." + truth tv1
-            let t2 = parseEvent <|  "b." + truth tv1         
-            let expected = [("<a ==> b>", Some <| neg(tv1, tv2))]
-            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation12 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: negation13" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<a <=> b>." + truth tv1
-            let t2 = parseEvent <|  "a." + truth tv1          
-            let expected = [("--<a <=> b>", Some <| neg(tv1, tv2))]
-            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation13 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: negation14" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<a <=> b>." + truth tv1
-            let t2 = parseEvent <|  "b." + truth tv1          
-            let expected = [("--<a <=> b>", Some <| neg(tv1, tv2))]
-            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation14 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: negation15" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "--<a <=> b>." + truth tv1
-            let t2 = parseEvent <|  "a." + truth tv1    
-            let expected = [("<a <=> b>", Some <| neg(tv1, tv2))]
-            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation15 failed"
-
-        testCase "Nal1_5_conversion_contrapostion_negation: negation16" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "--<a <=> b>." + truth tv1
-            let t2 = parseEvent <|  "b. " + truth tv1
-            let expected = [("<a <=> b>", Some <| neg(tv1, tv2))]
-            Expect.equal (testInfFunc Nal5_conversion_contrapostion_negation t1 t2)  expected "Nal1_5_conversion_contrapostion_negation: negation16 failed"
-
-        testCase "nal_5_implication_based_syllogism_Imp: 1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m ==> p>." + truth tv1
-            let t2 = parseEvent <|  "<s ==> m>." + truth tv1
-            let expected = [("<s ==> p>", Some <| ded(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 1 failed"
-
-        testCase "nal_5_implication_based_syllogism_Imp: 2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m =|> p>." + truth tv1
-            let t2 = parseEvent <|  "<s =|> m>." + truth tv1
-            let expected = [("<s =|> p>", Some <| ded(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 2 failed"
-
-        testCase "nal_5_implication_based_syllogism_Imp: 3" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m =-> p>." + truth tv1
-            let t2 = parseEvent <|  "<s =-> m>." + truth tv1
-            let expected = [("<s =-> p>", Some <| ded(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 3 failed"
-
-        testCase "nal_5_implication_based_syllogism_Imp: 4" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m =+> p>." + truth tv1
-            let t2 = parseEvent <|  "<s =+> m>." + truth tv1
-            let expected = [("<s =+> p>", Some <| ded(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 4 failed"
-
-        testCase "nal_5_implication_based_syllogism_Imp: 5" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p ==> m>." + truth tv1
-            let t2 = parseEvent <|  "<s ==> m>." + truth tv1
-            let expected = [("<s ==> p>", Some <| ind(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 5 failed"
-
-        testCase "nal_5_implication_based_syllogism_Imp: 6" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p =|> m>." + truth tv1
-            let t2 = parseEvent <|  "<s =|> m>." + truth tv1
-            let expected = [("<s =|> p>", Some <| ind(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 6 failed"
-
-        testCase "nal_5_implication_based_syllogism_Imp: 7" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p =+> m>." + truth tv1
-            let t2 = parseEvent <|  "<s =+> m>." + truth tv1
-            let expected = [("<s =|> p>", Some <| ind(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 7 failed"
-
-        testCase "nal_5_implication_based_syllogism_Imp: 8" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p =-> m>." + truth tv1
-            let t2 = parseEvent <|  "<s =-> m>." + truth tv1
-            let expected = [("<s =|> p>", Some <| ind(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 8 failed"
-
-        testCase "nal_5_implication_based_syllogism_Imp: 9" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m ==> p>." + truth tv1
-            let t2 = parseEvent <|  "<m ==> s>." + truth tv1
-            let expected = [("<s ==> p>", Some <| abd(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 9 failed"
-
-        testCase "nal_5_implication_based_syllogism_Imp: 10" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m =+> p>." + truth tv1
-            let t2 = parseEvent <|  "<m =+> s>." + truth tv1
-            let expected = [("<s =|> p>", Some <| abd(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 10 failed"
-
-        testCase "nal_5_implication_based_syllogism_Imp: 11" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m =|> p>." + truth tv1
-            let t2 = parseEvent <|  "<m =|> s>." + truth tv1
-            let expected = [("<s =|> p>", Some <| abd(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 11 failed"
-
-        testCase "nal_5_implication_based_syllogism_Imp: 12" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m =-> p>." + truth tv1
-            let t2 = parseEvent <|  "<m =-> s>." + truth tv1
-            let expected = [("<s =|> p>", Some <| abd(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 12 failed"
-
-        testCase "nal_5_implication_based_syllogism_Imp: 13" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p ==> m>." + truth tv1
-            let t2 = parseEvent <|  "<m ==> s>." + truth tv1
-            let expected = [("<s ==> p>", Some <| exe(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 13 failed"
-
-        testCase "nal_5_implication_based_syllogism_Imp: 14" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p =+> m>." + truth tv1
-            let t2 = parseEvent <|  "<m =+> s>." + truth tv1
-            let expected = [("<s =-> p>", Some <| exe(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 14 failed"
-
-        testCase "nal_5_implication_based_syllogism_Imp: 15" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p =-> m>." + truth tv1
-            let t2 = parseEvent <|  "<m =-> s>." + truth tv1
-            let expected = [("<s =+> p>", Some <| exe(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 15 failed"
-
-        testCase "nal_5_implication_based_syllogism_Imp: 16" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p =|> m>." + truth tv1
-            let t2 = parseEvent <|  "<m =|> s>." + truth tv1
-            let expected = [("<s =|> p>", Some <| exe(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Imp t1 t2)  expected "nal_5_implication_based_syllogism_Imp: 16 failed"
-
-        testCase "nal_5_implication_based_syllogism_Equ1: 1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<s ==> p>." + truth tv1
-            let t2 = parseEvent <|  "<p ==> s>." + truth tv1
-            let expected = [("<s <=> p>", Some <| int(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ1 t1 t2)  expected "nal_5_implication_based_syllogism_Equ1: 1 failed"
-
-        testCase "nal_5_implication_based_syllogism_Equ1: 2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<s =|> p>." + truth tv1
-            let t2 = parseEvent <|  "<p =|> s>." + truth tv1
-            let expected = [("<s <|> p>", Some <| int(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ1 t1 t2)  expected "nal_5_implication_based_syllogism_Equ1: 2 failed"
-
-        testCase "nal_5_implication_based_syllogism_Equ1: 3" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<s =+> p>." + truth tv1
-            let t2 = parseEvent <|  "<p =-> s>." + truth tv1
-            let expected = [("<s <+> p>", Some <| int(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ1 t1 t2)  expected "nal_5_implication_based_syllogism_Equ1: 3 failed"
-
-        testCase "nal_5_implication_based_syllogism_Equ1: 4" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<s =-> p>." + truth tv1
-            let t2 = parseEvent <|  "<p =+> s>." + truth tv1
-            let expected = [("<p <+> s>", Some <| int(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ1 t1 t2)  expected "nal_5_implication_based_syllogism_Equ1: 4 failed"
-
-        testCase "nal_5_implication_based_syllogism_Equ1: 5" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p ==> m>." + truth tv1
-            let t2 = parseEvent <|  "<s ==> m>." + truth tv1
-            let expected = [("<s <=> p>", Some <| ind(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ1 t1 t2)  expected "nal_5_implication_based_syllogism_Equ1: 5 failed"
-
-        testCase "nal_5_implication_based_syllogism_Equ1: 6" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p =+> m>." + truth tv1
-            let t2 = parseEvent <|  "<s =+> m>." + truth tv1
-            let expected = [("<s <|> p>", Some <| ind(tv1, tv2))
-                            ("<s <+> p>", Some <| ind(tv1, tv2))
-                            ("<p <+> s>", Some <| ind(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ1 t1 t2)  expected "nal_5_implication_based_syllogism_Equ1: 6 failed"
-
-        testCase "nal_5_implication_based_syllogism_Equ1: 7" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p =|> m>." + truth tv1
-            let t2 = parseEvent <|  "<s =|> m>." + truth tv1
-            let expected = [("<s <|> p>", Some <| ind(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ1 t1 t2)  expected "nal_5_implication_based_syllogism_Equ1: 7 failed"
-
-        testCase "nal_5_implication_based_syllogism_Equ1: 8" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p =-> m>." + truth tv1
-            let t2 = parseEvent <|  "<s =-> m>." + truth tv1
-            let expected = [("<s <|> p>", Some <| ind(tv1, tv2))
-                            ("<s <+> p>", Some <| ind(tv1, tv2))
-                            ("<p <+> s>", Some <| ind(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ1 t1 t2)  expected "nal_5_implication_based_syllogism_Equ1: 8 failed"
-
-        testCase "nal_5_implication_based_syllogism_Equ1: 9" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m ==> p>." + truth tv1
-            let t2 = parseEvent <|  "<m ==> s>." + truth tv1
-            let expected = [("<s <=> p>", Some <| com(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ1 t1 t2)  expected "nal_5_implication_based_syllogism_Equ1: 9 failed"
-
-        testCase "nal_5_implication_based_syllogism_Equ1: 10" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m =+> p>." + truth tv1
-            let t2 = parseEvent <|  "<m =+> s>." + truth tv1
-            let expected = [("<s <|> p>", Some <| com(tv1, tv2))
-                            ("<s <+> p>", Some <| com(tv1, tv2))
-                            ("<p <+> s>", Some <| com(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ1 t1 t2)  expected "nal_5_implication_based_syllogism_Equ1: 10 failed"
-
-        testCase "nal_5_implication_based_syllogism_Equ1: 11" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m =|> p>." + truth tv1
-            let t2 = parseEvent <|  "<m =|> s>." + truth tv1
-            let expected = [("<s <|> p>", Some <| com(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ1 t1 t2)  expected "nal_5_implication_based_syllogism_Equ1: 11 failed"
-
-        testCase "nal_5_implication_based_syllogism_Equ2: 1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m ==> p>." + truth tv1
-            let t2 = parseEvent <|  "<s <=> m>." + truth tv1
-            let expected = [("<s ==> p>", Some <| ana(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ2 t1 t2)  expected "nal_5_implication_based_syllogism_Equ2: 1 failed"
-
-        testCase "nal_5_implication_based_syllogism_Equ2: 2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m =+> p>." + truth tv1
-            let t2 = parseEvent <|  "<s <+> m>." + truth tv1
-            let expected = [("<s =+> p>", Some <| ana(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ2 t1 t2)  expected "nal_5_implication_based_syllogism_Equ2: 2 failed"
-
-        testCase "nal_5_implication_based_syllogism_Equ2: 3" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m =+> p>." + truth tv1
-            let t2 = parseEvent <|  "<s <|> m>." + truth tv1
-            let expected = [("<s =+> p>", Some <| ana(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ2 t1 t2)  expected "nal_5_implication_based_syllogism_Equ2: 3 failed"
-
-        testCase "nal_5_implication_based_syllogism_Equ2: 4" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m =|> p>." + truth tv1
-            let t2 = parseEvent <|  "<s <|> m>." + truth tv1
-            let expected = [("<s =|> p>", Some <| ana(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ2 t1 t2)  expected "nal_5_implication_based_syllogism_Equ2: 4 failed"
-
-        testCase "nal_5_implication_based_syllogism_Equ2: 5" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m =-> p>." + truth tv1
-            let t2 = parseEvent <|  "<s <+> m>." + truth tv1
-            let expected = [("<s =-> p>", Some <| ana(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ2 t1 t2)  expected "nal_5_implication_based_syllogism_Equ2: 5 failed"
-
-        testCase "nal_5_implication_based_syllogism_Equ2: 6" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m =-> p>." + truth tv1
-            let t2 = parseEvent <|  "<s <|> m>." + truth tv1
-            let expected = [("<s =-> p>", Some <| ana(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ2 t1 t2)  expected "nal_5_implication_based_syllogism_Equ2: 6 failed"
-
-        testCase "nal_5_implication_based_syllogism_Equ2: 7" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p ==> m>." + truth tv1
-            let t2 = parseEvent <|  "<s <=> m>." + truth tv1
-            let expected = [("<s ==> p>", Some <| ana(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ2 t1 t2)  expected "nal_5_implication_based_syllogism_Equ2: 7 failed"
-
-        testCase "nal_5_implication_based_syllogism_Equ2: 8" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p =+> m>." + truth tv1
-            let t2 = parseEvent <|  "<s <|> m>." + truth tv1
-            let expected = [("<p =-> s>", Some <| ana(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ2 t1 t2)  expected "nal_5_implication_based_syllogism_Equ2: 8 failed"
-
-        testCase "nal_5_implication_based_syllogism_Equ2: 9" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p =|> m>." + truth tv1
-            let t2 = parseEvent <|  "<s <|> m>." + truth tv1
-            let expected = [("<p =|> s>", Some <| ana(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ2 t1 t2)  expected "nal_5_implication_based_syllogism_Equ2: 9 failed"
-
-        testCase "nal_5_implication_based_syllogism_Equ2: 10" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p =-> m>." + truth tv1
-            let t2 = parseEvent <|  "<s <+> m>." + truth tv1
-            let expected = [("<p =-> s>", Some <| ana(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ2 t1 t2)  expected "nal_5_implication_based_syllogism_Equ2: 10 failed"
-
-        testCase "nal_5_implication_based_syllogism_Equ2: 11" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p =-> m>." + truth tv1
-            let t2 = parseEvent <|  "<s <|> m>." + truth tv1
-            let expected = [("<p =-> s>", Some <| ana(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ2 t1 t2)  expected "nal_5_implication_based_syllogism_Equ2: 11 failed"
-
-        testCase "nal_5_implication_based_syllogism_Equ2: 12" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m <+> p>." + truth tv1
-            let t2 = parseEvent <|  "<s <|> m>." + truth tv1
-            let expected = [("<s <+> p>", Some <| res(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ2 t1 t2)  expected "nal_5_implication_based_syllogism_Equ2: 12 failed"
-
-        testCase "nal_5_implication_based_syllogism_Equ2: 13" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m <|> p>." + truth tv1
-            let t2 = parseEvent <|  "<s <+> m>." + truth tv1
-            let expected = [("<s <+> p>", Some <| res(tv1, tv2))]
-            Expect.equal (testInfFunc nal_5_implication_based_syllogism_Equ2 t1 t2)  expected "nal_5_implication_based_syllogism_Equ2: 13 failed"
-
-        testCase "nal5_implication_based_composition: 1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p ==> m>." + truth tv1
-            let t2 = parseEvent <|  "<s ==> m>." + truth tv1
-            let expected = [("<(p || s) ==> m>", Some <| int(tv1, tv2))
-                            ("<(p && s) ==> m>", Some <| uni(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_implication_based_composition t1 t2)  expected "nal5_implication_based_composition: 1 failed"
-
-        testCase "nal5_implication_based_composition: 2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p =|> m>." + truth tv1
-            let t2 = parseEvent <|  "<s =|> m>." + truth tv1
-            let expected = [("<(p || s) =|> m>", Some <| int(tv1, tv2))
-                            ("<(p ; s) =|> m>", Some <| uni(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_implication_based_composition t1 t2)  expected "nal5_implication_based_composition: 2 failed"
-
-        testCase "nal5_implication_based_composition: 3" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p =+> m>." + truth tv1
-            let t2 = parseEvent <|  "<s =+> m>." + truth tv1
-            let expected = [("<(p || s) =+> m>", Some <| int(tv1, tv2))
-                            ("<(p ; s) =+> m>", Some <| uni(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_implication_based_composition t1 t2)  expected "nal5_implication_based_composition: 3 failed"
-
-        testCase "nal5_implication_based_composition: 4" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<p =-> m>." + truth tv1
-            let t2 = parseEvent <|  "<s =-> m>." + truth tv1
-            let expected = [("<(p || s) =-> m>", Some <| int(tv1, tv2))
-                            ("<(p ; s) =-> m>", Some <| uni(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_implication_based_composition t1 t2)  expected "nal5_implication_based_composition: 4 failed"
-
-        testCase "nal5_implication_based_composition: 5" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m ==> p>." + truth tv1
-            let t2 = parseEvent <|  "<m ==> s>." + truth tv1
-            let expected = [("<m ==> (p && s)>", Some <| int(tv1, tv2))
-                            ("<m ==> (p || s)>", Some <| uni(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_implication_based_composition t1 t2)  expected "nal5_implication_based_composition: 5 failed"
-
-        testCase "nal5_implication_based_composition: 6" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m =+> p>." + truth tv1
-            let t2 = parseEvent <|  "<m =+> s>." + truth tv1
-            let expected = [("<m =+> (p ; s)>", Some <| int(tv1, tv2))
-                            ("<m =+> (p || s)>", Some <| uni(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_implication_based_composition t1 t2)  expected "nal5_implication_based_composition: 6 failed"
-
-        testCase "nal5_implication_based_composition: 7" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m =|> p>." + truth tv1
-            let t2 = parseEvent <|  "<m =|> s>." + truth tv1
-            let expected = [("<m =|> (p ; s)>", Some <| int(tv1, tv2))
-                            ("<m =|> (p || s)>", Some <| uni(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_implication_based_composition t1 t2)  expected "nal5_implication_based_composition: 7 failed"
-
-        testCase "nal5_implication_based_composition: 8" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m =-> p>." + truth tv1
-            let t2 = parseEvent <|  "<m =-> s>." + truth tv1
-            let expected = [("<m =-> (p ; s)>", Some <| int(tv1, tv2))
-                            ("<m =-> (p || s)>", Some <| uni(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_implication_based_composition t1 t2)  expected "nal5_implication_based_composition: 8 failed"
-
-        testCase "nal5_implication_based_composition: 9" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<d =+> r>." + truth tv1
-            let t2 = parseEvent <|  "<d =-> k>." + truth tv1
-            let expected = [("<k =+> r>", Some <| abd(tv1, tv2))
-                            ("<k =-> r>", Some <| ind(tv1, tv2))
-                            ("<k <+> r>", Some <| com(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_implication_based_composition t1 t2)  expected "nal5_implication_based_composition: 9 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition1: 1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<s ==> m>." + truth tv1
-            let t2 = parseEvent <|  "<(s || (r || t)) ==> m>." + truth tv1
-            let expected = [("<(r || t) ==> m>", Some <| pnn(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition1 t1 t2)  expected "nal5_nal8_implication_based_decomposition1: 1 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition1: 2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<s =+> m>." + truth tv1
-            let t2 = parseEvent <|  "<(s || (r || t)) ==> m>." + truth tv1
-            let expected = [("<(r || t) =+> m>", Some <| pnn(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition1 t1 t2)  expected "nal5_nal8_implication_based_decomposition1: 2 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition1: 3" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<s =|> m>." + truth tv1
-            let t2 = parseEvent <|  "<(s || (r || t)) ==> m>." + truth tv1
-            let expected = [("<(r || t) =|> m>", Some <| pnn(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition1 t1 t2)  expected "nal5_nal8_implication_based_decomposition1: 3 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition1: 4" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<s =-> m>." + truth tv1
-            let t2 = parseEvent <|  "<(s || (r || t)) ==> m>." + truth tv1
-            let expected = [("<(r || t) =-> m>", Some <| pnn(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition1 t1 t2)  expected "nal5_nal8_implication_based_decomposition1: 4 failed"
-
-
-        testCase "nal5_nal8_implication_based_decomposition2: 1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<s ==> m>." + truth tv1
-            let t2 = parseEvent <|  "<(s && (r && t)) ==> m>." + truth tv1
-            let expected = [("<(r && t) ==> m>", Some <| npp(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition2 t1 t2)  expected "nal5_nal8_implication_based_decomposition2: 1 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition2: 2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<s =+> m>." + truth tv1
-            let t2 = parseEvent <|  "<(s && (r && t)) =+> m>." + truth tv1
-            let expected = [("<(r && t) =+> m>", Some <| npp(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition2 t1 t2)  expected "nal5_nal8_implication_based_decomposition2: 2 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition2: 3" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<s =|> m>." + truth tv1
-            let t2 = parseEvent <|  "<(s && (r && t)) =|> m>." + truth tv1
-            let expected = [("<(r && t) =|> m>", Some <| npp(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition2 t1 t2)  expected "nal5_nal8_implication_based_decomposition2: 3 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition2: 4" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<s =-> m>." + truth tv1
-            let t2 = parseEvent <|  "<(s && (r && t)) =-> m>." + truth tv1
-            let expected = [("<(r && t) =-> m>", Some <| npp(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition2 t1 t2)  expected "nal5_nal8_implication_based_decomposition2: 4 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition3: 1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m ==> s>." + truth tv1
-            let t2 = parseEvent <|  "<m ==> (s && (r && t))>." + truth tv1
-            let expected = [("<m ==> (r && t)>", Some <| pnn(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition3 t1 t2)  expected "nal5_nal8_implication_based_decomposition3: 1 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition3: 2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m =+> s>." + truth tv1
-            let t2 = parseEvent <|  "<m =+> (s && (r && t))>." + truth tv1
-            let expected = [("<m =+> (r && t)>", Some <| pnn(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition3 t1 t2)  expected "nal5_nal8_implication_based_decomposition3: 2 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition3: 3" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m =|> s>." + truth tv1
-            let t2 = parseEvent <|  "<m =|> (s && (r && t))>." + truth tv1
-            let expected = [("<m =|> (r && t)>", Some <| pnn(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition3 t1 t2)  expected "nal5_nal8_implication_based_decomposition3: 3 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition3: 4" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m =-> s>." + truth tv1
-            let t2 = parseEvent <|  "<m =-> (s && (r && t))>." + truth tv1
-            let expected = [("<m =-> (r && t)>", Some <| pnn(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition3 t1 t2)  expected "nal5_nal8_implication_based_decomposition3: 4 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition4: 1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m ==> s>." + truth tv1
-            let t2 = parseEvent <|  "<m ==> (s || (r || t))>." + truth tv1
-            let expected = [("<m ==> (r || t)>", Some <| npp(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition4 t1 t2)  expected "nal5_nal8_implication_based_decomposition4: 1 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition4: 2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m =+> s>." + truth tv1
-            let t2 = parseEvent <|  "<m =+> (s || (r || t))>." + truth tv1
-            let expected = [("<m =+> (r || t)>", Some <| npp(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition4 t1 t2)  expected "nal5_nal8_implication_based_decomposition4: 2 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition4: 3" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m =|> s>." + truth tv1
-            let t2 = parseEvent <|  "<m =|> (s || (r || t))>." + truth tv1
-            let expected = [("<m =|> (r || t)>", Some <| npp(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition4 t1 t2)  expected "nal5_nal8_implication_based_decomposition4: 3 failed"
-
-           
-        testCase "nal5_nal8_implication_based_decomposition5: 1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "m." + truth tv1
-            let t2 = parseEvent <|  "<m ==> p>." + truth tv1
-            let expected = [("p", Some <| ind(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 1 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition5: 2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "m." + truth tv1
-            let t2 = parseEvent <|  "<m =+> p>." + truth tv1
-            let expected = [("p", Some <| ind(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 2 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition5: 3" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "m." + truth tv1
-            let t2 = parseEvent <|  "<m =|> p>." + truth tv1
-            let expected = [("p", Some <| ind(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 3 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition5: 4" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "m." + truth tv1
-            let t2 = parseEvent <|  "<m =-> p>." + truth tv1
-            let expected = [("p", Some <| ind(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 4 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition5: 5" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "m." + truth tv1
-            let t2 = parseEvent <|  "<p ==> m>." + truth tv1
-            let expected = [("p", Some <| ind(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 5 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition5: 6" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "m." + truth tv1
-            let t2 = parseEvent <|  "<p =+> m>." + truth tv1
-            let expected = [("p", Some <| ind(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 6 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition5: 7" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "m." + truth tv1
-            let t2 = parseEvent <|  "<p =|> m>." + truth tv1
-            let expected = [("p", Some <| ind(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 7 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition5: 8" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "m." + truth tv1
-            let t2 = parseEvent <|  "<p =-> m>." + truth tv1
-            let expected = [("p", Some <| ind(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 8 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition5: 9" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "m." + truth tv1
-            let t2 = parseEvent <|  "<s <=> m>." + truth tv1
-            let expected = [("s", Some <| ana(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 9 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition5: 10" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "m." + truth tv1
-            let t2 = parseEvent <|  "<s <|> m>." + truth tv1
-            let expected = [("s", Some <| ana(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 10 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition5: 11" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "m." + truth tv1
-            let t2 = parseEvent <|  "<s <+> m>." + truth tv1
-            let expected = [("s", Some <| ana(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 11 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition5: 12" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "m." + truth tv1
-            let t2 = parseEvent <|  "<m <=> s>." + truth tv1
-            let expected = [("s", Some <| ana(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 12 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition5: 13" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "m." + truth tv1
-            let t2 = parseEvent <|  "<m <|> s>." + truth tv1
-            let expected = [("s", Some <| ana(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 13 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition5: 14" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "m." + truth tv1
-            let t2 = parseEvent <|  "<m <+> s>." + truth tv1
-            let expected = [("s", Some <| ana(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition5 t1 t2)  expected "nal5_nal8_implication_based_decomposition5: 14 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition6: 1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "(s && t)." + truth tv1
-            let t2 = parseEvent <|  "s." + truth tv1
-            let expected = [("s", Some <| ded(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition6 t1 t2)  expected "nal5_nal8_implication_based_decomposition6: 1 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition6: 2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "(s , t)." + truth tv1
-            let t2 = parseEvent <|  "s." + truth tv1
-            let expected = [("s", Some <| ded(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition6 t1 t2)  expected "nal5_nal8_implication_based_decomposition6: 2 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition6: 3" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "(s ; t)." + truth tv1
-            let t2 = parseEvent <|  "s." + truth tv1
-            let expected = [("s", Some <| ded(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition6 t1 t2)  expected "nal5_nal8_implication_based_decomposition6: 3 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition7: 1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "s." + truth tv1
-            let t2 = parseEvent <|  "(s , (r , t))." + truth tv1
-            let expected = [("(r , t)", Some <| pnn(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition7 t1 t2)  expected "nal5_nal8_implication_based_decomposition7: 1 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition7: 2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "s." + truth tv1
-            let t2 = parseEvent <|  "(s ; (r ; t))." + truth tv1
-            let expected = [("(r ; t)", Some <| pnn(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition7 t1 t2)  expected "nal5_nal8_implication_based_decomposition7: 2 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition7: 3" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "s." + truth tv1
-            let t2 = parseEvent <|  "(s && (r && t))." + truth tv1
-            let expected = [("(r && t)", Some <| pnn(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition7 t1 t2)  expected "nal5_nal8_implication_based_decomposition7: 3 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition7: 4" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "s." + truth tv1
-            let t2 = parseEvent <|  "(s || (r || t))." + truth tv1
-            let expected = [("(r || t)", Some <| pnn(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition7 t1 t2)  expected "nal5_nal8_implication_based_decomposition7: 4 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition8: 1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "s." + truth tv1
-            let t2 = parseEvent <|  "(--s , (r , t))." + truth tv1
-            let expected = [("(r , t)", Some <| nnn(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition8 t1 t2)  expected "nal5_nal8_implication_based_decomposition8: 1 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition8: 2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "s." + truth tv1
-            let t2 = parseEvent <|  "(--s ; (r ; t))." + truth tv2
-            let expected = [("(r ; t)", Some <| nnn(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition8 t1 t2)  expected "nal5_nal8_implication_based_decomposition8: 2 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition8: 3" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "s." + truth tv1
-            let t2 = parseEvent <|  "(--s && (r && t))." + truth tv2
-            let expected = [("(r && t)", Some <| nnn(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition8 t1 t2)  expected "nal5_nal8_implication_based_decomposition8: 3 failed"
-
-        testCase "nal5_nal8_implication_based_decomposition8: 4" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "s." + truth tv1
-            let t2 = parseEvent <|  "(--s || (r || t))." + truth tv2
-            let expected = [("(r || t)", Some <| nnn(tv1, tv2))]
-            Expect.equal (testInfFunc nal5_nal8_implication_based_decomposition8 t1 t2)  expected "nal5_nal8_implication_based_decomposition8: 4 failed"
-
-        testCase "nal6_variable_introduction: 1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<s --> m>." + truth tv1
-            let t2 = parseEvent <|  "<p --> m>." + truth tv2
-            let expected = [("<<p --> $X> ==> <s --> $X>>", Some <| abd(tv1, tv2))
-                            ("<<s --> $X> ==> <p --> $X>>", Some <| ind(tv1, tv2))
-                            ("<<p --> $X> <=> <s --> $X>>", Some <| com(tv1, tv2))
-                            ("(<p --> #Y> && <s --> #Y>)", Some <| int(tv1, tv2))
-
-                            ("<<p --> $X> =|> <s --> $X>>", Some <| abd(tv1, tv2))
-                            ("<<s --> $X> =|> <p --> $X>>", Some <| ind(tv1, tv2))
-                            ("<<p --> $X> =|> <s --> $X>>", Some <| ind(tv1, tv2))
-                            ("<<p --> $X> <|> <s --> $X>>", Some <| com(tv1, tv2))
-                            ("(<p --> #Y> ; <s --> #Y>)", Some <| int(tv1, tv2))]
-            Expect.equal (testInfFunc nal6_variable_introduction t1 t2)  expected "nal6_variable_introduction: 1 failed"
-
-        testCase "nal6_variable_introduction: 2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<m --> s>." + truth tv1
-            let t2 = parseEvent <|  "<m --> p>." + truth tv2
-            let expected = [("<<$X --> s> ==> <$X --> p>>", Some <| ind(tv1, tv2))
-                            ("<<$X --> p> ==> <$X --> s>>", Some <| abd(tv1, tv2))
-                            ("<<$X --> s> <=> <$X --> p>>", Some <| com(tv1, tv2))
-                            ("(<#Y --> s> && <#Y --> p>)", Some <| int(tv1, tv2))
-
-                            ("<<$X --> s> =|> <$X --> p>>", Some <| ind(tv1, tv2))
-                            ("<<$X --> p> =|> <$X --> s>>", Some <| abd(tv1, tv2))
-                            ("<<$X --> s> =|> <$X --> p>>", Some <| ind(tv1, tv2))
-                            ("<<$X --> s> <|> <$X --> p>>", Some <| com(tv1, tv2))
-                            ("(<#Y --> s> ; <#Y --> p>)", Some <| int(tv1, tv2))]
-            Expect.equal (testInfFunc nal6_variable_introduction t1 t2)  expected "nal6_variable_introduction: 2 failed"
-
-        testCase "nal6_variable_syllogisms: 1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<<a --> r> ==> z>." + truth tv1
-            let t2 = parseEvent <|  "<(<#Y --> b> && <#Y --> r>) ==> z>." + truth tv2
-            let expected = [("<a --> b>", Some <| abd(tv1, tv2))]
-            Expect.equal (testInfFunc nal6_variable_syllogisms t1 t2)  expected "nal6_variable_syllogisms: 1 failed"
-
-        testCase "nal6_variable_syllogisms: 1a" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<<a --> r> ==> z>." + truth tv1
-            let t2 = parseEvent <|  "<(<#Y --> r> && <#Y --> b>) ==> z>." + truth tv2
-            let expected = [("<a --> b>", Some <| abd(tv1, tv2))]
-            Expect.equal (testInfFunc nal6_variable_syllogisms t1 t2)  expected "nal6_variable_syllogisms: 1a failed"
-
-        testCase "nal6_variable_syllogisms: 2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<u --> l>." + truth tv1
-            let t2 = parseEvent <|  "<(<#Y --> l> && <#Y --> r>) ==> z>." + truth tv2
-            let expected = [("<<u --> r> ==> z>", Some <| ded(tv1, tv2))]
-            Expect.equal (testInfFunc nal6_variable_syllogisms t1 t2)  expected "nal6_variable_syllogisms: 2 failed"
-
-        testCase "nal6_variable_syllogisms: 2a" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<u --> l>." + truth tv1
-            let t2 = parseEvent <|  "<(<#Y --> r> && <#Y --> l>) ==> z>." + truth tv2
-            let expected = [("<<u --> r> ==> z>", Some <| ded(tv1, tv2))]
-            Expect.equal (testInfFunc nal6_variable_syllogisms t1 t2)  expected "nal6_variable_syllogisms: 2a failed"
-
-        testCase "nal6_variable_elimination: 1" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
-            let t2 = parseEvent <|  "(<($x * $y) --> larger> && <($y * $x) --> smaller>)." + truth tv2
-            let expected = [("<(apple * earth) --> smaller>", Some <| anon_ana(tv1, tv2))]
-            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 1 failed"
-
-        testCase "nal6_variable_elimination: 2" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
-            let t2 = parseEvent <|  "(<($x * $y) --> smaller> && <($y * $x) --> larger>)." + truth tv2
-            let expected = [("<(apple * earth) --> smaller>", Some <| anon_ana(tv1, tv2))]
-            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 2 failed"
-
-        testCase "nal6_variable_elimination: 3" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "(<($x * $y) --> smaller> && <($y * $x) --> larger>)." + truth tv2
-            let t2 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1            
-            let expected = [("<(apple * earth) --> smaller>", Some <| ded(tv1, tv2))]
-            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 3 failed"
-
-        testCase "nal6_variable_elimination: 4" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "(<($x * $y) --> smaller> && <($y * $x) --> larger>)." + truth tv2
-            let t2 = parseEvent <|  "<(earth * apple) --> smaller>." + truth tv1            
-            let expected = [("<(apple * earth) --> larger>", Some <| ded(tv1, tv2))]
-            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 4 failed"
-
-        testCase "nal6_variable_elimination: 5" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
-            let t2 = parseEvent <|  "<<($x * $y) --> larger> ==> <($y * $x) --> smaller>>." + truth tv2
-            let expected = [("<(apple * earth) --> smaller>", Some <| ded(tv1, tv2))]
-            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 1 failed"
-
-        testCase "nal6_variable_elimination: 6" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
-            let t2 = parseEvent <|  "<<($x * $y) --> larger> =+> <($y * $x) --> smaller>>." + truth tv2
-            let expected = [("<(apple * earth) --> smaller>", Some <| ded(tv1, tv2))]
-            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 2 failed"
-
-        testCase "nal6_variable_elimination: 7" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
-            let t2 = parseEvent <|  "<<($x * $y) --> larger> =|> <($y * $x) --> smaller>>." + truth tv2
-            let expected = [("<(apple * earth) --> smaller>", Some <| ded(tv1, tv2))]
-            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 7 failed"
-        
-        testCase "nal6_variable_elimination: 8" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
-            let t2 = parseEvent <|  "<<($x * $y) --> larger> =-> <($y * $x) --> smaller>>." + truth tv2
-            let expected = [("<(apple * earth) --> smaller>", Some <| ded(tv1, tv2))]
-            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 8 failed"
-
-        testCase "nal6_variable_elimination: 9" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
-            let t2 = parseEvent <|  "<<($x * $y) --> smaller> ==> <($y * $x) --> larger>>." + truth tv2
-            let expected = [("<(apple * earth) --> smaller>", Some <| abd(tv1, tv2))]
-            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 9 failed"
-
-        testCase "nal6_variable_elimination: 10" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
-            let t2 = parseEvent <|  "<<($x * $y) --> smaller> =+> <($y * $x) --> larger>>." + truth tv2
-            let expected = [("<(apple * earth) --> smaller>", Some <| abd(tv1, tv2))]
-            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 10 failed"
-
-        testCase "nal6_variable_elimination: 11" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
-            let t2 = parseEvent <|  "<<($x * $y) --> smaller> =|> <($y * $x) --> larger>>." + truth tv2
-            let expected = [("<(apple * earth) --> smaller>", Some <| abd(tv1, tv2))]
-            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 11 failed"
-
-        testCase "nal6_variable_elimination: 12" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
-            let t2 = parseEvent <|  "<<($x * $y) --> smaller> =-> <($y * $x) --> larger>>." + truth tv2
-            let expected = [("<(apple * earth) --> smaller>", Some <| abd(tv1, tv2))]
-            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 12 failed"
-
-        testCase "nal6_variable_elimination: 13" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
-            let t2 = parseEvent <|  "<<($x * $y) --> larger> <=> <($y * $x) --> smaller>>." + truth tv2
-            let expected = [("<(apple * earth) --> smaller>", Some <| ana(tv1, tv2))]
-            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 13 failed"
-        
-        testCase "nal6_variable_elimination: 14" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
-            let t2 = parseEvent <|  "<<($x * $y) --> larger> <|> <($y * $x) --> smaller>>." + truth tv2
-            let expected = [("<(apple * earth) --> smaller>", Some <| ana(tv1, tv2))]
-            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 14 failed"
-
-        testCase "nal6_variable_elimination: 14a" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "(<rabbit --> animal> ; <PETER --> word>)." + truth tv1
-            let t2 = parseEvent <|  "<($1 ; <$2 --> word>) <|> <(REPRESENT / $2 _) <-> $1>>." + truth tv2
-            let expected = [("<(REPRESENT / PETER _) <-> <rabbit --> animal>>", Some <| ana(tv1, tv2))]
-            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 14a failed"
-
-
-        testCase "nal6_variable_elimination: 15" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
-            let t2 = parseEvent <|  "<<($x * $y) --> larger> <+> <($y * $x) --> smaller>>." + truth tv2
-            let expected = [("<(apple * earth) --> smaller>", Some <| ana(tv1, tv2))]
-            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 15 failed"
-
-        testCase "nal6_variable_elimination: 16" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
-            let t2 = parseEvent <|  "<<($x * $y) --> smaller> <=> <($y * $x) --> larger>>." + truth tv2
-            let expected = [("<(apple * earth) --> smaller>", Some <| ana(tv1, tv2))]
-            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 16 failed"
-
-        testCase "nal6_variable_elimination: 17" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
-            let t2 = parseEvent <|  "<<($x * $y) --> smaller> <|> <($y * $x) --> larger>>." + truth tv2
-            let expected = [("<(apple * earth) --> smaller>", Some <| ana(tv1, tv2))]
-            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 17 failed"
-
-        testCase "nal6_variable_elimination: 18" <| fun () ->   
-            let tv1 = {F = 1.0f; C = 0.9f}
-            let tv2 = {F = 1.0f; C = 0.9f}
-            let t1 = parseEvent <|  "<(earth * apple) --> larger>." + truth tv1
-            let t2 = parseEvent <|  "<<($x * $y) --> smaller> <+> <($y * $x) --> larger>>." + truth tv2
-            let expected = [("<(apple * earth) --> smaller>", Some <| ana(tv1, tv2))]
-            Expect.equal (testInfFunc nal6_variable_elimination t1 t2)  expected "nal6_variable_elimination: 18 failed"
-        
-        // TODO Missing test cases for variable elimination
-
-        //testCase "nal7_temporal_inference: 1" <| fun () ->   
-        //    let tv1 = {F = 1.0f; C = 0.9f}
-        //    let tv2 = {F = 1.0f; C = 0.9f}
-        //    let t1 = parseEvent <|  "s." + truth tv1
-        //    Thread.Sleep(200);
-        //    let t2 = parseEvent <|  "p." + truth tv2
-        //    let expected = [("<s =+> p>", Some <| ind(tv1, tv2))
-        //                    ("<p =-> s>", Some <| abd(tv1, tv2))
-        //                    ("<s <+> p>", Some <| com(tv1, tv2))
-        //                    ("(s , p)", Some <| int(tv1, tv2))]
-        //    Expect.equal (testTemporalInfFunc t1 t2)  expected "nal7_temporal_inference: 1 failed"
-
-        //testCase "nal7_temporal_inference: 2" <| fun () ->   
-        //    let tv1 = {F = 1.0f; C = 0.9f}
-        //    let tv2 = {F = 1.0f; C = 0.9f}
-        //    let t1 = parseEvent <|  "p." + truth tv1
-        //    Thread.Sleep(200);
-        //    let t2 = parseEvent <|  "s." + truth tv2
-        //    let expected = [("<p =+> s>", Some <| ind(tv1, tv2))
-        //                    ("<s =-> p>", Some <| abd(tv1, tv2))
-        //                    ("<p <+> s>", Some <| com(tv1, tv2))
-        //                    ("(p , s)", Some <| int(tv1, tv2))]
-        //    Expect.equal (testTemporalInfFunc t2 t1)  expected "nal7_temporal_inference: 2 failed"
-
-]
-
diff --git a/ALANNStreams/Tests/Parser/ParserTests.fs b/ALANNStreams/Tests/Parser/ParserTests.fs
new file mode 100644
index 0000000..3a86b60
--- /dev/null
+++ b/ALANNStreams/Tests/Parser/ParserTests.fs
@@ -0,0 +1,345 @@
+ (*
+ * The MIT License
+ *
+ * Copyright 2018 The ALANN2018 authors.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *)
+
+module ParserTests
+
+open Types
+open Parser
+open Expecto
+
+[<Tests>]
+let tests =
+    testList "BudgetTests" [
+        testCase "BudgetTest1" <| fun () ->
+            let expected = Some {STI = 1.0f; LTI = 0.99f}
+            Expect.equal (testp pav_ws "[1.0 0.99]") expected "Incorrect budget"
+
+        testCase "BudgetTest2" <| fun () ->
+            let expected = None
+            Expect.notEqual (testp pav_ws "[0.0 0.99]") expected "Incorrect budget"
+
+        testCase "BudgetTest3" <| fun () ->
+            let expected = Some {STI = 1.0f; LTI = 0.9999f}
+            Expect.equal (testp pav_ws "[1.000000  0.9999] ") expected "Incorrect budget"
+    ]
+
+[<Tests>]
+let test1 =
+    testList "TVTests" [
+        testCase "TVTest1" <| fun () ->
+            let expected = Some {F = 1.0f; C = 0.99f}
+            Expect.equal (testp ptruth_ws "{1.0 0.99}") expected "Incorrect TV"
+
+        testCase "TVTest2" <| fun () ->
+            let expected = Some {F = 0.0f; C = 0.99f}
+            Expect.notEqual (testp ptruth_ws "{1.0 0.99}") expected "Incorrect TV"
+
+        testCase "TVTest3" <| fun () ->
+            let expected = Some {F = 1.0f; C = 0.9999f}
+            Expect.equal (testp ptruth_ws "{1.000000  0.9999} ") expected "Incorrect TV"
+    ]
+
+[<Tests>]
+let test1a =
+    testList "WordTests" [
+        testCase "WordTest1" <| fun () ->
+            let expected = Some (Word "a")
+            Expect.equal (testp pword_ws " a ") expected "Incorrect Word"
+
+        testCase "WordTest2" <| fun () ->
+            let expected = Some (Word "1")
+            Expect.equal (testp pword_ws " 1 ") expected "Incorrect Word"
+
+        testCase "WordTest3" <| fun () ->
+            let expected = Some (Word "_")
+            Expect.equal (testp pword_ws " _ ") expected "Incorrect Word"
+
+        testCase "WordTest4" <| fun () ->
+            let expected = Some (Word "1_a")
+            Expect.equal (testp pword_ws " 1_a ") expected "Incorrect Word"
+
+        testCase "WordTest5" <| fun () ->
+            let expected = Some (Word "abcdefghijklmnopqrstuvwxyz")
+            Expect.equal (testp pword_ws " abcdefghijklmnopqrstuvwxyz ") expected "Incorrect long Word"
+    ]
+
+[<Tests>]
+let tests4 =
+    // test in sequqnce to avoid single threading in parser with var renaming
+    testSequenced  <| 
+        testList "VariableTests" [
+            testCase "VariableTest1" <| fun () ->
+                let expected = Some (Var(QVar, "1"))
+                Expect.equal (testp pvariable_ws " ?what ") expected "Incorrect variable"
+
+            testCase "VariableTest2" <| fun () ->
+                let expected = Some (Var(QVar, "1"))
+                Expect.equal (testp pvariable_ws " ?1 ") expected "Incorrect variable"
+
+            testCase "VariableTest3" <| fun () ->
+                let expected = Some (Var(DVar, "1"))
+                Expect.equal (testp pvariable_ws " #1 ") expected "Incorrect variable"
+
+            testCase "VariableTest4" <| fun () ->
+                let expected = Some (Var(IVar, "1"))
+                Expect.equal (testp pvariable_ws " $cat ") expected "Incorrect variable"
+
+            testCase "VariableTest5" <| fun () ->
+                let expected = Some (Var(IVar, "1"))
+                Expect.equal (testp pvariable_ws " $1 ") expected "Incorrect variable"
+        ]
+
+[<Tests>]
+let tests5a =
+    testList "SetTests" [
+        testCase "SetTest1" <| fun () ->
+            let expected = Some (Term(ExtSet, [Word "1"; Word "2"]))
+            Expect.equal (testp pset_ws "{ 2  1 } ") expected "Incorrect extSet"
+
+        testCase "SetTest2" <| fun () ->
+            let expected = Some (Term(IntSet, [Word "1"; Word "2"]))
+            Expect.equal (testp pset_ws "[ 2 1 ] ") expected "Incorrect intSet"
+    ]
+
+[<Tests>]
+let tests5 =
+    testList "CompoundTermTests" [
+        testCase "CompoundTermTest3" <| fun () ->
+            let expected = Some (Term(And, [Word "1"; Word"2"]))
+            Expect.equal (testp pcompound_term_ws " ( 1 && 2 ) ") expected "Incorrect conjunction"
+
+        testCase "CompoundTermTest4" <| fun () ->
+            let expected = Some (Term(Or, [Word "1"; Word"2"]))
+            Expect.equal (testp pcompound_term_ws " ( 1 || 2 ) ") expected "Incorrect disjunction"
+
+        testCase "CompoundTermTest5" <| fun () ->
+            let expected = Some (Term(Prod, [Word "1"; Word "2"]))
+            Expect.equal (testp pcompound_term_ws " ( 1 * 2 ) ") expected "Incorrect product"
+
+        testCase "CompoundTermTest5a" <| fun () ->
+            let expected = Some (Term(Prod, [Word "1"; Term(Prod, [Word "2"; Word "3"])]))
+            Expect.equal (testp pcompound_term_ws " ( 1 * ( 2 * 3 ) ) ") expected "Incorrect nested product"
+
+        testCase "CompoundTermTest6" <| fun () ->
+            let expected = Some (Term(Par, [Word "a"; Word "b"]))
+            Expect.equal (testp pcompound_term_ws " ( a ; b ) ") expected "Incorrect par"
+
+        testCase "CompoundTermTest6a" <| fun () ->
+            let expected = Some (Term(Par, [Word "b"; Term(Par, [Word "a"; Word "c"])]))
+            Expect.equal (testp pcompound_term_ws " ( b ; ( a ; c ) ) ") expected "Incorrect nested par"
+
+        testCase "CompoundTermTest7" <| fun () ->
+            let expected = Some (Term(Seq, [Word "a"; Word "b"]))
+            Expect.equal (testp pcompound_term_ws " ( a , b ) ") expected "Incorrect seq"
+
+        testCase "CompoundTermTest7a" <| fun () ->
+            let expected = Some (Term(Seq, [Word "a"; Word "b"]))
+            Expect.equal (testp pcompound_term_ws "(a, b)") expected "Incorrect seq"
+
+        testCase "CompoundTermTest7b" <| fun () ->
+            let expected = Some (Term(Seq, [Word "a"; Term(Seq, [Word "b"; Word "c"])]))
+            Expect.equal (testp pcompound_term_ws " ( a , ( b , c) ) ") expected "Incorrect nested seq"
+
+        testCase "CompoundTermTest7c" <| fun () ->
+            let expected = Some (Term(Seq, [Word "a"; Term(Seq, [Word "b"; Word "c"])]))
+            Expect.equal (testp pcompound_term_ws "(a,(b,c))") expected "Incorrect nested seq"
+
+        testCase "CompoundTermTest7d" <| fun () ->
+            let expected = Some (Term(Seq, [Term(Seq, [Word "a"; Word "b"]); Word "c"]))
+            Expect.equal (testp pcompound_term_ws "((a,b),c)") expected "Incorrect nested seq"
+
+        testCase "CompoundTermTest8" <| fun () ->
+            let expected = Some (Term(IntInt, [Word "a"; Word "b"]))
+            Expect.equal (testp pcompound_term_ws " ( a | b ) ") expected "Incorrect intInt"
+
+        testCase "CompoundTermTest9" <| fun () ->
+            let expected = Some (Term(ExtInt, [Word "a"; Word "b"]))
+            Expect.equal (testp pcompound_term_ws " ( a & b ) ") expected "Incorrect extInt"
+
+        testCase "CompoundTermTest10" <| fun () ->
+            let expected = Some (Term(ExtImg, [Word "a"; Word "b"; Word "_"]))
+            Expect.equal (testp pcompound_term_ws " ( a / b _ ) ") expected "Incorrect extImg"
+
+        testCase "CompoundTermTest11" <| fun () ->
+            let expected = Some (Term(IntImg, [Word "a"; Word "b"; Word "_"]))
+            Expect.equal (testp pcompound_term_ws " ( a \  b _ ) ") expected "Incorrect intImg"
+
+        testCase "CompoundTermTest12" <| fun () ->
+            let expected = Some (Term(ExtDif, [Word "a"; Word "b"]))
+            Expect.equal (testp pcompound_term_ws " ( a - b ) ") expected "Incorrect extInt"
+
+        testCase "CompoundTermTest13" <| fun () ->
+            let expected = Some (Term(IntDif, [Word "a"; Word "b"]))
+            Expect.equal (testp pcompound_term_ws " ( a ~ b ) ") expected "Incorrect extInt"
+
+        testCase "CompoundTermTest14" <| fun () ->
+            let expected = Some (Term(Par, [Term(Inh, [Word "a"; Word "b"]); Term(Inh, [Word "b"; Word "c"])]))
+            Expect.equal (testp pcompound_term_ws " (<a --> b> ; <b --> c>) ") expected "Incorrect par term"
+
+        testCase "CompoundTermTest15" <| fun () ->
+            let t1 = Term (Seq, [Term(Inh, [Word "a"; Word "b"]); Term(Inh, [Word "b"; Word "c"])] )
+            let t2 = Term (Seq, [Term(Inh, [Word "a"; Word "b"]); Term(Inh, [Word "b"; Word "c"])] )
+            let expected = Some (Term(Seq, [t1; t2]))
+            Expect.equal (testp pcompound_term_ws " ((<a --> b> , <b --> c>) , (<a --> b> , <b --> c>)) ") expected "Incorrect par term"
+
+        testCase "CompoundTermTest16" <| fun () ->
+            let expected = Some (Term(Seq, [Term(Inh, [Word "a"; Word "b"]); Term(Inh, [Word "b"; Word "c"])]))
+            Expect.equal (testp pcompound_term_ws " (<a --> b> , <b --> c>) ") expected "Incorrect seq term"
+    ]
+
+[<Tests>]
+let tests6 =
+    testList "StatementExprTests" [
+        testCase "StatementExprTest1" <| fun () ->
+            let expected = Some (Term(Inh, [Word "a"; Word "b"]))
+            Expect.equal (testp statement " < a --> b > ") expected "Incorrect inh"
+
+        testCase "StatementExprTest2" <| fun () ->
+            let expected = Some (Term(Sim, [Word "a"; Word "b"]))
+            Expect.equal (testp statement " < a <-> b > ") expected "Incorrect sim"
+
+        testCase "StatementExprTest3" <| fun () ->
+            let expected = Some (Term(Inh, [Term(ExtSet, [Word "a"]); Word "b"]))
+            Expect.equal (testp statement " < a {-- b > ") expected "Incorrect instance"
+
+        testCase "StatementExprTest4" <| fun () ->
+            let expected = Some (Term(Inh, [Word "a"; Term(IntSet, [Word "b"])]))
+            Expect.equal (testp statement " < a --] b > ") expected "Incorrect property"
+
+        testCase "StatementExprTest5" <| fun () ->
+            let expected = Some (Term(Inh, [Term(ExtSet, [Word "a"]); Term(IntSet, [Word "b"])]))
+            Expect.equal (testp statement " < a {-] b > ") expected "Incorrect instProp"
+
+        testCase "StatementExprTest6" <| fun () ->
+            let expected = Some (Term(Imp, [Word "a"; Word "b"]))
+            Expect.equal (testp statement " < a ==> b > ") expected "Incorrect imp"
+
+        testCase "StatementExprTest7" <| fun () ->
+            let expected = Some (Term(Equ, [Word "a"; Word "b"]))
+            Expect.equal (testp statement " < a <=> b > ") expected "Incorrect equ"
+
+        testCase "StatementExprTest8" <| fun () ->
+            let expected = Some (Term(ConEqu, [Word "a"; Word "b"]))
+            Expect.equal (testp statement " < a <|> b > ") expected "Incorrect conEqu"
+
+        testCase "StatementExprTest9" <| fun () ->
+            let expected = Some (Term(PreEqu, [Word "a"; Word "b"]))
+            Expect.equal (testp statement " < a <+> b > ") expected "Incorrect preEqu"
+
+        testCase "StatementExprTest10" <| fun () ->
+            let expected = Some (Term(PreImp, [Word "a"; Word "b"]))
+            Expect.equal (testp statement " < a =+> b > ") expected "Incorrect preImp"
+
+        testCase "StatementExprTest11" <| fun () ->
+            let expected = Some (Term(ConImp, [Word "a"; Word "b"]))
+            Expect.equal (testp statement " < a =|> b > ") expected "Incorrect conImp"
+
+        testCase "StatementExprTest12" <| fun () ->
+            let expected = Some (Term(RetImp, [Word "a"; Word "b"]))
+            Expect.equal (testp statement " < a =-> b > ") expected "Incorrect retImp"
+    ]
+
+[<Tests>]
+let tests7 =
+    testList "TermTests" [
+        testCase "TermTest1" <| fun () ->
+            let expected = Some (Word "cat")
+            Expect.equal (testp pterm " cat ") expected "Incorrect Word"
+
+        testCase "TermTest2" <| fun () ->
+            let expected = Some (Var(QVar, "1"))
+            Expect.equal (testp pterm " ?what ") expected "Incorrect variable"
+
+        testCase "TermTest3" <| fun () ->
+            let expected = Some (Term(Not, [Word "cat"]))
+            Expect.equal (testp pterm " -- cat ") expected "Incorrect compoundTerm"
+
+        testCase "TermTest4" <| fun () ->
+            let expected = Some (Term(Not, [Word "cat"]))
+            Expect.equal (testp pterm "--cat ") expected "Incorrect compoundTerm"
+
+        testCase "TermTest5" <| fun () ->
+            let expected = Some (Term(Not, [Word "cat"]))
+            Expect.equal (testp pterm " -- cat ") expected "Incorrect compoundTerm"
+
+        testCase "TermTest6" <| fun () ->
+            let expected = Some (Term(Inh, [Word "cat"; Word "animal"]))
+            Expect.equal (testp pterm " < cat --> animal > ") expected "Incorrect statementExpr"
+    ]
+
+[<Tests>]
+let tests8 =
+    testList "StatementTests" [
+        testCase "StatementTest1" <| fun () ->
+            let expected = Some (Term(Imp, [Term(Inh, [Word "a"; Word "b"]); Term(Sim, [Word "b"; Word "c"])]))
+            Expect.equal (testp statement " <<a --> b> ==> <b <-> c>> ") expected "Incorrect statementExpr"
+    ]
+
+[<Tests>]
+let tests9 =
+    testList "SentenceTests" [
+        testCase "SentenceTest1" <| fun () ->
+            let expected = Some {EventType = Belief; Term = Term(Inh, [Word "a"; Word "b"]); TV = Some {F = 1.0f; C = 0.9f}}
+            Expect.equal (testp psentence_ws " <a --> b>.") expected "Incorrect belief no options"
+
+        testCase "SentenceTest2" <| fun () ->
+            let expected = Some {EventType = Belief; Term = Term(Inh, [Word "a"; Word "b"]); TV = Some {F = 1.0f; C = 0.9f}}
+            Expect.equal (testp psentence_ws " <a --> b>. ") expected "Incorrect belief with present tense"
+
+        testCase "SentenceTest3" <| fun () ->
+            let expected = Some {EventType = Belief; Term = Term(Inh, [Word "a"; Word "b"]); TV = Some {F = 0.5f; C = 0.75f}}
+            Expect.equal (testp psentence_ws " <a --> b>. {0.5 0.75}") expected "Incorrect belief with truth"
+
+        testCase "SentenceTest4" <| fun () ->
+            let expected = Some {EventType = Belief; Term = Term(Inh, [Word "a"; Word "b"]); TV = Some {F = 0.5f; C = 0.75f}}
+            Expect.equal (testp psentence_ws " <a --> b>. {0.5 0.75}") expected "Incorrect belief with truth and interval tense"
+
+        testCase "SentenceTest5" <| fun () ->
+            let expected = Some {EventType = Question; Term = Term(Inh, [Word "a"; Word "b"]); TV = None}
+            Expect.equal (testp psentence_ws " <a --> b>?") expected "Incorrect questions no options"
+
+        testCase "SentenceTest6" <| fun () ->
+            let expected = Some {EventType = Question; Term = Term(Inh, [Word "a"; Word "b"]); TV = None}
+            Expect.equal (testp psentence_ws " <a --> b>? ") expected "Incorrect questions with tense"
+
+        testCase "SentenceTest7" <| fun () ->
+            let expected = Some {EventType = Question; Term = Term(Inh, [Var(QVar, "1"); Word "b"]); TV = None}
+            Expect.equal (testp psentence_ws " <?what --> b>? ") expected "Incorrect questions with tense"
+
+        testCase "SentenceTest8" <| fun () ->
+            let expected = Some {EventType = Goal; Term = Term(Inh, [Word "a"; Word "b"]); TV = Some {F =1.0f; C = 0.9f}}
+            Expect.equal (testp psentence_ws " <a --> b>!") expected "Incorrect goal"
+
+        testCase "SentenceTest9" <| fun () ->
+            let expected = Some {EventType = Goal; Term = Word "a"; TV = Some {F =1.0f; C = 0.9f}}
+            Expect.equal (testp psentence_ws " a!") expected "Incorrect goal"
+
+        testCase "SentenceTest10" <| fun () ->
+            let expected = Some {EventType = Quest; Term = Term(Inh, [Word "a"; Word "b"]); TV = None}
+            Expect.equal (testp psentence_ws " <a --> b>@") expected "Incorrect quest"
+
+        testCase "SentenceTest11" <| fun () ->
+            let expected = Some {EventType = Quest; Term = Word "a"; TV = None}
+            Expect.equal (testp psentence_ws " a@") expected "Incorrect quest"
+    ]
diff --git a/ALANNStreams/Tests/Unify/UniifyTests.fs b/ALANNStreams/Tests/Unify/UniifyTests.fs
index 1ba37c4..5c4962b 100644
--- a/ALANNStreams/Tests/Unify/UniifyTests.fs
+++ b/ALANNStreams/Tests/Unify/UniifyTests.fs
@@ -91,4 +91,11 @@ let test1 =
             let q1 = parseTerm "<?what ==> <d --> e>>"
             let expected = true
             Expect.equal  (unifies t1 q1) expected "Incorrect format"
+
+        testCase "FormatTest10" <| fun () ->   
+            let t1 = parseTerm "<<$x --> bird> ==> <$x --> flyer>>"
+            let q1 = parseTerm "<<$y --> bird> ==> <$y --> flyer>>. {0.00 0.70} "
+            let expected = true
+            Expect.equal  (unifies t1 q1) expected "Incorrect format"
+
     ]
diff --git a/ALANNStreams/TypesPlus/Types.fs b/ALANNStreams/TypesPlus/Types.fs
index 23a827f..efe5425 100644
--- a/ALANNStreams/TypesPlus/Types.fs
+++ b/ALANNStreams/TypesPlus/Types.fs
@@ -160,6 +160,7 @@ type IStore =
     abstract GetSuperBeliefs : unit -> seq<Belief>
     abstract GetTemporalBeliefs : unit -> seq<Belief>
     abstract GetGeneralBeliefs : unit -> seq<Belief>
+    abstract GetVariableBeliefs : unit -> seq<Belief>
 
 type Node     = {Term : Term
                  Beliefs : IStore
@@ -177,6 +178,7 @@ type Message = | ProcessEvent of Event
 type Command = | Show_General_Beliefs of Term
                | Show_Temporal_Beliefs of Term
                | Show_Super_Beliefs of Term
+               | Show_Variable_Beliefs of Term
                | Show_Node of Term
                | Node_Count
                | Enable_Trace of Term