z3 0.0.20161010 → 0.0.20161117

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6cae47eadb8b6cb435ab68a3c1d5e64e7ab7ef10
-  data.tar.gz: 59e4479e128bad8ea7588b8de42ef9c6ad9af4e5
+  metadata.gz: 23036614e8d142331481794ca573d49be3d4c18f
+  data.tar.gz: 1d765179f046c53ae950605fbf4d431d9bc3d7b6
 SHA512:
-  metadata.gz: 9e3a0cf9fff6457c318ad086e987029fad72a292080572ea0ddc204cf5c054881c95b515977456aed9a07bb57a86718d85c8ac03e4144c5379c7417a1c667696
-  data.tar.gz: 3bf40c2ff99cb57ef7b623415ddf50605bbdde75d524c05c40223ca38d81e3cd58d122d39a1b51dc490bc2575dde884823e24cd2fc06a8568d5ee42f4a4cb216
+  metadata.gz: f49fb4df1ff7df3b283aa2f2eada3b263d13af54ddf0b9e7640d315efcae9fe5cdcaa00b5f4693e5ead379d9babf45923832c269de5dedef84b516a9c1245f78
+  data.tar.gz: c936f488e71e3b8fe99f86ec8602bfde64848d1c008407a73316739dec194e0f99a0567487f3d6371ba775265431bfb44fa64ea52c1a7042941f4b5289a71fcb

data/README.md

@@ -1,18 +1,16 @@
 This is Ruby interface for Z3 [ https://github.com/Z3Prover/z3 ].
 
-It's in extremely early stages of development. Pull requests always welcome.
+It's in very early stages of development. Pull requests always welcome.
 
 ### Interface
 
-`Z3::VeryLowLever` / `Z3::LowLevel` are low level FFI interface, and they shouldn't be used directly.
+The public interface is various methods in `Z3` module, and on objects created by it. `examples/` directory is probably the best place to start.
 
-The rest of `Z3` is high level API, but the interface is extremely unstable at this point, and it's pretty much guaranteed to  change many times. Check specs or `examples/` directory for usage.
+You can use most Ruby operators to construct Z3 expressions, but use `| &` instead of `|| &&` for boolean operators. They unfortunately have wrong operator precedence so you'll need to use some extra parentheses.
 
-You can use most Ruby operators to construct Z3 expressions, but use `~ | &` instead of `! || &&` for boolean operators. They unfortunately have wrong operator precedence so you'll need to use some extra parentheses.
+The interface is potentially unstable, and can change in the future.
 
-As for API internals, attributes starting with `_` are FFI internals you shouldn't touch, other attributes are generally legitimate Ruby objects.
-
-Bit vectors are treated as signed by default. [well, mostly, more systematic treatment of this is on TODO list]
+`Z3::VeryLowLever` and `Z3::LowLevel` are FFI interface for internal use, and they shouldn't be used directly. Also don't use any method starting with `_`. Doing this is likely to lead to segmentation faults unless extreme care is taken.
 
 ### Requirements
 
@@ -22,12 +20,12 @@ To use it, you'll need to install `z3`. On OSX that would be:
 
 On other systems use appropriate package manager.
 
-### Known Bugs
+### Known Issues
 
-Ruby API tries to catch the most common mistakes, but if you use API in a weird way you can get C crash instead of nice Ruby exception.
+As Z3 is a C library, doing anything weird with it will segfault your process. Ruby API tries its best to prevent such problems and turn them into exceptions instead, but if you do anything weird (especially touch any method prefixed with `_` or `Z3::LowLevel` interface), crashes are possible. If you have reproducible crash on reasonable looking code, definitely submit it as a bug, and I'll try to come up with a workaround.
 
-Memory will leak a good deal. Generally avoid in long running processes.
+As Z3 mixes aggressively interning ASTs and reference counting, it's not very compatible with Ruby style memory management, so memory will leak a good deal. It's usually not much worse than the usual Symbol memory leak, but you might want to avoid Z3 in a long running processes exposed to public input.
 
-### Python versions
+### Python examples
 
-Most of example solvers have Python versions available from https://github.com/taw/puzzle-solvers
+Some of example solvers also have Python versions available from https://github.com/taw/puzzle-solvers

data/examples/crossflip

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+
+require "z3"
+
+class CrossFlipSolver
+  def initialize(board)
+    # 0 - light
+    # 1 - dark
+    # 2 - wall
+    @board = board.split(",").map{|line| line.chars.map(&:to_i)}
+    @ysize = @board.size
+    @xsize = @board[0].size
+  end
+
+  def board(x,y)
+    @board[y][x]
+  end
+
+  def wall?(x,y)
+    board(x,y) == 2
+  end
+
+  def click(x,y)
+    Z3.Bool("click[#{x},#{y}]")
+  end
+
+  def cells_visible_from(x0,y0)
+    result = []
+    result << click(x0,y0)
+    (x0+1...@xsize).each do |x|
+      break if wall?(x,y0)
+      result << click(x,y0)
+    end
+    (0..x0-1).reverse_each do |x|
+      break if wall?(x,y0)
+      result << click(x,y0)
+    end
+    (y0+1...@ysize).each do |y|
+      break if wall?(x0,y)
+      result << click(x0,y)
+    end
+    (0..y0-1).reverse_each do |y|
+      break if wall?(x0,y)
+      result << click(x0,y)
+    end
+    result
+  end
+
+  def solve!
+    @solver = Z3::Solver.new
+
+    @ysize.times do |y|
+      @xsize.times do |x|
+        if wall?(x,y)
+          @solver.assert click(x,y) == false
+        else
+          starts_light = (board(x,y) == 0)
+          ends_light = Z3.Xor(*cells_visible_from(x,y)) ^ starts_light
+          @solver.assert ends_light
+        end
+      end
+    end
+
+    unless @solver.satisfiable?
+      raise "This can't be solved, go away!"
+    end
+    model = @solver.model
+
+    @ysize.times do |y|
+      @xsize.times do |x|
+        clicked = (model[click(x,y)].to_s == "true")
+        print clicked ? "[x] " : "[ ] "
+      end
+      print "\n"
+    end
+  end
+end
+
+
+
+board = "1021,1000"
+CrossFlipSolver.new(board).solve!

data/examples/mortal_coil_puzzle

@@ -0,0 +1,105 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/z3"
+require "pathname"
+
+# From hacker.org
+class MortalCoilSolver
+  def initialize(path)
+    data = Pathname(path).read
+    data = data.strip.split("\n").map do |line|
+      line.chars.map{|c| c == "x" ? true : false}
+    end
+    @data = data
+    @solver = Z3::Solver.new
+    @size_y = @data.size
+    @size_x = @data[0].size
+    @empty_count = @data.flatten.count{|x| !x}
+  end
+
+  def setup_vars!
+    empty_cell_vars = []
+    @vars = {}
+    (0...@size_x).each do |x|
+      (0...@size_y).each do |y|
+        v = Z3.Int("c#{x},#{y}")
+        if @data[y][x]
+          @solver.assert v == -1
+        else
+          @solver.assert v >= 1
+          @solver.assert v <= @empty_count
+          empty_cell_vars << v
+        end
+        @vars[[x,y]] = v
+      end
+    end
+    @solver.assert Z3.Distinct(*empty_cell_vars)
+  end
+
+  def line_continuity!
+    (0...@size_y).each do |y|
+      (0...@size_x).each do |x|
+        v = @vars[[x,y]]
+        neighbours = [[x-1,y], [x+1,y], [x,y-1], [x,y+1]].map{|a,b| @vars[[a,b]]}.compact
+        @solver.assert Z3.Or(v == -1, v == @empty_count, *neighbours.map{|n| n == v+1})
+        @solver.assert Z3.Or(v == -1, v == 1, *neighbours.map{|n| n == v-1})
+      end
+    end
+  end
+
+  def keep_going!(a,b,c)
+    # If line goes from a to b (b == a+1), then it must:
+    # * hit a wall (c == nil)
+    # * hit a filled block (c == -1)
+    # * continue (c == b+1)
+    # * hit earlier line (c < b)
+    return unless a and c
+    @solver.assert (b == a+1).implies(Z3.Or(
+        c == -1,
+        c == b+1,
+        c < b,
+      )
+    )
+  end
+
+  def line_goes_until_it_hits_something!
+    (0...@size_y).each do |y|
+      (0...@size_x).each do |x|
+        v = @vars[[x,y]]
+        left  = @vars[[x-1,y]]
+        right = @vars[[x+1,y]]
+        up    = @vars[[x,y-1]]
+        down  = @vars[[x,y+1]]
+        keep_going! left, v, right
+        keep_going! right, v, left
+        keep_going! up, v, down
+        keep_going! down, v, up
+      end
+    end
+  end
+
+  def solve!
+    setup_vars!
+    line_continuity!
+    line_goes_until_it_hits_something!
+
+    if @solver.satisfiable?
+      model = @solver.model
+      (0...@size_y).each do |y|
+        puts (0...@size_x).map{|x|
+          v = model[@vars[[x,y]]].to_i
+          if v == -1
+            "###"
+          else
+            "% 3d" % v
+          end
+        }.join(" ")
+      end
+    else
+      puts "Puzzle has no solution"
+    end
+  end
+end
+
+path = ARGV[0] || Pathname(__dir__) + "mortal_coil_puzzle-9.txt"
+MortalCoilSolver.new(path).solve!

data/examples/mortal_coil_puzzle-9.txt

@@ -0,0 +1,6 @@
+---x--
+-x-x--
+------
+----x-
+-x--x-
+------

data/examples/oneofus

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby
+
+require "z3"
+require "pry"
+
+class OneofusSolver
+  def initialize
+    @x_size = 3
+    @y_size = 3
+    @board_str = "CbBbCbAaCbCaCbAbCb"
+    @solver = Z3::Solver.new
+
+    @board = (0...@x_size).map{|x|
+      (0...@y_size).map{|y| @board_str[(y * @x_size+x) * 2, 2]  }
+    }.transpose
+  end
+
+  def print_board
+    3.times do |y|
+      puts 3.times.map{|x|
+        cell = @board[y][x]
+        shape = {"C" => "Triangle", "B" => "Circle", "A" => "Square"}[cell[0]]
+        color = {"b" => "grey", "a"=> "purple"}[cell[1]]
+        "#{color} #{shape}"
+      }.join(" ")
+    end
+  end
+
+  def shape_number(x,y)
+    cell = @board[y][x]
+    {"C" => 2, "B" => 1, "A" => 0}[cell[0]]
+  end
+
+  def color_number(x,y)
+    cell = @board[y][x]
+    {"b" => 1, "a"=> 0}[cell[1]]
+  end
+
+  def run!
+    print_board
+    puts ""
+
+    9.times do |i|
+      cx = Z3.Int("click_#{i}_x")
+      cy = Z3.Int("click_#{i}_y")
+      cc = Z3.Int("click_#{i}_color")
+      cs = Z3.Int("click_#{i}_shape")
+      @solver.assert (cx >= 0) & (cx <= 2)
+      @solver.assert (cy >= 0) & (cy <= 2)
+      cn = Z3.Int("click_#{i}_n")
+      @solver.assert cn == (3 * cx + cy)
+    end
+    @solver.assert Z3.Distinct(
+      *9.times.map{|i|
+        Z3.Int("click_#{i}_n")
+      }
+    )
+    8.times do |i|
+      cx = Z3.Int("click_#{i}_x")
+      cy = Z3.Int("click_#{i}_y")
+      cc = Z3.Int("click_#{i}_color")
+      cs = Z3.Int("click_#{i}_shape")
+      cx_next = Z3.Int("click_#{i+1}_x")
+      cy_next = Z3.Int("click_#{i+1}_y")
+      cc_next = Z3.Int("click_#{i+1}_color")
+      cs_next = Z3.Int("click_#{i+1}_shape")
+      @solver.assert (cx == cx_next) | (cy == cy_next)
+      @solver.assert (cc == cc_next) | (cs == cs_next)
+    end
+    9.times do |i|
+      3.times do |y|
+        3.times do |x|
+          cx = Z3.Int("click_#{i}_x")
+          cy = Z3.Int("click_#{i}_y")
+          cc = Z3.Int("click_#{i}_color")
+          cs = Z3.Int("click_#{i}_shape")
+          @solver.assert (
+            (cx == x)  & (cy == y)
+          ).implies(
+            (cs == shape_number(x,y)) & (cc == color_number(x,y))
+          )
+        end
+      end
+    end
+
+    print_solution
+  end
+
+  def print_solution
+    raise "FAIL" unless @solver.satisfiable?
+    model = @solver.model
+    9.times do |i|
+      cx = model[Z3.Int("click_#{i}_x")].to_i
+      cy = model[Z3.Int("click_#{i}_y")].to_i
+      cc = ["purple", "grey"][model[Z3.Int("click_#{i}_color")].to_i]
+      cs = ["Square", "Circle", "Triangle"][model[Z3.Int("click_#{i}_shape")].to_i]
+      puts "Click #{i}: #{cx},#{cy} - #{cc} #{cs}"
+    end
+  end
+end
+
+OneofusSolver.new.run!

data/examples/regexp_crossword/beginner-1.txt

@@ -0,0 +1,5 @@
+[^SPEAK]+
+EP|IP|EF
+
+HE|LL|O+
+[PLEASE]+

data/examples/regexp_crossword/beginner-2.txt

@@ -0,0 +1,5 @@
+(A|B|C)\1
+(AB|OE|SK)
+
+.*M?O.*
+(AN|FE|BE)

data/examples/regexp_crossword/beginner-3.txt

@@ -0,0 +1,5 @@
+[COBRA]+
+(AB|O|OR)+
+
+(.)+\1
+[^ABRC]+

data/examples/regexp_crossword/beginner-4.txt

@@ -0,0 +1,5 @@
+.?.+
+.+
+
+[*]+
+/+

data/examples/regexp_crossword/beginner-5.txt

@@ -0,0 +1,5 @@
+\d[2480]
+56|94|73
+
+18|19|20
+[6789]\d

data/examples/regexp_crossword/experienced-1.txt

@@ -0,0 +1,9 @@
+(FI|A)+
+(YE|OT)K
+(.)[IF]+
+[NODE]+
+(FY|F|RG)+
+
+(Y|F)(.)\2[DAF]\1
+(U|O|I)*T[FRO]+
+[KANE]*[GIN]*

data/examples/regexp_crossword/experienced-2.txt

@@ -0,0 +1,11 @@
+[ARK]*O.*
+(.).*\1N\1
+(SOD|DO|GE)*
+[FAXUS]*
+[LOPITY]*
+
+[UGLER]*
+[CAST]*REX[PEA]*
+[SIRES]*
+(L|OFT|ON)*
+H*(AY|ED)*

data/examples/regexp_crossword/experienced-3.txt

@@ -0,0 +1,11 @@
+[ABC]*(.)\1(ME|UO)
+(.)T*E*\1
+[HAS]*(SN|PA)
+(WE|GA|AL)T*O+
+(EG|BEEE)[WIQ]*
+
+[QA].[WEST]*
+(HE|RT|TK)*.
+(RE|QR)[QUART]*
+[EUW]*S[RITE]*
+(.)(.)\2\1[WE]

data/examples/regexp_crossword/experienced-4.txt

@@ -0,0 +1,11 @@
+(!!|\?!|;\?)*\?
+[<!?*#>]*
+[?*!].\?[!<*]*
+(.)[?#]\1\?\1
+[<?>][\[!]*[?\|#]
+
+[#?]!*[:?;]
+(.)([;?])\1\2\1
+["!"]*\?!*#?
+.[;?][>!?]*
+(.)[;!"]*!\1

data/examples/regexp_crossword/experienced-5.txt

@@ -0,0 +1,11 @@
+[RUTH]*(OE|EO)[RB]*
+(BG|ON|KK)+[RIF]+
+(MN|BO|FI)[EU]{2,}
+(KT|AL|ET)+G
+[OH](PR|AX|TR)+
+
+[IT](O)*(BE|AD)*\1
+[NORMAL]+T{2}
+.*(XA|BE).*
+(EG|UL){2}[ALF]*
+[REQ]*(G|P)(.)+

data/examples/regexp_crossword/tutorial-1.txt

@@ -0,0 +1,3 @@
+A|B
+
+A|Z

data/examples/regexp_crossword/tutorial-2.txt

@@ -0,0 +1,3 @@
+[ABC]
+
+[BDF]

data/examples/regexp_crossword/tutorial-3.txt

@@ -0,0 +1,3 @@
+[^AB]
+
+[ABC]

data/examples/regexp_crossword/tutorial-4.txt

@@ -0,0 +1,4 @@
+A*
+
+A
+AB*

data/examples/regexp_crossword/tutorial-5.txt

@@ -0,0 +1,4 @@
+A?B?
+
+A|C
+B

data/examples/regexp_crossword/tutorial-6.txt

@@ -0,0 +1,4 @@
+A+
+
+A|B	
+A|Z

data/examples/regexp_crossword/tutorial-7.txt

@@ -0,0 +1,4 @@
+(A)\1
+
+A|B	
+A|B

data/examples/regexp_crossword/tutorial-8.txt

@@ -0,0 +1,4 @@
+A{2,}
+
+A{1}
+B|A

data/examples/regexp_crossword/tutorial-9.txt

@@ -0,0 +1,3 @@
+A|\s
+
+\s

data/examples/regexp_crossword_solver

@@ -0,0 +1,80 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/z3"
+require "pathname"
+require_relative "simple_regexp_parser"
+require_relative "regexp_string_matcher"
+
+class RegexpCrosswordSolver
+  def initialize(path)
+    data = Pathname(path).read
+    data = data.strip.split("\n")
+    col_number = data.index("")
+    row_number = data.size - col_number - 1
+    # left to right
+    @cols = data.first(col_number)
+    # top to bottom
+    @rows = data.last(row_number)
+    @solver = Z3::Solver.new
+    @xsize = @cols.size
+    @ysize = @rows.size
+  end
+
+  def setup_cell(x,y)
+    v = Z3.Int("cell#{x},#{y}")
+    @solver.assert v >= 0
+    @solver.assert v <= 127
+    v
+  end
+
+  def col_str(x)
+    (0...@ysize).map{|y| @crossword[[x,y]]}
+  end
+
+  def row_str(y)
+    (0...@xsize).map{|x| @crossword[[x,y]]}
+  end
+
+  def col_rx(x)
+    SimpleRegexpParser.new(@cols[x], "col-#{x}").parse
+  end
+
+  def row_rx(y)
+    SimpleRegexpParser.new(@rows[y], "row-#{y}").parse
+  end
+
+  def solve!
+    @crossword = {}
+    @xsize.times do |x|
+      @ysize.times do |y|
+        @crossword[[x,y]] = setup_cell(x,y)
+      end
+    end
+
+    @xsize.times do |x|
+      RegexpStringMatcher.new(@solver, col_rx(x), col_str(x), "col-#{x}").run!
+    end
+    @ysize.times do |y|
+      RegexpStringMatcher.new(@solver, row_rx(y), row_str(y), "row-#{y}").run!
+    end
+
+    print_answer
+  end
+
+  def print_answer
+    if @solver.satisfiable?
+      @model = @solver.model
+      @ysize.times do |y|
+        puts @xsize.times.map{|x|
+          @model[@crossword[[x,y]]].to_i.chr
+        }.join.inspect[1...-1]
+      end
+    else
+      raise
+      print "Crossword has no solution"
+    end
+  end
+end
+
+path = ARGV[0] || Pathname(__dir__) + "regexp_crossword/tutorial-1.txt"
+RegexpCrosswordSolver.new(path).solve!

data/examples/regexp_solver

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/z3"
+require_relative "simple_regexp_parser"
+require_relative "regexp_string_matcher"
+
+class RegexpSolver
+  def initialize(length, rx)
+    @length = length
+    @rx = SimpleRegexpParser.new(rx, "").parse
+    @solver = Z3::Solver.new
+  end
+
+  def solve!
+    @str = (0...@length).map do |i|
+      v = Z3.Int("char[#{i}]")
+      @solver.assert v >= 0
+      @solver.assert v <= 127
+      v
+    end
+
+    RegexpStringMatcher.new(@solver, @rx, @str, "").run!
+    print_answer
+  end
+
+  def print_answer
+    if @solver.satisfiable?
+      @model = @solver.model
+      puts @str.map{|c| @model[c].to_i.chr }.join.inspect[1...-1]
+    else
+      raise
+      print "Crossword has no solution"
+    end
+  end
+end
+
+unless ARGV.size == 2
+  STDERR.puts "Usage: #{$0} <length> <regexp>"
+  exit 1
+end
+
+length = ARGV[0].to_i
+regexp = ARGV[1]
+RegexpSolver.new(length, regexp).solve!

data/examples/regexp_string_matcher.rb

@@ -0,0 +1,124 @@
+require "set"
+
+class RegexpStringMatcher
+  # rx comes from SimpleRegexpParser
+  # str is a bunch of Z3.Ints with proper constraints (0..127)
+  def initialize(solver, rx, str, context)
+    @solver = solver
+    @rx = rx
+    @str = str
+    @context = context
+    @subexprs = Set[]
+  end
+
+  def group_equal(group_identifier, start_idx, end_idx)
+    str = @str[start_idx...end_idx]
+    Z3.And(
+      Z3.Int("group-#{group_identifier}-size") == str.size,
+      *str.each_with_index.map{|s,i| Z3.Int("group-#{group_identifier}-char[#{i}]") == s }
+    )
+  end
+
+  def anchor_match(anchor, start_idx)
+    case anchor[0]
+    when :bos
+      start_idx == 0
+    when :eos
+      start_idx == @str.size
+    when :bol
+      if start_idx == 0
+        true
+      else
+        @str[start_idx-1] == 10
+      end
+    when :eol
+      # This is actually tricky
+      # $ matches both before and after \n
+      if start_idx == @str.size
+        true
+      elsif start_idx == 0
+        (@str[start_idx] == 10)
+      else
+        (@str[start_idx] == 10) | (@str[start_idx-1] == 10)
+      end
+    when :lookahead
+      regexp_match([:seq, anchor[1], [:any_star]], start_idx, @str.size)
+    when :negative_lookahead
+      ~regexp_match([:seq, anchor[1], [:any_star]], start_idx, @str.size)
+    when :lookbehind
+      regexp_match([:seq, [:any_star], anchor[1]], 0, start_idx)
+    when :lookbehind
+      ~regexp_match([:seq, [:any_star], anchor[1]], 0, start_idx)
+    else
+      raise "Unknown anchor type #{anchor[0]}"
+    end
+  end
+
+  # @subexprs just prevents loops for self-referential regexps
+  def regexp_match(rx, start_idx, end_idx)
+    str = @str[start_idx...end_idx]
+    var = Z3.Bool("#{rx} =~ #{@context}[#{start_idx}...#{end_idx}]")
+    return var if @subexprs.include?(var)
+    @subexprs << var
+
+    expr = case rx[0]
+    when :seq
+      rx_a, rx_b = rx[1], rx[2]
+      possibilities = (start_idx..end_idx).map do |i|
+        a_ok = regexp_match(rx_a, start_idx, i)
+        b_ok = regexp_match(rx_b, i, end_idx)
+        a_ok & b_ok
+      end
+      Z3.Or(*possibilities)
+    when :set
+      if str.size == 1
+        Z3.Or(*rx[1].map{|c| str[0] == c })
+      else
+        false
+      end
+    when :neg_set
+      if str.size == 1
+        ~Z3.Or(*rx[1].map{|c| str[0] == c })
+      else
+        false
+      end
+    when :alt
+      rx_a, rx_b = rx[1], rx[2]
+      regexp_match(rx_a, start_idx, end_idx) | regexp_match(rx_b, start_idx, end_idx)
+    when :star
+      if str.size == 0
+        true
+      else
+        r = rx[1]
+        possibilities = (start_idx+1..end_idx).map do |i|
+          regexp_match(r, start_idx, i) & regexp_match(rx, i, end_idx)
+        end
+        Z3.Or(*possibilities)
+      end
+    when :group
+      n = rx[1]
+      rx_a = rx[2]
+      regexp_match(rx_a, start_idx, end_idx) & group_equal(n, start_idx, end_idx)
+    when :backref
+      group_equal(rx[1], start_idx, end_idx)
+    when :empty
+      (str.size == 0)
+    when :anchor
+      if str.size == 0
+        anchor_match(rx[1..-1], start_idx)
+      else
+        false
+      end
+    when :any_star # like /.*/m or /.*/s depending on language
+      true
+    else
+      raise "Unknown regexp type #{rx[0]}"
+    end
+    @solver.assert (var == expr).simplify
+    var
+  end
+
+  def run!
+    @solver.assert regexp_match(@rx, 0, @str.length)
+  end
+end

data/examples/simple_regexp_parser.rb

@@ -0,0 +1,187 @@
+require "regexp_parser"
+
+# Format generated by Regexp::Parser is not convenient at all,
+# let's translate it into something more useful
+class SimpleRegexpParser
+  def initialize(str, context)
+    @tree = Regexp::Parser.parse(str)
+    @context = context
+    @group_number = 0
+  end
+
+  def new_group
+    @group_number += 1
+    "#{@context}-#{@group_number}"
+  end
+
+  def sequence(*parts)
+    parts = parts.select{|x| x[0] != :empty}
+    case parts.size
+    when 0
+      [:empty]
+    when 1
+      parts[0]
+    else
+      while parts.size > 1
+        parts.unshift [:seq, parts.shift, parts.shift]
+      end
+      parts[0]
+    end
+  end
+
+  def alternative(*parts)
+    case parts.size
+    when 0
+      raise "Can't have empty alternative"
+    when 1
+      parts[0]
+    else
+      while parts.size > 1
+        parts.unshift [:alt, parts.shift, parts.shift]
+      end
+      parts[0]
+    end
+  end
+
+  # 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}
+    # This is mostly here to make debugging easier
+    if codes.size > 127-codes.size
+      [:neg_set, (0..127).to_a - codes]
+    else
+      [:set, codes]
+    end
+  end
+
+  def character_set(negated, members)
+    if negated
+      character_type "[^#{members.join}]"
+    else
+      character_type "[#{members.join}]"
+    end
+  end
+
+  def literal(chars)
+    sequence(*chars.map{|c| character_type(c)})
+  end
+
+  def star(part)
+    [:star, part]
+  end
+
+  def backref(num)
+    [:backref, "#{@context}-#{num}"]
+  end
+
+  def group(number, part)
+    [:group, number, part]
+  end
+
+  def empty
+    [:empty]
+  end
+
+  def repeat(part, min, max)
+    if max == -1
+      sequence(star(part), *([part]*min))
+    else
+      maybe_part = alternative([:empty], part)
+      sequence(*([part]*min), *([maybe_part] * (max-min)))
+    end
+  end
+
+  # Groups and qualifiers interact in weird ways, (a){3} is actually aa(a)
+  # We need to do extensive rewriting to make it work
+  def repeat_group(part, min, max)
+    base = part[2]
+    if max == -1
+      if min == 0 # (a)* -> |a*(a)
+        alternative(
+          empty,
+          sequence(repeat(base, min, max), part)
+        )
+      else # (a){2,} -> a{1,}(a)
+        sequence(repeat(base, min-1, max), part)
+      end
+    elsif max == 0 # a{0} -> empty, not really a thing
+      :empty
+    else
+      if min == 0
+        # (a){2,3} -> |a{1,2}(a)
+        alternative(
+          empty,
+          sequence(repeat(base, min, max-1), part)
+        )
+      else # (a){2,3} -> a{1,2}(a)
+        sequence(repeat(base, min-1, max-1), part)
+      end
+    end
+  end
+
+  # Try to express regexps with minimum number of primitives:
+  # * seq  - ab
+  # * alt  - a|b
+  # * star - a*
+  # * set  - a [a-z] [^a-z]
+  # * empty
+  # * backref - \1
+  # * group - (a)
+  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
+    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
+    end
+
+    result
+  end
+end

data/lib/z3/expr/bitvec_expr.rb

@@ -4,6 +4,10 @@ module Z3
       sort.new(LowLevel.mk_bvnot(self))
     end
 
+    def !
+      sort.new(LowLevel.mk_bvnot(self))
+    end
+
     def -@
       sort.new(LowLevel.mk_bvneg(self))
     end

data/lib/z3/expr/bool_expr.rb

@@ -4,6 +4,10 @@ module Z3
       sort.new(LowLevel.mk_not(self))
     end
 
+    def !
+      sort.new(LowLevel.mk_not(self))
+    end
+
     def &(other)
       Expr.And(self, other)
     end

data/lib/z3/probe.rb

@@ -20,6 +20,10 @@ module Z3
       Probe.new LowLevel.probe_not(self)
     end
 
+    def !
+      Probe.new LowLevel.probe_not(self)
+    end
+
     def ==(other)
       raise Z3::Exception, "Probe required" unless other.is_a?(Probe)
       Probe.new LowLevel.probe_eq(self, other)

data/spec/bitvec_expr_spec.rb

@@ -63,8 +63,9 @@ module Z3
       expect([a == 50, b == -a]).to have_solution(b => 206)
     end
 
-    it "~" do
+    it "~ and !" do
       expect([a == 50, b == ~a]).to have_solution(b => 205)
+      expect([a == 50, b == !a]).to have_solution(b => 205)
     end
 
     it ">> (sign-dependent)" do

data/spec/bool_expr_spec.rb

@@ -54,9 +54,11 @@ module Z3
       expect([a == false, b == false, c == (a == b)]).to have_solution(c =>  true)
     end
 
-    it "~" do
+    it "~ and !" do
       expect([a ==  true, b == ~a]).to have_solution(b => false)
       expect([a == false, b == ~a]).to have_solution(b =>  true)
+      expect([a ==  true, b == !a]).to have_solution(b => false)
+      expect([a == false, b == !a]).to have_solution(b =>  true)
     end
 
     it "if then else" do

data/spec/integration/crossflip_spec.rb

@@ -0,0 +1,8 @@
+describe "CrossFlip" do
+  it do
+    expect("crossflip").to have_output <<EOF
+[x] [ ] [ ] [ ]
+[ ] [x] [ ] [x]
+EOF
+  end
+end

data/spec/integration/mortal_coil_puzzle_spec.rb

@@ -0,0 +1,12 @@
+describe "Mortal Coil Puzzle" do
+  it do
+    expect("mortal_coil_puzzle").to have_output <<EOF
+ 22  21  20 ###  14  13
+ 23 ###  19 ###  15  12
+ 24   1  18  17  16  11
+ 25   2   3   4 ###  10
+ 26 ###  30   5 ###   9
+ 27  28  29   6   7   8
+EOF
+  end
+end

data/spec/integration/oneofus_spec.rb

@@ -0,0 +1,19 @@
+describe "OneOfUs" do
+  it do
+    expect("oneofus").to have_output <<EOF
+grey Triangle grey Circle grey Triangle
+purple Square grey Triangle purple Triangle
+grey Triangle grey Square grey Triangle
+
+Click 0: 0,1 - purple Square
+Click 1: 2,1 - purple Triangle
+Click 2: 2,2 - grey Triangle
+Click 3: 1,2 - grey Square
+Click 4: 1,1 - grey Triangle
+Click 5: 1,0 - grey Circle
+Click 6: 2,0 - grey Triangle
+Click 7: 0,0 - grey Triangle
+Click 8: 0,2 - grey Triangle
+EOF
+  end
+end

data/spec/integration/regexp_crossword_solver_spec.rb

@@ -0,0 +1,31 @@
+describe "Regexp Crossword Solver" do
+  let(:binary) { Pathname(__dir__) + "../../examples/regexp_crossword_solver" }
+
+  examples = (Pathname(__dir__) + "../../examples/regexp_crossword")
+             .children
+             .select{|x| x.extname == ".txt"}
+  examples.each do |example_path|
+    describe example_path.basename.to_s do
+      let(:example) { example_path.readlines.map(&:chomp) }
+      let(:col_number) { example.index("") }
+      let(:row_number) { example.size - col_number - 1 }
+      # left to right
+      let(:cols) { example.first(col_number) }
+      # top to bottom
+      let(:rows) { example.last(row_number) }
+
+      it "matches output" do
+        output_rows = `#{binary} #{example_path}`.split("\n").map(&:chomp)
+        output_cols = output_rows.map(&:chars).transpose.map(&:join)
+        expect(output_rows.size).to eq(rows.size)
+        expect(output_cols.size).to eq(cols.size)
+        output_rows.zip(rows).each do |s, rx|
+          expect(s).to match Regexp.new(/\A(?:#{rx})\z/)
+        end
+        output_cols.zip(cols).each do |s, rx|
+          expect(s).to match Regexp.new(/\A(?:#{rx})\z/)
+        end
+      end
+    end
+  end
+end

data/spec/integration/regexp_solver_spec.rb

@@ -0,0 +1,27 @@
+require "yaml"
+
+describe "Regexp Solver" do
+  let(:binary) { Pathname(__dir__) + "../../examples/regexp_solver" }
+
+  examples = [
+    [3 ,'lol'],
+    [3, '\d\d\d'],
+    [4, 'a*\Ab*\zc*'],
+    [2, '^\n^\n'],
+    [1, '(?=[ab])(?=[bc])[bd]'],
+    [1, '(?=[ab])(?![bc])[ac]'],
+    [2, '(?=a$)a\n'],
+    [2, '(?=a\s$)a\n'],
+  ]
+
+  examples.each do |length, rx|
+    describe rx do
+      it "matches output" do
+        actual_esc = `#{binary} #{length} '#{rx}'`.chomp
+        actual = YAML.load(%Q(---\n"#{actual_esc}"\n)) # avoid eval
+        expect(actual.size).to eq(length)
+        expect(actual).to match Regexp.new(/\A(?:#{rx})\z/)
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: z3
 version: !ruby/object:Gem::Version
-  version: 0.0.20161010
+  version: 0.0.20161117
 platform: ruby
 authors:
 - Tomasz Wegrzanowski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-10 00:00:00.000000000 Z
+date: 2016-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -66,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: regexp_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: ffi
   requirement: !ruby/object:Gem::Requirement
@@ -97,6 +111,7 @@ files:
 - examples/bridges-1.txt
 - examples/circuit_problems
 - examples/clogic_puzzle
+- examples/crossflip
 - examples/four_hackers_puzzle
 - examples/geometry_problem
 - examples/kakuro
@@ -109,8 +124,34 @@ files:
 - examples/light_up-1.txt
 - examples/minisudoku
 - examples/minisudoku-1.txt
+- examples/mortal_coil_puzzle
+- examples/mortal_coil_puzzle-9.txt
 - examples/nonogram
+- examples/oneofus
+- examples/regexp_crossword/beginner-1.txt
+- examples/regexp_crossword/beginner-2.txt
+- examples/regexp_crossword/beginner-3.txt
+- examples/regexp_crossword/beginner-4.txt
+- examples/regexp_crossword/beginner-5.txt
+- examples/regexp_crossword/experienced-1.txt
+- examples/regexp_crossword/experienced-2.txt
+- examples/regexp_crossword/experienced-3.txt
+- examples/regexp_crossword/experienced-4.txt
+- examples/regexp_crossword/experienced-5.txt
+- examples/regexp_crossword/tutorial-1.txt
+- examples/regexp_crossword/tutorial-2.txt
+- examples/regexp_crossword/tutorial-3.txt
+- examples/regexp_crossword/tutorial-4.txt
+- examples/regexp_crossword/tutorial-5.txt
+- examples/regexp_crossword/tutorial-6.txt
+- examples/regexp_crossword/tutorial-7.txt
+- examples/regexp_crossword/tutorial-8.txt
+- examples/regexp_crossword/tutorial-9.txt
+- examples/regexp_crossword_solver
+- examples/regexp_solver
+- examples/regexp_string_matcher.rb
 - examples/selfref
+- examples/simple_regexp_parser.rb
 - examples/sudoku
 - examples/sudoku-1.txt
 - examples/verbal_arithmetic
@@ -118,7 +159,6 @@ files:
 - lib/z3/ast.rb
 - lib/z3/context.rb
 - lib/z3/exception.rb
-- lib/z3/expr/.DS_Store
 - lib/z3/expr/arith_expr.rb
 - lib/z3/expr/array_expr.rb
 - lib/z3/expr/bitvec_expr.rb
@@ -138,7 +178,6 @@ files:
 - lib/z3/printer.rb
 - lib/z3/probe.rb
 - lib/z3/solver.rb
-- lib/z3/sort/.DS_Store
 - lib/z3/sort/array_sort.rb
 - lib/z3/sort/bitvec_sort.rb
 - lib/z3/sort/bool_sort.rb
@@ -151,7 +190,6 @@ files:
 - lib/z3/tactic.rb
 - lib/z3/very_low_level.rb
 - lib/z3/very_low_level_auto.rb
-- spec/.DS_Store
 - spec/array_expr_spec.rb
 - spec/array_sort_spec.rb
 - spec/bitvec_expr_spec.rb
@@ -171,6 +209,7 @@ files:
 - spec/integration/bit_tricks_spec.rb
 - spec/integration/bridges_spec.rb
 - spec/integration/cicruit_problem_spec.rb
+- spec/integration/crossflip_spec.rb
 - spec/integration/four_hackers_puzzle_spec.rb
 - spec/integration/geometry_problem_spec.rb
 - spec/integration/kakuro_spec.rb
@@ -179,7 +218,11 @@ files:
 - spec/integration/letter_connections_spec.rb
 - spec/integration/light_up_spec.rb
 - spec/integration/minisudoku_spec.rb
+- spec/integration/mortal_coil_puzzle_spec.rb
 - spec/integration/nonogram_spec.rb
+- spec/integration/oneofus_spec.rb
+- spec/integration/regexp_crossword_solver_spec.rb
+- spec/integration/regexp_solver_spec.rb
 - spec/integration/selfref_spec.rb
 - spec/integration/sudoku_spec.rb
 - spec/integration/verbal_arithmetic_spec.rb