z3 0.0.20160427 → 0.0.20161008

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b373cf9a8caebd1c5a05420660ac2301528613eb
-  data.tar.gz: 4c45e3aa7326aeaefddee63a17c8a4eeb1fe57e0
+  metadata.gz: f77923728739173352acc32c2b86d15d158df0aa
+  data.tar.gz: 6d14bf2597324dfaeb56fef62126466a80312b59
 SHA512:
-  metadata.gz: 6a2bd8245fcb32c67f0c609b477842a6f804fcc45d514f7d8d7a8ec047c8e6e70875167562aef1c51d04b637c900f001d4ad8e35368005f9aa3c7990239ab841
-  data.tar.gz: 73efd05c6292e8ef129c8a711a7de4b5a377c585991a11f4fe6930763c9e9e9ead23cc36fa98caba35966d9d7e5f897509ee7bb5bf003ff355d3ad2001b731f0
+  metadata.gz: 5c298ac6d9809173f284ac05ae13e19a52cebd56cff557f36894a6b8e5168f68bcfee71e1652ae3848d7009a2572bcdc3663e858e66f808b8c8a112f8a1a25bf
+  data.tar.gz: cf216b75b22a6c172f06613972a8d1c0644efee56ea1462df24d040aa189b58558d594d84156ba1e3ebc3e23b24fc4371faa661f519aecd8e2fa0afe47c98da9

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Rakefile

@@ -0,0 +1,56 @@
+require "json"
+
+task "default" => "spec"
+task "test" => "spec"
+task "test:integration" => "spec:integration"
+task "test:unit" => "spec:unit"
+
+desc "Regenerate API"
+task "api" do
+  system "./api/gen_api api/definitions.h"
+end
+
+desc "Clean up"
+task "clean" do
+  system "trash z3-*.gem coverage"
+end
+
+desc "Run tests"
+task "spec" do
+  system "rspec"
+end
+
+desc "Run unit tests"
+task "spec:unit" do
+  system "rspec spec/*_spec.rb"
+end
+
+desc "Run integration tests"
+task "spec:integration" do
+  system "rspec spec/integration/*_spec.rb"
+end
+
+desc "Build gem"
+task "gem:build" do
+  system "gem build z3.gemspec"
+end
+
+desc "Upload gem"
+task "gem:push" => "gem:build" do
+  gem_file = Dir["z3-*.gem"][-1] or raise "No gem found"
+  system "gem", "push", gem_file
+end
+
+desc "Report missing APIs"
+task "coverage:missing" do
+  system "COVERAGE=1 rake test"
+  data = JSON.load(open("coverage/.resultset.json"))["RSpec"]["coverage"]
+  lla_path = data.keys.find{|k| k.end_with?("lib/z3/low_level_auto.rb")}
+  coverage = data[lla_path].zip(File.readlines(lla_path).map(&:strip))
+  missing = coverage.each_cons(2).map(&:flatten).select{|_,_,bc,_| bc == 0}.map{|_,a,_,_| a.sub(/\Adef /, "")}
+  # Also missing is everything that uses too fancy calling convention for automated generation
+  # That's currently 60 functions
+  open("missing_apis.txt", "w") do |file|
+    file.puts missing
+  end
+end

data/examples/bit_tricks

@@ -2,15 +2,21 @@
 
 require_relative "../lib/z3"
 
+def c_boolean(expr)
+  one  = Z3::BitvecSort.new(32).from_const(1)
+  zero = Z3::BitvecSort.new(32).from_const(0)
+  expr.ite(one, zero)
+end
+
 def validate_sign_by_shift!
   """
   sign = v >> (sizeof(int) * CHAR_BIT - 1);
   """
   solver = Z3::Solver.new
   v = Z3.Bitvec("v", 32)
-  s = v >> 31
+  s = v.signed_rshift(31)
   puts "Validating sign trick:"
-  solver.prove! ((v < 0) & (s == -1)) | ((v >= 0) & (s == 0))
+  solver.prove! (v.signed_lt(0) & (s == -1)) | (v.signed_ge(0) & (s == 0))
 end
 
 def validate_opposite_sign_by_xor!
@@ -21,15 +27,15 @@ def validate_opposite_sign_by_xor!
   solver = Z3::Solver.new
   x = Z3.Bitvec("x", 32)
   y = Z3.Bitvec("y", 32)
-  f = (x^y) < 0
+  f = (x^y).signed_lt(0)
 
   puts "Validating sign trick:"
   solver.prove!(
     Z3.Or(
-      Z3.And(x >= 0, y >= 0, f == false),
-      Z3.And(x < 0, y < 0, f == false),
-      Z3.And(x >= 0, y < 0, f == true),
-      Z3.And(x < 0, y >= 0, f == true),
+      Z3.And(x.signed_ge(0), y.signed_ge(0), f == false),
+      Z3.And(x.signed_lt(0), y.signed_lt(0), f == false),
+      Z3.And(x.signed_ge(0), y.signed_lt(0), f == true),
+      Z3.And(x.signed_lt(0), y.signed_ge(0), f == true),
     )
   )
 end
@@ -43,14 +49,11 @@ def validate_abs_without_branching_1!
   """
   solver = Z3::Solver.new
   v = Z3.Bitvec("v", 32)
-  mask = v >> 31
+  mask = v.signed_rshift(31)
   r = (v + mask) ^ mask
   puts "Validating abs without branching, version 1"
   solver.prove!(
-    Z3.Or(
-      Z3.And(v >= 0, r==v),
-      Z3.And(v < 0, r==-v)
-    )
+    v.signed_ge(0).ite(r == v, r == -v)
   )
 end
 
@@ -63,28 +66,14 @@ def validate_abs_without_branching_2!
   """
   solver = Z3::Solver.new
   v = Z3.Bitvec("v", 32)
-  mask = v >> 31
+  mask = v.signed_rshift(31)
   r = (v^mask) - mask
   puts "Validating abs without branching, version 2"
   solver.prove!(
-    Z3.Or(
-      Z3.And(v >= 0, r==v),
-      Z3.And(v < 0, r==-v)
-    )
+    v.signed_ge(0).ite(r == v, r == -v)
   )
 end
 
-def c_boolean(solver, bool_expr, name)
-  expr_val = Z3.Bitvec(name, 32)
-  solver.assert(
-    Z3.Or(
-      Z3.And(bool_expr, expr_val == 1),
-      Z3.And(~bool_expr, expr_val == 0),
-    )
-  )
-  expr_val
-end
-
 def validate_min_without_branching!
   """
   int x;  // we want to find the minimum of x and y
@@ -95,13 +84,10 @@ def validate_min_without_branching!
   solver = Z3::Solver.new
   x = Z3.Bitvec("x", 32)
   y = Z3.Bitvec("y", 32)
-  r = y ^ ((x ^ y) & -c_boolean(solver, x < y, "t"))
+  r = y ^ ((x ^ y) & -c_boolean(x.signed_lt(y)))
   puts "Validating min without branching"
   solver.prove!(
-    Z3.Or(
-      Z3.And(x <= y, r == x),
-      Z3.And(y <= y, r == y),
-    )
+    x.signed_le(y).ite(r == x, r == y)
   )
 end
 
@@ -115,13 +101,10 @@ def validate_max_without_branching!
   solver = Z3::Solver.new
   x = Z3.Bitvec("x", 32)
   y = Z3.Bitvec("y", 32)
-  r = x ^ ((x ^ y) & -c_boolean(solver, x < y, "t"))
+  r = x ^ ((x ^ y) & -c_boolean(x.signed_lt(y)))
   puts "Validating max without branching"
   solver.prove!(
-    Z3.Or(
-      Z3.And(x >= y, r == x),
-      Z3.And(y >= y, r == y),
-    )
+    x.signed_ge(y).ite(r == x, r == y)
   )
 end
 

data/examples/circuit_problems

@@ -0,0 +1,170 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/z3"
+
+# It's totally possible everything is backwards
+class CircuitProblem
+  def initialize
+    @solver = Z3::Solver.new
+    @pins = {}
+  end
+
+  def battery(name, battery_voltage)
+    plus    = create_pin("#{name}+")
+    minus   = create_pin("#{name}-")
+    current = create_current("#{name}", "#{name}+", "#{name}-")
+    @solver.assert plus[:voltage] - minus[:voltage] == battery_voltage
+  end
+
+  def resistor(name, resistance)
+    a = create_pin("#{name}a")
+    b = create_pin("#{name}b")
+    current = create_current("#{name}", "#{name}a", "#{name}b")
+    # dV = RI
+    @solver.assert (a[:voltage] - b[:voltage]) == current * resistance
+  end
+
+  # This is super simple diode model
+  def diode(name)
+    a = create_pin("#{name}+")
+    b = create_pin("#{name}-")
+    current = create_current("#{name}", "#{name}+", "#{name}-")
+    # * current can't flow backwards
+    # * if voltage is reversed, current is stopped (infinite resistance)
+    # * if current is flowing, voltage is equalized (zero resistance)
+    # * voltage is same or current is zero
+    @solver.assert current >= 0
+    @solver.assert a[:voltage] <= b[:voltage]
+    # @solver.assert Z3.Implies(current > 0, a[:voltage] == b[:voltage])
+    # @solver.assert Z3.Implies(a[:voltage] < b[:voltage], current == 0)
+    @solver.assert Z3.Or(a[:voltage] == b[:voltage], current == 0)
+  end
+
+  def connect(a, b)
+    create_current("Wire #{a} #{b}", a, b)
+    @solver.assert @pins[a][:voltage] == @pins[b][:voltage]
+  end
+
+  def solve!(*vars)
+    setup_flow_rules!
+    with_solved_model do |model|
+      model.each do |n,v|
+        next unless vars.include?(n.to_s)
+        puts "* #{n} = #{v}"
+      end
+    end
+  end
+
+  def debug!
+    setup_flow_rules!
+    with_solved_model do |model|
+      model.each do |n,v|
+        puts "* #{n} = #{v}"
+      end
+    end
+  end
+
+  def ground(name)
+    @solver.assert @pins[name][:voltage] == 0
+  end
+
+  private
+
+  def with_solved_model
+    if @solver.check == :sat
+      yield @solver.model
+    else
+      puts "Can't solve the problem"
+    end
+  end
+
+  def setup_flow_rules!
+    @pins.each do |name, pin|
+      # All current flows are equal
+      @solver.assert Z3.Add(*pin[:current]) == 0
+    end
+  end
+
+  def create_pin(name)
+    raise "Pin named #{name} already exists" if @pins[name]
+    @pins[name] = {
+      voltage: Z3.Real("V #{name}"),
+      current: [],
+    }
+  end
+
+  def create_current(name, source, sink)
+    raise "No such pin: #{source}" unless @pins[source]
+    raise "No such pin: #{sink}" unless @pins[sink]
+    current = Z3.Real("I #{name}")
+    @pins[source][:current] << current
+    @pins[sink][:current] << -current
+    current
+  end
+end
+
+# http://physics.info/circuits-r/practice.shtml
+def problem_1!
+  problem = CircuitProblem.new
+  problem.battery  "V",  125
+  problem.ground "V-"
+  problem.resistor "R1", 20
+  problem.resistor "R2", 30
+  problem.resistor "R3", 50
+  problem.connect "V-", "R1a"
+  problem.connect "R1b", "R2a"
+  problem.connect "R2b", "R3a"
+  problem.connect "R3b", "V+"
+  problem.solve! "I V"
+end
+
+def problem_2!
+  problem = CircuitProblem.new
+  problem.battery  "V",  125
+  problem.ground "V-"
+  problem.resistor "R1", 20
+  problem.resistor "R2", 100
+  problem.resistor "R3", 50
+  problem.connect "V-", "R1a"
+  problem.connect "V-", "R2a"
+  problem.connect "V-", "R3a"
+  problem.connect "V+", "R1b"
+  problem.connect "V+", "R2b"
+  problem.connect "V+", "R3b"
+  problem.solve! "I V"
+end
+
+def problem_3!
+  # V+ [ D1 -> ] La
+  # V- [ D2 -> ] La
+  # V+ [ D3 <- ] Lb
+  # V- [ D4 <- ] Lb
+  [100, 50, 0, -50, -100].each do |v|
+    problem = CircuitProblem.new
+    problem.battery "V", v
+    problem.ground "V-"
+    problem.resistor "L", 100
+    problem.diode "D1"
+    problem.diode "D2"
+    problem.diode "D3"
+    problem.diode "D4"
+    problem.connect "D1-", "V+"
+    problem.connect "D1+",      "La"
+    problem.connect "D2-", "V-"
+    problem.connect "D2+",      "La"
+    problem.connect "D3-",      "Lb"
+    problem.connect "D3+", "V+"
+    problem.connect "D4-",      "Lb"
+    problem.connect "D4+", "V-"
+    problem.solve! "I V", "I L"
+  end
+end
+
+puts "Problem 1"
+problem_1!
+puts ""
+puts "Problem 2"
+problem_2!
+puts ""
+puts "Problem 3"
+problem_3!

data/lib/z3/ast.rb

@@ -16,16 +16,34 @@ module Z3
         5 => :func_decl,
         1000 => :unknown,
       }
-      kind_id = Z3::LowLevel.get_ast_kind(self)
+      kind_id = LowLevel.get_ast_kind(self)
       ast_kind_lookup[kind_id] or raise Z3::Exception, "Unknown AST kind #{kind_id}"
     end
 
+    def func_decl
+      raise Z3::Exception, "Only app ASTs can have func decls" unless ast_kind == :app
+      FuncDecl.new(LowLevel::get_app_decl(self))
+    end
+
+    def arguments
+      raise Z3::Exception, "Only app ASTs can have arguments" unless ast_kind == :app
+      num = LowLevel::get_app_num_args(self)
+      (0...num).map do |i|
+        _ast = LowLevel::get_app_arg(self, i)
+        Expr.new_from_pointer(_ast)
+      end
+    end
+
     def to_s
-      Z3::Printer.new.format(self)
+      Printer.new.format(self)
     end
 
     def sexpr
-      Z3::LowLevel.ast_to_string(self)
+      LowLevel.ast_to_string(self)
+    end
+
+    def simplify
+      sort.new(LowLevel.simplify(self))
     end
 
     private_class_method :new

data/lib/z3/context.rb

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

data/lib/z3/exception.rb

@@ -2,8 +2,7 @@ module Z3
   class Exception < StandardError
   end
 
-
-  Z3::LowLevel.set_error_handler do |ctx, error|
+  LowLevel.set_error_handler do |ctx, error|
     error_codes_enum = %W[
       Z3_OK
       Z3_SORT_ERROR

data/lib/z3/expr/arith_expr.rb

@@ -1,40 +1,39 @@
 module Z3
-  # IntExpr / RealExpr
-  module ArithExpr
+  class ArithExpr < Expr
     def +(other)
-      ::Z3.Add(self, other)
+      Expr.Add(self, other)
     end
 
     def -(other)
-      ::Z3.Sub(self, other)
+      Expr.Sub(self, other)
     end
 
     def *(other)
-      ::Z3.Mul(self, other)
+      Expr.Mul(self, other)
     end
 
     def /(other)
-      ::Z3.Div(self, other)
+      ArithExpr.Div(self, other)
     end
 
     def **(other)
-      ::Z3.Power(self, other)
+      ArithExpr.Power(self, other)
     end
 
     def >(other)
-      ::Z3.Gt(self, other)
+      Expr.Gt(self, other)
     end
 
     def >=(other)
-      ::Z3.Ge(self, other)
+      Expr.Ge(self, other)
     end
 
     def <=(other)
-      ::Z3.Le(self, other)
+      Expr.Le(self, other)
     end
 
     def <(other)
-      ::Z3.Lt(self, other)
+      Expr.Lt(self, other)
     end
 
     def -@
@@ -49,5 +48,24 @@ module Z3
       max_sort = [sort, other_sort].max
       [max_sort.from_const(other), max_sort.from_value(self)]
     end
+
+    class << self
+      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?(IntExpr) or args[0].is_a?(RealExpr)
+        args
+      end
+
+      def Div(a,b)
+        a, b = coerce_to_same_arith_sort(a, b)
+        a.sort.new(LowLevel.mk_div(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)
+        a.sort.new(LowLevel.mk_power(a, b))
+      end
+    end
   end
 end

data/lib/z3/expr/array_expr.rb

@@ -0,0 +1,5 @@
+module Z3
+  class ArrayExpr < Expr
+    public_class_method :new
+  end
+end