Commit 582ced11 authored by Christian Müller's avatar Christian Müller

fix a few things, add tests

parent e47aefd4
IGNORE
Workflow
forallmay i True -> R += (i)
......
......@@ -5,7 +5,7 @@ loop {
forallmay x:User, i:Info
Written(i, x) → Read += (x, i)
} {
forallmay x:User, i:Info
forall x:User, i:Info
Oracle(i, x) → Written += (i, x)
}
}
......
Workflow
loop {
choose {
forallmay x:User, i:Info
Written(i, x) → Read += (x, i)
} {
forall x:User, i:Info
Oracle(i, x) → Written += (i, x)
}
}
Declassify
Oracle(i:Info,x:User): Written(i:Info, u:User)
Target
Read(u:User, info:Info)
Workflow
forallmay p:Prof,s:Student,g:Grade
forall p:Prof,s:Student,g:Grade
(O(p,s,g)) -> Grading += (p,s,g)
forallmay p:Prof,t:TA
True -> Talk1 += (t, p)
......@@ -9,7 +9,7 @@ forallmay t:TA,s:Student
Declassify
O(p:Prof,s:Student,g:Grade): Grading(p:Prof,as:Student,g:Grade)
O(p:Prof,s:Student,g:Grade): False
Target
......
......@@ -7,7 +7,7 @@ forallmay x:A,p:P
forall x:A,p:P,r:R
(Assign(x,p) ∧ O(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 x:A,y:A,p:P,r:R (Assign(x,p) ∧ Review(y,p,r)) → Read += (x,p,r)
forallmay x:A,p:P,r:R (Assign(x,p)) → Review += (x,p,r)
}
......
Workflow
forallmay x:A,p:P
True → Conf += (x,p)
forallmay x:A,p:P
!Conf(x,p) → Assign += (x,p)
forall x:A,y:A,p:P,q:P
(Assign(x,p) ∧ Assign(y,p) ∧ Conf(x,q) ∧ !Conf(y,q)) → Assign -= (y,p)
forall x:A,p:P,r:R
(Assign(x,p) ∧ O(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)
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)
Target
Read(xt:A, rt:R)
Workflow
forallmay x:X,p:P
True -> Conf += (x,p)
forallmay x:X,p:P
!Conf(x,p) -> Assign += (x,p)
forall x:X,y:X,p:P,q:P
(Conf(x,p) ∧ ¬ Conf(y,p) ∧ Assign(x,q) ∧ Assign(y,q)) -> Assign -= (y,q)
forall x:X,p:P,r:R
(Assign(x,p) ∧ O(x,p,r)) -> Read += (x,p,r)
forallmay y:X,x:X,p:P
(Assign(x,p) ∧ Assign(y,p)) -> Comm += (x,y,p)
Declassify
O(x:X,p:P,r:R): ¬ Conf(xt:X,p:P)
Target
Comm(xt:X, yt:X, pt:P)
Workflow
forallmay x:A,p:P
True → Conf += (x,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)
loop {
forall x:A,y:A,p:P,r:R (Assign(x,p) ∧ Review(y,p,r)) → Read += (x,p,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)
Target
Read(xt:A, rt:R)
# /bin/bash
shopt -s nullglob
shopt -s globstar
TIMEOUT=1m
......@@ -8,20 +9,20 @@ echo "Gobbling up metrics"
rm -f results/allmetrics.metrics
touch results/allmetrics.metrics
for FILE in results/*/*.metrics
for FILE in results/**/*.metrics
do
echo "${FILE}:" >> results/allmetrics.metrics
cat ${FILE} >> results/allmetrics.metrics
echo -e "\n\n" >> results/allmetrics.metrics
done
for FILE in results/*/*.png
for FILE in results/**/*.png
do
echo "Deleting ${FILE}"
rm $FILE
done
for FILE in results/*/*.dot
for FILE in results/**/*.dot
do
NAME=$(basename ${FILE} .dot)
DIR=$(dirname "${FILE}")
......
......@@ -14,6 +14,7 @@ import scalax.collection.edge.LBase.LEdgeImplicits
import scalax.collection.io.dot._
import implicits._
import Implicits._
import de.tum.workflows.toz3.InvProperties
import scalax.collection.GraphTraversal.{BreadthFirst, DepthFirst}
object Encoding extends LazyLogging {
......@@ -194,9 +195,9 @@ object Encoding extends LazyLogging {
// And.make(List(cfg, sanity, sem, init))
// }
val MAXINVLENGTH = 1200
val MAXINVLENGTH = 800
def toDot(g: WorkflowGraph)(labels:Map[Int, String], edges:Set[g.EdgeT]) = {
def toDot(g: WorkflowGraph, elaboration:Option[(InvProperties, Spec)] = None)(labels:Map[Int, String], edges:Set[g.EdgeT]) = {
val root = DotRootGraph(
directed = true,
id = Some("Invariant Labelling"))
......@@ -206,24 +207,28 @@ object Encoding extends LazyLogging {
case label: SimpleBlock => {
val green = edges.exists(_ == innerEdge)
val color = List(DotAttr("color", if (green) "green" else "red"))
val labelled = if (label.nonEmpty) {
DotAttr("label", label.toString) :: color
} else { color }
val elaborated = (elaboration map {
case (prop, spec) => Preconditions.elaborate(label, spec, prop)
}).getOrElse(List(label))
val strlabel = elaborated.mkString("\n")
val labelled = DotAttr("label", strlabel) :: color
Some((
root,
DotEdgeStmt(
source.toString,
target.toString,
labelled
)
)
))
}
}
}
def nodeTransformer(innerNode: WorkflowGraph#NodeT): Option[(DotGraph, DotNodeStmt)] = {
val str = labels(innerNode.value)
val str = labels.withDefault(d => s"$d").apply(innerNode.value)
val label = if (str.length() > MAXINVLENGTH) str.substring(0, MAXINVLENGTH) + "..." + s"(${str.length()} characters)" else str
Some((root, DotNodeStmt(innerNode.toString, List(DotAttr("label", "Node " + innerNode + ":\n" + label)))))
}
......
......@@ -27,9 +27,9 @@ object MainInvariants extends App with LazyLogging {
val (res, dot, t) = InvariantChecker.checkInvariantFPDot(spec, invariant(spec))
val msg = s"Invariant was ${if (res) "" else "not "}proven (took $t ms)\n"
write(s"$name.inv", msg)
write(name, s"$name.inv", msg)
for ((s, i) <- dot.zipWithIndex) {
write(s"${name}_$i.dot", s)
write(name, s"${name}_$i.dot", s)
}
}
......
......@@ -8,6 +8,7 @@ import de.tum.workflows.foltl.FOLTL._
import de.tum.workflows.foltl.FOTransformers
import de.tum.workflows.synth.Model
import de.tum.workflows.toz3._
import de.tum.workflows.foltl.Properties
// Labelled Edge to Block
import Implicits._
......@@ -97,22 +98,24 @@ object MainInvariantsInference extends App with LazyLogging {
val steeredinv = instinv.everywhere {
case f:Fun if z3map.contains(f) => z3map(f)
}
val steeredInfinv = steeredinv.assumeEmpty(Properties.INFNAME)
// just for testing
// val tocheck = List("Conf")
//
// val modelmap = for ((f, vs) <- newmodel.state; v <- vs if !tocheck.contains(f.name)) yield {
// v match {
// case Neg(f) => (f, False)
// case f:Fun => (f, True)
// }
// }
//
// val modelinv = steeredinv.everywhere {
// case f:Fun if modelmap.contains(f) => modelmap(f)
// }
val easyinv = steeredinv.simplify()
val tocheck = List("Assign")
val modelmap = for ((f, vs) <- newmodel.state; v <- vs if !tocheck.contains(f.name)) yield {
v match {
case Neg(f) => (f, False)
case f:Fun => (f, True)
}
}
val modelinv = steeredInfinv.everywhere {
case f:Fun if modelmap.contains(f) => modelmap(f)
}
// val easyinv = modelinv.simplify()
val easyinv = steeredInfinv.simplify()
logger.info(s"inv: $easyinv")
......
......@@ -20,7 +20,7 @@ object MainLTL extends App with LazyLogging {
var metrics = List[String]()
write(s"$name.foltl", prop.pretty())
write(name, s"$name.foltl", prop.pretty())
metrics :+= s"$name.foltl: ${prop.opsize()}"
if (!FormulaFunctions.checkSanity(prop)) {
......@@ -44,8 +44,8 @@ object MainLTL extends App with LazyLogging {
metrics :+= s"$name.ltl: ${ltlprop.opsize()}"
metrics :+= s"Universe: $universe"
write(s"$name.ltl", ltlprop.toString())
write(s"$name.ppltl", ltlprop.pretty())
write(name, s"$name.ltl", ltlprop.toString())
write(name, s"$name.ppltl", ltlprop.pretty())
val owlform = OwlTransformer.toOwl(ltlprop)
......@@ -53,7 +53,7 @@ object MainLTL extends App with LazyLogging {
val (t, sat) = time {
// simplify owl
val simped = SimplifierFactory.applyDefault(owlform.formula()).nnf()
write(s"$name.owlltl", simped.toString)
write(name, s"$name.owlltl",simped.toString)
logger.info("Simplified owl formula")
// check owl sat
logger.info("Checking satisfiability")
......@@ -65,7 +65,7 @@ object MainLTL extends App with LazyLogging {
metrics :+= s"Satisfiable: $sat"
metrics :+= s"Owl runtime: $t ms"
write(s"$name.metrics", metrics.mkString("", "\n", "\n"))
write(name, s"$name.metrics", metrics.mkString("", "\n", "\n"))
}
def generate(name: String, spec: Spec, onlystubborn:Boolean) {
......
......@@ -10,7 +10,10 @@ import de.tum.workflows.toz3.InvProperties
object Preconditions extends LazyLogging {
private def elaborateSteps(b: SimpleBlock, s: Spec): List[SimpleBlock] = {
val newsteps = for (stmt <- b.steps if stmt.tuple.head.typ == s.target.params.head.typ) yield {
val newsteps = for (
stmt <- b.steps
if s.causals.map(_.typ).contains(stmt.tuple.head.typ) ||
stmt.tuple.head.typ == s.target.params.head.typ) yield {
val fun = Fun(stmt.fun, stmt.tuple)
// TODO
val guard = Neg(Eq(fun.in(T1), fun.in(T2)))
......@@ -20,7 +23,7 @@ object Preconditions extends LazyLogging {
}
// For oracly blocks, remove O from guard and add to ForallMay choice predicate
def elaborateOraclyBlock(b: SimpleBlock, s: Spec) = {
private def elaborateOraclyBlock(b: SimpleBlock, s: Spec) = {
if (b.isoracly) {
val stmt = b.steps.head // can only be one
def fixguard(f: Formula) = {
......@@ -62,7 +65,8 @@ object Preconditions extends LazyLogging {
}
})
}
// TODO: make this a transformation instead of a logics block
def getUpdate(s:Statement, b:SimpleBlock, choice:Option[Fun], spec:Spec, properties:InvProperties) = {
// val list = List(s.guard) ++ choice.toList
......@@ -109,7 +113,6 @@ object Preconditions extends LazyLogging {
def elaborate(block: SimpleBlock, spec:Spec, properties:InvProperties) = {
val stepOne = if (!properties.stubborn) elaborateSteps(block, spec) else List(block)
stepOne map { b => elaborateOraclyBlock(b, spec) }
}
......
......@@ -53,8 +53,8 @@ object Utils extends LazyLogging {
recclear(fol)
}
def write(name: String, prop: String) {
val file = new File(s"$RESULTSFOLDER/$name")
def write(dir: String, filename:String, prop: String) {
val file = new File(s"$RESULTSFOLDER/$dir/$filename")
if (file.exists()) {
file.delete()
}
......@@ -62,34 +62,39 @@ object Utils extends LazyLogging {
val writer = new PrintWriter(file)
writer.print(prop)
writer.close()
logger.info(s"Written $name")
logger.info(s"Written $file")
}
def check(name:String, desc:String, inv:Formula, spec:Spec, properties:InvProperties) = {
val model = if (properties.stubborn) "stubborn" else "causal"
val filenames = s"${name}_$model${if (desc.isEmpty()) "" else s"_$desc"}"
val basename = name.split("/").last
val filenames = s"${basename}_$model${if (desc.isEmpty()) "" else s"_$desc"}"
// do not blow up the formula with auxilliary elimination
val (res, graph, labelling, provens, dot, time) =
InvariantChecker.checkInvariantFPLabelling(spec, inv, properties)
for ((s, i) <- dot.zipWithIndex) {
Utils.write(s"${filenames}_$i.dot", s)
Utils.write(name,s"${filenames}_$i.dot", s)
}
val strengthenings = for (List(a, b) <- labelling.sliding(2) if (a != b)) yield {
true
}
val elabdot = Encoding.toDot(graph, Some(properties, spec))(Map(), Set())
Utils.write(name, s"${filenames}_elaborated.dot", elabdot)
val labels = (for ((node, inv) <- labelling.last) yield {
s"Node ${node}:\n${inv.pretty()}\n"
}).mkString("\n")
Utils.write(s"$filenames.invariants", labels)
Utils.write(name, s"$filenames.invariants", labels)
val wfsize = graph.edges.size - 1
val invsizes = labelling.last.map(_._2.opsize())
val maxsize = invsizes.max
val avgsize = invsizes.sum / invsizes.size
Utils.write(s"$filenames.metrics",
Utils.write(name, s"$filenames.metrics",
s"""Name: $name
Description: $desc
Invariant: $inv
......
......@@ -468,8 +468,10 @@ object FormulaFunctions extends LazyLogging {
if (!changed) sub else toCNFSub(sub)
}
// FIXME: can we do it without prenex? may be expensive later on
val normalized = f.toNegNf.toPrenex.simplify()
val normalized = f.toNegNf.simplify().toPrenex.simplify()
logger.debug(s"Computing CNF of prenex formula of opsize ${normalized.opsize()}")
// normalized is now Quantifiers, then only And/Or with Negation inside
// no simplification here
......
......@@ -122,7 +122,7 @@ object InvariantChecker extends LazyLogging {
} else {
logger.info("Relabelled initial node. Terminating.")
// logger.info(s"Model: ${Z3.printModel(solver.getModel())}")
(false, newlabels, provenlist)
(false, labellist, provenlist)
}
}
}
......@@ -140,7 +140,8 @@ object InvariantChecker extends LazyLogging {
val dot1 = labellings.zip(proven).reverse
val dot2 = dot1.map(tup => Encoding.toDot(graph)(tup._1.map(t => (t._1, {
if (t._2.opsize() <= 5000) t._2.pretty() else "TOO BIG"
// if (t._2.opsize() <= 5000) t._2.pretty() else "TOO BIG"
t._2.pretty()
})), tup._2))
(result, graph, labellings.reverse, proven.reverse, dot2, time)
......
......@@ -12,6 +12,7 @@ import de.tum.workflows.foltl.FOTransformers
import de.tum.workflows.foltl.FormulaFunctions
import it.unimi.dsi.fastutil.longs.Long2BooleanArrayMap
object Z3QFree extends LazyLogging {
......
package de.tum.workflows.tests.papertests
import org.scalatest.FlatSpec
import org.scalatest.Matchers._
import org.scalatest.Inspectors._
import de.tum.workflows.foltl.FOLTL._
import de.tum.workflows.Implicits._
import de.tum.workflows.blocks._
import de.tum.workflows.Preconditions
import de.tum.workflows.foltl.FormulaFunctions
import de.tum.workflows.ExampleWorkflows
import de.tum.workflows.toz3.InvariantChecker
import de.tum.workflows.Encoding._
import de.tum.workflows.Utils
import de.tum.workflows.Encoding
import de.tum.workflows.tests.TestUtils._
import de.tum.workflows.toz3.InvariantGenerator
class DemoNoStrengtheningTests extends FlatSpec {
// fixed arity, nonomitting - easy
it should "fail to prove nonomitting/fixedarity10 alleq" in {
val name = "nonomitting/fixedarity10"
val inv = InvariantGenerator.invariantAllEqual(ExampleWorkflows.parseExample(name).get)
assert(!checkSafeStubborn(name, "alleq", inv))
}
it should "prove nonomitting/fixedarity10_safe alleq" in {
val name = "nonomitting/fixedarity10safe"
val inv = InvariantGenerator.invariantAllEqual(ExampleWorkflows.parseExample(name).get)
assert(checkSafeStubborn(name, "alleq", inv))
}
it should "fail to prove nonomitting/fixedarity15 alleq" in {
val name = "nonomitting/fixedarity15"
val inv = InvariantGenerator.invariantAllEqual(ExampleWorkflows.parseExample(name).get)
assert(!checkSafeStubborn(name, "alleq", inv))
}
it should "prove nonomitting/fixedarity15_safe alleq" in {
val name = "nonomitting/fixedarity15safe"
val inv = InvariantGenerator.invariantAllEqual(ExampleWorkflows.parseExample(name).get)
assert(checkSafeStubborn(name, "alleq", inv))
}
it should "fail to prove nonomitting/fixedarity20 alleq" in {
val name = "nonomitting/fixedarity20"
val inv = InvariantGenerator.invariantAllEqual(ExampleWorkflows.parseExample(name).get)
assert(!checkSafeStubborn(name, "alleq", inv))
}
it should "prove nonomitting/fixedarity20_safe alleq" in {
val name = "nonomitting/fixedarity20safe"
val inv = InvariantGenerator.invariantAllEqual(ExampleWorkflows.parseExample(name).get)
assert(checkSafeStubborn(name, "alleq", inv))
}
// nonomitting, incarity
it should "prove nonomitting/incarity5 alleq" in {
val name = "nonomitting/incarity5"
val inv = InvariantGenerator.invariantAllEqual(ExampleWorkflows.parseExample(name).get)
assert(checkSafeStubborn(name, "alleq", inv))
}
// nonomitting, tests
it should "prove tests/simpleChoiceDeclassified alleq" in {
val name = "tests/simpleChoiceDeclassified"
val inv = InvariantGenerator.invariantAllEqual(ExampleWorkflows.parseExample(name).get)
assert(checkSafeStubborn(name, "alleq", inv))
}
it should "prove tests/simpleChoiceDeclassified causal alleq" in {
val name = "tests/simpleChoiceDeclassified"
val inv = InvariantGenerator.invariantAllEqual(ExampleWorkflows.parseExample(name).get)
assert(checkSafeCausal(name, "alleq", inv))
}
it should "prove tests/simpleChoiceCausal alleq" in {
val name = "tests/simpleChoiceCausal"
val inv = InvariantGenerator.invariantNoninterSingleBS(ExampleWorkflows.parseExample(name).get)
assert(checkSafeStubborn(name, "alleq", inv))
}
it should "prove tests/simpleChoiceCausal causal alleq" in {
val name = "tests/simpleChoiceCausal"
val inv = InvariantGenerator.invariantNoninterSingleBS(ExampleWorkflows.parseExample(name).get)
assert(!checkSafeCausal(name, "alleq", inv))
}
}
package de.tum.workflows.tests.papertests
import org.scalatest.FlatSpec
import org.scalatest.Matchers._
import org.scalatest.Inspectors._
import de.tum.workflows.foltl.FOLTL._
import de.tum.workflows.Implicits._
import de.tum.workflows.blocks._
import de.tum.workflows.Preconditions
import de.tum.workflows.foltl.FormulaFunctions
import de.tum.workflows.ExampleWorkflows
import de.tum.workflows.toz3.InvariantChecker
import de.tum.workflows.Encoding._
import de.tum.workflows.Utils
import de.tum.workflows.Encoding
import de.tum.workflows.tests.TestUtils._
import de.tum.workflows.toz3.InvariantGenerator
class DemoNotebookTest extends FlatSpec {
it should "prove nonomitting/notebook alleq" in {
val name = "nonomitting/notebook_stubborn"
val inv = InvariantGenerator.invariantAllEqual(ExampleWorkflows.parseExample(name).get)
assert(checkSafeStubbornNoElim(name, inv))
}
it should "prove nonomitting/notebook causal alleq" in {
val name = "nonomitting/notebook"
val inv = InvariantGenerator.invariantAllEqual(ExampleWorkflows.parseExample(name).get)
assert(checkSafeCausal(name, "alleq", inv))
}
it should "prove nonomitting/notebook causal elim alleq" in {
val name = "nonomitting/notebook"
val inv = InvariantGenerator.invariantAllEqual(ExampleWorkflows.parseExample(name).get)
assert(checkSafeCausalElim(name, "elim", inv))
}
}
package de.tum.workflows.tests.papertests
import org.scalatest.FlatSpec
import org.scalatest.Matchers._
import org.scalatest.Inspectors._
import de.tum.workflows.foltl.FOLTL._
import de.tum.workflows.Implicits._
import de.tum.workflows.blocks._
import de.tum.workflows.Preconditions
import de.tum.workflows.foltl.FormulaFunctions
import de.tum.workflows.ExampleWorkflows
import de.tum.workflows.toz3.InvariantChecker
import de.tum.workflows.Encoding._
import de.tum.workflows.Utils
import de.tum.workflows.Encoding
import de.tum.workflows.tests.TestUtils._
import de.tum.workflows.toz3.InvariantGenerator
class DemoUniversityTest extends FlatSpec {
it should "prove nonomitting/university alleq" in {
val name = "nonomitting/university"
val inv = InvariantGenerator.invariantAllEqual(ExampleWorkflows.parseExample(name).get)
assert(checkSafeStubbornNoElim(name, inv))
}
it should "prove nonomitting/university causal alleq" in {
val name = "nonomitting/university"
val inv = InvariantGenerator.invariantNoninterSingleBS(ExampleWorkflows.parseExample(name).get)
assert(!checkSafeCausal(name, "alleq", inv))
}
}
......@@ -16,7 +16,6 @@ import de.tum.workflows.Utils
import de.tum.workflows.Encoding
import de.tum.workflows.tests.TestUtils._
import de.tum.workflows.foltl.Properties
import de.tum.workflows.toz3.InvariantGenerator
class InvariantCausalFilesTest extends FlatSpec {
......@@ -85,22 +84,23 @@ class InvariantCausalFilesTest extends FlatSpec {
// assert(!checkSafeCausal(name, inv))
// }
//
// // about 60 seconds
// it should "fail to prove omitting/conference alleq" in {
// val name = "omitting/conference"
// val inv = InvariantGenerator.invariantAllEqual(ExampleWorkflows.parseExample(name).get)
// assert(!checkSafeCausal(name, "alleq", inv))
// }
it should "prove omitting/conference_fixed" in {
val name = "omitting/conference_fixed"
val xt = Var("xt","A")
val pt = Var("rt","R")
val inv = Forall(List(xt, pt), genEq("Read", List(xt, pt)))
assert(checkSafeCausal(name, inv))
// about 10 seconds
it should "fail to prove omitting/conference alleq" in {
val name = "omitting/conference"
val inv = InvariantGenerator.invariantAllEqual(ExampleWorkflows.parseExample(name).get)
assert(!checkSafeCausal(name, "alleq", inv))
}
// it should "prove omitting/conference_fixed" in {
// val name = "omitting/conference_fixed"
// val xt = Var("xt","A")
// val pt = Var("rt","R")
// val inv = Forall(List(xt, pt), genEq("Read", List(xt, pt)))
// assert(checkSafeCausal(name, "without_elim", inv))
// }
//
// it should "prove omitting/conference_fixed alleq" ignore {
// it should "prove omitting/conference_fixed alleq" in {
// val name = "omitting/conference_fixed"
// val inv = InvariantGenerator.invariantAllEqual(ExampleWorkflows.parseExample(name).get)
// assert(checkSafeCausal(name, "alleq", inv))
......
......@@ -39,48 +39,55 @@ class InvariantEasychairTest extends FlatSpec {
// assert(checkSafeStubborn(name, inv))
// }
//
// it should "prove stubborn conference_linear alleq" in {
// val name = "nonomitting/conference_linear"
// val inv = InvariantGenerator.invariantAllEqual(ExampleWorkflows.parseExample(name).get)
// assert(checkSafeStubborn(name, "alleq", inv))
// }
// it should "prove stubborn conference_linear alleq" in {
// val name = "omitting/conference_linear_fixed_stubborn"
// val inv = InvariantGenerator.invariantAllEqual(ExampleWorkflows.parseExample(name).get)
// assert(checkSafeStubbornNoElim(name, inv))
// }
it should "prove omitting/conference_fixed" in {
val name = "omitting/conference_fixed"
val xt = Var("xt", "A")
val pt = Var("rt", "R")
val inv = Forall(List(xt, pt), genEq("Read", List(xt, pt)))
assert(checkSafeStubbornNoElim(name, inv))
}
// it should "prove stubborn conference_linear alleq" in {
// val name = "omitting/conference_linear_fixed_stubborn"
// val inv = InvariantGenerator.invariantAllEqual(ExampleWorkflows.parseExample(name).get)
// assert(checkSafeStubborn(name, "with_elim", inv))
// }
it should "prove omitting/conference_fixed alleq" ignore {
val name = "omitting/conference_fixed"
val inv = InvariantGenerator.invariantAllEqual(ExampleWorkflows.parseExample(name).get)
assert(checkSafeStubborn(name, "alleq", inv))
}
// it should "prove omitting/conference_fixed" in {
// val name = "omitting/conference_fixed_stubborn"
// val xt = Var("xt", "A")