z3 0.0.20160221 → 0.0.20160323

data/lib/z3/model.rb

@@ -23,7 +23,7 @@ class Z3::Model
   end
 
   def model_eval(ast, model_completion=false)
-    Z3::Ast.new(Z3::LowLevel.model_eval(self, ast, model_completion))
+    Z3::Value.new_from_pointer(Z3::LowLevel.model_eval(self, ast, model_completion))
   end
 
   def [](ast)
@@ -40,9 +40,10 @@ class Z3::Model
 
   def each
     consts.sort_by(&:name).each do |c|
+      _ast = Z3::LowLevel.model_get_const_interp(self, c)
       yield(
         c.name,
-        Z3::Ast::new(Z3::LowLevel.model_get_const_interp(self, c))
+        Z3::Value.new_from_pointer(_ast)
       )
     end
   end

data/lib/z3/solver.rb

@@ -1,68 +1,79 @@
-class Z3::Solver
-  attr_reader :_solver
-  def initialize
-    @_solver = Z3::LowLevel.mk_solver
-    Z3::LowLevel.solver_inc_ref(self)
-  end
+module Z3
+  class Solver
+    attr_reader :_solver
+    def initialize
+      @_solver = Z3::LowLevel.mk_solver
+      Z3::LowLevel.solver_inc_ref(self)
+    end
 
-  def push
-    Z3::LowLevel.solver_push(self)
-  end
+    def push
+      Z3::LowLevel.solver_push(self)
+    end
 
-  def pop(n=1)
-    Z3::LowLevel.solver_pop(self, n)
-  end
+    def pop(n=1)
+      Z3::LowLevel.solver_pop(self, n)
+    end
 
-  def reset
-    Z3::LowLevel.solver_reset(self)
-  end
+    def reset
+      Z3::LowLevel.solver_reset(self)
+    end
 
-  def assert(ast)
-    Z3::LowLevel.solver_assert(self, ast)
-  end
+    def assert(ast)
+      Z3::LowLevel.solver_assert(self, ast)
+    end
 
-  def check
-    check_sat_results(Z3::LowLevel.solver_check(self))
-  end
+    def check
+      check_sat_results(Z3::LowLevel.solver_check(self))
+    end
 
-  def model
-    Z3::Model.new(
-      Z3::LowLevel.solver_get_model(self)
-    )
-  end
+    def model
+      Z3::Model.new(
+        Z3::LowLevel.solver_get_model(self)
+      )
+    end
 
-  def prove!(ast)
-    push
-    assert(~ast)
-    case check
-    when :sat
-      puts "Counterexample exists"
-      model.each do |n,v|
-        puts "* #{n} = #{v}"
+    def assertions
+      _ast_vector = Z3::LowLevel.solver_get_assertions(self)
+      n = Z3::VeryLowLevel.Z3_ast_vector_size(Z3::LowLevel._ctx_pointer, _ast_vector)
+      (0...n).map{|i|
+        _ast = Z3::VeryLowLevel.Z3_ast_vector_get(Z3::LowLevel._ctx_pointer, _ast_vector, i)
+        Z3::Value.new_from_pointer(_ast)
+      }
+    end
+
+    def prove!(ast)
+      push
+      assert(~ast)
+      case check
+      when :sat
+        puts "Counterexample exists"
+        model.each do |n,v|
+          puts "* #{n} = #{v}"
+        end
+      when :unknown
+        puts "Unknown"
+      when :unsat
+        puts "Proven"
+      else
+        raise "Wrong SAT result #{r}"
       end
-    when :unknown
-      puts "Unknown"
-    when :unsat
-      puts "Proven"
-    else
-      raise "Wrong SAT result #{r}"
+    ensure
+      pop
     end
-  ensure
-    pop
-  end
 
-  private
+    private
 
-  def check_sat_results(r)
-    case r
-    when 1
-      :sat
-    when 0
-      :unknown
-    when -1
-      :unsat
-    else
-      raise "Wrong SAT result #{r}"
+    def check_sat_results(r)
+      case r
+      when 1
+        :sat
+      when 0
+        :unknown
+      when -1
+        :unsat
+      else
+        raise "Wrong SAT result #{r}"
+      end
     end
   end
 end

data/lib/z3/sort/bitvec_sort.rb

@@ -0,0 +1,40 @@
+module Z3
+  class BitvecSort < Sort
+    def initialize(n)
+      super LowLevel.mk_bv_sort(n)
+    end
+
+    def value_class
+      BitvecValue
+    end
+
+    def from_const(val)
+      if val.is_a?(Integer) or val.is_a?(Float)
+        new LowLevel.mk_numeral(val.to_s, self)
+      else
+        raise Z3::Exception, "Cannot convert #{val.class} to #{self.class}"
+      end
+    end
+
+    def size
+      LowLevel.get_bv_sort_size(self)
+    end
+
+    def to_s
+      "Bitvec(#{size})"
+    end
+
+    def inspect
+      "BitvecSort(#{size})"
+    end
+
+    def >(other)
+      raise ArgumentError unless other.is_a?(Sort)
+      return true if other.is_a?(IntSort)
+      return true if other.is_a?(BitvecSort) and size > other.size
+      false
+    end
+
+    public_class_method :new
+  end
+end

data/lib/z3/sort/bool_sort.rb

@@ -0,0 +1,31 @@
+module Z3
+  class BoolSort < Sort
+    def initialize
+      super LowLevel.mk_bool_sort
+    end
+
+    def value_class
+      BoolValue
+    end
+
+    def from_const(val)
+      if val == true
+        BoolValue.new(LowLevel.mk_true, self)
+      elsif val == false
+        BoolValue.new(LowLevel.mk_false, self)
+      else
+        raise Z3::Exception, "Cannot convert #{val.class} to #{self.class}"
+      end
+    end
+
+    def True
+      from_const(true)
+    end
+
+    def False
+      from_const(false)
+    end
+
+    public_class_method :new
+  end
+end

data/lib/z3/sort/int_sort.rb

@@ -0,0 +1,21 @@
+module Z3
+  class IntSort < Sort
+    def initialize
+      super LowLevel.mk_int_sort
+    end
+
+    def value_class
+      IntValue
+    end
+
+    def from_const(val)
+      if val.is_a?(Integer)
+        new(LowLevel.mk_numeral(val.to_s, self))
+      else
+        raise Z3::Exception, "Cannot convert #{val.class} to #{self.class}"
+      end
+    end
+
+    public_class_method :new
+  end
+end

data/lib/z3/sort/real_sort.rb

@@ -0,0 +1,36 @@
+module Z3
+  class RealSort < Sort
+    def initialize
+      super LowLevel.mk_real_sort
+    end
+
+    def value_class
+      RealValue
+    end
+
+    def from_const(val)
+      if val.is_a?(Integer) or val.is_a?(Float)
+        new LowLevel.mk_numeral(val.to_s, self)
+      else
+        raise Z3::Exception, "Cannot convert #{val.class} to #{self.class}"
+      end
+    end
+
+    def from_value(val)
+      if val.is_a?(IntValue)
+        new LowLevel.mk_int2real(val)
+      elsif val.is_a?(RealValue)
+        val
+      else
+        raise Z3::Exception, "Cannot convert #{val.class} to #{self.class}"
+      end
+    end
+
+    def >(other)
+      raise ArgumentError unless other.is_a?(Sort)
+      other.is_a?(IntSort)
+    end
+
+    public_class_method :new
+  end
+end

data/lib/z3/sort/sort.rb

@@ -0,0 +1,76 @@
+module Z3
+  class Sort
+    attr_reader :_sort
+    def initialize(_sort)
+      @_sort = _sort
+    end
+
+    include Comparable
+    def ==(other)
+      other.is_a?(Sort) and @_sort == other._sort
+    end
+
+    def >(other)
+      raise ArgumentError unless other.is_a?(Sort)
+      false
+    end
+
+    # Reimplementing Comparable
+    # Check if it can handle partial orders OK
+    def <(other)
+      raise ArgumentError unless other.is_a?(Sort)
+      other > self
+    end
+
+    def >=(other)
+      raise ArgumentError unless other.is_a?(Sort)
+      self == other or self > other
+    end
+
+    def <=(other)
+      raise ArgumentError unless other.is_a?(Sort)
+      other >= self
+    end
+
+    def <=>(other)
+      raise ArgumentError unless other.is_a?(Sort)
+      return 0 if self == other
+      return 1 if self > other
+      return -1 if other > self
+      nil
+    end
+
+    def to_s
+      LowLevel.sort_to_string(self)
+    end
+
+    def inspect
+      "#{self}Sort"
+    end
+
+    def var(name)
+      new(
+        Z3::LowLevel.mk_const(
+          Z3::LowLevel.mk_string_symbol(name),
+          self,
+        )
+      )
+    end
+
+    # We pretend to be a class, sort of
+    def new(_ast)
+      value_class.new(_ast, self)
+    end
+
+    def value_class
+      raise "SubclassResponsibility"
+    end
+
+    def from_value(v)
+      return v if v.sort == self
+      raise Z3::Exception, "Can't convert #{v.sort} into #{self}"
+    end
+
+    private_class_method :new
+  end
+end

data/lib/z3/value/arith_value.rb

@@ -0,0 +1,53 @@
+module Z3
+  # IntValue / RealValue
+  module ArithValue
+    def +(other)
+      ::Z3.Add(self, other)
+    end
+
+    def -(other)
+      ::Z3.Sub(self, other)
+    end
+
+    def *(other)
+      ::Z3.Mul(self, other)
+    end
+
+    def /(other)
+      ::Z3.Div(self, other)
+    end
+
+    def **(other)
+      ::Z3.Power(self, other)
+    end
+
+    def >(other)
+      ::Z3.Gt(self, other)
+    end
+
+    def >=(other)
+      ::Z3.Ge(self, other)
+    end
+
+    def <=(other)
+      ::Z3.Le(self, other)
+    end
+
+    def <(other)
+      ::Z3.Lt(self, other)
+    end
+
+    def -@
+      sort.new(LowLevel.mk_unary_minus(self))
+    end
+
+    # Recast so 1 + x:Float
+    # is:  (+ 1.0 x)
+    # not: (+ (to_real 1) x)
+    def coerce(other)
+      other_sort = Value.sort_for_const(other)
+      max_sort = [sort, other_sort].max
+      [max_sort.from_const(other), max_sort.from_value(self)]
+    end
+  end
+end

data/lib/z3/value/bitvec_value.rb

@@ -0,0 +1,67 @@
+module Z3
+  class BitvecValue < Value
+    def ~
+      sort.new(LowLevel.mk_bvnot(self))
+    end
+
+    def -@
+      sort.new(LowLevel.mk_bvneg(self))
+    end
+
+    def &(other)
+      Z3.And(self, other)
+    end
+
+    def |(other)
+      Z3.Or(self, other)
+    end
+
+    def ^(other)
+      Z3.Xor(self, other)
+    end
+
+    def +(other)
+      ::Z3.Add(self, other)
+    end
+
+    def -(other)
+      ::Z3.Sub(self, other)
+    end
+
+    def *(other)
+      ::Z3.Mul(self, other)
+    end
+
+    def >>(other)
+      Z3.RShift(self, other)
+    end
+
+    def <<(other)
+      Z3.LShift(self, other)
+    end
+
+    def >(other)
+      ::Z3.Gt(self, other)
+    end
+
+    def >=(other)
+      ::Z3.Ge(self, other)
+    end
+
+    def <=(other)
+      ::Z3.Le(self, other)
+    end
+
+    def <(other)
+      ::Z3.Lt(self, other)
+    end
+
+    def coerce(other)
+      other_sort = Value.sort_for_const(other)
+      max_sort = [sort, other_sort].max
+      [max_sort.from_const(other), max_sort.from_value(self)]
+    end
+
+    public_class_method :new
+  end
+end

data/lib/z3/value/bool_value.rb

@@ -0,0 +1,29 @@
+module Z3
+  class BoolValue < Value
+    def ~
+      sort.new(LowLevel.mk_not(self))
+    end
+
+    def &(other)
+      Z3.And(self, other)
+    end
+
+    def |(other)
+      Z3.Or(self, other)
+    end
+
+    def ^(other)
+      Z3.Xor(self, other)
+    end
+
+    def iff(other)
+      Z3.Iff(self, other)
+    end
+
+    def implies(other)
+      Z3.Implies(self, other)
+    end
+
+    public_class_method :new
+  end
+end

data/lib/z3/value/int_value.rb

@@ -0,0 +1,7 @@
+module Z3
+  class IntValue < Value
+    include ArithValue
+
+    public_class_method :new
+  end
+end

data/lib/z3/value/real_value.rb

@@ -0,0 +1,7 @@
+module Z3
+  class RealValue < Value
+    include ArithValue
+
+    public_class_method :new
+  end
+end

data/lib/z3/value/value.rb

@@ -0,0 +1,48 @@
+module Z3
+  class Value
+    attr_reader :_ast, :sort
+    def initialize(_ast, sort)
+      @_ast = _ast
+      @sort = sort
+    end
+
+    def to_s
+      Z3::LowLevel.ast_to_string(self)
+    end
+
+    def inspect
+      "Value<#{to_s} :: #{sort.to_s}>"
+    end
+
+    def ==(other)
+      ::Z3.Eq(self, other)
+    end
+
+    def !=(other)
+      ::Z3.Distinct(self, other)
+    end
+
+    private_class_method :new
+
+    class << self
+      def sort_for_const(a)
+        case a
+        when TrueClass, FalseClass
+          BoolSort.new
+        when Integer
+          IntSort.new
+        when Float
+          RealSort.new
+        else
+          raise Z3::Exception, "No idea how to autoconvert `#{a.class}': `#{a.inspect}'"
+        end
+      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
+      end
+    end
+  end
+end

data/lib/z3/very_low_level.rb

@@ -5,53 +5,36 @@ require 'ffi'
 module Z3::VeryLowLevel
   extend FFI::Library
   ffi_lib "z3"
-  # Aliases defined just to make APIs below look nicer
-  ast_pointer = :pointer
-  ctx_pointer = :pointer
-  fixedpoint_pointer = :pointer
-  func_decl_pointer = :pointer
-  goal_pointer = :pointer
-  model_pointer = :pointer
-  optimize_pointer = :pointer
-  param_descrs_pointer = :pointer
-  params_pointer = :pointer
-  pattern_pointer = :pointer
-  probe_pointer = :pointer
-  solver_pointer = :pointer
-  sort_pointer = :pointer
-  symbol_pointer = :pointer
-  tactic_pointer = :pointer
-  rcf_num_pointer = :pointer
-  stats_pointer = :pointer
-  app_pointer = :pointer
-  apply_result_pointer = :pointer
-  ast_map_pointer = :pointer
-  ast_vector_pointer = :pointer
-  config_pointer = :pointer
-  constructor_pointer = :pointer
-  constructor_list_pointer = :pointer
-  func_entry_pointer = :pointer
-  func_interp_pointer = :pointer
 
+  class << self
+    # Aliases defined just to make APIs below look nicer
+    def attach_function(name, arg_types, return_type)
 
-  ### Manually added functions gen_api can't handle [yet]
-  callback :error_handler, [ctx_pointer, :int], :void
-  attach_function :Z3_get_version, [:pointer, :pointer, :pointer, :pointer], :void
-  attach_function :Z3_set_error_handler, [ctx_pointer, :error_handler], :void
-  attach_function :Z3_mk_context, [], ctx_pointer
-  attach_function :Z3_model_eval, [ctx_pointer, model_pointer, ast_pointer, :bool, :pointer], :int
-
-  # attach_function :Z3_model_get_const_decl, [ctx_pointer, model_pointer, :int], func_decl_pointer
-  # attach_function :Z3_model_get_const_interp, [ctx_pointer, model_pointer, func_decl_pointer], ast_pointer
-  # attach_function :Z3_get_decl_name, [ctx_pointer, func_decl_pointer], symbol_pointer
+      arg_types = arg_types.map{|t| map_type(t)}
+      return_type = map_type(return_type)
+      super(name, arg_types, return_type)
+    end
 
-  attach_function :Z3_mk_and, [ctx_pointer, :int, :pointer], ast_pointer
-  attach_function :Z3_mk_or, [ctx_pointer, :int, :pointer], ast_pointer
-  attach_function :Z3_mk_add, [ctx_pointer, :int, :pointer], ast_pointer
-  attach_function :Z3_mk_sub, [ctx_pointer, :int, :pointer], ast_pointer
-  attach_function :Z3_mk_mul, [ctx_pointer, :int, :pointer], ast_pointer
-  attach_function :Z3_mk_distinct, [ctx_pointer, :int, :pointer], ast_pointer
+    def map_type(t)
+      if t.to_s =~ /\A(.*)_pointer\z/
+        :pointer
+      else
+        t
+      end
+    end
+  end
 
-  ### Automatically generated, do not edit that file
-  eval open("#{__dir__}/very_low_level_auto.rb").read
+  ### Manually added functions gen_api can't handle [yet]
+  # callback :error_handler, [:ctx_pointer, :int], :void
+  callback :error_handler, [:pointer, :int], :void
+  attach_function :Z3_get_version, [:pointer, :pointer, :pointer, :pointer], :void
+  attach_function :Z3_set_error_handler, [:ctx_pointer, :error_handler], :void
+  attach_function :Z3_mk_context, [], :ctx_pointer
+  attach_function :Z3_model_eval, [:ctx_pointer, :model_pointer, :ast_pointer, :bool, :pointer], :int
+  attach_function :Z3_mk_and, [:ctx_pointer, :int, :pointer], :ast_pointer
+  attach_function :Z3_mk_or, [:ctx_pointer, :int, :pointer], :ast_pointer
+  attach_function :Z3_mk_add, [:ctx_pointer, :int, :pointer], :ast_pointer
+  attach_function :Z3_mk_sub, [:ctx_pointer, :int, :pointer], :ast_pointer
+  attach_function :Z3_mk_mul, [:ctx_pointer, :int, :pointer], :ast_pointer
+  attach_function :Z3_mk_distinct, [:ctx_pointer, :int, :pointer], :ast_pointer
 end