inspector

examples/omitting/conference.spec

@@ -5,19 +5,19 @@ forallmay x:A,p:P
 forallmay x:A,p:P
 	!Conf(x,p) → Assign += (x,p)
 forall x:A,p:P,r:R
-	(Assign(x,p) ∧ O(x,p,r)) → Review += (x,p,r)
+	(Assign(x,p) ∧ Oracle(x,p,r)) → Review += (x,p,r)
 loop {
-	forall x:A,y:A,p:P,r:R (Assign(x,p) ∧ Review(y,p,r)) → Read += (x,r)
+	forall xa:A,xb:A,p:P,r:R (Assign(xa,p) ∧ Review(xb,p,r)) → Read += (xa,r)
 	forallmay x:A,p:P,r:R (Assign(x,p)) → Review += (x,p,r)
 }
 
 Declassify
 
-O(x:A,p:P,r:R): ¬ Conf(xt:A,p:P)
+Oracle(x:A,p:P,r:R): ¬ Conf(xat:A,p:P)
 
 Target
 
-Read(xt:A, rt:R)
+Read(xat:A, rt:R)
 
 Causality
 

src/main/scala/de/tum/workflows/InvariantInspector.scala

@@ -16,6 +16,7 @@ import de.tum.workflows.foltl.FormulaFunctions
 import de.tum.workflows.toz3.InvariantChecker
 import de.tum.workflows.toz3.InvariantGenerator
 import de.tum.workflows.toz3.InvProperties
+import de.tum.workflows.toz3.Z3QFree
 
 object InvariantInspector extends App with LazyLogging {
 
@@ -37,10 +38,39 @@ object InvariantInspector extends App with LazyLogging {
 
     val (t, (res, dot)) = time {
       //        InvariantChecker.checkInvariantOnce(spec.w, inv(spec), true)
+      val props = InvProperties(stubborn = false, eliminateAux = true)
       val (result, graph, afterlabels, proven, dot, time) = 
-        InvariantChecker.checkInvariantFPLabelling(spec, invariant(spec), InvProperties.DEFAULT)
-      println(graph)  
-      println(afterlabels.last)
+        InvariantChecker.checkInvariantFPLabelling(spec, invariant(spec), props)
+        
+      // non-omitting conference linear inspection
+      val lastlabels = afterlabels.last
+      val inv = lastlabels(2)
+      val emptyinv = inv.assumeEmpty(List("informed", "Read", "Comm")).simplify()
+      logger.info(s"empty: ${emptyinv.pretty()}")
+      
+//      val auxes = List("O", "choice2")
+      // Different Os
+      val diffos = emptyinv everywhere {
+        case Fun("O", Some(t), vars) => Fun(s"O$t", vars)
+      }
+      val auxes = List("Ot1", "Ot2")
+//      val auxes = List()
+      val auxless = auxes.foldLeft(diffos)((inv, p) =>
+          FOTransformers.eliminateAuxiliaryPredicate(inv, p)
+          )
+      val simped = auxless.toCNF.simplify()
+      logger.info(s"auxless: ${simped.pretty()}")
+      
+      logger.info("Computing with B now")
+      val withB = simped everywhere {
+        case Fun("Assign",t,vars) => And(Fun("Assign",t,vars), Neg(Fun("B",vars)))
+//        case Fun("Assign",t,vars) => Fun("B",vars)
+      }
+      logger.info(s"withB: ${withB.simplify().pretty()}")
+      logger.info(s"withB CNF: ${withB.toCNF.simplify().pretty()}")
+        
+      logger.info(s"Graph: $graph")  
+      logger.info(s"Final Invariants:\n${afterlabels.last}")
       (result, dot)
     }
     val msg = s"Invariant was ${if (res) "" else "not "}proven (took $t ms)\n"
@@ -51,7 +81,7 @@ object InvariantInspector extends App with LazyLogging {
     }
   }
   
-//  inspect("omitting/conference")
-      inspect("tests/loopexampleNoOracle")
+  inspect("nonomitting/conference_linear")
+//      inspect("tests/loopexampleNoOracle")
   //  generateAllExamples()
 }
\ No newline at end of file

src/main/scala/de/tum/workflows/foltl/FOTransformers.scala

@@ -52,17 +52,8 @@ object FOTransformers extends LazyLogging {
   def eliminateAuxiliaryPredicate(f:Formula, AUX:String) = {
     val (quantifiers, clauses) = FormulaFunctions.toCNFClauses(f)
     
-    // Inspect clauses
-    val simped = 
-      for (c <- clauses;
-        removeclause = (for (c1 <- c if (c.contains(Neg(c1)))) yield true)
-        if (removeclause.isEmpty)
-      ) yield {
-        c
-      }
-    
     // TODO: improve
-    val form = And.make(simped.map(Or.make))
+    val form = And.make(clauses.map(Or.make))
     val newform = quantifiers.foldRight(form)((q, inner) => if(q._1) Exists(q._2, inner) else Forall(q._2, inner))
     
     // TODO: add equalities?
@@ -70,8 +61,8 @@ object FOTransformers extends LazyLogging {
       case Neg(Fun(AUX, _, _)) => False
       case Fun(AUX, _, _) => False
     }
-    
-    repld.simplify()
+    // TODO: improve runtime here
+    repld.toCNF.simplify()
   }
   
   /**

src/main/scala/de/tum/workflows/toz3/InvariantGenerator.scala

@@ -42,6 +42,8 @@ object InvariantGenerator {
 
     val conclusion = genEq(spec.target, spec.target.params)
     Forall(spec.target.params, conclusion).simplify()
+    // Constants
+//    conclusion
   }
   
 //  def invariantNoninterStubbornBS(spec: Spec) = {

src/test/scala/de/tum/workflows/tests/FOLTLTest.scala

@@ -6,6 +6,7 @@ import org.scalatest.Inspectors._
 import de.tum.workflows.foltl.FOLTL._
 import de.tum.workflows.Implicits._
 import de.tum.workflows.foltl.FOLTL
+import de.tum.workflows.foltl.FormulaFunctions
 
 class FOLTLTest extends FlatSpec {
   "Formulas" should "be constructed correctly" in {
@@ -150,4 +151,20 @@ class FOLTLTest extends FlatSpec {
       ))    
     )
   }
+  
+  it should "not fail at doing so" in {
+    val f = Forall(List("xt","pt","yt","p"), And.make(
+        Neg(Fun("B", List("xt","pt"))),
+        Neg(Fun("B", List("yt","p"))),
+        Neg(Fun("B", List("yt","pt"))),
+        Neg(Fun("Conf",Some("t1"),List("xt","p")))
+        ))
+        
+     f.toCNF should be (f)
+  }
+    
+  "quantifier pushing" should "work" in {
+    val f = Forall("x", And(Fun("f","x"), Fun("f","c")))
+    FormulaFunctions.pushQuantifiers(f) should be (And(Forall("x", Fun("f","x")),Fun("f","c")))
+  }
 }
\ No newline at end of file

src/test/scala/de/tum/workflows/tests/FOTransformTest.scala

@@ -151,4 +151,5 @@ class FOTransformSpec extends FlatSpec {
     )
 
   }
+
 }
\ No newline at end of file