z3 0.0.20181229 → 0.0.20220320

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b88561867f390fe0aa80a1744d15f5daf65e018e3eec21c659aaaa4747a33774
-  data.tar.gz: 8b78a9f60131dcf2f3945894ea1e5e418910729ebae07868e3447713529e71a5
+  metadata.gz: 66d1bea928681fdde1b5e1314825832a73a7799008ea43acf31d9f3a2130616d
+  data.tar.gz: f0359749f08556ec7b33ad51118ed9f02f829d4d116246ea7241c37da91b516a
 SHA512:
-  metadata.gz: 72c8908ad9bb03adce26c2ab5b10a32fb651cc0c970f3f3c346c4b9a7db98eafd839a313875bee213f5d0caef29c0fea5f09f234765bb0150fd0da2a04ee33fd
-  data.tar.gz: d6385ee4215aee32b4bc50b427f48afed7efdc8637c0ffd6d4ccd4af8345d41acc9d4beae79f3ccf7bb9408b6fad527af430e87c32c1a9fc28c402be97cb19b5
+  metadata.gz: 89ff9d1b9273f6395d955ee0bf52a00f4c94e44a932f88ca2f33e9e38ae9a539e8887b1f2e0845296a36eda454d06873fd405d905e4022d3cabad437005ebaf5
+  data.tar.gz: c42b4bbc1211f319a06d82ac9442cfe6341238319b2ae9f4f1ba9deaf482607fa3ced8aaedd77249586b45d89ff990ef111d5476b5695bad855e0a1e788f13fd

data/README.md

@@ -25,8 +25,6 @@ bundle install
 rake spec
 ```
 
-*NB: On Linux, since FFI will look for `libz3.so`, you might need to install `libz3-dev`using your usual package manager.*
-
 ### Known Issues
 
 As Z3 is a C library, doing anything weird with it will segfault your process. Ruby API tries its best to prevent such problems and turn them into exceptions instead, but if you do anything weird (especially touch any method prefixed with `_` or `Z3::LowLevel` interface), crashes are possible. If you have reproducible crash on reasonable looking code, definitely submit it as a bug, and I'll try to come up with a workaround.

data/Rakefile

@@ -5,6 +5,13 @@ task "test" => "spec"
 task "test:integration" => "spec:integration"
 task "test:unit" => "spec:unit"
 
+desc "Regenerate api/definitions.h"
+task "definitions" do
+  headers = `brew list -v z3`.split("\n").grep(/\.h\z/)
+  # Need to bump it to latest version
+  sh "./api/gen_definitions", *headers
+end
+
 desc "Regenerate API"
 task "api" do
   sh "./api/gen_api api/definitions.h"
@@ -53,4 +60,4 @@ task "coverage:missing" do
   open("missing_apis.txt", "w") do |file|
     file.puts missing
   end
-end
+end

data/examples/abc_path

@@ -0,0 +1,187 @@
+#!/usr/bin/env ruby
+
+require "pathname"
+require "set"
+require_relative "../lib/z3"
+
+# https://www.janko.at/Raetsel/Abc-Pfad/index.htm
+
+class ABCPath
+  def initialize(path)
+    @data = Pathname(path).readlines.map(&:chomp).map{|line| line.split.map{|c| c == "." ? nil : c}}
+    raise unless @data.size == 7
+    raise unless @data.all?{|line| line.size == 7}
+    @solver = Z3::Solver.new
+  end
+
+  def var(x,y)
+    return unless on_board?(x,y)
+    Z3.Int("c#{x},#{y}")
+  end
+
+  def each_xy
+    5.times do |y|
+      5.times do |x|
+        yield(x,y)
+      end
+    end
+  end
+
+  def on_board?(x,y)
+    x >= 0 and y >= 0 and x <= 4 and y <= 4
+  end
+
+  def neighbours(x,y)
+    [
+      [x-1, y-1],
+      [x  , y-1],
+      [x+1, y-1],
+      [x-1, y  ],
+      [x+1, y  ],
+      [x-1, y+1],
+      [x  , y+1],
+      [x+1, y+1],
+    ].select{|nx,ny| on_board?(nx,ny)}
+  end
+
+  def col_vars(x)
+    (0..4).map{|y| var(x,y)}
+  end
+
+  def row_vars(y)
+    (0..4).map{|x| var(x,y)}
+  end
+
+  def diag_vars
+    (0..4).map{|x| var(x,x)}
+  end
+
+  def counter_diag_vars
+    (0..4).map{|x| var(x,4-x)}
+  end
+
+  def assert_letters
+    each_xy do |x,y|
+      @solver.assert var(x,y) >= 0
+      @solver.assert var(x,y) <= 24
+    end
+    @solver.assert Z3.Distinct(*enum_for(:each_xy).map{|x,y| var(x,y)})
+  end
+
+  def assert_path
+    each_xy do |x,y|
+      @solver.assert Z3.Or((var(x,y) == 0), *neighbours(x,y).map{|nx,ny| var(x,y) == var(nx,ny) + 1 })
+    end
+  end
+
+  def assert_has_letter(vars, letter)
+    u = letter.ord - 65
+    @solver.assert Z3.Or(*vars.map{|v| v == u})
+  end
+
+  def assert_cols
+    5.times do |x|
+      assert_has_letter col_vars(x), @data[0][x+1]
+      assert_has_letter col_vars(x), @data[6][x+1]
+    end
+  end
+
+  def assert_rows
+    5.times do |y|
+      assert_has_letter row_vars(y), @data[y+1][0]
+      assert_has_letter row_vars(y), @data[y+1][6]
+    end
+  end
+
+  def assert_diagonals
+    assert_has_letter diag_vars, @data[0][0]
+    assert_has_letter diag_vars, @data[6][6]
+    assert_has_letter counter_diag_vars, @data[0][6]
+    assert_has_letter counter_diag_vars, @data[6][0]
+  end
+
+  def call
+    assert_letters
+    assert_path
+    assert_cols
+    assert_rows
+    assert_diagonals
+
+    if @solver.satisfiable?
+      @model = @solver.model
+      print_solution
+    else
+      puts "There is no solution"
+    end
+  end
+
+  def connected?(x1,y1,x2,y2)
+    v1 = var(x1,y1)
+    v2 = var(x2,y2)
+    return false unless v1 and v2
+    c1 = @model[v1].to_i
+    c2 = @model[v2].to_i
+    (c1-c2).abs == 1
+  end
+
+  def print_cell(x,y)
+    if on_board?(x,y)
+      c = @model[var(x,y)].to_i
+      print (65+32+c).chr
+    elsif x == -1 or y == -1 or x == 5 or y == 5
+      print @data[y+1][x+1]
+    else
+      print " "
+    end
+  end
+
+  def print_hcon(x,y)
+    if connected?(x,y,x+1,y)
+      print "-"
+    else
+      print " "
+    end
+  end
+
+  def print_vcon(x,y)
+    if connected?(x,y,x,y+1)
+      print "|"
+    else
+      print " "
+    end
+  end
+
+  def print_xcon(x,y)
+    d = connected?(x,y,x+1,y+1)
+    cd = connected?(x,y+1,x+1,y)
+    if d and cd
+      print "x"
+    elsif d
+      print "\\"
+    elsif cd
+      print "/"
+    else
+      print " "
+    end
+  end
+
+  def print_solution
+    (-1..5).each do |y|
+      (-1..5).each do |x|
+        print_cell(x,y)
+        print_hcon(x,y)
+      end
+      print "\n"
+
+      break if y == 5
+      (-1..5).each do |x|
+        print_vcon(x,y)
+        print_xcon(x,y)
+      end
+      print "\n"
+    end
+  end
+end
+
+path = ARGV[0] || Pathname(__dir__) + "abc_path-1.txt"
+ABCPath.new(path).call

data/examples/abc_path-1.txt

@@ -0,0 +1,7 @@
+C O R D F B U
+N . . . . . L
+G . . . . . I
+Q . . . . . H
+V . . . . . S
+T . . . . . X
+J P M W K Y E

data/examples/algebra_problems

@@ -21,7 +21,7 @@ class AlgebraProblem
 end
 
 class AlgebraProblem01 < AlgebraProblem
-  def solve!
+  def call
     x = Z3.Real("x")
     solver.assert 5*(-3*x - 2) - (x - 3) == -4*(4*x + 5) + 13
     print_solution! "01"
@@ -37,7 +37,7 @@ class AlgebraProblem03 < AlgebraProblem
     )
   end
 
-  def solve!
+  def call
     x = Z3.Real("x")
     xm2abs = Z3.Real("|x-2|")
     declare_abs(xm2abs, x-2)
@@ -55,7 +55,7 @@ class AlgebraProblem04 < AlgebraProblem
     solver.assert a_b**2 == (ax-bx)**2 + (ay-by)**2
   end
 
-  def solve!
+  def call
     ax = Z3.Real("ax")
     ay = Z3.Real("ay")
     bx = Z3.Real("bx")
@@ -71,7 +71,7 @@ class AlgebraProblem04 < AlgebraProblem
 end
 
 class AlgebraProblem05 < AlgebraProblem
-  def solve!
+  def call
     x = Z3.Real("x")
     y = Z3.Real("y")
     solver.assert 2*x - 4*y == 9
@@ -85,7 +85,7 @@ class AlgebraProblem06 < AlgebraProblem
     solver.assert y == 6*x + 1
   end
 
-  def solve!
+  def call
     x1 = Z3.Real("x1")
     y1 = Z3.Real("y1")
     x2 = Z3.Real("x2")
@@ -108,7 +108,7 @@ class AlgebraProblem10 < AlgebraProblem
     )
   end
 
-  def solve!
+  def call
     x = Z3.Real("x")
     y = Z3.Real("|-2x + 2|")
     declare_abs(y, -2*x + 2)
@@ -117,12 +117,12 @@ class AlgebraProblem10 < AlgebraProblem
   end
 end
 
-AlgebraProblem01.new.solve!
-AlgebraProblem03.new.solve!
-AlgebraProblem04.new.solve!
-AlgebraProblem05.new.solve!
-AlgebraProblem06.new.solve!
-AlgebraProblem10.new.solve!
+AlgebraProblem01.new.call
+AlgebraProblem03.new.call
+AlgebraProblem04.new.call
+AlgebraProblem05.new.call
+AlgebraProblem06.new.call
+AlgebraProblem10.new.call
 
 """
 http://www.analyzemath.com/Algebra1/Algebra1.html

data/examples/aquarium

@@ -0,0 +1,133 @@
+#!/usr/bin/env ruby
+
+require "pathname"
+require_relative "../lib/z3"
+
+class Aquarium
+  def initialize(path)
+    data = Pathname(path).readlines.map(&:chomp).map(&:split)
+    @cols = data.shift.map(&:to_i)
+    @rows = data.map(&:shift).map(&:to_i)
+    @xsize =  @cols.size
+    @ysize = @rows.size
+    raise unless data.all?{|row| row.size == @xsize}
+    @data = data
+    @solver = Z3::Solver.new
+  end
+
+  def call
+    # How cells relate to containers
+    @ysize.times do |y|
+      @xsize.times do |x|
+        @solver.assert cell_var(x, y) == container_var(container_at(x, y), y)
+      end
+    end
+
+    # Row sums
+    @ysize.times do |y|
+      sum = Z3.Add(*@xsize.times.map{|x| cell_var(x, y).ite(1, 0) })
+      @solver.assert sum == @rows[y]
+    end
+
+    # Col sums
+    @xsize.times do |x|
+      sum = Z3.Add(*@ysize.times.map{|y| cell_var(x, y).ite(1, 0) })
+      @solver.assert sum == @cols[x]
+    end
+
+    # Container water flow
+    containers.each do |name|
+      (0...@ysize).each do |y|
+        @solver.assert container_var(name, y).implies container_var(name, y+1)
+      end
+    end
+
+    if @solver.satisfiable?
+      @model = @solver.model
+      print_answer
+    else
+      puts "failed to solve"
+    end
+  end
+
+  private
+
+  def containers
+    @containers ||= @data.flatten.uniq.sort
+  end
+
+  def container_var(name, level)
+    Z3.Bool("b#{name},#{level}")
+  end
+
+  def cell_var(x, y)
+    return nil unless (0...@xsize).include?(x)
+    return nil unless (0...@ysize).include?(y)
+    Z3.Bool("c#{x},#{y}")
+  end
+
+  def container_at(x, y)
+    return nil unless (0...@xsize).include?(x)
+    return nil unless (0...@ysize).include?(y)
+    @data[y][x]
+  end
+
+  def print_corner(x, y)
+    if [
+        container_at(x, y),
+        container_at(x, y-1),
+        container_at(x-1, y),
+        container_at(x-1, y-1),
+      ].uniq.size == 1
+      print " "
+    else
+      print "+"
+    end
+  end
+
+  def print_vertical(x, y)
+    if x == 0 or container_at(x, y) != container_at(x-1, y)
+      print "|"
+    else
+      print " "
+    end
+  end
+
+  def print_horizontal(x, y)
+    if y == 0 or container_at(x, y) != container_at(x, y-1)
+      print "-"
+    else
+      print " "
+    end
+  end
+
+  def print_cell(x, y)
+    if @model[cell_var(x, y)].to_b
+      print "#"
+    else
+      print " "
+    end
+  end
+
+  def print_answer
+    (0..@ysize).each do |y|
+      (0..@xsize).each do |x|
+        print_corner x, y
+        next if x == @xsize
+        print_horizontal x, y
+      end
+      print "\n"
+
+      next if y == @ysize
+      (0..@xsize).each do |x|
+        print_vertical x, y
+        next if x == @xsize
+        print_cell x, y
+      end
+      print "\n"
+    end
+  end
+end
+
+path = ARGV[0] || Pathname(__dir__) + "aquarium-1.txt"
+Aquarium.new(path).call

data/examples/aquarium-1.txt

@@ -0,0 +1,11 @@
+  9 6 4 2 2 4 8 6 6 7
+9 b b c c c c c d d e
+6 b j n n n n c c d e
+7 b j n i i h h g g f
+4 b j n t t o o g g f
+1 b t t t t o o p p p
+5 b t s t t m o p q q
+4 b t s s s m o r q q
+7 b t t s s m r r r q
+3 a s s s s m r l k k
+8 a a a s s m m l k k

data/examples/bridges

@@ -15,7 +15,7 @@ class Bridges
     @solver = Z3::Solver.new
   end
 
-  def solve!
+  def call
     @vars = {}
     (0...@xsize).each do |x|
       (0...@ysize).each do |y|
@@ -122,4 +122,4 @@ class Bridges
 end
 
 path = ARGV[0] || Pathname(__dir__) + "bridges-1.txt"
-Bridges.new(path).solve!
+Bridges.new(path).call

data/examples/cats_organized_neatly

@@ -0,0 +1,133 @@
+#!/usr/bin/env ruby
+
+require "pathname"
+require_relative "../lib/z3"
+
+class CatsOrganizedNeatly
+  def initialize(path)
+    data = Pathname(path).read
+
+    @board, *@cats = data.split("\n\n").map{|n| n.lines.map(&:chomp)}
+
+    raise "Board and cats mismatch" unless @board.join.scan(/\S/).count == @cats.join.scan(/\S/).count
+
+    @ysize = @board.size
+    @xsize = @board.map(&:size).max
+
+    # Up to user to make them unique
+    @cat_labels = @cats.map{|c| c.join[/\S/]}
+
+    @solver = Z3::Solver.new
+  end
+
+  def setup_board_vars
+    @bvars = {}
+    @ysize.times do |y|
+      @xsize.times do |x|
+        next unless @board[y][x] == "."
+        @bvars[[x,y]] = Z3.Int("b#{x},#{y}")
+        @solver.assert @bvars[[x,y]] >= 0
+        @solver.assert @bvars[[x,y]] < @cats.size
+      end
+    end
+  end
+
+  def setup_cats_vars
+    @cx = []
+    @cy = []
+    @co = []
+    @cats.each_with_index do |cat, i|
+      @cx[i] = Z3.Int("cx#{i}")
+      @cy[i] = Z3.Int("cy#{i}")
+      @co[i] = Z3.Int("co#{i}")
+      @solver.assert @cx[i] >= 0
+      @solver.assert @cx[i] <= (@xsize-1)
+      @solver.assert @cy[i] >= 0
+      @solver.assert @cy[i] <= (@ysize-1)
+      @solver.assert @co[i] >= 0
+      @solver.assert @co[i] <= 3
+    end
+  end
+
+  def cat_to_shifts(cat)
+    result = []
+    cat.each_with_index do |line, y|
+      line.chars.each_with_index do |c, x|
+        next if c == " "
+        result << [x,y]
+      end
+    end
+    result
+  end
+
+  def cat_at(shifts, x, y, i)
+    Z3.And(*shifts.map{|sx, sy|
+      v = @bvars[[sx+x,sy+y]]
+      return false unless v
+      v == i
+    })
+  end
+
+  def setup_cat_board_var(shifts0, i)
+    cx = @cx[i]
+    cy = @cy[i]
+    co = @co[i]
+
+    shiftss = [
+      shifts0,
+      shifts0.map{|x,y| [y,-x]},
+      shifts0.map{|x,y| [-x,-y]},
+      shifts0.map{|x,y| [-y,x]},
+    ]
+
+    shiftss.each_with_index do |shifts, o|
+      @ysize.times do |y|
+        @ysize.times do |x|
+          @solver.assert(
+            Z3.And(cx == x, cy == y, co == o).implies(cat_at(shifts, x, y, i))
+          )
+        end
+      end
+    end
+  end
+
+  def setup_cats_board_vars
+    @cats.each_with_index do |cat, i|
+      shifts = cat_to_shifts(cat)
+      setup_cat_board_var(shifts, i)
+    end
+  end
+
+  def call
+    # Each cell is just one of the cats
+    setup_board_vars
+    setup_cats_vars
+    setup_cats_board_vars
+
+    if @solver.satisfiable?
+      @model = @solver.model
+      print_answer!
+    else
+      binding.pry
+      puts "failed to solve"
+    end
+  end
+
+  def print_answer!
+    @ysize.times do |y|
+      @xsize.times do |x|
+        if @bvars[[x,y]]
+          cat_number = @model[@bvars[[x,y]]].to_i
+          print @cat_labels[cat_number]
+        else
+          print "."
+        end
+      end
+      print "\n"
+    end
+  end
+end
+
+
+path = ARGV[0] || Pathname(__dir__) + "cats_organized_neatly-48.txt"
+CatsOrganizedNeatly.new(path).call

data/examples/cats_organized_neatly-10.txt

@@ -0,0 +1,15 @@
+...
+. .
+....
+....
+
+a
+aa
+
+bbb
+
+cc
+c
+
+dd
+dd

data/examples/cats_organized_neatly-3.txt

@@ -0,0 +1,8 @@
+...
+...
+...
+
+aaa
+
+bbb
+bbb

data/examples/cats_organized_neatly-48.txt

@@ -0,0 +1,32 @@
+ .......
+ .......
+........
+........
+........
+........
+.......
+  .....
+
+aaaaa
+aaaaa
+
+bbb
+bbbb
+bbbb
+
+ ccc
+cccc
+
+ddd
+ddd
+ddd
+
+eee
+ e
+
+ffff
+f
+
+gggg
+gggg
+gggg

data/examples/circuit_problems

@@ -45,7 +45,7 @@ class CircuitProblem
     @solver.assert @pins[a][:voltage] == @pins[b][:voltage]
   end
 
-  def solve!(*vars)
+  def call(*vars)
     setup_flow_rules!
     with_solved_model do |model|
       model.each do |n,v|
@@ -115,7 +115,7 @@ def problem_1!
   problem.connect "R1b", "R2a"
   problem.connect "R2b", "R3a"
   problem.connect "R3b", "V+"
-  problem.solve! "I V"
+  problem.call "I V"
 end
 
 def problem_2!
@@ -131,7 +131,7 @@ def problem_2!
   problem.connect "V+", "R1b"
   problem.connect "V+", "R2b"
   problem.connect "V+", "R3b"
-  problem.solve! "I V"
+  problem.call "I V"
 end
 
 def problem_3!
@@ -156,7 +156,7 @@ def problem_3!
     problem.connect "D3+", "V+"
     problem.connect "D4-",      "Lb"
     problem.connect "D4+", "V-"
-    problem.solve! "I V", "I L"
+    problem.call "I V", "I L"
   end
 end