z3 0.0.0

data/lib/z3/ast.rb

@@ -0,0 +1,302 @@
+class Z3::Ast
+  attr_reader :_ast
+  # Do not use .new directly
+  def initialize(_ast)
+    @_ast = _ast
+  end
+
+  def sort
+    Z3::Sort.new(Z3::LowLevel.get_sort(self))
+  end
+
+  def to_s
+    Z3::LowLevel.ast_to_string(self)
+  end
+
+  def inspect
+    "Z3::Ast<#{to_s} :: #{sort.to_s}>"
+  end
+
+  def ~
+    raise Z3::Exception, "Can only be used on booleans" unless bool?
+    Z3::Ast.not(self)
+  end
+
+  def int?
+    sort == Z3::Sort.int
+  end
+
+  def bool?
+    sort == Z3::Sort.bool
+  end
+
+  def real?
+    sort == Z3::Sort.real
+  end
+
+  private def binary_arithmetic_operator(op, b)
+    b = Z3::Ast.from_const(b, sort) unless b.is_a?(Z3::Ast)
+    raise Z3::Exception, "Can't be used on booleans" if bool? or b.bool?
+    if sort == b.sort
+      a = self
+    else
+      a, b = Z3::Ast.coerce_to_same_sort(self, b)
+    end
+    Z3::Ast.send(op, a, b)
+  end
+
+  private def binary_int_operator(op, b)
+    b = Z3::Ast.from_const(b, sort) unless b.is_a?(Z3::Ast)
+    raise Z3::Exception, "Can only be used on integers" unless int? and b.int?
+    Z3::Ast.send(op, a, b)
+  end
+
+  def |(b)
+    b = Z3::Ast.from_const(b, sort) unless b.is_a?(Z3::Ast)
+    raise Z3::Exception, "Can only be used on booleans" unless bool? and b.bool?
+    Z3::Ast.or(self, b)
+  end
+
+  def &(b)
+    b = Z3::Ast.from_const(b, sort) unless b.is_a?(Z3::Ast)
+    raise Z3::Exception, "Can only be used on booleans" unless bool? and b.bool?
+    Z3::Ast.and(self, b)
+  end
+
+  def +(b)
+    binary_arithmetic_operator(:add, b)
+  end
+
+  def *(b)
+    binary_arithmetic_operator(:mul, b)
+  end
+
+  def -(b)
+    binary_arithmetic_operator(:sub, b)
+  end
+
+  def >=(b)
+    binary_arithmetic_operator(:ge, b)
+  end
+
+  def >(b)
+    binary_arithmetic_operator(:gt, b)
+  end
+
+  def <=(b)
+    binary_arithmetic_operator(:le, b)
+  end
+
+  def <(b)
+    binary_arithmetic_operator(:lt, b)
+  end
+
+  def **(b)
+    binary_arithmetic_operator(:power, b)
+  end
+
+  def /(b)
+    binary_arithmetic_operator(:div, b)
+  end
+
+  def %(b)
+    binary_int_operator(:mod, b)
+  end
+
+  def rem(b)
+    binary_int_operator(:rem, b)
+  end
+
+  def -@
+    raise "Can only apply unary negation to Int or Real" unless int? or real?
+    Z3::Ast.new(Z3::LowLevel.mk_unary_minus(self))
+  end
+
+  def ==(b)
+    b = Z3::Ast.from_const(b, sort) unless b.is_a?(Z3::Ast)
+    if sort != b.sort
+      a, b = Z3::Ast.coerce_to_same_sort(self, b)
+    else
+      a = self
+    end
+    Z3::Ast.eq(self, b)
+  end
+
+  def !=(b)
+    b = Z3::Ast.from_const(b, sort) unless b.is_a?(Z3::Ast)
+    if sort != b.sort
+      a, b = Z3::Ast.coerce_to_same_sort(self, b)
+    else
+      a = self
+    end
+    Z3::Ast.distinct(a, b)
+  end
+
+  def coerce(other)
+    [Z3::Ast.from_const(other, sort), self]
+  end
+
+  def int_to_real
+    raise Z3::Exception, "Type mismatch" unless int?
+    Z3::Ast.new(Z3::LowLevel.mk_int2real(self))
+  end
+
+  class <<self
+    def from_const(value, sort)
+      case sort
+      when Z3::Sort.bool
+        raise Z3::Exception, "Can't convert #{value.class} to Bool" unless value == true or value == false
+        if value
+          Z3::Ast.true
+        else
+          Z3::Ast.false
+        end
+      when Z3::Sort.int
+        # (int_var == 2.4) gets changed to
+        # ((int_to_real int_var) == (mknumeral 2.4))
+        raise Z3::Exception, "Can't convert #{value.class} to Real" unless value.is_a?(Numeric)
+        if value.is_a?(Float)
+          Z3::Ast.new(Z3::LowLevel.mk_numeral(value.to_s, Z3::Sort.real))
+        else
+          Z3::Ast.new(Z3::LowLevel.mk_numeral(value.to_s, sort))
+        end
+      when Z3::Sort.real
+        raise Z3::Exception, "Can't convert #{value.class} to Real" unless value.is_a?(Numeric)
+        Z3::Ast.new(Z3::LowLevel.mk_numeral(value.to_s, sort))
+      end
+    end
+
+    def coerce_bool(value)
+      if value.is_a?(Z3::Ast)
+        return value if value.bool?
+        raise Z3::Exception, "Can't convert #{value.sort} to Bool"
+      end
+      raise Z3::Exception, "Can't convert #{value.class} to Bool" unless value == true or value == false
+        if value
+          Z3::Ast.true
+        else
+          Z3::Ast.false
+        end
+    end
+
+    def coerce_to_same_sort(a, b)
+      if a.sort == Z3::Sort.int and b.sort == Z3::Sort.real
+        [a.int_to_real, b]
+      elsif b.sort == Z3::Sort.int and a.sort == Z3::Sort.real
+        [a, b.int_to_real]
+      else
+        raise Z3::Exception, "No rules how to coerce #{a.sort} and #{b.sort}"
+      end
+    end
+
+    def true
+      Z3::Ast.new(Z3::LowLevel.mk_true)
+    end
+
+    def false
+      Z3::Ast.new(Z3::LowLevel.mk_false)
+    end
+
+    def eq(a, b)
+      Z3::Ast.new(Z3::LowLevel.mk_eq(a, b))
+    end
+
+    def ge(a, b)
+      Z3::Ast.new(Z3::LowLevel.mk_ge(a, b))
+    end
+
+    def gt(a, b)
+      Z3::Ast.new(Z3::LowLevel.mk_gt(a, b))
+    end
+
+    def le(a, b)
+      Z3::Ast.new(Z3::LowLevel.mk_le(a, b))
+    end
+
+    def lt(a, b)
+      Z3::Ast.new(Z3::LowLevel.mk_lt(a, b))
+    end
+
+    def power(a, b)
+      Z3::Ast.new(Z3::LowLevel.mk_power(a, b))
+    end
+
+    def div(a, b)
+      Z3::Ast.new(Z3::LowLevel.mk_div(a, b))
+    end
+
+    def mod(a, b)
+      Z3::Ast.new(Z3::LowLevel.mk_mod(a, b))
+    end
+
+    def rem(a, b)
+      Z3::Ast.new(Z3::LowLevel.mk_rem(a, b))
+    end
+
+    def not(a)
+      a = coerce_bool(a)
+      Z3::Ast.new(Z3::LowLevel.mk_not(a))
+    end
+
+    def distinct(*args)
+      Z3::Ast.new(Z3::LowLevel.mk_distinct(args))
+    end
+
+    def and(*args)
+      args = args.map{|a| coerce_bool(a)}
+      Z3::Ast.new(Z3::LowLevel.mk_and(args))
+    end
+
+    def or(*args)
+      args = args.map{|a| coerce_bool(a)}
+      Z3::Ast.new(Z3::LowLevel.mk_or(args))
+    end
+
+    def add(*args)
+      Z3::Ast.new(Z3::LowLevel.mk_add(args))
+    end
+
+    def iff(a, b)
+      a = coerce_bool(a)
+      b = coerce_bool(b)
+      Z3::Ast.new(Z3::LowLevel.mk_iff(a, b))
+    end
+
+    def implies(a, b)
+      a = coerce_bool(a)
+      b = coerce_bool(b)
+      Z3::Ast.new(Z3::LowLevel.mk_implies(a, b))
+    end
+
+    def sub(*args)
+      Z3::Ast.new(Z3::LowLevel.mk_sub(args))
+    end
+
+    def mul(*args)
+      Z3::Ast.new(Z3::LowLevel.mk_mul(args))
+    end
+
+    def bool(name)
+      var(name, Z3::Sort.bool)
+    end
+
+    def int(name)
+      var(name, Z3::Sort.int)
+    end
+
+    def real(name)
+      var(name, Z3::Sort.real)
+    end
+
+    private
+
+    def var(name, sort)
+      Z3::Ast.new(
+        Z3::LowLevel.mk_const(
+          Z3::LowLevel.mk_string_symbol(name),
+          sort,
+        )
+      )
+    end
+  end
+end

data/lib/z3/context.rb

@@ -0,0 +1,10 @@
+class Z3::Context
+  attr_reader :_context
+  def initialize
+    @_context = Z3::LowLevel.mk_context
+  end
+
+  def self.instance
+    @instance ||= new
+  end
+end

data/lib/z3/func_decl.rb

@@ -0,0 +1,31 @@
+class Z3::FuncDecl
+  attr_reader :_func_decl
+  def initialize(_func_decl)
+    @_func_decl = _func_decl
+  end
+
+  def name
+    Z3::LowLevel.get_symbol_string(Z3::LowLevel.get_decl_name(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 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
+end

data/lib/z3/low_level.rb

@@ -0,0 +1,254 @@
+# Seriously do not use this directly in your code
+# They unwrap inputs, but don't wrap returns yet
+
+module Z3::LowLevel
+  class << self
+    # Common API
+    def get_version
+      a = FFI::MemoryPointer.new(:int)
+      b = FFI::MemoryPointer.new(:int)
+      c = FFI::MemoryPointer.new(:int)
+      d = FFI::MemoryPointer.new(:int)
+      Z3::VeryLowLevel.Z3_get_version(a,b,c,d)
+      [a.get_uint(0), b.get_uint(0), c.get_uint(0), d.get_uint(0)]
+    end
+
+    def set_error_handler(&block)
+      Z3::VeryLowLevel.Z3_set_error_handler(_ctx_pointer, block)
+    end
+
+    def global_param_set(k,v)
+      Z3::VeryLowLevel.Z3_global_param_set(k.to_s, v.to_s)
+    end
+
+    # Context API
+    def mk_context
+      Z3::VeryLowLevel.Z3_mk_context
+    end
+
+    # Symbol API
+    def mk_string_symbol(name)
+      Z3::VeryLowLevel.Z3_mk_string_symbol(_ctx_pointer, name)
+    end
+
+    def get_symbol_string(symbol)
+      Z3::VeryLowLevel.Z3_get_symbol_string(_ctx_pointer, symbol)
+    end
+
+    # Sort API
+    def mk_bool_sort
+      Z3::VeryLowLevel.Z3_mk_bool_sort(_ctx_pointer)
+    end
+
+    def mk_int_sort
+      Z3::VeryLowLevel.Z3_mk_int_sort(_ctx_pointer)
+    end
+
+    def mk_real_sort
+      Z3::VeryLowLevel.Z3_mk_real_sort(_ctx_pointer)
+    end
+
+    def sort_to_string(sort)
+      Z3::VeryLowLevel.Z3_sort_to_string(_ctx_pointer, sort._sort)
+    end
+
+    # Solver API
+    def mk_solver
+      Z3::VeryLowLevel.Z3_mk_solver(_ctx_pointer)
+    end
+
+    def solver_push(solver)
+      Z3::VeryLowLevel.Z3_solver_push(_ctx_pointer, solver._solver)
+    end
+
+    def solver_pop(solver, n)
+      Z3::VeryLowLevel.Z3_solver_pop(_ctx_pointer, solver._solver, n)
+    end
+
+    def solver_reset(solver)
+      Z3::VeryLowLevel.Z3_solver_reset(_ctx_pointer, solver._solver)
+    end
+
+    def solver_assert(solver, ast)
+      Z3::VeryLowLevel.Z3_solver_assert(_ctx_pointer, solver._solver, ast._ast)
+    end
+
+    def solver_check(solver)
+      Z3::VeryLowLevel.Z3_solver_check(_ctx_pointer, solver._solver)
+    end
+
+    def solver_inc_ref(solver)
+      Z3::VeryLowLevel.Z3_solver_inc_ref(_ctx_pointer, solver._solver)
+    end
+
+    # Model API
+    def solver_get_model(solver)
+      Z3::VeryLowLevel.Z3_solver_get_model(_ctx_pointer, solver._solver)
+    end
+
+    def model_get_num_consts(model)
+      Z3::VeryLowLevel.Z3_model_get_num_consts(_ctx_pointer, model._model)
+    end
+
+    def model_get_num_funcs(model)
+      Z3::VeryLowLevel.Z3_model_get_num_funcs(_ctx_pointer, model._model)
+    end
+
+    def model_get_num_sorts(model)
+      Z3::VeryLowLevel.Z3_model_get_num_sorts(_ctx_pointer, model._model)
+    end
+
+    def model_eval(model, ast, model_completion)
+      rv_ptr = FFI::MemoryPointer.new(:pointer)
+      result = Z3::VeryLowLevel.Z3_model_eval(_ctx_pointer, model._model, ast._ast, !!model_completion, rv_ptr)
+      if result == 1
+        rv_ptr.get_pointer(0)
+      else
+        raise Z3::Exception, "Evaluation of `#{ast}' failed"
+      end
+    end
+
+    def model_get_const_decl(model, i)
+      Z3::VeryLowLevel.Z3_model_get_const_decl(_ctx_pointer, model._model, i)
+    end
+
+    # FuncDecl API
+    def func_decl_to_ast(func_decl)
+      Z3::VeryLowLevel.Z3_func_decl_to_ast(_ctx_pointer, func_decl._func_decl)
+    end
+
+    def get_decl_name(func_decl)
+      Z3::VeryLowLevel.Z3_get_decl_name(_ctx_pointer, func_decl._func_decl)
+    end
+
+    def get_arity(func_decl)
+      Z3::VeryLowLevel.Z3_get_arity(_ctx_pointer, func_decl._func_decl)
+    end
+
+    def get_decl_ast_parameter(func_decl, i)
+      Z3::VeryLowLevel.Z3_get_decl_ast_parameter(_ctx_pointer, func_decl._func_decl, i)
+    end
+
+    def model_get_const_interp(model, func_decl)
+      Z3::VeryLowLevel.Z3_model_get_const_interp(_ctx_pointer, model._model, func_decl._func_decl)
+    end
+
+    # AST API
+    def mk_true
+      Z3::VeryLowLevel.Z3_mk_true(_ctx_pointer)
+    end
+
+    def mk_false
+      Z3::VeryLowLevel.Z3_mk_false(_ctx_pointer)
+    end
+
+    def mk_eq(a,b)
+      Z3::VeryLowLevel.Z3_mk_eq(_ctx_pointer, a._ast, b._ast)
+    end
+
+    def mk_ge(a,b)
+      Z3::VeryLowLevel.Z3_mk_ge(_ctx_pointer, a._ast, b._ast)
+    end
+
+    def mk_gt(a,b)
+      Z3::VeryLowLevel.Z3_mk_gt(_ctx_pointer, a._ast, b._ast)
+    end
+
+    def mk_le(a,b)
+      Z3::VeryLowLevel.Z3_mk_le(_ctx_pointer, a._ast, b._ast)
+    end
+
+    def mk_lt(a,b)
+      Z3::VeryLowLevel.Z3_mk_lt(_ctx_pointer, a._ast, b._ast)
+    end
+
+    def mk_power(a,b)
+      Z3::VeryLowLevel.Z3_mk_power(_ctx_pointer, a._ast, b._ast)
+    end
+
+    def mk_rem(a,b)
+      Z3::VeryLowLevel.Z3_mk_rem(_ctx_pointer, a._ast, b._ast)
+    end
+
+    def mk_mod(a,b)
+      Z3::VeryLowLevel.Z3_mk_mod(_ctx_pointer, a._ast, b._ast)
+    end
+
+    def mk_div(a,b)
+      Z3::VeryLowLevel.Z3_mk_div(_ctx_pointer, a._ast, b._ast)
+    end
+
+    def mk_not(a)
+      Z3::VeryLowLevel.Z3_mk_not(_ctx_pointer, a._ast)
+    end
+
+    def mk_const(_symbol, sort)
+      Z3::VeryLowLevel.Z3_mk_const(_ctx_pointer, _symbol, sort._sort)
+    end
+
+    def mk_and(asts)
+      Z3::VeryLowLevel.Z3_mk_and(_ctx_pointer, asts.size, asts_vector(asts))
+    end
+
+    def mk_or(asts)
+      Z3::VeryLowLevel.Z3_mk_or(_ctx_pointer, asts.size, asts_vector(asts))
+    end
+
+    def mk_iff(asts)
+      Z3::VeryLowLevel.Z3_mk_iff(_ctx_pointer, a._ast, b._ast)
+    end
+
+    def mk_implies(a, b)
+      Z3::VeryLowLevel.Z3_mk_implies(_ctx_pointer, a._ast, b._ast)
+    end
+
+    def mk_mul(asts)
+      Z3::VeryLowLevel.Z3_mk_mul(_ctx_pointer, asts.size, asts_vector(asts))
+    end
+
+    def mk_add(asts)
+      Z3::VeryLowLevel.Z3_mk_add(_ctx_pointer, asts.size, asts_vector(asts))
+    end
+
+    def mk_sub(asts)
+      Z3::VeryLowLevel.Z3_mk_sub(_ctx_pointer, asts.size, asts_vector(asts))
+    end
+
+    def mk_distinct(asts)
+      Z3::VeryLowLevel.Z3_mk_distinct(_ctx_pointer, asts.size, asts_vector(asts))
+    end
+
+    def ast_to_string(ast)
+      Z3::VeryLowLevel.Z3_ast_to_string(_ctx_pointer, ast._ast)
+    end
+
+    def get_sort(ast)
+      Z3::VeryLowLevel.Z3_get_sort(_ctx_pointer, ast._ast)
+    end
+
+    def mk_int2real(ast)
+      Z3::VeryLowLevel.Z3_mk_int2real(_ctx_pointer, ast._ast)
+    end
+
+    def mk_numeral(str, sort)
+      Z3::VeryLowLevel.Z3_mk_numeral(_ctx_pointer, str, sort._sort)
+    end
+
+    def mk_unary_minus(ast)
+      Z3::VeryLowLevel.Z3_mk_unary_minus(_ctx_pointer, ast._ast)
+    end
+
+    private
+
+    def asts_vector(args)
+      raise if args.empty?
+      c_args = FFI::MemoryPointer.new(:pointer, args.size)
+      c_args.write_array_of_pointer args.map(&:_ast)
+      c_args
+    end
+
+    def _ctx_pointer
+      @_ctx_pointer ||= Z3::Context.instance._context
+    end
+  end
+end

data/lib/z3/model.rb

@@ -0,0 +1,49 @@
+class Z3::Model
+  include Enumerable
+
+  attr_reader :_model
+  def initialize(_model)
+    @_model = _model
+  end
+
+  def num_consts
+    Z3::LowLevel.model_get_num_consts(self)
+  end
+
+  def consts
+    (0...num_consts).map{|i| Z3::FuncDecl.new(Z3::LowLevel.model_get_const_decl(self, i)) }
+  end
+
+  def num_sorts
+    Z3::LowLevel.model_get_num_sorts(self)
+  end
+
+  def num_funcs
+    Z3::LowLevel.model_get_num_funcs(self)
+  end
+
+  def model_eval(ast, model_completion=false)
+    Z3::Ast.new(Z3::LowLevel.model_eval(self, ast, model_completion))
+  end
+
+  def [](ast)
+    model_eval(ast)
+  end
+
+  def to_s
+    "Z3::Model<#{ map{|n,v| "#{n}=#{v}"}.join(", ") }>"
+  end
+
+  def inspect
+    to_s
+  end
+
+  def each
+    consts.sort_by(&:name).each do |c|
+      yield(
+        c.name,
+        Z3::Ast::new(Z3::LowLevel.model_get_const_interp(self, c))
+      )
+    end
+  end
+end

data/lib/z3/solver.rb

@@ -0,0 +1,68 @@
+class Z3::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 pop(n=1)
+    Z3::LowLevel.solver_pop(self, n)
+  end
+
+  def reset
+    Z3::LowLevel.solver_reset(self)
+  end
+
+  def assert(ast)
+    Z3::LowLevel.solver_assert(self, ast)
+  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 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
+  ensure
+    pop
+  end
+
+  private
+
+  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