z3 0.0.20181229 → 0.0.20211213

data/examples/suguru

@@ -0,0 +1,199 @@
+#!/usr/bin/env ruby
+
+require "pathname"
+require_relative "../lib/z3"
+
+class Suguru
+  def initialize(path)
+    @data = Pathname(path).readlines.map(&:chomp)
+    @ysize = (@data.size - 1) / 2
+    @xsize = (@data[0].size - 1) / 2
+    raise unless @data.size == 2 * @ysize + 1
+    raise unless @data.all?{ |row| row.size == 2 * @xsize + 1 }
+    @solver = Z3::Solver.new
+  end
+
+  def call
+    @connections = calculate_connections
+    @containers = calculate_containers
+
+    @ysize.times do |y|
+      @ysize.times do |x|
+        v = cell_data(x, y)
+        if v
+          @solver.assert cell(x, y) == v
+        end
+      end
+    end
+
+    @containers.each do |name, cells|
+      @solver.assert Z3.Distinct(*cells)
+      cells.each do |c|
+        @solver.assert c >= 1
+        @solver.assert c <= cells.size
+      end
+    end
+
+    @ysize.times do |y|
+      @xsize.times do |x|
+        @solver.assert cell(x, y) != cell(x+1, y)
+        @solver.assert cell(x, y) != cell(x-1, y+1)
+        @solver.assert cell(x, y) != cell(x,   y+1)
+        @solver.assert cell(x, y) != cell(x+1, y+1)
+      end
+    end
+
+    if @solver.satisfiable?
+      @model = @solver.model
+      print_answer
+    else
+      puts "failed to solve"
+    end
+  end
+
+  private
+
+  def calculate_containers
+    cells = @xsize.times.flat_map{|x| @ysize.times.map{|y| [x,y]}}
+
+    containers = {}
+    cell_assignments = {}
+    cells.each do |c|
+      ct = c.join(",")
+      containers[ct] = [c]
+      cell_assignments[c] = ct
+    end
+
+    @connections.each do |c1, c2|
+      # Already in same container
+      ct1 = cell_assignments[c1]
+      ct2 = cell_assignments[c2]
+      next if ct1 == ct2
+      containers.delete(ct2).each do |c3|
+        cell_assignments[c3] = ct1
+        containers[ct1] << c3
+      end
+    end
+
+    containers.transform_values{|cells| cells.map{|x,y| cell(x,y)}}
+  end
+
+  def calculate_connections
+    result = []
+
+    @ysize.times do |y|
+      (0..@xsize-2).each do |x|
+        if cell_open_right?(x, y)
+          result << [[x,y], [x+1,y]]
+        end
+      end
+    end
+
+    @xsize.times do |x|
+      (0..@ysize-2).each do |y|
+        if cell_open_down?(x, y)
+          result << [[x,y], [x,y+1]]
+        end
+      end
+    end
+
+    result
+  end
+
+  def cell_open_right?(x, y)
+    @data[2*y+1][2*x+2] == " "
+  end
+
+  def cell_open_down?(x, y)
+    @data[2*y+2][2*x+1] == " "
+  end
+
+  def cell_data(x, y)
+    v = @data[2*y+1][2*x+1]
+    return nil if v == " "
+    v.to_i
+  end
+
+  def cell(x, y)
+    Z3.Int("c#{x},#{y}")
+  end
+
+  def print_answer
+    output = @data.map(&:dup)
+    @ysize.times do |y|
+      @xsize.times do |x|
+        # This only works for 1-9, could use hex or something for more
+        value = @model[cell(x,y)].to_s
+        output[2*y+1][2*x+1, 1] = value
+      end
+    end
+
+    puts output
+  end
+end
+
+path = ARGV[0] || Pathname(__dir__) + "suguru-1.txt"
+Suguru.new(path).call
+
+
+__END__
+
+# Based on https://play.google.com/store/apps/details?id=com.alexuvarov.android.kropki.puzzle&hl=en_GB
+#
+# NxN grid
+# Each cell contains numbers 1 to N
+# Each row and each column contains distinct numbers
+# If there's black dot (o) between cells, one is twice the other
+# If there's white dot (*) between cells, one is the other plus one
+# If there's no dot, neither of these is true
+# (for 1/2, dot can be of either color)
+
+class Kropki
+  def call
+    # Cells contain numbers 1 - N
+    @size.times do |y|
+      @size.times do |x|
+        @solver.assert cell(x, y) >= 1
+        @solver.assert cell(x, y) <= @size
+      end
+    end
+
+    # Each row and column distinct
+    @size.times do |y|
+      @solver.assert Z3.Distinct(*@size.times.map{ |x| cell(x,y) })
+    end
+    @size.times do |x|
+      @solver.assert Z3.Distinct(*@size.times.map{ |y| cell(x,y) })
+    end
+
+    # Horizontal dots
+    @size.times do |y|
+      (0...@size).each do |x|
+        dot_constraints cell(x, y), cell(x+1, y), @data[2*y+1][2*x+2]
+      end
+    end
+
+    # Vertical dots
+    @size.times do |x|
+      (0...@size).each do |y|
+        dot_constraints cell(x, y), cell(x, y+1), @data[2*y+2][2*x+1]
+      end
+    end
+  end
+
+  private
+
+  def dot_constraints(c1, c2, dot)
+    if dot == "o"
+      @solver.assert Z3.Or(c1 == c2 + 1, c2 == c1 + 1)
+    elsif dot == "*"
+      @solver.assert Z3.Or(c1 == c2 * 2, c2 == c1 * 2)
+    else
+      @solver.assert c1 != c2 + 1
+      @solver.assert c2 != c1 + 1
+      @solver.assert c1 != c2 * 2
+      @solver.assert c2 != c1 * 2
+    end
+  end
+
+end

data/examples/suguru-1.txt

@@ -0,0 +1,17 @@
++---+-----+
+|   |1 4  |
+|   | +---+
+|2 6| |  2|
+|   | |   |
+|   | |4 3|
++---+-+   |
+|  3  |   |
+|   +-+---+
+|2  |     |
++-+ +-+   |
+| |   |6 4|
++-+---+   |
+| |3  |  3|
+| |   +---+
+| |  1 2  |
++-+-------+

data/examples/verbal_arithmetic

@@ -16,7 +16,7 @@ class VerbalArithmetic
     @c = c.chars.map{|v| @vars[v]}
   end
 
-  def solve!
+  def call
     @solver.assert @a[0] != 0
     @solver.assert @b[0] != 0
     @solver.assert @c[0] != 0
@@ -44,4 +44,4 @@ class VerbalArithmetic
   end
 end
 
-VerbalArithmetic.new("SEND", "MORE", "MONEY").solve!
+VerbalArithmetic.new("SEND", "MORE", "MONEY").call

data/examples/yajilin

@@ -0,0 +1,268 @@
+#!/usr/bin/env ruby
+
+require "pathname"
+require_relative "../lib/z3"
+
+class Yajilin
+  def initialize(path)
+    @data = Pathname(path)
+      .readlines
+      .map{|line|
+        line
+          .chomp
+          .split
+          .map{|x| x == "." ? nil : x}
+      }
+    @xsize = @data.size
+    @ysize = @data[0].size
+    raise unless @data.all?{|row| row.size == @xsize}
+    @solver = Z3::Solver.new
+  end
+
+  def on_board?(x,y)
+    x >= 0 and y >= 0 and x < @xsize and y < @ysize
+  end
+
+  # true = white
+  # false = black
+  def cvar(x,y)
+    return unless on_board?(x,y)
+    Z3.Bool("c[#{x},#{y}]")
+  end
+
+  # true - connected
+  # right from (x,y)
+  def hvar(x,y)
+    return unless on_board?(x,y) and x != @xsize - 1
+    Z3.Bool("h[#{x},#{y}]")
+  end
+
+  # true - connected
+  # down from (x,y)
+  def vvar(x,y)
+    return unless on_board?(x,y) and y != @ysize - 1
+    Z3.Bool("v[#{x},#{y}]")
+  end
+
+  # Every cell has a number that shows its position within the loop
+  def nvar(x,y)
+    Z3.Int("n[#{x},#{y}]")
+  end
+
+  def hint_cell?(x,y)
+    !!@data[y][x]
+  end
+
+  def neighbours(x,y)
+    [
+      [x+1, y  ],
+      [x-1, y  ],
+      [x,   y+1],
+      [x,   y-1],
+    ].select{|nx,ny|
+      on_board?(nx, ny) and !hint_cell?(nx,ny)
+    }
+  end
+
+  def neighbour_cvars(x,y)
+    neighbours(x,y)
+      .map{|nx,ny| cvar(nx, ny)}
+  end
+
+  def connections_at(x,y)
+    [
+      hvar(x,y),
+      hvar(x-1,y),
+      vvar(x,y),
+      vvar(x,y-1),
+    ].compact
+  end
+
+  def count_loops_at(x,y)
+    Z3.Add(*connections_at(x,y).map{|n| n.ite(1,0)})
+  end
+
+  def assert_connections
+    each_xy do |x,y|
+      if hint_cell?(x, y)
+        @solver.assert count_loops_at(x,y) == 0
+      else
+        @solver.assert cvar(x,y).implies(count_loops_at(x,y) == 2)
+        @solver.assert (~cvar(x,y)).implies(count_loops_at(x,y) == 0)
+      end
+    end
+  end
+
+  def assert_no_black_multiples
+    each_xy do |x,y|
+      next if hint_cell?(x, y)
+      @solver.assert (~cvar(x,y)).implies(Z3.And(*neighbour_cvars(x,y)))
+    end
+  end
+
+  def stripe_left(x0,y)
+    (0...x0).map{|x| cvar(x,y) unless hint_cell?(x,y) }.compact
+  end
+
+  def stripe_right(x0,y)
+    (x0+1...@xsize).map{|x| cvar(x,y) unless hint_cell?(x,y) }.compact
+  end
+
+  def stripe_up(x,y0)
+    (0...y0).map{|y| cvar(x,y) unless hint_cell?(x,y) }.compact
+  end
+
+  def stripe_down(x,y0)
+    (y0+1...@ysize).map{|y| cvar(x,y) unless hint_cell?(x,y) }.compact
+  end
+
+  def assert_arrows
+    each_xy do |x,y|
+      if hint_cell?(x, y)
+        count = @data[y][x][0].to_i
+        dir = @data[y][x][1]
+        case dir
+        when "<", "←"
+          stripe = stripe_left(x,y)
+        when ">", "→"
+          stripe = stripe_right(x,y)
+        when "^", "↑"
+          stripe = stripe_up(x,y)
+        when "_", "↓"
+          stripe = stripe_down(x,y)
+        else
+          raise
+        end
+
+        @solver.assert Z3.Add(*stripe.map{|c| c.ite(0,1)}) == count
+      end
+    end
+  end
+
+  def each_xy
+    @ysize.times do |y|
+      @xsize.times do |x|
+        yield(x,y)
+      end
+    end
+  end
+
+  def connections_and_nvars(x,y)
+    [
+      [x+1, y, hvar(x, y)],
+      [x-1, y, hvar(x-1, y)],
+      [x, y+1, vvar(x, y)],
+      [x, y-1, vvar(x, y-1)],
+    ].select{|nx,ny,convar|
+      on_board?(nx, ny) and !hint_cell?(nx,ny)
+    }.map{|nx,ny,convar| [nvar(nx,ny), convar] }
+  end
+
+  # Loop will have Ns of 0+, all distinct and consecutive
+  # Non-loop will have Ns of MAX + cell_number
+  def assert_single_loop
+    # max_value = @xsize * @ysize + 10
+    max_value = 1000
+
+    each_xy do |x,y|
+      cell_idx = x + y * @xsize
+      @solver.assert nvar(x,y) >= 0
+      if hint_cell?(x,y)
+        @solver.assert nvar(x,y) == max_value + cell_idx
+      else
+        @solver.assert (~cvar(x,y)).implies( nvar(x,y) == max_value + cell_idx )
+
+        nval = connections_and_nvars(x,y)
+          .map{|n,c| c.ite(n+1, max_value) }
+          .reduce{|a,b| (a <= b).ite(a, b) }
+
+        @solver.assert cvar(x,y).implies((nvar(x,y) == 0) | (nvar(x,y) == nval) )
+        @solver.assert cvar(x,y).implies(nvar(x,y) < max_value)
+      end
+    end
+
+    # only one loop start
+    @solver.assert Z3.Add(
+      *enum_for(:each_xy).map{|x,y|
+        (nvar(x,y) == 0).ite(1,0)
+      }) == 1
+  end
+
+  def call
+    assert_connections
+    assert_no_black_multiples
+    assert_arrows
+    assert_single_loop
+
+    if @solver.satisfiable?
+      @model = @solver.model
+      print_answer
+    else
+      puts "failed to solve"
+    end
+  end
+
+  def hint_data(x,y)
+    u = @data[y][x]
+    n = u[0]
+    a = {
+      "<" => "←",
+      ">" => "→",
+      "_" => "↓",
+      "^" => "↑",
+    }[u[1]] || u[1]
+    n + a
+  end
+
+  # TODO: make it nicer
+  def print_answer
+    @ysize.times do |y|
+      @xsize.times do |x|
+        if hint_cell?(x,y)
+          print hint_data(x,y)
+          # print "O "
+        else
+          c = @model[cvar(x,y)].to_b
+          if c
+            print "* "
+          else
+            print "# "
+          end
+        end
+
+        next if x == @xsize - 1
+        if @model[hvar(x,y)].to_b
+          print "-"
+        else
+          print " "
+        end
+      end
+      print "\n"
+
+      next if y == @ysize-1
+      @xsize.times do |x|
+        if @model[vvar(x,y)].to_b
+          print "|  "
+        else
+          print "   "
+        end
+      end
+
+      print "\n"
+    end
+  end
+
+  def print_debug_loop_info
+    print "\n"
+    @ysize.times do |y|
+      @xsize.times do |x|
+        n = @model[nvar(x,y)].to_i
+        print "%8d" % n
+      end
+      print "\n"
+    end
+  end
+end
+
+path = ARGV[0] || Pathname(__dir__) + "yajilin-1.txt"
+Yajilin.new(path).call

data/examples/yajilin-1.txt

@@ -0,0 +1,10 @@
+.  .  .  .  .  .  .  .  .  .
+.  .  .  .  2↓ .  .  .  .  .
+.  .  .  .  .  .  .  .  .  .
+.  .  2↑ .  .  .  .  2↑ .  .
+.  .  .  1↓ .  .  .  .  .  .
+.  .  .  .  .  .  1→ .  .  .
+.  .  .  .  .  .  .  .  0→ .
+0↑ .  .  1← .  1↓ .  .  .  .
+.  .  .  .  .  .  .  .  2← .
+.  .  .  .  .  .  .  .  .  .

data/lib/z3/expr/expr.rb

@@ -115,7 +115,7 @@ module Z3
             a.sort.new(Z3::LowLevel.mk_bvand(a, b))
           end
         else
-          raise Z3::Exception, "Can't perform logic operations on #{a.sort} exprs, only Bool and Bitvec"
+          raise Z3::Exception, "Can't perform logic operations on #{args[0].sort} exprs, only Bool and Bitvec"
         end
       end
 
@@ -129,7 +129,7 @@ module Z3
             a.sort.new(Z3::LowLevel.mk_bvor(a, b))
           end
         else
-          raise Z3::Exception, "Can't perform logic operations on #{a.sort} exprs, only Bool and Bitvec"
+          raise Z3::Exception, "Can't perform logic operations on #{args[0].sort} exprs, only Bool and Bitvec"
         end
       end
 
@@ -145,7 +145,7 @@ module Z3
             a.sort.new(Z3::LowLevel.mk_bvxor(a, b))
           end
         else
-          raise Z3::Exception, "Can't perform logic operations on #{a.sort} exprs, only Bool and Bitvec"
+          raise Z3::Exception, "Can't perform logic operations on #{args[0].sort} exprs, only Bool and Bitvec"
         end
       end