z3 0.0.20181229 → 0.0.20220320

data/examples/miracle_sudoku

@@ -0,0 +1,135 @@
+#!/usr/bin/env ruby
+
+require "pathname"
+require_relative "../lib/z3"
+
+class MiracleSudokuSolver
+  def initialize(path)
+    data = Pathname(path).read
+    data = data.strip.split("\n").map do |line|
+      line.split.map{|c| c == "." ? nil : c.to_i}
+    end
+    @data = data
+    raise "Bad size" unless @data.size == 9
+    raise "Bad size" unless @data.all?{|row| row.size == 9}
+    @solver = Z3::Solver.new
+  end
+
+  def king_moves
+    [
+      [-1,-1],
+      [-1, 0],
+      [-1,+1],
+      [ 0,-1],
+      [ 0,+1],
+      [+1,-1],
+      [+1, 0],
+      [+1,+1],
+    ]
+  end
+
+  def knight_moves
+    [
+      [-2, -1],
+      [-2, +1],
+      [-1, -2],
+      [-1, +2],
+      [+1, -2],
+      [+1, +2],
+      [+2, -1],
+      [+2, +1],
+    ]
+  end
+
+  def orthogonal_moves
+    [
+      [-1,  0],
+      [+1,  0],
+      [ 0, -1],
+      [ 0, +1],
+    ]
+  end
+
+  def call
+    @cells = (0..8).map do |y|
+      (0..8).map do |x|
+        cell_var(data_at(x,y), 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
+
+    each_coord do |x,y|
+      [*king_moves, *knight_moves].each do |dx, dy|
+        x2 = x + dx
+        y2 = y + dy
+        next unless in_bounds?(x2, y2)
+        @solver.assert var_at(x,y) != var_at(x2,y2)
+      end
+
+      orthogonal_moves.each do |dx, dy|
+        x2 = x + dx
+        y2 = y + dy
+        next unless in_bounds?(x2, y2)
+        @solver.assert var_at(x,y) != var_at(x2,y2) + 1
+        @solver.assert var_at(x,y) != var_at(x2,y2) - 1
+      end
+    end
+
+    if @solver.satisfiable?
+      @model = @solver.model
+      print_answer!
+    else
+      puts "failed to solve"
+    end
+  end
+
+  def each_coord
+    9.times do |x|
+      9.times do |y|
+        yield(x, y)
+      end
+    end
+  end
+
+  def in_bounds?(x,y)
+    (0..8).include?(x) and (0..8).include?(y)
+  end
+
+  def var_at(x, y)
+    return nil unless in_bounds?(x,y)
+    @cells[y][x]
+  end
+
+  def data_at(x, y)
+    return nil unless in_bounds?(x,y)
+    @data[y][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__) + "miracle_sudoku-1.txt"
+MiracleSudokuSolver.new(path).call

data/examples/miracle_sudoku-1.txt

@@ -0,0 +1,9 @@
+. . . . . . . . .
+. . . . . . . . .
+. . . . . . . . .
+. . . . . . . . .
+. . 1 . . . . . .
+. . . . . . 2 . .
+. . . . . . . . .
+. . . . . . . . .
+. . . . . . . . .

data/examples/mortal_coil_puzzle

@@ -78,7 +78,7 @@ class MortalCoilSolver
     end
   end
 
-  def solve!
+  def call
     setup_vars!
     line_continuity!
     line_goes_until_it_hits_something!
@@ -102,4 +102,4 @@ class MortalCoilSolver
 end
 
 path = ARGV[0] || Pathname(__dir__) + "mortal_coil_puzzle-9.txt"
-MortalCoilSolver.new(path).solve!
+MortalCoilSolver.new(path).call

data/examples/nanro

@@ -0,0 +1,245 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/z3"
+require "pathname"
+
+# https://www.gmpuzzles.com/blog/nanro-rules-and-info/
+
+class Nanro
+  def initialize(path)
+    data = Pathname(path)
+      .readlines
+      .map{|row| row.chomp.split}
+    @ysize = data.size
+    @xsize = data[0].size
+    raise unless data.all?{|row| row.size == @ysize}
+    @regions = data
+      .map{|row|
+        row.map{|cell|
+          cell.gsub(/\d|\./, "")
+        }
+      }
+    @hints = data
+      .map{|row|
+        row.map{|cell|
+          cell[1] =~ /(\d+)/ ? $1.to_i : nil
+        }
+      }
+    @solver = Z3::Solver.new
+  end
+
+  def assert_each_cell_is_0_or_rvar
+    each_xy do |x,y|
+      @solver.assert Z3.Or(
+        cvar(x,y) == 0,
+        cvar(x,y) == rvar(region_at(x,y))
+      )
+    end
+  end
+
+  def assert_rvar_equals_number_of_numbered_cells_in_region
+    cells_by_region.each do |r, xys|
+      nonzeroes = xys.map{|x,y| (cvar(x,y) == 0).ite(0,1)}
+      @solver.assert rvar(r) == Z3.Add(*nonzeroes)
+      @solver.assert rvar(r) >= 1
+    end
+  end
+
+  def assert_hints_obeyed
+    each_xy do |x,y|
+      if hint_at(x,y)
+        @solver.assert cvar(x,y) == hint_at(x,y)
+      end
+    end
+  end
+
+  def assert_no_numbered_squares
+    each_xy do |x,y|
+      next unless on_board?(x+1,y+1)
+      @solver.assert Z3.Or(
+        cvar(x,y) == 0,
+        cvar(x+1,y) == 0,
+        cvar(x,y+1) == 0,
+        cvar(x+1,y+1) == 0,
+      )
+    end
+  end
+
+  def assert_no_same_number_between_regions
+    each_xy do |x,y|
+      neighbours(x,y).each do |nx,ny|
+        next if region_at(x,y) == region_at(nx,ny)
+        @solver.assert (cvar(x,y) != 0).implies(cvar(x,y) != cvar(nx,ny))
+      end
+    end
+  end
+
+  def assert_numbered_cells_all_connected
+    max_value = @xsize * @ysize + 10
+
+    each_xy do |x,y|
+      @solver.assert nvar(x,y) >= 0
+      @solver.assert (cvar(x,y) == 0).implies(nvar(x,y) == max_value)
+      @solver.assert (cvar(x,y) != 0).implies(nvar(x,y) < max_value)
+
+      nval = neighbours(x,y)
+        .map{|nx,ny|
+          (cvar(nx,ny) == 0).ite(max_value, nvar(nx,ny) + 1)
+        }
+        .reduce{|a,b| (a <= b).ite(a, b) }
+
+      @solver.assert (cvar(x,y) != 0).implies(Z3.Or(nvar(x,y) == 0, nvar(x,y) == nval))
+    end
+
+    @solver.assert Z3.Add(
+      *enum_for(:each_xy).map{|x,y|
+        (nvar(x,y) == 0).ite(1,0)
+      }) == 1
+  end
+
+  def call
+    assert_hints_obeyed
+    assert_no_numbered_squares
+    assert_each_cell_is_0_or_rvar
+    assert_rvar_equals_number_of_numbered_cells_in_region
+    assert_no_same_number_between_regions
+    assert_numbered_cells_all_connected
+
+    if @solver.satisfiable?
+      @model = @solver.model
+      print_answer!
+    else
+      puts "failed to solve"
+    end
+  end
+
+  private
+
+  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 cells_by_region
+    @cells_by_region ||= enum_for(:each_xy).group_by{|x,y| region_at(x,y)}
+  end
+
+  def rvar(r)
+    Z3.Int("r[#{r}]")
+  end
+
+  def cvar(x,y)
+    Z3.Int("c[#{x},#{y}]")
+  end
+
+  def nvar(x,y)
+    Z3.Int("n[#{x},#{y}]")
+  end
+
+  def each_xy
+    @ysize.times do |y|
+      @xsize.times do |x|
+        yield(x,y)
+      end
+    end
+  end
+
+  def on_board?(x,y)
+    x >= 0 and y >= 0 and x < @xsize and y < @ysize
+  end
+
+  def region_at(x,y)
+    return nil unless on_board?(x,y)
+    @regions[y][x]
+  end
+
+  def hint_at(x,y)
+    return nil unless on_board?(x,y)
+    @hints[y][x]
+  end
+
+  def print_corner?(x, y)
+    [
+      region_at(x,y),
+      region_at(x-1,y),
+      region_at(x,y-1),
+      region_at(x-1,y-1),
+    ].uniq.size > 1
+  end
+
+  def print_edge?(x1, y1, x2, y2)
+    region_at(x1,y1) != region_at(x2,y2)
+  end
+
+  def corner_output(x,y)
+    if print_corner?(x, y)
+      "*"
+    else
+      " "
+    end
+  end
+
+  def vedge_output(x,y)
+    if print_edge?(x, y, x, y-1)
+      "---"
+    else
+      "   "
+    end
+  end
+
+  def hedge_output(x,y)
+    if print_edge?(x, y, x-1, y)
+      "|"
+    else
+      " "
+    end
+  end
+
+  def print_answer!
+    (0..@ysize).each do |y|
+      (0..@xsize).each do |x|
+        print corner_output(x,y)
+        next if x == @xsize
+        print vedge_output(x,y)
+      end
+      print "\n"
+
+      next if y == @ysize
+
+      (0..@xsize).each do |x|
+        print hedge_output(x,y)
+        next if x == @xsize
+        print "   "
+      end
+      print "\n"
+
+      (0..@xsize).each do |x|
+        print hedge_output(x,y)
+        next if x == @xsize
+        print " "
+        c = @model[cvar(x,y)].to_i
+        if c == 0
+          print " "
+        else
+          print c
+        end
+        print " "
+      end
+      print "\n"
+
+      (0..@xsize).each do |x|
+        print hedge_output(x,y)
+        next if x == @xsize
+        print "   "
+      end
+      print "\n"
+    end
+  end
+end
+
+path = ARGV[0] || Pathname(__dir__) + "nanro-1.txt"
+Nanro.new(path).call

data/examples/nanro-1.txt

@@ -0,0 +1,8 @@
+a6 a. a. a. a. e. f. f3
+a. c. a. a. d. e. f. f.
+b. c. t. t. w. e. u. f.
+g. r. s. x. w. v. u. f.
+g. r. x. x. w. u. u3 p.
+g. q. x. l. m. o. o. p.
+g. i. j. l. o. o3 o. p.
+h. i. j. k. n2 n. n. p.

data/examples/nine_clocks

@@ -0,0 +1,106 @@
+#!/usr/bin/env ruby
+# From Tested on Humans Escape Room game
+
+require_relative "../lib/z3"
+
+class NineClocks
+  def initialize
+    @solver = Z3::Solver.new
+
+    @inputs = {}
+    @outputs = {}
+
+    # Setup
+    each_xy do |x,y|
+      @inputs[[x,y]] = Z3.Bitvec("i#{x},#{y}", 2)
+      @outputs[[x,y]] = Z3.Bitvec("o#{x},#{y}", 2)
+    end
+
+    # Rules
+    neighbours = {}
+    each_xy do |x,y|
+      out = @outputs[[x,y]]
+      neighbours[out] = []
+      each_xy do |xx, yy|
+        if (xx-x).abs + (yy-y).abs <= 1
+          neighbours[out] << @inputs[[xx,yy]]
+        end
+      end
+
+      neighbours.each do |ovar, ivars|
+        @solver.assert ovar == Z3.Add(*ivars)
+      end
+    end
+  end
+
+  def each_xy
+    3.times do |x|
+      3.times do |y|
+        yield(x,y)
+      end
+    end
+  end
+
+  def target_corner
+    each_xy do |x,y|
+      if x == 0 and y == 0
+        @solver.assert @outputs[[x,y]] == 1
+      else
+        @solver.assert @outputs[[x,y]] == 0
+      end
+    end
+    self
+  end
+
+  def target_edge
+    each_xy do |x,y|
+      if x == 0 and y == 1
+        @solver.assert @outputs[[x,y]] == 1
+      else
+        @solver.assert @outputs[[x,y]] == 0
+      end
+    end
+    self
+  end
+
+  def target_center
+    each_xy do |x,y|
+      if x == 1 and y == 1
+        @solver.assert @outputs[[x,y]] == 1
+      else
+        @solver.assert @outputs[[x,y]] == 0
+      end
+    end
+    self
+  end
+
+  def solve
+    if @solver.satisfiable?
+      model = @solver.model
+
+      puts "IN:"
+      3.times do |x|
+        3.times do |y|
+          ivar = model[@inputs[[x,y]]]
+          print ivar, " "
+        end
+        print "\n"
+      end
+
+      puts "OUT:"
+      3.times do |x|
+        3.times do |y|
+          ivar = model[@outputs[[x,y]]]
+          print ivar, " "
+        end
+        print "\n"
+      end
+    else
+      puts "Not satisfiable"
+    end
+  end
+end
+
+NineClocks.new.target_corner.solve
+NineClocks.new.target_edge.solve
+NineClocks.new.target_center.solve

data/examples/nonogram

@@ -76,7 +76,7 @@ class Nonogram
     end
   end
 
-  def solve!
+  def call
     @cells = (0...@ysize).map{|y|
       (0...@xsize).map{|x|
         Z3.Bool("cell[#{x+1},#{y+1}]")
@@ -149,4 +149,4 @@ nonogram = Nonogram.new(
   ]
 )
 
-nonogram.solve!
+nonogram.call

data/examples/pyramid_nonogram

@@ -27,7 +27,7 @@ class PyramidNonogram
     end
   end
 
-  def solve!
+  def call
     if @solver.satisfiable?
       @model = @solver.model
       print_answer!
@@ -163,4 +163,4 @@ pyramid_nonogram.left_to_bottom(
   [_],
   [_],
 )
-pyramid_nonogram.solve!
+pyramid_nonogram.call

data/examples/regexp_crossword_solver

@@ -43,7 +43,7 @@ class RegexpCrosswordSolver
     SimpleRegexpParser.new(@rows[y], "row-#{y}").parse
   end
 
-  def solve!
+  def call
     @crossword = {}
     @xsize.times do |x|
       @ysize.times do |y|
@@ -77,4 +77,4 @@ class RegexpCrosswordSolver
 end
 
 path = ARGV[0] || Pathname(__dir__) + "regexp_crossword/tutorial-1.txt"
-RegexpCrosswordSolver.new(path).solve!
+RegexpCrosswordSolver.new(path).call

data/examples/regexp_solver

@@ -11,7 +11,7 @@ class RegexpSolver
     @solver = Z3::Solver.new
   end
 
-  def solve!
+  def call
     @str = (0...@length).map do |i|
       v = Z3.Int("char[#{i}]")
       @solver.assert v >= 0
@@ -40,4 +40,4 @@ end
 
 length = ARGV[0].to_i
 regexp = ARGV[1]
-RegexpSolver.new(length, regexp).solve!
+RegexpSolver.new(length, regexp).call