z3 0.0.20180629 → 0.0.20220203

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/simple_regexp_parser.rb

@@ -15,7 +15,7 @@ class SimpleRegexpParser
   end
 
   def sequence(*parts)
-    parts = parts.select{|x| x[0] != :empty}
+    parts = parts.select { |x| x[0] != :empty }
     case parts.size
     when 0
       [:empty]
@@ -46,9 +46,9 @@ class SimpleRegexpParser
   # Saves us time to reuse ruby regexp engine for 1 character case
   def character_type(char_rx)
     char_rx = Regexp.new(char_rx)
-    codes = (0..127).select{|c| c.chr =~ char_rx}
+    codes = (0..127).select { |c| c.chr =~ char_rx }
     # This is mostly here to make debugging easier
-    if codes.size > 127-codes.size
+    if codes.size > 127 - codes.size
       [:neg_set, (0..127).to_a - codes]
     else
       [:set, codes]
@@ -64,7 +64,7 @@ class SimpleRegexpParser
   end
 
   def literal(chars)
-    sequence(*chars.map{|c| character_type(c)})
+    sequence(*chars.map { |c| character_type(c) })
   end
 
   def star(part)
@@ -85,10 +85,10 @@ class SimpleRegexpParser
 
   def repeat(part, min, max)
     if max == -1
-      sequence(star(part), *([part]*min))
+      sequence(star(part), *([part] * min))
     else
       maybe_part = alternative([:empty], part)
-      sequence(*([part]*min), *([maybe_part] * (max-min)))
+      sequence(*([part] * min), *([maybe_part] * (max - min)))
     end
   end
 
@@ -105,7 +105,7 @@ class SimpleRegexpParser
           sequence(repeat(base, min, max), part)
         )
       else # (a){2,} -> a{1,}(a)
-        sequence(repeat(base, min-1, max), part)
+        sequence(repeat(base, min - 1, max), part)
       end
     elsif max == 0 # a{0} -> empty, not really a thing
       :empty
@@ -115,10 +115,10 @@ class SimpleRegexpParser
         # with same group id for both ()s
         alternative(
           [:group, group, empty],
-          sequence(repeat(base, min, max-1), part)
+          sequence(repeat(base, min, max - 1), part)
         )
       else # (a){2,3} -> a{1,2}(a)
-        sequence(repeat(base, min-1, max-1), part)
+        sequence(repeat(base, min - 1, max - 1), part)
       end
     end
   end
@@ -131,58 +131,60 @@ class SimpleRegexpParser
   # * empty
   # * backref - \1
   # * group - (a)
-  def parse(node=@tree)
+  def parse(node = @tree)
     result = case node
-    when Regexp::Expression::Group::Capture
-      # Assumes it's going to be parsed in right order
-      group(new_group, sequence(*node.expressions.map{|n| parse(n)}))
-    when Regexp::Expression::Alternation
-      alternative(*node.expressions.map{|n| parse(n)})
-    when Regexp::Expression::Assertion::Lookahead
-      [:anchor, :lookahead, sequence(*node.expressions.map{|n| parse(n)})]
-    when Regexp::Expression::Assertion::NegativeLookahead
-      [:anchor, :negative_lookahead, sequence(*node.expressions.map{|n| parse(n)})]
-    when Regexp::Expression::Assertion::Lookbehind
-      [:anchor, :lookbehind, sequence(*node.expressions.map{|n| parse(n)})]
-    when Regexp::Expression::Assertion::NegativeLookbehind
-      [:anchor, :negative_lookbehind, sequence(*node.expressions.map{|n| parse(n)})]
-    when Regexp::Expression::Subexpression
-      # It's annoyingly subtypes a lot
-      raise unless node.class == Regexp::Expression::Subexpression or
-                   node.class == Regexp::Expression::Group::Passive or
-                   node.class == Regexp::Expression::Root or
-                   node.class == Regexp::Expression::Alternative
-      sequence(*node.expressions.map{|n| parse(n)})
-    when Regexp::Expression::CharacterSet
-      character_set(node.negative?, node.members)
-    when Regexp::Expression::Literal
-      literal(node.text.chars)
-    when Regexp::Expression::CharacterType::Base
-      character_type(node.text)
-    when Regexp::Expression::EscapeSequence::Base
-      character_type(node.text)
-    when Regexp::Expression::Backreference::Number
-      num = node.text[%r[\A\\(\d+)\z], 1] or raise "Parse error"
-      backref(num.to_i)
-    when Regexp::Expression::Anchor::BeginningOfString
-      [:anchor, :bos]
-    when Regexp::Expression::Anchor::EndOfString
-      [:anchor, :eos]
-    when Regexp::Expression::Anchor::BeginningOfLine
-      [:anchor, :bol]
-    when Regexp::Expression::Anchor::EndOfLine
-      [:anchor, :eol]
-    else
-      raise "Unknown expression"
-    end
+             when Regexp::Expression::Group::Capture
+               # Assumes it's going to be parsed in right order
+               group(new_group, sequence(*node.expressions.map { |n| parse(n) }))
+             when Regexp::Expression::Alternation
+               alternative(*node.expressions.map { |n| parse(n) })
+             when Regexp::Expression::Assertion::Lookahead
+               [:anchor, :lookahead, sequence(*node.expressions.map { |n| parse(n) })]
+             when Regexp::Expression::Assertion::NegativeLookahead
+               [:anchor, :negative_lookahead, sequence(*node.expressions.map { |n| parse(n) })]
+             when Regexp::Expression::Assertion::Lookbehind
+               [:anchor, :lookbehind, sequence(*node.expressions.map { |n| parse(n) })]
+             when Regexp::Expression::Assertion::NegativeLookbehind
+               [:anchor, :negative_lookbehind, sequence(*node.expressions.map { |n| parse(n) })]
+             when Regexp::Expression::CharacterSet
+               character_set(node.negative?, node.expressions)
+             when Regexp::Expression::Subexpression
+               # It's annoyingly subtypes a lot
+               unless (node.class == Regexp::Expression::Subexpression or
+                       node.class == Regexp::Expression::Group::Passive or
+                       node.class == Regexp::Expression::Root or
+                       node.class == Regexp::Expression::Alternative)
+                 raise "Don't know how to deal with #{node.class}"
+               end
+               sequence(*node.expressions.map { |n| parse(n) })
+             when Regexp::Expression::Literal
+               literal(node.text.chars)
+             when Regexp::Expression::CharacterType::Base
+               character_type(node.text)
+             when Regexp::Expression::EscapeSequence::Base
+               character_type(node.text)
+             when Regexp::Expression::Backreference::Number
+               num = node.text[%r[\A\\(\d+)\z], 1] or raise "Parse error"
+               backref(num.to_i)
+             when Regexp::Expression::Anchor::BeginningOfString
+               [:anchor, :bos]
+             when Regexp::Expression::Anchor::EndOfString
+               [:anchor, :eos]
+             when Regexp::Expression::Anchor::BeginningOfLine
+               [:anchor, :bol]
+             when Regexp::Expression::Anchor::EndOfLine
+               [:anchor, :eol]
+             else
+               raise "Unknown expression"
+             end
     if node.quantified?
       min = node.quantifier.min
       max = node.quantifier.max
       result = if result[0] == :group
-        repeat_group(result, min, max)
-      else
-        repeat(result, min, max)
-      end
+                 repeat_group(result, min, max)
+               else
+                 repeat(result, min, max)
+               end
     end
 
     result

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