z3 0.0.0 → 0.0.20160221

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9155c71b227576436cf55fe332fb04748bf8a2ed
-  data.tar.gz: bf1c5200d857ed21311d2f5cb468e8cceac2f627
+  metadata.gz: 73f23f4e1511fe002de7b2e1d3d91945bc6f8be6
+  data.tar.gz: e6662d712ccaedd2b76a9c560dac242228d51311
 SHA512:
-  metadata.gz: 67c4b499c50f0c288900667f13bcdcca543629d55332a6247011c8e135b1d9b41a4865f9900e2884155aa28844492c3fcb1d5aacad775e1b556e3d1a6a265d3a
-  data.tar.gz: 88e74e1966920896bc2ca0ec8a2712c8180aeb79a97be8551aceb69b21016df907a579091fded5b688f8ebc8bdd3ad4ede8037f6a4458b7fa1831081b5f2bcee
+  metadata.gz: 206d8cb1e08173e3013da2426359a922c72631c28e84957ac8b94ce1219e5295960436fbd78513eb128cd0eb1b396bdf4f534247b183848ecb92df4d16d9e452
+  data.tar.gz: 04f74e3844e9e017bb6636cd26b96fd0cc79e05e59a86650c66fe18b271a3bc9798ee8481fb9979ec134cb298354f03c2b097b14f9c531166bf0f0ac87ea0ce6

data/examples/bridges_solver

@@ -0,0 +1,132 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/z3"
+
+class Bridges
+  def initialize(data)
+    data = data.strip.split("\n").map do |line|
+      line.split.map{|c| c == "_" ? nil : c.to_i}
+    end
+    @xsize = data[0].size
+    @ysize = data.size
+    @data = map_coordinates{|x,y| data[y][x]}
+    @solver = Z3::Solver.new
+  end
+
+  def solve!
+    @vars = {}
+    (0...@xsize).each do |x|
+      (0...@ysize).each do |y|
+        u = int012(x,y,"u")
+        d = int012(x,y,"d")
+        r = int012(x,y,"r")
+        l = int012(x,y,"l")
+        @vars[[x,y,"u"]] = u
+        @vars[[x,y,"d"]] = d
+        @vars[[x,y,"r"]] = r
+        @vars[[x,y,"l"]] = l
+        if @data[[x,y]] == nil
+          @solver.assert u == d
+          @solver.assert l == r
+          @solver.assert (u==0) | (l==0)
+        else
+          @solver.assert u+d+r+l == @data[[x,y]]
+        end
+        # Nothing goes out of the map
+        if x == 0
+          @solver.assert l == 0
+        end
+        if x == @xsize - 1
+          @solver.assert r == 0
+        end
+        if y == 0
+          @solver.assert u == 0
+        end
+        if y == @ysize - 1
+          @solver.assert d == 0
+        end
+      end
+    end
+
+    (0...@xsize).each do |x|
+      (0...@ysize).each do |y|
+        if x != @xsize-1
+          @solver.assert @vars[[x,y,"r"]] == @vars[[x+1,y,"l"]]
+        end
+        if y != @ysize-1
+          @solver.assert @vars[[x,y,"d"]] == @vars[[x,y+1,"u"]]
+        end
+      end
+    end
+
+    if @solver.check == :sat
+      @model = @solver.model
+      print_answer!
+    else
+      puts "failed to solve"
+    end
+  end
+
+  private
+
+  def map_coordinates
+    Hash[(0...@xsize).to_a.product((0...@ysize).to_a).map{|x,y| [[x,y],yield(x,y)]}]
+  end
+
+  def print_answer!
+    picture = (0...@ysize*3).map do
+      [" "] * (3*@xsize)
+    end
+
+    @data.each do |(x,y),v|
+      if v == nil
+        u = @model[@vars[[x,y,"u"]]].to_s.to_i
+        l = @model[@vars[[x,y,"l"]]].to_s.to_i
+        if u > 0
+          picture[y*3+1][x*3+1] = " |\u2016"[u]
+        elsif l > 0
+          picture[y*3+1][x*3+1] = " -="[l]
+        else
+          picture[y*3+1][x*3+1] = " "
+        end
+      else
+        picture[y*3+1][x*3+1] = v.to_s
+      end
+    end
+
+    @data.each do |(x,y),_|
+      u = @model[@vars[[x,y,"u"]]].to_s.to_i
+      d = @model[@vars[[x,y,"d"]]].to_s.to_i
+      l = @model[@vars[[x,y,"l"]]].to_s.to_i
+      r = @model[@vars[[x,y,"r"]]].to_s.to_i
+
+      picture[y*3+1][x*3  ] = " -="[l]
+      picture[y*3+1][x*3+2] = " -="[r]
+      picture[y*3  ][x*3+1] = " |\u2016"[u]
+      picture[y*3+2][x*3+1] = " |\u2016"[d]
+    end
+
+    picture.each do |row|
+      puts row.join
+    end
+  end
+
+  def int012(x, y, d)
+    v = Z3::Ast.int("#{x},#{y},#{d}")
+    @solver.assert v >= 0
+    @solver.assert v <= 2
+    v
+  end
+end
+
+Bridges.new(
+"""
+3 _ _ 6 _ _ 4
+_ 1 _ _ _ _ _
+_ _ _ 4 _ 4 _
+_ _ _ _ _ _ _
+_ _ 1 _ 3 _ _
+1 _ _ _ _ 2 _
+_ 3 _ _ 5 _ 3
+"""
+).solve!

data/examples/kakuro_solver

@@ -0,0 +1,124 @@
+#!/usr/bin/env ruby
+
+class Hash
+  def compact
+    ht = {}
+    each do |k,v|
+      ht[k] = v unless v.nil?
+    end
+    ht
+  end
+end
+
+require_relative "../lib/z3"
+
+class Kakuro
+  def initialize(data)
+    data = data.strip.split("\n").map do |line|
+      line.split.map{|cell| parse_cell(cell)}
+    end
+    @xsize = data[0].size
+    @ysize = data.size
+    @data  = map_coordinates{|x,y| data[y][x]}
+    @solver = Z3::Solver.new
+  end
+
+  def solve!
+    @cells = map_coordinates{|x,y| cell_var(x,y) if @data[[x,y]] == nil}.compact
+
+    (0...@ysize).each do |y|
+      (0...@xsize).each do |x|
+        cell = @data[[x,y]]
+        next if cell == nil
+        (a,b) = cell
+        setup_line!(x,y,0,1,a)
+        setup_line!(x,y,1,0,b)
+      end
+    end
+
+    if @solver.check() == :sat
+      @model = @solver.model
+      print_board!
+    else
+      puts "failed to solve"
+    end
+  end
+
+  private
+
+  def map_coordinates
+    Hash[(0...@xsize).to_a.product((0...@ysize).to_a).map{|x,y| [[x,y],yield(x,y)]}]
+  end
+
+  def print_board!
+    (0...@ysize).each do |y|
+      (0...@xsize).each do |x|
+        cell = @data[[x,y]]
+        if cell == nil
+          if @model and @cells.has_key?([x,y])
+            a = @model[@cells[[x,y]]].to_s
+            print(" [#{a}] ")
+          else
+            print("  _  ")
+          end
+        elsif cell == [0,0]
+          print("  x  ")
+        else
+          (a,b) = cell
+          a = if a == 0 then "  " else ("%2d" % a) end
+          b = if b == 0 then "  " else ("%-2d" % b) end
+          print("#{a}/#{b}")
+        end
+        print " "
+      end
+      print "\n"
+    end
+  end
+
+  def parse_cell(cell)
+    if cell == "_"
+      nil
+    elsif cell == "x"
+      [0,0]
+    else
+      a,b = cell.split("/")
+      [a.to_i, b.to_i]
+    end
+  end
+
+  def cell_var(x,y)
+    v = Z3::Ast.int("c#{x},#{y}")
+    @solver.assert v >= 1
+    @solver.assert v <= 9
+    v
+  end
+
+  def setup_line!(x0, y0, dx, dy, sum)
+    return if sum == 0
+    vs = []
+    x, y = x0+dx, y0+dy
+    while @cells.has_key?([x,y])
+      vs << @cells[[x,y]]
+      x += dx
+      y += dy
+    end
+    return if vs.empty?
+    @solver.assert Z3::Ast.distinct(*vs)
+    @solver.assert Z3::Ast.add(*vs) == sum
+  end
+end
+
+Kakuro.new(
+"""
+  x     x     x   10/   24/   29/     x   11/   21/   10/
+  x   11/   19/24   _     _     _     /6    _     _     _
+  /31   _     _     _     _     _   10/20   _     _     _
+  /4    _     _   22/18   _     _     _   23/13   _     _
+  /18   _     _     _   24/26   _     _     _     _     _
+  x   19/   30/16   _     _   10/11   _     _   11/   20/
+  /34   _     _     _     _     _   23/23   _     _     _
+  /7    _     _    9/16   _     _     _    3/4    _     _
+  /24   _     _     _     /23   _     _     _     _     _
+  /10   _     _     _     /11   _     _     _     x     x
+"""
+).solve!

data/examples/letter_connections_solver

@@ -0,0 +1,199 @@
+#!/usr/bin/env ruby
+
+# NOTE: This solver can fill empty spaces with phantom loops,
+#       so it's not technically totally legit true
+# As in:
+#  A..
+#  A..
+#
+#  Into:
+#  A* A→ A↓
+#  A↑ A↑ A←
+#
+# Instead of more correct:
+#
+#  A* A← A←
+#  A→ A→ A↑
+#
+# This affects few enough real world puzzles and would complicate solution enough
+# that I let it be.
+require_relative "../lib/z3"
+
+class LetterConnections
+  def initialize(data)
+    data = data.strip.split("\n")
+    @xsize = data[0].size
+    @ysize = data.size
+    @letters  = {}
+    @rletters = {}
+    @starts   = {}
+    @ends     = {}
+    @special_ends = {}
+    @special_starts = {}
+
+    data = map_coordinates{|x,y| data[y][x]}
+
+    data.sort.each do |(x,y), letter|
+      next if letter == "."
+      if @letters.has_key?(letter)
+        if @ends.has_key?(letter)
+          raise "Letter #{letter} occurs more than twice"
+        end
+        @ends[letter] = [x,y]
+        @special_ends[[x,y]] = letter
+      else
+        i = @letters.size
+        @letters[letter] = i
+        @rletters[i] = letter
+        @starts[letter] = [x,y]
+        @special_starts[[x,y]] = letter
+      end
+    end
+    @letters.each_key do |letter|
+      unless @ends.has_key?(letter)
+        raise "Letter #{letter} occurs only once"
+      end
+    end
+
+    @solver = Z3::Solver.new
+  end
+
+  def solve!
+    @line = map_coordinates{|x,y| line_var(x,y) }
+    @dir  = map_coordinates{|x,y| dir_var(x,y) }
+
+    @letters.each do |letter, i|
+      @solver.assert @line[@starts[letter]] == i
+      @solver.assert @line[@ends[letter]] == i
+    end
+
+    (0...@ysize).each do |y|
+      (0...@xsize).each do |x|
+        next if @special_ends.has_key?([x,y])
+        # Direction Left
+        if x == 0
+          @solver.assert @dir[[x,y]] != 0
+        else
+          @solver.assert Z3::Ast.implies(@dir[[x,y]] == 0, @line[[x,y]] == @line[[x-1,y]])
+          @solver.assert Z3::Ast.implies(@dir[[x,y]] == 0, @dir[[x-1,y]] != 2)
+        end
+        # Direction Up
+        if y == 0
+          @solver.assert @dir[[x,y]] != 1
+        else
+          @solver.assert Z3::Ast.implies(@dir[[x,y]] == 1, @line[[x,y]] == @line[[x,y-1]])
+          @solver.assert Z3::Ast.implies(@dir[[x,y]] == 1, @dir[[x,y-1]] != 3)
+        end
+        # Direction Right
+        if x == @xsize - 1
+          @solver.assert @dir[[x,y]] != 2
+        else
+          @solver.assert Z3::Ast.implies(@dir[[x,y]] == 2, @line[[x,y]] == @line[[x+1,y]])
+          @solver.assert Z3::Ast.implies(@dir[[x,y]] == 2, @dir[[x+1,y]] != 0)
+        end
+        # Direction Down
+        if y == @ysize - 1
+          @solver.assert @dir[[x,y]] != 3
+        else
+          @solver.assert Z3::Ast.implies(@dir[[x,y]] == 3, @line[[x,y]] == @line[[x,y+1]])
+          @solver.assert Z3::Ast.implies(@dir[[x,y]] == 3, @dir[[x,y+1]] != 1)
+        end
+      end
+    end
+
+    # Everything except start node has one incoming arrow
+    # End nodes not counted for this
+
+    (0...@ysize).each do |y|
+      (0...@xsize).each do |x|
+        next if @special_starts.has_key?([x,y])
+        potential_incoming = potential_incoming(x,y)
+        condition_exactly_one(
+          potential_incoming.map{|i,j,d| @dir[[i,j]] == d}
+        )
+      end
+    end
+    if @solver.check == :sat
+      @model = @solver.model
+      print_answer!
+    else
+      puts "failed to solve"
+    end
+  end
+
+  private
+
+  def map_coordinates
+    Hash[(0...@xsize).to_a.product((0...@ysize).to_a).map{|x,y| [[x,y],yield(x,y)]}]
+  end
+
+  def line_var(x, y)
+    v = Z3::Ast.int("l#{x},#{y}")
+    @solver.assert v >= 0
+    @solver.assert v < @letters.size
+    v
+  end
+
+  def dir_var(x, y)
+    v = Z3::Ast.int("d#{x},#{y}")
+    @solver.assert v >= 0
+    @solver.assert v <= 3
+    v
+  end
+
+  def potential_incoming(x0, y0)
+    [
+      [x0+1,y0,0],
+      [x0-1,y0,2],
+      [x0,y0+1,1],
+      [x0,y0-1,3],
+    ].select do |x,y,d|
+      @dir.has_key?([x,y]) and not @special_ends.has_key?([x,y])
+    end
+  end
+
+  # Surely Z3 must have a thing for it
+  def condition_exactly_one(conds)
+    @solver.assert Z3::Ast.or(*conds)
+    (0...conds.size).each do |ci|
+      (0...conds.size).each do |cj|
+        if ci < cj
+          @solver.assert ~conds[ci] | ~conds[cj]
+        end
+      end
+    end
+  end
+
+  def print_answer!
+    (0...@ysize).each do |y|
+      (0...@xsize).each do |x|
+        li = @model[@line[[x,y]]].to_s.to_i
+        l = @rletters[li]
+        d = @model[@dir[[x,y]]].to_s.to_i
+        if [x,y] == @starts[l]
+          print("\u2190\u2191\u2192\u2193"[d]+l+" ")
+        elsif [x,y] == @ends[l]
+          print("*"+l+" ")
+        else
+          print("\u2190\u2191\u2192\u2193"[d]+l.downcase+" ")
+        end
+      end
+      puts ""
+    end
+  end
+end
+
+LetterConnections.new(
+"""
+..KJ....FE
+.FJ.......
+......G...
+.K.I......
+.......D..
+IE......B.
+...H...CD.
+...A..C...
+.A.H......
+...B.G....
+"""
+).solve!

data/lib/z3/ast.rb

@@ -48,7 +48,7 @@ class Z3::Ast
   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)
+    Z3::Ast.send(op, self, b)
   end
 
   def |(b)

data/lib/z3/low_level.rb

@@ -3,7 +3,6 @@
 
 module Z3::LowLevel
   class << self
-    # Common API
     def get_version
       a = FFI::MemoryPointer.new(:int)
       b = FFI::MemoryPointer.new(:int)
@@ -17,87 +16,10 @@ module Z3::LowLevel
       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)
@@ -108,84 +30,6 @@ module Z3::LowLevel
       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
@@ -194,14 +38,6 @@ module Z3::LowLevel
       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
@@ -218,25 +54,8 @@ module Z3::LowLevel
       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
+    ### Automatically generated, do not edit that file
+    eval open("#{__dir__}/low_level_auto.rb").read
 
     private