Merge ND-evaluator into master

src/test/resources/regression/verification/purescala/invalid/Existentials.scala

+import leon.lang._
+
+object Existentials {
+
+  def exists[A](p: A => Boolean): Boolean = !forall((x: A) => !p(x))
+
+  def check1(y: BigInt, p: BigInt => Boolean) : Boolean = {
+    p(y) == exists((y1:BigInt) => p(y1))
+  }.holds
+
+  /*
+  def check2(y: BigInt, p: BigInt => Boolean) : Boolean = {
+    p(y) ==> exists((y1:BigInt) => p(y1))
+  }.holds
+  */
+}

src/test/resources/regression/verification/purescala/invalid/ForallAssoc.scala

+import leon.lang._
+
+object ForallAssoc {
+
+  /*
+  def test3(f: (BigInt, BigInt) => BigInt): Boolean = {
+    require(forall((x: BigInt, y: BigInt, z: BigInt) => f(x, f(y, z)) == f(f(x, y), z)))
+    f(1, f(2, f(3, f(4, 5)))) == f(f(f(f(1, 2), 3), 4), 4)
+  }.holds
+  */
+
+  def test4(f: (BigInt, BigInt) => BigInt): Boolean = {
+    require(forall((x: BigInt, y: BigInt, z: BigInt) => f(x, f(y, z)) == f(f(x, y), z)))
+    f(1, f(2, f(3, 4))) == 0
+  }.holds
+
+}

src/test/resources/regression/verification/purescala/valid/Existentials.scala

+import leon.lang._
+
+object Existentials {
+
+  def exists[A](p: A => Boolean): Boolean = !forall((x: A) => !p(x))
+
+  /*
+  def check1(y: BigInt, p: BigInt => Boolean) : Boolean = {
+    p(y) == exists((y1:BigInt) => p(y1))
+  }.holds
+  */
+
+  def check2(y: BigInt, p: BigInt => Boolean) : Boolean = {
+    p(y) ==> exists((y1:BigInt) => p(y1))
+  }.holds
+}

src/test/resources/regression/verification/purescala/valid/ForallAssoc.scala

+import leon.lang._
+
+object ForallAssoc {
+
+  def ex[A](x1: A, x2: A, x3: A, x4: A, x5: A, f: (A, A) => A) = {
+    require(forall {
+      (x: A, y: A, z: A) => f(x, f(y, z)) == f(f(x, y), z)
+    })
+
+    f(x1, f(x2, f(x3, f(x4, x5)))) == f(f(x1, f(x2, f(x3, x4))), x5)
+  }.holds
+
+  def test1(f: (BigInt, BigInt) => BigInt): Boolean = {
+    require(forall((x: BigInt, y: BigInt, z: BigInt) => f(x, f(y, z)) == f(f(x, y), z)))
+    f(1, f(2, f(3, 4))) == f(f(f(1, 2), 3), 4)
+  }.holds
+
+  def test2(f: (BigInt, BigInt) => BigInt): Boolean = {
+    require(forall((x: BigInt, y: BigInt, z: BigInt) => f(x, f(y, z)) == f(f(x, y), z)))
+    f(1, f(2, f(3, f(4, 5)))) == f(f(f(f(1, 2), 3), 4), 5)
+  }.holds
+
+}

src/test/resources/regression/verification/purescala/valid/Predicate.scala

+package leon.monads.predicate
+
+import leon.collection._
+import leon.lang._
+import leon.annotation._
+
+object Predicate {
+
+  def exists[A](p: A => Boolean): Boolean = !forall((a: A) => !p(a))
+
+  // Monadic bind
+  @inline
+  def flatMap[A,B](p: A => Boolean, f: A => (B => Boolean)): B => Boolean = {
+    (b: B) => exists[A](a => p(a) && f(a)(b))
+  }
+
+  // All monads are also functors, and they define the map function
+  @inline
+  def map[A,B](p: A => Boolean, f: A => B): B => Boolean = {
+    (b: B) => exists[A](a => p(a) && f(a) == b)
+  }
+
+  /*
+  @inline
+  def >>=[B](f: A => Predicate[B]): Predicate[B] = flatMap(f)
+
+  @inline
+  def >>[B](that: Predicate[B]) = >>= ( _ => that )
+
+  @inline
+  def withFilter(f: A => Boolean): Predicate[A] = {
+    Predicate { a => p(a) && f(a) }
+  }
+  */
+
+  def equals[A](p: A => Boolean, that: A => Boolean): Boolean = {
+    forall[A](a => p(a) == that(a))
+  }
+
+  def test[A,B,C](p: A => Boolean, f: A => B, g: B => C): Boolean = {
+    equals(map(map(p, f), g), map(p, (a: A) => g(f(a))))
+  }.holds
+
+  def testInt(p: BigInt => Boolean, f: BigInt => BigInt, g: BigInt => BigInt): Boolean = {
+    equals(map(map(p, f), g), map(p, (x: BigInt) => g(f(x))))
+  }.holds
+}
+

src/test/scala/leon/integration/solvers/SolversSuite.scala

@@ -32,61 +32,72 @@ class SolversSuite extends LeonTestSuiteWithProgram {
     ) else Nil)
   }
 
-  // Check that we correctly extract several types from solver models
-  for ((sname, sf) <- getFactories) {
-    test(s"Model Extraction in $sname") { implicit fix =>
-      val ctx = fix._1
-      val pgm = fix._2
+  val types = Seq(
+    BooleanType,
+    UnitType,
+    CharType,
+    RealType,
+    IntegerType,
+    Int32Type,
+    TypeParameter.fresh("T"),
+    SetType(IntegerType),
+    MapType(IntegerType, IntegerType),
+    FunctionType(Seq(IntegerType), IntegerType),
+    TupleType(Seq(IntegerType, BooleanType, Int32Type))
+  )
 
-      val solver = sf(ctx, pgm)
+  val vs = types.map(FreshIdentifier("v", _).toVariable)
 
-      val types = Seq(
-        BooleanType,
-        UnitType,
-        CharType,
-        IntegerType,
-        Int32Type,
-        TypeParameter.fresh("T"),
-        SetType(IntegerType),
-        MapType(IntegerType, IntegerType),
-        TupleType(Seq(IntegerType, BooleanType, Int32Type))
-      )
+  // We need to make sure models are not co-finite
+  val cnstrs = vs.map(v => v.getType match {
+    case UnitType =>
+      Equals(v, simplestValue(v.getType))
+    case SetType(base) =>
+      Not(ElementOfSet(simplestValue(base), v))
+    case MapType(from, to) =>
+      Not(Equals(MapApply(v, simplestValue(from)), simplestValue(to)))
+    case FunctionType(froms, to) =>
+      Not(Equals(Application(v, froms.map(simplestValue)), simplestValue(to)))
+    case _ =>
+      not(Equals(v, simplestValue(v.getType)))
+  })
 
-      val vs = types.map(FreshIdentifier("v", _).toVariable)
+  def checkSolver(solver: Solver, vs: Set[Variable], cnstr: Expr)(implicit fix: (LeonContext, Program)): Unit = {
+    try {
+      solver.assertCnstr(cnstr)
 
-
-      // We need to make sure models are not co-finite
-      val cnstr = andJoin(vs.map(v => v.getType match {
-        case UnitType =>
-          Equals(v, simplestValue(v.getType))
-        case SetType(base) =>
-          Not(ElementOfSet(simplestValue(base), v))
-        case MapType(from, to) =>
-          Not(Equals(MapApply(v, simplestValue(from)), simplestValue(to)))
-        case _ =>
-          not(Equals(v, simplestValue(v.getType)))
-      }))
-
-      try {
-        solver.assertCnstr(cnstr)
-
-        solver.check match {
-          case Some(true) =>
-            val model = solver.getModel
-            for (v <- vs) {
-              if (model.isDefinedAt(v.id)) {
-                assert(model(v.id).getType === v.getType, "Extracting value of type "+v.getType)
-              } else {
-                fail("Model does not contain "+v.id+" of type "+v.getType)
-              }
+      solver.check match {
+        case Some(true) =>
+          val model = solver.getModel
+          for (v <- vs) {
+            if (model.isDefinedAt(v.id)) {
+              assert(model(v.id).getType === v.getType, "Extracting value of type "+v.getType)
+            } else {
+              fail("Model does not contain "+v.id+" of type "+v.getType)
             }
-          case _ =>
-            fail("Constraint "+cnstr.asString+" is unsat!?")
-        }
-      } finally {
-        solver.free()
+          }
+        case _ =>
+          fail("Constraint "+cnstr.asString+" is unsat!?")
       }
+    } finally {
+      solver.free
+    }
+  }
+
+  // Check that we correctly extract several types from solver models
+  for ((sname, sf) <- getFactories) {
+    test(s"Model Extraction in $sname") { implicit fix =>
+      val ctx = fix._1
+      val pgm = fix._2
+      val solver = sf(ctx, pgm)
+      checkSolver(solver, vs.toSet, andJoin(cnstrs))
+    }
+  }
 
+  test(s"Data generation in enum solver") { implicit fix =>
+    for ((v,cnstr) <- vs zip cnstrs) {
+      val solver = new EnumerationSolver(fix._1, fix._2)
+      checkSolver(solver, Set(v), cnstr)
     }
   }
 }

src/test/scala/leon/regression/synthesis/SynthesisSuite.scala

@@ -154,9 +154,9 @@ object Injection {
   case class Nil() extends List
 
   // proved with unrolling=0
-  def size(l: List) : Int = (l match {
-      case Nil() => 0
-      case Cons(t) => 1 + size(t)
+  def size(l: List) : BigInt = (l match {
+      case Nil() => BigInt(0)
+      case Cons(t) => BigInt(1) + size(t)
   }) ensuring(res => res >= 0)
 
   def simple(in: List) = choose{out: List => size(out) == size(in) }
@@ -274,10 +274,10 @@ object ChurchNumerals {
   case object Z extends Num
   case class  S(pred: Num) extends Num
 
-  def value(n:Num) : Int = {
+  def value(n:Num) : BigInt = {
     n match {
-      case Z => 0
-      case S(p) => 1 + value(p)
+      case Z => BigInt(0)
+      case S(p) => BigInt(1) + value(p)
     }
   } ensuring (_ >= 0)
 
@@ -309,10 +309,10 @@ object ChurchNumerals {
   case object Z extends Num
   case class  S(pred: Num) extends Num
 
-  def value(n:Num) : Int = {
+  def value(n:Num) : BigInt = {
     n match {
-      case Z => 0
-      case S(p) => 1 + value(p)
+      case Z => BigInt(0)
+      case S(p) => BigInt(1) + value(p)
     }
   } ensuring (_ >= 0)
 

src/test/scala/leon/regression/verification/purescala/PureScalaVerificationSuite.scala

@@ -59,10 +59,10 @@ class PureScalaValidSuite3 extends PureScalaValidSuite {
   val optionVariants = List(opts(2))
 }
 class PureScalaValidSuiteZ3 extends PureScalaValidSuite {
-  val optionVariants = if (isZ3Available) List(opts(3)) else Nil
+  val optionVariants = Nil//if (isZ3Available) List(opts(3)) else Nil
 }
 class PureScalaValidSuiteCVC4 extends PureScalaValidSuite {
-  val optionVariants = if (isCVC4Available) List(opts(4)) else Nil
+  val optionVariants = Nil//if (isCVC4Available) List(opts(4)) else Nil
 }
 
 class PureScalaInvalidSuite extends PureScalaVerificationSuite {

testcases/synthesis/etienne-thesis/List/Split.scala

@@ -30,10 +30,12 @@ object Complete {
     if(i < 0) -i else i
   } ensuring(_ >= 0)
 
+  def dispatch(es: (BigInt, BigInt), rest: (List, List)): (List, List) = {
+    (Cons(es._1, rest._1), Cons(es._2, rest._2))
+  }
+
   def split(list : List) : (List,List) = {
     choose { (res : (List,List)) => splitSpec(list, res) }
   }
 
-  // case (h1, (h2, t)) => (h1 :: split(t)._1, h2 :: split(t)._2)
-
 }