z3 0.0.20181229 → 0.0.20211213

data/examples/clogic_puzzle

@@ -65,7 +65,7 @@ class CLogicPuzzleSolver
     v
   end
 
-  def solve!
+  def call
     # Everyone occurs twice, this is not quite that
     solver.assert Z3.Add(*@digit_vars.values) == 90
 
@@ -106,7 +106,7 @@ class CLogicPuzzleSolver
   end
 end
 
-CLogicPuzzleSolver.new.solve!
+CLogicPuzzleSolver.new.call
 
 # The puzzle:
 """

data/examples/color_nonogram

@@ -0,0 +1,150 @@
+#!/usr/bin/env ruby
+
+# Inspired by Hungry Cat Picross app
+
+require "pathname"
+require "paint"
+require_relative "../lib/z3"
+
+# With pluses, it means continuous
+# Without pluses, it is not continuous
+
+class ColorNonogram
+  def initialize(path)
+    data = Pathname(path).readlines.map(&:chomp)
+    @colors = data.shift.split
+    @csize = @colors.size
+    raise unless data.shift.empty?
+    @cols = []
+    @rows = []
+    target = @cols
+    while row = data.shift
+      if row.empty?
+        target = @rows
+        next
+      end
+      target << parse_row(row)
+    end
+    @xsize = @cols.size
+    @ysize = @rows.size
+    @board = {}
+    @solver = Z3::Solver.new
+  end
+
+  def call
+    sanity_checks
+    setup_board_vars
+    constraint_lines
+
+    if @solver.satisfiable?
+      @model = @solver.model
+      print_board!
+    else
+      puts "There is no solution"
+    end
+  end
+
+  private
+
+  def constraint_lines
+    @ysize.times do |y|
+      constraint_line @rows[y], row_vars(y)
+    end
+    @xsize.times do |x|
+      constraint_line @cols[x], col_vars(x)
+    end
+  end
+
+  def constraint_line(color_constraints, line_vars)
+    color_constraints.each_with_index do |(expected_total, expected_continuity), color_index|
+      correct_color = line_vars.map{|vi| (vi == color_index) }
+      total = Z3.Add(*correct_color.map{|cc| cc.ite(1, 0)})
+      @solver.assert total == expected_total
+      # For 0 / 1 this is all
+      if expected_total >= 2
+        continuity = continuity_somewhere(correct_color, expected_total)
+        @solver.assert continuity == expected_continuity
+      end
+    end
+  end
+
+  def continuity_somewhere(correct, total)
+    Z3.Or(*correct.size.times.map{|start_i|
+      continuity_at(correct, total, start_i)
+    })
+  end
+
+  def continuity_at(correct, total, start_index)
+    end_index = start_index + total - 1
+    return Z3.False unless correct[end_index]
+    Z3.And(*correct[start_index, total])
+  end
+
+
+  def row_vars(y)
+    @xsize.times.map{|x| @board[[x,y]] }
+  end
+
+  def col_vars(x)
+    @ysize.times.map{|y| @board[[x,y]] }
+  end
+
+  def print_board!
+    # Add colors please
+    @ysize.times do |y|
+      @xsize.times do |x|
+        v = @model[@board[[x,y]]].to_i
+        print Paint[v, @colors[v]], " "
+      end
+      print "\n"
+    end
+  end
+
+  def setup_board_vars
+    @xsize.times do |x|
+      @ysize.times do |y|
+        v = Z3.Int("c#{x},#{y}")
+        @solver.assert v >= 0
+        @solver.assert v < @csize
+        @board[[x,y]] = v
+      end
+    end
+  end
+
+  # Z3 will return can't solve, but we might as well get better errors
+  def sanity_checks
+    @rows.each do |row|
+      e = row.map(&:first).sum
+      raise "Wrong row count" unless e == @xsize
+    end
+
+    @cols.each do |col|
+      e = col.map(&:first).sum
+      raise "Wrong col count" unless e == @ysize
+    end
+  end
+
+  def parse_row(row)
+    parts = row.split.map{|x| parse_part(x)}
+    unless parts.size == @csize
+      raise "Incorrect row size, expected #{@csize}: #{row.inspect}"
+    end
+    parts
+  end
+
+  def parse_part(x)
+    case x
+    when "."
+      [0, false]
+    when /\A(\d+)\z/
+      [$1.to_i, false]
+    when /\A(\d+)\+\z/
+      [$1.to_i, true]
+    else
+      raise "Incorrect part #{x.inspect}"
+    end
+  end
+end
+
+path = ARGV[0] || Pathname(__dir__) + "color_nonogram-1.txt"
+ColorNonogram.new(path).call

data/examples/color_nonogram-1.txt

@@ -0,0 +1,23 @@
+red black white brown
+
+2+ .  .   8
+6  .  2   2
+4  1  3   2
+5  1  2   2
+6  .  2+  2
+6  .  2+  2
+4  1  3   2
+6  2+ 1   1
+9+ .  .   1
+2+ .  .   8
+
+.  .  .  10+
+6  .  2+  2
+8+ .  .   2
+4  2  2   2
+5  2+ .   3+
+9+ .  .   1
+2  1  6   1
+4  .  5+  1
+8+ .  .   2
+4  .  .   6

data/examples/crossflip

@@ -46,7 +46,7 @@ class CrossFlipSolver
     result
   end
 
-  def solve!
+  def call
     @solver = Z3::Solver.new
 
     @ysize.times do |y|
@@ -76,7 +76,5 @@ class CrossFlipSolver
   end
 end
 
-
-
 board = "1021,1000"
-CrossFlipSolver.new(board).solve!
+CrossFlipSolver.new(board).call

data/examples/dominion

@@ -0,0 +1,153 @@
+#!/usr/bin/env ruby
+
+require "pathname"
+require "set"
+require_relative "../lib/z3"
+
+# https://www.janko.at/Raetsel/Dominion/index.htm
+
+class Dominion
+  def initialize(path)
+    @data = Pathname(path).readlines.map(&:chomp)
+    @ysize = @data.size
+    @xsize = @data[0].size
+    raise unless @data.all?{|line| line.size == @xsize}
+    @vars = (@data.flat_map(&:chars).uniq - ["."]).sort.map.with_index{|v,c| [v,c+1]}.to_h
+    @areas_count = @vars.size
+    @solver = Z3::Solver.new
+  end
+
+  def on_board?(x,y)
+    x >= 0 and y >= 0 and x < @xsize and y < @ysize
+  end
+
+  def given(x,y)
+    return unless on_board?(x,y)
+    @vars[@data[y][x]] || nil
+  end
+
+  def var(x,y)
+    return unless on_board?(x,y)
+    Z3.Int("c[#{x},#{y}]")
+  end
+
+  def dvar(x,y)
+    return unless on_board?(x,y)
+    Z3.Int("d[#{x},#{y}]")
+  end
+
+  def domino?(x,y)
+    var(x,y) == 0
+  end
+
+  def neighbours(x,y)
+    [
+      [x-1,y],
+      [x+1,y],
+      [x,y-1],
+      [x,y+1],
+    ].select{|nx,ny| on_board?(nx,ny)}
+  end
+
+  def count_neighbour_dominoes(x,y)
+    Z3.Add(*neighbours(x,y).map{|x,y| domino?(x,y).ite(1,0) })
+  end
+
+  def assign_primary
+    seen = Set[]
+    @primary = Set[]
+    each_xy do |x,y|
+      g = given(x,y)
+      next unless g
+      next if seen.include?(g)
+      @primary << [x,y]
+      seen << g
+    end
+  end
+
+  def primary?(x,y)
+    @primary.include?([x,y])
+  end
+
+  def each_xy
+    @ysize.times do |y|
+      @ysize.times do |x|
+        yield(x,y)
+      end
+    end
+  end
+
+  def assert_cells_are_assigned_to_areas
+    each_xy do |x,y|
+      @solver.assert var(x,y) >= 0
+      @solver.assert var(x,y) <= @areas_count
+      g = given(x,y)
+      if g
+        @solver.assert var(x,y) == g
+      end
+    end
+  end
+
+  def assert_dominos
+    each_xy do |x,y|
+      @solver.assert(
+        domino?(x,y).implies(count_neighbour_dominoes(x,y) == 1)
+      )
+    end
+  end
+
+  def assert_areas_separated
+    each_xy do |x,y|
+      v = var(x,y)
+      neighbours(x,y).each do |nx,ny|
+        n = var(nx,ny)
+        @solver.assert Z3.Or(n == 0, v == 0, n == v)
+      end
+    end
+  end
+
+  def assert_each_area_connected
+    # Just some bogus big value
+    max_value = @xsize * @ysize + 10
+    each_xy do |x,y|
+      @solver.assert dvar(x,y) >= 0
+      @solver.assert dvar(x,y) < max_value
+
+      next_ds_same_area = neighbours(x,y).map{|nx,ny| (var(nx,ny) == var(x,y)).ite(dvar(nx,ny) + 1, max_value) }
+      next_d = next_ds_same_area.reduce{|a,b| (a <= b).ite(a, b) }
+      @solver.assert(
+        dvar(x,y) == Z3.Or(primary?(x,y), domino?(x,y)).ite(0, next_d)
+      )
+    end
+  end
+
+  def call
+    assign_primary
+
+    assert_cells_are_assigned_to_areas
+    assert_dominos
+    assert_areas_separated
+
+    assert_each_area_connected
+
+    if @solver.satisfiable?
+      @model = @solver.model
+      print_solution
+    else
+      puts "There is no solution"
+    end
+  end
+
+  def print_solution
+    @ysize.times do |y|
+      @ysize.times do |x|
+        c = @model[var(x,y)].to_i
+        print @vars.invert[c] || "*"
+      end
+      print "\n"
+    end
+  end
+end
+
+path = ARGV[0] || Pathname(__dir__) + "dominion-1.txt"
+Dominion.new(path).call

data/examples/dominion-1.txt

@@ -0,0 +1,8 @@
+..A....B
+....A...
+F.......
+........
+..E.G...
+.G.....D
+........
+.....C.C

data/examples/dominosa

@@ -0,0 +1,133 @@
+#!/usr/bin/env ruby
+
+require "pathname"
+require_relative "../lib/z3"
+
+class Dominosa
+  def initialize(path)
+    @data = Pathname(path).readlines.map{|line| line.split.map(&:to_i)}
+    @solver = Z3::Solver.new
+    @ysize = @data.size
+    @xsize = @data[0].size
+  end
+
+  def connect_var(x1,y1,x2,y2)
+    Z3.Bool("#{x1},#{y1}-#{x2},#{y2}")
+  end
+
+  def valid?(x,y)
+    return false if x < 0 or y < 0
+    return false if x >= @xsize or y >= @ysize
+    true
+  end
+
+  def down_var(x,y)
+    return unless valid?(x,y+1)
+    connect_var(x,y,x,y+1)
+  end
+
+  def up_var(x,y)
+    return unless valid?(x,y-1)
+    connect_var(x,y-1,x,y)
+  end
+
+  def right_var(x,y)
+    return unless valid?(x+1,y)
+    connect_var(x,y,x+1,y)
+  end
+
+  def left_var(x,y)
+    return unless valid?(x-1,y)
+    connect_var(x-1,y,x,y)
+  end
+
+  def each_x
+    @xsize.times do |x|
+      yield(x, x == @xsize - 1)
+    end
+  end
+
+  def each_y
+    @ysize.times do |y|
+      yield(y, y == @ysize - 1)
+    end
+  end
+
+  def assert_no_duplicate_connections
+    all = Hash.new{|ht,k| ht[k] = []}
+
+    each_y do |y, last_y|
+      each_x do |x, last_x|
+        unless last_x
+          c = right_var(x,y)
+          v = [@data[y][x], @data[y][x+1]].sort
+          all[v] << c
+        end
+
+        unless last_y
+          c = down_var(x,y)
+          v = [@data[y][x], @data[y+1][x]].sort
+          all[v] << c
+        end
+      end
+    end
+
+    all.each do |_, vars|
+      @solver.assert Z3.Add(*vars.map{|v| v.ite(1,0) }) == 1
+    end
+  end
+
+  def assert_solution_made_of_dominoes
+    @ysize.times do |y|
+      @xsize.times do |x|
+        vars = [
+          down_var(x,y),
+          right_var(x,y),
+          left_var(x,y),
+          up_var(x,y),
+        ].compact
+        @solver.assert Z3.Add(*vars.map{|v| v.ite(1,0) }) == 1
+      end
+    end
+  end
+
+  def call
+    assert_no_duplicate_connections
+    assert_solution_made_of_dominoes
+
+    if @solver.satisfiable?
+      @model = @solver.model
+      print_solution
+    else
+      puts "There is no solution"
+    end
+  end
+
+  private
+
+  def print_connection(var)
+    c = @model[var].to_b
+    print c ? "*" : " "
+  end
+
+  def print_solution
+    each_y do |y, last_y|
+      each_x do |x, last_x|
+        print @data[y][x]
+        print_connection right_var(x,y) unless last_x
+      end
+      print "\n"
+
+      unless last_y
+        each_x do |x, last_x|
+          print_connection down_var(x,y)
+          print " " unless last_x
+        end
+        print "\n"
+      end
+    end
+  end
+end
+
+path = ARGV[0] || Pathname(__dir__) + "dominosa-1.txt"
+Dominosa.new(path).call

data/examples/dominosa-1.txt

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

data/examples/eulero

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+
+require "pathname"
+require "set"
+require_relative "../lib/z3"
+
+# https://www.janko.at/Raetsel/Eulero/index.htm
+
+class Eulero
+  def initialize(path)
+    @data = Pathname(path).readlines.map(&:chomp).map(&:split)
+    @size = @data.size
+    raise unless @data.all?{|row| row.size == @size}
+    raise unless @data.flatten.all?{|c| c =~ /\A[A-Z\.][1-9\.]\z/ }
+    @solver = Z3::Solver.new
+  end
+
+  def lvar(x,y)
+    Z3.Int("l[#{x},#{y}]")
+  end
+
+  def nvar(x,y)
+    Z3.Int("n[#{x},#{y}]")
+  end
+
+  def xvar(x,y)
+    Z3.Int("x[#{x},#{y}]")
+  end
+
+  def assert_vars
+    @size.times do |y|
+      @size.times do |x|
+        @solver.assert lvar(x,y) >= 1
+        @solver.assert lvar(x,y) <= @size
+        @solver.assert nvar(x,y) >= 1
+        @solver.assert nvar(x,y) <= @size
+        @solver.assert xvar(x,y) == @size * lvar(x,y) + nvar(x,y)
+
+        dl = @data[y][x][0]
+        dn = @data[y][x][1]
+        if dl =~ /[A-Z]/
+          @solver.assert lvar(x,y) == (dl.ord - "A".ord + 1)
+        end
+        if dn =~ /[1-9]/
+          @solver.assert nvar(x,y) == (dn.ord - "1".ord + 1)
+        end
+      end
+    end
+  end
+
+  def assert_cols
+    @size.times do |x|
+      @solver.assert Z3.Distinct(*@size.times.map{|y| lvar(x,y)})
+      @solver.assert Z3.Distinct(*@size.times.map{|y| nvar(x,y)})
+    end
+  end
+
+  def assert_rows
+    @size.times do |y|
+      @solver.assert Z3.Distinct(*@size.times.map{|x| lvar(x,y)})
+      @solver.assert Z3.Distinct(*@size.times.map{|x| nvar(x,y)})
+    end
+  end
+
+  def assert_distinct
+    xvars = @size.times.map{|x| @size.times.map{|y| xvar(x,y) }}.flatten
+    @solver.assert Z3.Distinct(*xvars)
+  end
+
+  def call
+    assert_vars
+    assert_cols
+    assert_rows
+    assert_distinct
+
+    if @solver.satisfiable?
+      @model = @solver.model
+      print_solution
+    else
+      puts "There is no solution"
+    end
+  end
+
+  def print_solution
+    @size.times do |y|
+      @size.times do |x|
+        l = @model[lvar(x,y)].to_i
+        n = @model[nvar(x,y)].to_i
+        print ("A".ord + l - 1).chr
+        print ("1".ord + n - 1).chr
+        print " "
+      end
+      print "\n"
+    end
+  end
+end
+
+path = ARGV[0] || Pathname(__dir__) + "eulero-1.txt"
+Eulero.new(path).call

data/examples/eulero-1.txt

@@ -0,0 +1,5 @@
+C. .. .. .1 ..
+.. .. B3 .. ..
+E. .3 .. .. .5
+.. E. .. .. D.
+.. .. .. .4 .1

data/examples/four_hackers_puzzle

@@ -58,7 +58,7 @@ class LogicPuzzle
     @vars[key][idx] == val_idx
   end
 
-  def solve!
+  def call
     add_assertions!
     if @solver.satisfiable?
       @solver.model.each do |k,v|
@@ -152,7 +152,7 @@ class FourHackersPuzzle < LogicPuzzle
   end
 end
 
-FourHackersPuzzle.new.solve!
+FourHackersPuzzle.new.call
 
 """
 There is little we can do but wait, so we may as well take another job.