z3 0.0.20160221 → 0.0.20160323

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 73f23f4e1511fe002de7b2e1d3d91945bc6f8be6
-  data.tar.gz: e6662d712ccaedd2b76a9c560dac242228d51311
+  metadata.gz: 3ec7feb43474477a1c3a7220fbbd5c6e11246cd2
+  data.tar.gz: 687aedb2c8aaeca944108d4361459bba5ba08eb5
 SHA512:
-  metadata.gz: 206d8cb1e08173e3013da2426359a922c72631c28e84957ac8b94ce1219e5295960436fbd78513eb128cd0eb1b396bdf4f534247b183848ecb92df4d16d9e452
-  data.tar.gz: 04f74e3844e9e017bb6636cd26b96fd0cc79e05e59a86650c66fe18b271a3bc9798ee8481fb9979ec134cb298354f03c2b097b14f9c531166bf0f0ac87ea0ce6
+  metadata.gz: 9e641cf575e0810de111a96f394747b1316dc2f9cebd63c7a52390c2439c7836abf1660d67b52998f5e4a048fea74a569121e7f9fd9e4a2e32bce82367082362
+  data.tar.gz: 9d1c79300d21645a5ed1e121a8f069fd0a4504c5731ff07c5e5f6a6727647c94ae64fb885c4f4e5bfb2b4641183b2e697f8128d3f66f784cdc9ab6dcce3361fe

data/README.md

@@ -8,10 +8,12 @@ It's in extremely early stages of development. Pull requests always welcome.
 
 The rest of `Z3` is high level API, but the interface is extremely unstable at this point, and it's pretty much guaranteed to  change many times. Check specs or `examples/` directory for usage.
 
-You can use most Ruby operators to construct ASTs, but use `~ | &` instead of `! || &&` for boolean operators.
+You can use most Ruby operators to construct Z3 expressions, but use `~ | &` instead of `! || &&` for boolean operators. They unfortunately have wrong operator precedence so you'll need to use some extra parentheses.
 
 As for API internals, attributes starting with `_` are FFI internals you shouldn't touch, other attributes are generally legitimate Ruby objects.
 
+Bit vectors are treated as signed by default. [well, mostly, more systematic treatment of this is on TODO list]
+
 ### Requirements
 
 To use it, you'll need to install `z3`. On OSX that would be:

data/examples/algebra_problems

@@ -22,7 +22,7 @@ end
 
 class AlgebraProblem01 < AlgebraProblem
   def solve!
-    x = Z3::Ast.real("x")
+    x = Z3.Real("x")
     solver.assert 5*(-3*x - 2) - (x - 3) == -4*(4*x + 5) + 13
     print_solution! "01"
     # No nice way to say x is unconstrained
@@ -31,17 +31,17 @@ end
 
 class AlgebraProblem03 < AlgebraProblem
   def declare_abs(var, expr)
-    solver.assert Z3::Ast.or(
-      Z3::Ast.and(var == expr,  expr >= 0),
-      Z3::Ast.and(var == -expr, expr <= 0)
+    solver.assert Z3.Or(
+      Z3.And(var == expr,  expr >= 0),
+      Z3.And(var == -expr, expr <= 0)
     )
   end
 
   def solve!
-    x = Z3::Ast.real("x")
-    xm2abs = Z3::Ast.real("|x-2|")
+    x = Z3.Real("x")
+    xm2abs = Z3.Real("|x-2|")
     declare_abs(xm2abs, x-2)
-    m6abs = Z3::Ast.real("|-6|")
+    m6abs = Z3.Real("|-6|")
     declare_abs(m6abs, -6)
     solver.assert x < 2
     solver.assert xm2abs == 4*m6abs
@@ -56,11 +56,11 @@ class AlgebraProblem04 < AlgebraProblem
   end
 
   def solve!
-    ax = Z3::Ast.real("ax")
-    ay = Z3::Ast.real("ay")
-    bx = Z3::Ast.real("bx")
-    by = Z3::Ast.real("by")
-    a_b = Z3::Ast.real("|a-b|")
+    ax = Z3.Real("ax")
+    ay = Z3.Real("ay")
+    bx = Z3.Real("bx")
+    by = Z3.Real("by")
+    a_b = Z3.Real("|a-b|")
     declare_distance(a_b, ax, ay, bx, by)
     solver.assert ax == -4
     solver.assert ay == -5
@@ -72,8 +72,8 @@ end
 
 class AlgebraProblem05 < AlgebraProblem
   def solve!
-    x = Z3::Ast.real("x")
-    y = Z3::Ast.real("y")
+    x = Z3.Real("x")
+    y = Z3.Real("y")
     solver.assert 2*x - 4*y == 9
     solver.assert y == 0
     print_solution! "05"
@@ -86,11 +86,11 @@ class AlgebraProblem06 < AlgebraProblem
   end
 
   def solve!
-    x1 = Z3::Ast.real("x1")
-    y1 = Z3::Ast.real("y1")
-    x2 = Z3::Ast.real("x2")
-    y2 = Z3::Ast.real("y2")
-    answer = Z3::Ast.real("answer")
+    x1 = Z3.Real("x1")
+    y1 = Z3.Real("y1")
+    x2 = Z3.Real("x2")
+    y2 = Z3.Real("y2")
+    answer = Z3.Real("answer")
     solver.assert x2 == 2
     solver.assert x1 == 1
     declare_f(x1, y1)
@@ -102,15 +102,15 @@ end
 
 class AlgebraProblem10 < AlgebraProblem
   def declare_abs(var, expr)
-    solver.assert Z3::Ast.or(
-      Z3::Ast.and(var == expr,  expr >= 0),
-      Z3::Ast.and(var == -expr, expr <= 0)
+    solver.assert Z3.Or(
+      Z3.And(var == expr,  expr >= 0),
+      Z3.And(var == -expr, expr <= 0)
     )
   end
 
   def solve!
-    x = Z3::Ast.real("x")
-    y = Z3::Ast.real("|-2x + 2|")
+    x = Z3.Real("x")
+    y = Z3.Real("|-2x + 2|")
     declare_abs(y, -2*x + 2)
     solver.assert y - 3 == -3
     print_solution! "10"

data/examples/basic_int_math

@@ -3,8 +3,8 @@
 require_relative "../lib/z3"
 
 def check_multiplication_laws_1
-  a = Z3::Ast.int("a")
-  b = Z3::Ast.int("b")
+  a = Z3.Int("a")
+  b = Z3.Int("b")
   solver = Z3::Solver.new
   puts "Checking if (a+b)(a-b)==a*a-b*b"
   solver.prove!(
@@ -13,17 +13,17 @@ def check_multiplication_laws_1
 end
 
 def check_inequalities
-  a = Z3::Ast.int("a")
-  b = Z3::Ast.int("b")
+  a = Z3.Int("a")
+  b = Z3.Int("b")
   solver = Z3::Solver.new
   puts "Checking if a+b >= a"
-  solver.prove!(a+b >= a)
+  solver.prove! a+b >= a
 
   solver = Z3::Solver.new
-  solver.assert(a >= 0)
-  solver.assert(b >= 0)
+  solver.assert a >= 0
+  solver.assert b >= 0
   puts "Checking if a+b >= a if a,b >= 0"
-  solver.prove!(a+b >= a)
+  solver.prove! a+b >= a
 end
 
 check_multiplication_laws_1

data/examples/basic_logic

@@ -3,16 +3,16 @@
 require_relative "../lib/z3"
 
 def check_if_true_is_true
-  a = Z3::Ast.true
-  b = Z3::Ast.true
+  a = Z3.True
+  b = Z3.True
   solver = Z3::Solver.new
   puts "Checking if true == true"
   solver.prove!(a == b)
 end
 
 def check_if_true_is_false
-  a = Z3::Ast.true
-  b = Z3::Ast.false
+  a = Z3.True
+  b = Z3.False
   solver = Z3::Solver.new
   puts "Checking if true == false"
   solver.prove!(a==b)
@@ -20,16 +20,16 @@ end
 
 # We prove it by checking that negation is unsatisfiable
 def check_de_morgan_law_1
-  a = Z3::Ast::bool("a")
-  b = Z3::Ast::bool("b")
+  a = Z3.Bool("a")
+  b = Z3.Bool("b")
   solver = Z3::Solver.new
   puts "Proving ~(a & b) == (~a | ~b)"
   solver.prove!(~(a & b) == (~a | ~b))
 end
 
 def check_de_morgan_law_2
-  a = Z3::Ast::bool("a")
-  b = Z3::Ast::bool("b")
+  a = Z3.Bool("a")
+  b = Z3.Bool("b")
   solver = Z3::Solver.new
   puts "Proving ~(a | b) == (~a & ~b)"
   solver.prove!(~(a | b) == (~a & ~b))

data/examples/bit_tricks

@@ -0,0 +1,161 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/z3"
+
+def validate_sign_by_shift!
+  """
+  sign = v >> (sizeof(int) * CHAR_BIT - 1);
+  """
+  solver = Z3::Solver.new
+  v = Z3.Bitvec("v", 32)
+  s = v >> 31
+  puts "Validating sign trick:"
+  solver.prove! ((v < 0) & (s == -1)) | ((v >= 0) & (s == 0))
+end
+
+def validate_opposite_sign_by_xor!
+  """
+  int x, y;               // input values to compare signs
+  bool f = ((x ^ y) < 0); // true iff x and y have opposite signs
+  """
+  solver = Z3::Solver.new
+  x = Z3.Bitvec("x", 32)
+  y = Z3.Bitvec("y", 32)
+  f = (x^y) < 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),
+    )
+  )
+end
+
+def validate_abs_without_branching_1!
+  """
+  int v;           // we want to find the absolute value of v
+  unsigned int r;  // the result goes here
+  int const mask = v >> sizeof(int) * CHAR_BIT - 1;
+  r = (v + mask) ^ mask;
+  """
+  solver = Z3::Solver.new
+  v = Z3.Bitvec("v", 32)
+  mask = v >> 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)
+    )
+  )
+end
+
+def validate_abs_without_branching_2!
+  """
+  int v;           // we want to find the absolute value of v
+  unsigned int r;  // the result goes here
+  int const mask = v >> sizeof(int) * CHAR_BIT - 1;
+  r = (v ^ mask) - mask;
+  """
+  solver = Z3::Solver.new
+  v = Z3.Bitvec("v", 32)
+  mask = v >> 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)
+    )
+  )
+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
+  int y;
+  int r;  // the result goes here
+  r = y ^ ((x ^ y) & -(x < y)); // min(x, y)
+  """
+  solver = Z3::Solver.new
+  x = Z3.Bitvec("x", 32)
+  y = Z3.Bitvec("y", 32)
+  r = y ^ ((x ^ y) & -c_boolean(solver, x < y, "t"))
+  puts "Validating min without branching"
+  solver.prove!(
+    Z3.Or(
+      Z3.And(x <= y, r == x),
+      Z3.And(y <= y, r == y),
+    )
+  )
+end
+
+def validate_max_without_branching!
+  """
+  int x;  // we want to find the minimum of x and y
+  int y;
+  int r;  // the result goes here
+  r = x ^ ((x ^ y) & -(x < y)); // max(x, y)
+  """
+  solver = Z3::Solver.new
+  x = Z3.Bitvec("x", 32)
+  y = Z3.Bitvec("y", 32)
+  r = x ^ ((x ^ y) & -c_boolean(solver, x < y, "t"))
+  puts "Validating max without branching"
+  solver.prove!(
+    Z3.Or(
+      Z3.And(x >= y, r == x),
+      Z3.And(y >= y, r == y),
+    )
+  )
+end
+
+def validate_is_power_of_two!
+  """
+  unsigned int v; // we want to see if v is a power of 2
+  bool f;         // the result goes here
+
+  f = (v & (v - 1)) == 0;
+  """
+  solver = Z3::Solver.new
+  v = Z3.Bitvec("v", 32)
+  f = (v & (v - 1)) == 0
+
+  powers_of_two = (0..31).map{|i| 2**i}
+  naive_is_f_power_of_two = Z3.Or(*powers_of_two.map{|k| v == k})
+
+  puts "Validating is power of two"
+  solver.prove!(
+    Z3.Or(
+      f == naive_is_f_power_of_two,
+      v == 0,
+    )
+  )
+end
+
+validate_sign_by_shift!
+validate_opposite_sign_by_xor!
+validate_abs_without_branching_1!
+validate_abs_without_branching_2!
+validate_min_without_branching!
+validate_max_without_branching!
+validate_is_power_of_two!
+
+"""
+Based on https://graphics.stanford.edu/~seander/bithacks.html
+"""

data/examples/bridges_solver

@@ -112,7 +112,7 @@ class Bridges
   end
 
   def int012(x, y, d)
-    v = Z3::Ast.int("#{x},#{y},#{d}")
+    v = Z3.Int("#{x},#{y},#{d}")
     @solver.assert v >= 0
     @solver.assert v <= 2
     v

data/examples/clogic_puzzle_solver

@@ -0,0 +1,135 @@
+#!/usr/bin/env ruby
+
+# NOTE: This is not part of integration test suite as it's fairly slow (30s or so on my machine)
+
+require_relative "../lib/z3"
+
+class CLogicPuzzleSolver
+  attr_reader :solver, :wv
+  def initialize
+    @solver = Z3::Solver.new
+    @digits = ["b", "c", "d", "f", "g", "h", "i", "j", "l", "n", "o", "q", "s", "t", "u", "v", "w", "x", "y", "z"]
+    @digit_vars = Hash[@digits.map{|v| [v, digit_var(v)]}]
+    @words = [
+      "bytwycju",
+      "bzuwtwol",
+      "cgyoyfjg",
+      "ctvtwysu",
+      "dhcqxtfw",
+      "diffhlnl",
+      "fjivucti",
+      "htwizvwi",
+      "jqxizzxq",
+      "niiqztgs",
+      "nshtztns",
+      "nttuhlnq",
+      "oigsjgoj",
+      "oncycbxh",
+      "oqbctlzh",
+      "oqcnwbsd",
+      "sfgsoxdd",
+      "sugvqgww",
+      "syhjizjq",
+      "szblgodf",
+      "thhwohwn",
+      "ttligxut",
+      "uclfqvdu",
+      "udluvhcz",
+      "ugdztnwv",
+      "uxztiywn",
+      "vugljtyn",
+      "vyhyjivb",
+      "wwnnnqbw",
+      "xbfziozy",
+      "xsvuojtx",
+      "yjjowdqh",
+      "yzdgotby",
+      "yzvyjjdy",
+      "zoljwdfl",
+    ]
+    @wv = Hash[@words.map{|w| [w, word_var(w)]}]
+  end
+
+  def digit_var(name)
+    v = Z3.Bitvec(name, 32)
+    solver.assert v >= 0
+    solver.assert v <= 9
+    v
+  end
+
+  def word_var(name)
+    v = Z3.Bitvec(name, 32)
+    digits = name.chars.map{|c| @digit_vars[c] }
+    val_v = digits.inject(0){|a,b| a*10+b}
+    solver.assert val_v == v
+    v
+  end
+
+  def solve!
+    # Everyone occurs twice, this is not quite that
+    solver.assert Z3.Add(*@digit_vars.values) == 90
+
+    # ^| operator precedence is not like Python's for some reason
+
+    solver.assert wv["bytwycju"] + wv["yzvyjjdy"] ^ wv["vugljtyn"] + wv["ugdztnwv"] | wv["xbfziozy"] == wv["bzuwtwol"]
+    solver.assert wv["wwnnnqbw"] - wv["uclfqvdu"] & wv["oncycbxh"] |(wv["oqcnwbsd"] ^ wv["cgyoyfjg"])== wv["vyhyjivb"]
+    solver.assert wv["yzdgotby"] | wv["oigsjgoj"] | wv["ttligxut"] - wv["dhcqxtfw"] & wv["szblgodf"] == wv["sfgsoxdd"]
+    solver.assert wv["yjjowdqh"] & wv["niiqztgs"] + wv["ctvtwysu"] & wv["diffhlnl"] - wv["thhwohwn"] == wv["xsvuojtx"]
+    solver.assert wv["nttuhlnq"] ^ wv["oqbctlzh"] - wv["nshtztns"] ^ wv["htwizvwi"] + wv["udluvhcz"] == wv["syhjizjq"]
+
+    solver.assert wv["bytwycju"] ^ wv["wwnnnqbw"] & wv["yzdgotby"] + wv["yjjowdqh"] - wv["nttuhlnq"] == wv["fjivucti"]
+    solver.assert wv["yzvyjjdy"] ^ wv["uclfqvdu"] & wv["oigsjgoj"] + wv["niiqztgs"] - wv["oqbctlzh"] == wv["zoljwdfl"]
+    solver.assert wv["vugljtyn"] ^ wv["oncycbxh"] & wv["ttligxut"] + wv["ctvtwysu"] - wv["nshtztns"] == wv["sugvqgww"]
+    solver.assert wv["ugdztnwv"] ^ wv["oqcnwbsd"] & wv["dhcqxtfw"] + wv["diffhlnl"] - wv["htwizvwi"] == wv["uxztiywn"]
+    solver.assert wv["xbfziozy"] ^ wv["cgyoyfjg"] & wv["szblgodf"] + wv["thhwohwn"] - wv["udluvhcz"] == wv["jqxizzxq"]
+
+    key = %W[iw hu fv lu dv cy og lc gy fq od lo fq is ig gu hs hi ds cy oo os iu fs gu lh dq lv gu iw hv gu di hs cy oc iw gc]
+
+    if solver.check == :sat
+      model = solver.model
+      model_vars = {}
+      model.each do |k,v|
+        v = v.to_s.sub(/\A#x/, "").to_i(16)
+        model_vars[k] = v
+        puts "#{k.to_s}=#{v.to_s}"
+      end
+      result = key.map do |ab|
+        a,b = ab.chars
+        av = model_vars[a]
+        bv = model_vars[b]
+        (10*av+bv).chr
+      end
+      puts "Result: #{result.join}"
+    else
+      puts "failed to solve"
+    end
+  end
+end
+
+CLogicPuzzleSolver.new.solve!
+
+# The puzzle:
+"""
+We've captured a strange message. It looks like it is encrypted somehow ...
+iw, hu, fv, lu, dv, cy, og, lc, gy, fq, od, lo, fq, is, ig, gu, hs, hi, ds, cy, oo, os, iu, fs, gu, lh, dq, lv, gu, iw, hv, gu, di, hs, cy, oc, iw, gc
+
+
+We've also intercepted what seems to be a hint to the key:
+bytwycju + yzvyjjdy ^ vugljtyn + ugdztnwv | xbfziozy = bzuwtwol
+    ^         ^          ^          ^          ^
+wwnnnqbw - uclfqvdu & oncycbxh | oqcnwbsd ^ cgyoyfjg = vyhyjivb
+    &         &          &          &          &
+yzdgotby | oigsjgoj | ttligxut - dhcqxtfw & szblgodf = sfgsoxdd
+    +         +          +          +          +
+yjjowdqh & niiqztgs + ctvtwysu & diffhlnl - thhwohwn = xsvuojtx
+    -         -           -         -          -
+nttuhlnq ^ oqbctlzh - nshtztns ^ htwizvwi + udluvhcz = syhjizjq
+    =         =           =         =          =
+fjivucti   zoljwdfl   sugvqgww   uxztiywn   jqxizzxq
+
+Note:
+  assume q != 0
+  a letter is a decimal digit is a letter
+  each digit has exactly two different letter representations
+  C-like operator precedence
+"""