z3 0.0.20160330 → 0.0.20160427

data/examples/sudoku-1.txt

@@ -0,0 +1,9 @@
+_ 6 _ 5 _ 9 _ 4 _
+9 2 _ _ _ _ _ 7 6
+_ _ 1 _ _ _ 9 _ _
+7 _ _ 6 _ 3 _ _ 9
+_ _ _ _ _ _ _ _ _
+3 _ _ 4 _ 1 _ _ 7
+_ _ 6 _ _ _ 7 _ _
+2 4 _ _ _ _ _ 6 5
+_ 9 _ 1 _ 8 _ 3 _

data/lib/z3.rb

@@ -8,6 +8,7 @@ require_relative "z3/low_level"
 require_relative "z3/low_level_auto"
 
 # Classes
+require_relative "z3/ast"
 require_relative "z3/context"
 require_relative "z3/solver"
 require_relative "z3/model"
@@ -22,12 +23,15 @@ require_relative "z3/sort/bool_sort"
 require_relative "z3/sort/bitvec_sort"
 
 # ASTs
-require_relative "z3/value/value"
-require_relative "z3/value/arith_value"
-require_relative "z3/value/int_value"
-require_relative "z3/value/real_value"
-require_relative "z3/value/bool_value"
-require_relative "z3/value/bitvec_value"
+require_relative "z3/expr/expr"
+require_relative "z3/expr/arith_expr"
+require_relative "z3/expr/int_expr"
+require_relative "z3/expr/real_expr"
+require_relative "z3/expr/bool_expr"
+require_relative "z3/expr/bitvec_expr"
 
 # Python-style interface
 require_relative "z3/interface"
+
+# Printer
+require_relative "z3/printer"

data/lib/z3/ast.rb

@@ -0,0 +1,33 @@
+module Z3
+  class AST
+    attr_reader :_ast
+    def initialize(_ast)
+      raise Z3::Exception, "AST expected, got #{_ast.class}" unless _ast.is_a?(FFI::Pointer)
+      @_ast = _ast
+    end
+
+    def ast_kind
+      ast_kind_lookup = {
+        0 => :numeral,
+        1 => :app,
+        2 => :var,
+        3 => :quantifier,
+        4 => :sort,
+        5 => :func_decl,
+        1000 => :unknown,
+      }
+      kind_id = Z3::LowLevel.get_ast_kind(self)
+      ast_kind_lookup[kind_id] or raise Z3::Exception, "Unknown AST kind #{kind_id}"
+    end
+
+    def to_s
+      Z3::Printer.new.format(self)
+    end
+
+    def sexpr
+      Z3::LowLevel.ast_to_string(self)
+    end
+
+    private_class_method :new
+  end
+end

data/lib/z3/{value/arith_value.rb → expr/arith_expr.rb}

@@ -1,6 +1,6 @@
 module Z3
-  # IntValue / RealValue
-  module ArithValue
+  # IntExpr / RealExpr
+  module ArithExpr
     def +(other)
       ::Z3.Add(self, other)
     end
@@ -45,7 +45,7 @@ module Z3
     # is:  (+ 1.0 x)
     # not: (+ (to_real 1) x)
     def coerce(other)
-      other_sort = Value.sort_for_const(other)
+      other_sort = Expr.sort_for_const(other)
       max_sort = [sort, other_sort].max
       [max_sort.from_const(other), max_sort.from_value(self)]
     end

data/lib/z3/{value/bitvec_value.rb → expr/bitvec_expr.rb}

@@ -1,5 +1,5 @@
 module Z3
-  class BitvecValue < Value
+  class BitvecExpr < Expr
     def ~
       sort.new(LowLevel.mk_bvnot(self))
     end

data/lib/z3/{value/bool_value.rb → expr/bool_expr.rb}

@@ -1,5 +1,5 @@
 module Z3
-  class BoolValue < Value
+  class BoolExpr < Expr
     def ~
       sort.new(LowLevel.mk_not(self))
     end
@@ -24,6 +24,10 @@ module Z3
       Z3.Implies(self, other)
     end
 
+    def ite(a, b)
+      Z3.IfThenElse(self, a, b)
+    end
+
     public_class_method :new
   end
 end

data/lib/z3/{value/value.rb → expr/expr.rb}

@@ -1,17 +1,14 @@
 module Z3
-  class Value
-    attr_reader :_ast, :sort
+  class Expr < AST
+    attr_reader :sort
     def initialize(_ast, sort)
-      @_ast = _ast
+      super(_ast)
       @sort = sort
-    end
-
-    def to_s
-      Z3::LowLevel.ast_to_string(self)
+      raise Z3::Exception, "Values must have AST kind numeral or app" unless [:numeral, :app].include?(ast_kind)
     end
 
     def inspect
-      "Value<#{to_s} :: #{sort.to_s}>"
+      "#{sort.to_s}<#{to_s}>"
     end
 
     def ==(other)
@@ -22,8 +19,6 @@ module Z3
       ::Z3.Distinct(self, other)
     end
 
-    private_class_method :new
-
     class << self
       def sort_for_const(a)
         case a
@@ -39,9 +34,8 @@ module Z3
       end
 
       def new_from_pointer(_ast)
-        _txt = Z3::VeryLowLevel.Z3_ast_to_string(Z3::LowLevel._ctx_pointer, _ast)
-        # raise "No idea how to convert this value"
-        # if == Z3::LowLevel.mk_bool_sort
+        _sort = Z3::VeryLowLevel.Z3_get_sort(Z3::LowLevel._ctx_pointer, _ast)
+        Sort.from_pointer(_sort).new(_ast)
       end
     end
   end

data/lib/z3/expr/int_expr.rb

@@ -0,0 +1,15 @@
+module Z3
+  class IntExpr < Expr
+    include ArithExpr
+
+    def mod(other)
+      ::Z3.Mod(self, other)
+    end
+
+    def rem(other)
+      ::Z3.Rem(self, other)
+    end
+
+    public_class_method :new
+  end
+end

data/lib/z3/{value/int_value.rb → expr/real_expr.rb}

@@ -1,6 +1,6 @@
 module Z3
-  class IntValue < Value
-    include ArithValue
+  class RealExpr < Expr
+    include ArithExpr
 
     public_class_method :new
   end

data/lib/z3/func_decl.rb

@@ -1,31 +1,41 @@
-class Z3::FuncDecl
-  attr_reader :_func_decl
-  def initialize(_func_decl)
-    @_func_decl = _func_decl
-  end
+module Z3
+  class FuncDecl < AST
+    def initialize(_ast)
+      super(_ast)
+      raise Z3::Exception, "FuncDecls must have AST kind func decl" unless ast_kind == :func_decl
+    end
 
-  def name
-    Z3::LowLevel.get_symbol_string(Z3::LowLevel.get_decl_name(self))
-  end
+    def name
+      Z3::LowLevel.get_symbol_string(Z3::LowLevel.get_decl_name(self))
+    end
 
-  def arity
-    Z3::LowLevel.get_arity(self)
-  end
+    def arity
+      Z3::LowLevel.get_arity(self)
+    end
 
-  # def to_ast
-  #   Z3::Ast.new(Z3::LowLevel.func_decl_to_ast(self))
-  # end
+    def domain(i)
+      a = arity
+      raise Z3::Exception, "Trying to access domain #{i} but function arity is #{a}" if i < 0 or i >= a
+      Sort.from_pointer(Z3::LowLevel::get_domain(self, i))
+    end
 
-  # def ast_parameter(i)
-  #   # vs arity ?
-  #   Z3::Ast.new(Z3::LowLevel.get_decl_ast_parameter(self, i))
-  # end
+    def range
+      Sort.from_pointer(Z3::LowLevel::get_range(self))
+    end
 
-  def to_s
-    name
-  end
+    # def ast_parameter(i)
+    #   # vs arity ?
+    #   Z3::Ast.new(Z3::LowLevel.get_decl_ast_parameter(self, i))
+    # end
+
+    def to_s
+      name
+    end
+
+    def inspect
+      "Z3::FuncDecl<#{name}/#{arity}>"
+    end
 
-  def inspect
-    "Z3::FuncDecl<#{name}/#{arity}>"
+    public_class_method :new
   end
 end

data/lib/z3/interface.rb

@@ -23,45 +23,51 @@ module Z3
     BoolSort.new.False
   end
 
+  def Const(v)
+    Expr.sort_for_const(v).from_const(v)
+  end
+
   def And(*args)
     args = coerce_to_same_sort(*args)
     case args[0]
-    when BoolValue
+    when BoolExpr
       BoolSort.new.new(Z3::LowLevel.mk_and(args))
-    when BitvecValue
+    when BitvecExpr
       args.inject do |a,b|
         a.sort.new(Z3::LowLevel.mk_bvand(a, b))
       end
     else
-      raise ArgumentError, "Can't perform logic operations on #{a.sort} values, only Bool and Bitvec"
+      raise ArgumentError, "Can't perform logic operations on #{a.sort} exprs, only Bool and Bitvec"
     end
   end
 
   def Or(*args)
     args = coerce_to_same_sort(*args)
     case args[0]
-    when BoolValue
+    when BoolExpr
       BoolSort.new.new(Z3::LowLevel.mk_or(args))
-    when BitvecValue
+    when BitvecExpr
       args.inject do |a,b|
         a.sort.new(Z3::LowLevel.mk_bvor(a, b))
       end
     else
-      raise ArgumentError, "Can't perform logic operations on #{a.sort} values, only Bool and Bitvec"
+      raise ArgumentError, "Can't perform logic operations on #{a.sort} exprs, only Bool and Bitvec"
     end
   end
 
   def Xor(*args)
     args = coerce_to_same_sort(*args)
     case args[0]
-    when BoolValue
-      BoolSort.new.new(Z3::LowLevel.mk_xor(args))
-    when BitvecValue
+    when BoolExpr
+      args.inject do |a,b|
+        BoolSort.new.new(Z3::LowLevel.mk_xor(a, b))
+      end
+    when BitvecExpr
       args.inject do |a,b|
         a.sort.new(Z3::LowLevel.mk_bvxor(a, b))
       end
     else
-      raise ArgumentError, "Can't perform logic operations on #{a.sort} values, only Bool and Bitvec"
+      raise ArgumentError, "Can't perform logic operations on #{a.sort} exprs, only Bool and Bitvec"
     end
   end
 
@@ -85,23 +91,23 @@ module Z3
     raise ArgumentError if args.empty?
     args = coerce_to_same_sort(*args)
     case args[0]
-    when ArithValue
+    when ArithExpr
       args[0].sort.new(LowLevel.mk_add(args))
-    when BitvecValue
+    when BitvecExpr
       args.inject do |a,b|
         a.sort.new(LowLevel.mk_bvadd(a,b))
       end
     else
-      raise ArgumentError, "Can't perform logic operations on #{args[0].sort} values, only Int/Real/Bitvec"
+      raise ArgumentError, "Can't perform logic operations on #{args[0].sort} exprs, only Int/Real/Bitvec"
     end
   end
 
   def Sub(*args)
     args = coerce_to_same_sort(*args)
     case args[0]
-    when ArithValue
+    when ArithExpr
       args[0].sort.new(LowLevel.mk_sub(args))
-    when BitvecValue
+    when BitvecExpr
       args.inject do |a,b|
         a.sort.new(LowLevel.mk_bvsub(a,b))
       end
@@ -113,9 +119,9 @@ module Z3
   def Mul(*args)
     args = coerce_to_same_sort(*args)
     case args[0]
-    when ArithValue
+    when ArithExpr
       args[0].sort.new(LowLevel.mk_mul(args))
-    when BitvecValue
+    when BitvecExpr
       args.inject do |a,b|
         a.sort.new(LowLevel.mk_bvmul(a,b))
       end
@@ -129,6 +135,16 @@ module Z3
     a.sort.new(LowLevel.mk_div(a, b))
   end
 
+  def Mod(a,b)
+    a, b = coerce_to_same_int_sort(a, b)
+    a.sort.new(LowLevel.mk_mod(a, b))
+  end
+
+  def Rem(a,b)
+    a, b = coerce_to_same_int_sort(a, b)
+    a.sort.new(LowLevel.mk_rem(a, b))
+  end
+
   def Power(a, b)
     # Wait, is this even legitimate that it's I**I and R**R?
     a, b = coerce_to_same_arith_sort(a, b)
@@ -148,9 +164,9 @@ module Z3
   def Gt(a, b)
     a, b = coerce_to_same_sort(a, b)
     case a
-    when ArithValue
+    when ArithExpr
       BoolSort.new.new(LowLevel.mk_gt(a, b))
-    when BitvecValue
+    when BitvecExpr
       BoolSort.new.new(LowLevel.mk_bvsgt(a, b))
     else
       raise ArgumentError, "Can't compare #{a.sort} values"
@@ -160,9 +176,9 @@ module Z3
   def Ge(a, b)
     a, b = coerce_to_same_sort(a, b)
     case a
-    when ArithValue
+    when ArithExpr
       BoolSort.new.new(LowLevel.mk_ge(a, b))
-    when BitvecValue
+    when BitvecExpr
       BoolSort.new.new(LowLevel.mk_bvsge(a, b))
     else
       raise ArgumentError, "Can't compare #{a.sort} values"
@@ -172,9 +188,9 @@ module Z3
   def Lt(a, b)
     a, b = coerce_to_same_sort(a, b)
     case a
-    when ArithValue
+    when ArithExpr
       BoolSort.new.new(LowLevel.mk_lt(a, b))
-    when BitvecValue
+    when BitvecExpr
       BoolSort.new.new(LowLevel.mk_bvslt(a, b))
     else
       raise ArgumentError, "Can't compare #{a.sort} values"
@@ -184,9 +200,9 @@ module Z3
   def Le(a, b)
     a, b = coerce_to_same_sort(a, b)
     case a
-    when ArithValue
+    when ArithExpr
       BoolSort.new.new(LowLevel.mk_le(a, b))
-    when BitvecValue
+    when BitvecExpr
       BoolSort.new.new(LowLevel.mk_bvsle(a, b))
     else
       raise ArgumentError, "Can't compare #{a.sort} values"
@@ -223,9 +239,9 @@ module Z3
   def coerce_to_same_sort(*args)
     # This will raise exception unless one of the sorts is highest
     # So [true, IntSort]
-    max_sort = args.map{|a| a.is_a?(Value) ? a.sort : Value.sort_for_const(a)}.max
+    max_sort = args.map{|a| a.is_a?(Expr) ? a.sort : Expr.sort_for_const(a)}.max
     args.map do |a|
-      if a.is_a?(Value)
+      if a.is_a?(Expr)
         if  a.sort == max_sort
           a
         else
@@ -239,19 +255,25 @@ module Z3
 
   def coerce_to_same_bool_sort(*args)
     args = coerce_to_same_sort(*args)
-    raise Z3::Exception, "Bool value expected" unless args[0].is_a?(BoolValue)
+    raise Z3::Exception, "Bool value expected" unless args[0].is_a?(BoolExpr)
     args
   end
 
   def coerce_to_same_arith_sort(*args)
     args = coerce_to_same_sort(*args)
-    raise Z3::Exception, "Int or Real value expected" unless args[0].is_a?(IntValue) or args[0].is_a?(RealValue)
+    raise Z3::Exception, "Int or Real value expected" unless args[0].is_a?(IntExpr) or args[0].is_a?(RealExpr)
     args
   end
 
   def coerce_to_same_bv_sort(*args)
     args = coerce_to_same_sort(*args)
-    raise Z3::Exception, "Bitvec value with same nize expected" unless args[0].is_a?(BitvecValue)
+    raise Z3::Exception, "Bitvec value with same size expected" unless args[0].is_a?(BitvecExpr)
+    args
+  end
+
+  def coerce_to_same_int_sort(*args)
+    args = coerce_to_same_sort(*args)
+    raise Z3::Exception, "Int value expected" unless args[0].is_a?(IntExpr)
     args
   end