z3 0.0.20181229 → 0.0.20211213

data/examples/sandwich_sudoku

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby
+
+require "pathname"
+require_relative "../lib/z3"
+require "paint"
+
+class SandwichSudokuSolver
+  def initialize(path)
+    data = Pathname(path).read
+    data = data.strip.split("\n").map do |line|
+      line.split.map{|c| c =~ /\A\d+\z/ ? c.to_i : nil}
+    end
+    @col_counts = data.shift
+    @row_counts = data.map(&:shift)
+    @xsize = @col_counts.size
+    @ysize = @row_counts.size
+    @data = data
+    raise unless data.size == @ysize
+    raise unless data.all?{|r| r.size == @ysize}
+    @solver = Z3::Solver.new
+  end
+
+  def call
+    @cells = (0..8).map do |y|
+      (0..8).map do |x|
+        cell_var(@data[y][x], x, y)
+      end
+    end
+
+    @cells.each do |row|
+      @solver.assert Z3.Distinct(*row)
+    end
+    @cells.transpose.each do |column|
+      @solver.assert Z3.Distinct(*column)
+    end
+    @cells.each_slice(3) do |rows|
+      rows.transpose.each_slice(3) do |square|
+        @solver.assert Z3.Distinct(*square.flatten)
+      end
+    end
+
+    9.times do |x|
+      assert_sandwich "c#{x+1}", @col_counts[x], col_vars(x)
+    end
+
+    9.times do |y|
+      assert_sandwich "s#{y+1}", @row_counts[y], row_vars(y)
+    end
+
+    # TODO: SANDWICHES
+
+    if @solver.satisfiable?
+      @model = @solver.model
+      print_answer!
+    else
+      puts "failed to solve"
+    end
+  end
+
+  def assert_sandwich(name, count, vars)
+    ss = Z3.Int("#{name}-ss")
+    se = Z3.Int("#{name}-se")
+    @solver.assert ss >= 0
+    @solver.assert ss <= 8
+    @solver.assert se >= 0
+    @solver.assert se <= 8
+    @solver.assert ss < se
+    9.times do |i|
+      @solver.assert ((vars[i] == 1) | (vars[i] == 9)) == ((ss == i) | (se == i))
+    end
+    e = 9.times.map{|i|
+      Z3.And(i > ss, i < se).ite(vars[i], 0)
+    }
+    @solver.assert Z3.Add(*e) == count
+  end
+
+  def row_vars(y)
+    @cells[y]
+  end
+
+  def col_vars(x)
+    @cells.map{|line| line[x]}
+  end
+
+  def cell_var(cell, x, y)
+    v = Z3.Int("cell[#{x+1},#{y+1}]")
+    @solver.assert v >= 1
+    @solver.assert v <= 9
+    @solver.assert v == cell if cell != nil
+    v
+  end
+
+  def print_answer!
+    @cells.each do |row|
+      puts row.map{|v| @model[v]}.join(" ")
+    end
+  end
+end
+
+path = ARGV[0] || Pathname(__dir__) + "sandwich_sudoku-1.txt"
+SandwichSudokuSolver.new(path).call

data/examples/sandwich_sudoku-1.txt

@@ -0,0 +1,10 @@
+   19  7 15 19  4  0  6  9 35
+ 5  .  .  .  .  .  .  .  .  1
+13  .  .  .  .  .  .  .  .  .
+20  .  .  .  .  .  .  .  .  .
+ 9  .  .  .  .  .  .  .  .  .
+12  .  .  .  .  1  .  .  .  .
+ 0  .  .  .  .  .  .  .  .  .
+ 4  .  .  .  .  .  .  .  .  .
+14  .  .  .  .  .  .  .  .  .
+ 5  .  .  .  .  .  .  .  .  .

data/examples/selfref

@@ -30,7 +30,7 @@ class SelfRefPuzzleSolver
     Z3.Or(*ary.map{|i| cons_answers == i})
   end
 
-  def solve!
+  def call
     @a_answers = Z3.Add(*(1..20).map{|i| @a[i][1]})
     @b_answers = Z3.Add(*(1..20).map{|i| @a[i][2]})
     @c_answers = Z3.Add(*(1..20).map{|i| @a[i][3]})
@@ -205,7 +205,7 @@ class SelfRefPuzzleSolver
 end
 
 
-SelfRefPuzzleSolver.new.solve!
+SelfRefPuzzleSolver.new.call
 
 __END__
 http://faculty.uml.edu/jpropp/srat-Q.txt

data/examples/skyscrapers

@@ -0,0 +1,118 @@
+#!/usr/bin/env ruby
+
+require "pathname"
+require_relative "../lib/z3"
+
+class SkyscrapersSolver
+  def initialize(path)
+    parse_data(Pathname(path).read)
+    @solver = Z3::Solver.new
+  end
+
+  def call
+    setup_grid_vars
+    setup_constraints
+
+    if @solver.satisfiable?
+      @model = @solver.model
+      print_answer
+    else
+      puts "No solution"
+    end
+  end
+
+  private
+
+  def setup_grid_vars
+    @gridvars = @size.times.map do |y|
+      @size.times.map do |x|
+        v = Z3.Int("g#{x},#{y}")
+        if @grid[y][x]
+          @solver.assert v == @grid[y][x]
+        else
+          @solver.assert v >= 1
+          @solver.assert v <= @size
+        end
+        v
+      end
+    end
+    [*@gridvars, *@gridvars.transpose].each do |row|
+      @solver.assert Z3.Distinct(*row)
+    end
+  end
+
+  def setup_constraints
+    @size.times do |i|
+      setup_visibility "L#{i}", @left[i], @gridvars[i]
+      setup_visibility "R#{i}", @right[i], @gridvars[i].reverse
+      setup_visibility "T#{i}", @top[i], @gridvars.map{|row| row[i] }
+      setup_visibility "B#{i}", @bottom[i], @gridvars.map{|row| row[i] }.reverse
+    end
+  end
+
+  def setup_visibility(label, expected, vars)
+    return unless expected
+    # Variables between cells:
+    # - count seen
+    # - max seen
+
+    count_vars = (0..@size).map{|i| Z3.Int("#{label}-c#{i}") }
+    max_vars = (0..@size).map{|i| Z3.Int("#{label}-m#{i}") }
+
+    @solver.assert count_vars.first == expected
+    @solver.assert max_vars.first == 0
+
+    @size.times do |i|
+      count_near = count_vars[i]
+      count_far = count_vars[i+1]
+      max_near = max_vars[i]
+      max_far = max_vars[i+1]
+      current = vars[i]
+      visible = Z3.Bool("#{label}-v#{i}")
+      @solver.assert visible == (current > max_near)
+      @solver.assert count_near == Z3.IfThenElse(visible, count_far+1, count_far)
+      @solver.assert max_far == Z3.IfThenElse(visible, current, max_near)
+    end
+
+    @solver.assert count_vars.last == 0
+    # This is redundant:
+    @solver.assert max_vars.last == @size
+  end
+
+  def print_answer
+    @size.times do |y|
+      @size.times do |x|
+        v = @model[@gridvars[y][x]]
+        print "#{v} "
+      end
+      print "\n"
+    end
+  end
+
+  def parse_data(data)
+    data = data.lines.map do |line|
+      line.split.map do |x|
+        if x =~ /\d+/
+          x.to_i
+        elsif x == "." or x == "-"
+          nil
+        else
+          raise "Unrecognized symbol #{x.inspect} in input"
+        end
+      end
+    end
+
+    @top = data.shift
+    @bottom = data.pop
+    @left = data.map(&:shift)
+    @right = data.map(&:pop)
+    @size = @top.size
+    raise "Grid must be square" unless [@top.size, @bottom.size, @left.size, @right.size, *data.map(&:size)].uniq.size == 1
+    @grid = data
+  end
+
+end
+
+path = ARGV[0] || Pathname(__dir__) + "skyscrapers-1.txt"
+SkyscrapersSolver.new(path).call
+

data/examples/skyscrapers-1.txt

@@ -0,0 +1,6 @@
+  2 - - -
+- . . 1 . -
+- . . . . 3
+- . . . 2 -
+- . . . . -
+  3 - - 1

data/examples/skyscrapers-2.txt

@@ -0,0 +1,11 @@
+  3 - 4 - - 3 3 3 3
+- . . . . . . . . 6 -
+- . 1 . . . . . . . -
+- 1 6 . . . . . . . -
+- . . . 3 . . . . . 3
+4 . . . 7 . . . . . 3
+3 . . . . . 5 . . . 1
+4 . . . 4 . . . 6 5 3
+- . . 4 . . . . . . 3
+- . . . . . 2 6 . . -
+  - - - 3 4 2 4 4 -

data/examples/star_battle

@@ -0,0 +1,134 @@
+#!/usr/bin/env ruby
+
+require "pathname"
+require_relative "../lib/z3"
+
+class StarBattle
+  def initialize(path)
+    @data = Pathname(path).readlines.map(&:chomp).map(&:split)
+    @size = @data.size
+    raise unless @data.all?{|row| row.size == @size}
+    raise unless containers.size == @size
+    @solver = Z3::Solver.new
+  end
+
+  def call
+    # Each row contains 2 stars
+    @size.times do |y|
+      sum = Z3.Add(*@size.times.map{|x| cell_var(x, y).ite(1, 0) })
+      @solver.assert sum == 2
+    end
+
+    # Each column contains 2 stars
+    @size.times do |x|
+      sum = Z3.Add(*@size.times.map{|y| cell_var(x, y).ite(1, 0) })
+      @solver.assert sum == 2
+    end
+
+    # Each container contains 2 stars
+    coords.group_by{|x,y| container_at(x,y) }.each do |name, cells|
+      sum = Z3.Add(*cells.map{|x,y| cell_var(x, y).ite(1, 0) })
+      @solver.assert sum == 2
+    end
+
+    # Can't be adjacent
+    coords.each do |x, y|
+      @solver.assert cell_var(x, y).implies !cell_var(x+1, y)
+      @solver.assert cell_var(x, y).implies !cell_var(x-1, y+1)
+      @solver.assert cell_var(x, y).implies !cell_var(x,   y+1)
+      @solver.assert cell_var(x, y).implies !cell_var(x+1, y+1)
+    end
+
+    if @solver.satisfiable?
+      @model = @solver.model
+      print_answer
+    else
+      puts "failed to solve"
+    end
+  end
+
+  private
+
+  def coords
+    @size.times.flat_map do |y|
+      @size.times.map do |x|
+        [x,y]
+      end
+    end
+  end
+
+  def containers
+    @containers ||= @data.flatten.uniq.sort
+  end
+
+  def cell_var(x, y)
+    return nil unless (0...@size).include?(x)
+    return nil unless (0...@size).include?(y)
+    Z3.Bool("c#{x},#{y}")
+  end
+
+  def container_at(x, y)
+    return nil unless (0...@size).include?(x)
+    return nil unless (0...@size).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..@size).each do |y|
+      (0..@size).each do |x|
+        print_corner x, y
+        next if x == @size
+        print_horizontal x, y
+      end
+      print "\n"
+
+      next if y == @size
+      (0..@size).each do |x|
+        print_vertical x, y
+        next if x == @size
+        print_cell x, y
+      end
+      print "\n"
+    end
+  end
+end
+
+path = ARGV[0] || Pathname(__dir__) + "star_battle-1.txt"
+StarBattle.new(path).call

data/examples/star_battle-1.txt

@@ -0,0 +1,10 @@
+a a a a a a a a a b
+a c a d a a a a a b
+a c a d d d d d b b
+c c c d j j d b b b
+c j j d d j d h e e
+j j j j j j d h e e
+j j j i i i i h h e
+j g g g i i i h e e
+f g g f f h i h e e
+f f f f f h h h h h

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