z3 0.0.20181229 → 0.0.20220320

data/examples/stitches

@@ -0,0 +1,180 @@
+#!/usr/bin/env ruby
+
+require "pathname"
+require_relative "../lib/z3"
+require "paint"
+
+class StitchesSolver
+  def initialize(path)
+    data = Pathname(path).read
+    data = data.strip.split("\n").map do |line|
+      line.split
+    end
+    @col_counts = data.shift.map(&:to_i)
+    @row_counts = data.map(&:shift).map(&:to_i)
+    @xsize = @col_counts.size
+    @ysize = @row_counts.size
+    @data = data
+    raise unless data.size == @ysize
+    raise unless data.all?{|r| r.size == @ysize}
+    raise unless @col_counts.sum == @row_counts.sum
+    @solver = Z3::Solver.new
+    @groups = @data.flatten.uniq
+  end
+
+  def call
+    assign_colors!
+    setup_cell_vars!
+    setup_stitch_vars!
+
+    setup_cell_assertions!
+    setup_stitch_assertions!
+    setup_cell_stitch_assertions!
+
+    if @solver.satisfiable?
+      @model = @solver.model
+      print_answer!
+    else
+      puts "failed to solve"
+    end
+  end
+
+  def assign_colors!
+    @fg = @groups.to_h{|g| [g, [rand(256),rand(256),rand(256)]] }
+    @bg = @groups.to_h{|g| [g, [rand(256),rand(256),rand(256)]] }
+  end
+
+  def setup_cell_vars!
+    @cell_vars = {}
+    @xsize.times do |x|
+      @ysize.times do |y|
+        v = Z3.Bool("c#{x},#{y}")
+        @cell_vars[[x,y]] = v
+      end
+    end
+  end
+
+  def row_of_cell_vars(y)
+    @xsize.times.map{|x| @cell_vars[[x,y]].ite(1,0) }
+  end
+
+  def col_of_cell_vars(x)
+    @ysize.times.map{|y| @cell_vars[[x,y]].ite(1,0) }
+  end
+
+  def setup_cell_assertions!
+    @xsize.times do |x|
+      @solver.assert Z3.Add(*col_of_cell_vars(x)) == @col_counts[x]
+    end
+
+    @ysize.times do |y|
+      @solver.assert Z3.Add(*row_of_cell_vars(y)) == @row_counts[y]
+    end
+  end
+
+  def setup_stitch_vars!
+    @hstitch = {}
+    @vstitch = {}
+    @stitch_groups = {}
+
+    (@xsize-1).times do |x|
+      @ysize.times do |y|
+        v = Z3.Bool("h#{x},#{y}")
+        g1 = @data[y][x]
+        g2 = @data[y][x+1]
+        pair = [g1,g2].sort.uniq
+        next if pair.size == 1
+        @stitch_groups[pair] ||= []
+        @stitch_groups[pair] << v
+        @hstitch[[x,y]] = v
+      end
+    end
+
+    @xsize.times do |x|
+      (@ysize-1).times do |y|
+        v = Z3.Bool("v#{x},#{y}")
+        g1 = @data[y][x]
+        g2 = @data[y+1][x]
+        pair = [g1,g2].sort.uniq
+        next if pair.size == 1
+        @stitch_groups[pair] ||= []
+        @stitch_groups[pair] << v
+        @vstitch[[x,y]] = v
+      end
+    end
+
+    group_count = (2 * @stitch_groups.keys.size)
+    raise unless @col_counts.sum % group_count == 0
+    @stitch_count = @col_counts.sum / group_count
+  end
+
+  def setup_stitch_assertions!
+    @stitch_groups.each do |g, vars|
+      @solver.assert Z3.Add(*vars.map{|v| v.ite(1,0)}) == @stitch_count
+    end
+  end
+
+  def setup_cell_stitch_assertions!
+    @xsize.times do |x|
+      @ysize.times do |y|
+        vars = [
+          @hstitch[[x,y]],
+          @hstitch[[x-1,y]],
+          @vstitch[[x,y]],
+          @vstitch[[x,y-1]],
+        ].compact.map{|v| v.ite(1,0)}
+        if vars.empty?
+          @solver.assert !@cell_vars[[x,y]]
+        else
+          @solver.assert @cell_vars[[x,y]].ite(1,0) == Z3.Add(*vars)
+        end
+      end
+    end
+  end
+
+  def group_at(x,y)
+    return nil if x < 0 or y < 0
+    return nil if x >= @xsize or y >= @ysize
+    @data[y][x]
+  end
+
+  def paint_for(s,x1,y1,x2=x1,y2=y1)
+    g1 = group_at(x1,y1)
+    g2 = group_at(x2,y2)
+    if g1 == g2
+      Paint[s, @fg[g1], @bg[g1]]
+    else
+      s
+    end
+  end
+
+  def print_answer!
+    @ysize.times do |y|
+      @xsize.times do |x|
+        s = @model[@cell_vars[[x,y]]].to_b ? "*" : " "
+        print paint_for(s, x, y)
+        if @hstitch[[x,y]]
+          hs = @model[@hstitch[[x,y]]].to_b ? "-" : " "
+        else
+          hs = " "
+        end
+        print paint_for(hs, x, y, x+1, y)
+      end
+      print "\n"
+      next if y == @ysize - 1
+      @xsize.times do |x|
+        if @vstitch[[x,y]]
+          vs = @model[@vstitch[[x,y]]].to_b ? "|" : " "
+        else
+          vs = " "
+        end
+        print paint_for(vs, x, y, x,   y+1)
+        print paint_for(" ", x, y, x+1, y+1)
+      end
+      print "\n"
+    end
+  end
+end
+
+path = ARGV[0] || Pathname(__dir__) + "stitches-1.txt"
+StitchesSolver.new(path).call

data/examples/stitches-1.txt

@@ -0,0 +1,11 @@
+  6 8 6 9 2 5 4 8 2 2
+3 a a a a a a a b b b
+6 a a c c c a a b c b
+4 a f f c c b b b c b
+6 f f f f c c c c c b
+8 h h h f c h c b b b
+4 g h h h h h c c b b
+6 g g e e e h h h e b
+8 g g g g e h h e e e
+5 d d e e e e e e e e
+2 d d d d e e e e e e

data/examples/sudoku

@@ -13,7 +13,7 @@ class SudokuSolver
     @solver = Z3::Solver.new
   end
 
-  def solve!
+  def call
     @cells = (0..8).map do |j|
       (0..8).map do |i|
         cell_var(@data[j][i], i, j)
@@ -58,4 +58,4 @@ class SudokuSolver
 end
 
 path = ARGV[0] || Pathname(__dir__) + "sudoku-1.txt"
-SudokuSolver.new(path).solve!
+SudokuSolver.new(path).call

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← .
+.  .  .  .  .  .  .  .  .  .