z3 0.0.20160221 → 0.0.20160323

data/examples/four_hackers_puzzle

@@ -0,0 +1,194 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/z3"
+
+class LogicPuzzleCase
+  attr_reader :index
+  def initialize(puzzle, index)
+    @puzzle = puzzle
+    @index = index
+  end
+
+  def method_missing(key, *args)
+    key = key.to_s
+    if @puzzle.has_key?(key) and args.size == 1
+      @puzzle.attribute(@index, key, *args)
+    elsif @puzzle.has_key?(key) and args.size == 0
+      @puzzle.vars[key][@index]
+    else
+      super
+    end
+  end
+end
+
+class LogicPuzzle
+  attr_reader :vars, :dict
+  def initialize(count)
+    # In puzzles of this kind, all assignments are of same size
+    @count  = count
+    @solver = Z3::Solver.new
+    @vars   = {}
+    @dict   = {}
+    @cases  = @count.times.map{|i| LogicPuzzleCase.new(self, i) }
+  end
+
+  def each(&blk)
+    @cases.each(&blk)
+  end
+
+  def attribute_values(name, *vals)
+    raise "All assignments must have same number of elements" unless vals.size == @count
+    vars = @count.times.map{|i| Z3.Int("#{i}-#{name}") }
+    vars.each do |v|
+      @solver.assert v >= 0
+      @solver.assert v < @count
+    end
+    @solver.assert Z3.Distinct(*vars)
+    @dict[name] = vals
+    @vars[name] = vars
+  end
+
+  def has_key?(key)
+    @vars.has_key?(key)
+  end
+
+  def attribute(idx, key, val)
+    raise "Attribute #{key} not defined" unless @vars.has_key?(key)
+    val_idx = @dict[key].index(val) or raise "Value #{val} for attribute #{key} not possible"
+    @vars[key][idx] == val_idx
+  end
+
+  def solve!
+    add_assertions!
+    if @solver.check == :sat
+      @solver.model.each do |k,v|
+        i, name = k.split("-", 2)
+        puts "#{k} = #{@dict[name][v.to_i]}"
+      end
+    else
+      puts "Puzzle has no solutions"
+    end
+  end
+
+  def implies!(a, b)
+    @solver.assert Z3.Implies(a, b)
+  end
+end
+
+class FourHackersPuzzle < LogicPuzzle
+  def initialize
+    super(4)
+    attribute_values *%W[name Armand Dragonene Frogger Phineus]
+    attribute_values *%W[alias Badger Griffin Lennard Monks]
+    attribute_values *%W[country Belgium England Norway Yemen]
+    attribute_values *%W[language C Java Lisp Perl]
+    attribute_values *%W[amount 10000 80000 160000 640000]
+  end
+
+  def add_assertions!
+    each do |hacker|
+      implies!( hacker.name("Phineus"), hacker.amount("10000") )
+      implies!( hacker.alias("Lennard"), hacker.amount("160000") )
+      implies!( hacker.alias("Lennard"), ~hacker.country("England") )
+      # 2nd connection less money transferred than C coder
+      implies!( hacker.language("C"), @cases[1].amount < hacker.amount )
+      implies!( hacker.language("C"), ~hacker.country("Norway") )
+      implies!( hacker.name("Armand"), hacker.alias("Monks") )
+    end
+
+    # Armand stole more than Frogger
+    each do |a|
+      each do |b|
+        implies!(
+          a.name("Armand") & b.name("Frogger"),
+          a.amount > b.amount
+        )
+      end
+    end
+
+    each do |hacker|
+      implies!( hacker.name("Dragonene"), hacker.country("Belgium") )
+    end
+
+    # Dragonene less money than Perl coder
+    each do |a|
+      each do |b|
+        implies!(
+          a.name("Dragonene") & b.language("Perl"),
+          a.amount < b.amount
+        )
+      end
+    end
+    # perl coder made the connection before Dragonene?
+    each do |a|
+      each do |b|
+        implies!(
+          a.name("Dragonene") & b.language("Perl"),
+          a.index > b.index
+        )
+      end
+    end
+    # Lisp coder more money than Griffin
+    each do |a|
+      each do |b|
+        implies!(
+          a.alias("Griffin") & b.language("Lisp"),
+          a.amount < b.amount
+        )
+      end
+    end
+    # 3rd connection used Java
+    @solver.assert @cases[2].language("Java")
+    # Badger stole more than Yemen coder
+    each do |a|
+      each do |b|
+        implies!(
+          a.alias("Badger") & b.country("Yemen"),
+          a.amount > b.amount
+        )
+      end
+    end
+  end
+end
+
+FourHackersPuzzle.new.solve!
+
+"""
+There is little we can do but wait, so we may as well take another job.
+It seems there has been a bank robbery. Scotland Yard has turned to us for help in figuring out who did it.
+We have been the given the following information:
+
+    There were 4 hackers each connecting one after another.
+    Each hacker has a name and another alias too.
+    Each hacker connected from a different country.
+    Each hacker connected using a different programming language.
+    Each hacker transferred a different amount of money.
+
+    The 4 hacker names: Armand Dragonene Frogger Phineus
+    The 4 hacker aliases: Badger Griffin Lennard Monks
+    The 4 countries: Belgium England Norway Yemen
+    The 4 coding langauges: C Java Lisp Perl
+    The 4 amounts: 10000 80000 160000 640000
+    You must also determine the order the hackers connected: 1st, 2nd, 3rd, 4th
+
+Perhaps following the news may help. The attacks all took place on the 29th, but the newspapers reported it for a couple of days afterwards as they found new information:
+
+https://www.sabrefilms.co.uk/revolutionelite/casefiles/case9/img1.jpg
+https://www.sabrefilms.co.uk/revolutionelite/casefiles/case9/img2.jpg
+https://www.sabrefilms.co.uk/revolutionelite/casefiles/case9/img3.jpg
+
+--------------------------------------------------------------------------------
+Extracted rules:
+  Phineus => 10000
+  Lennard => 160000 && !England
+  2nd connection less money transferred than C coder
+  C coder !Norwary
+  Armand (Monks)
+  Armand stole more than Frogger
+  Dragonene => Belgium
+  Dragonene less money than Perl coder
+  perl coder made the connection before Dragonene?
+  Lisp coder more money than Griffin
+  3rd connection used Java
+  Badger stole more than Yemen coder
+"""

data/examples/geometry_problem

@@ -4,17 +4,17 @@ require_relative "../lib/z3"
 
 solver = Z3::Solver.new
 
-ax = Z3::Ast.real("a.x")
-ay = Z3::Ast.real("a.y")
-bx = Z3::Ast.real("b.x")
-by = Z3::Ast.real("b.y")
-cx = Z3::Ast.real("c.x")
-cy = Z3::Ast.real("c.y")
-dx = Z3::Ast.real("d.x")
-dy = Z3::Ast.real("d.y")
-
-a_c = Z3::Ast.real("|a-c|")
-b_d = Z3::Ast.real("|b-d|")
+ax = Z3.Real("a.x")
+ay = Z3.Real("a.y")
+bx = Z3.Real("b.x")
+by = Z3.Real("b.y")
+cx = Z3.Real("c.x")
+cy = Z3.Real("c.y")
+dx = Z3.Real("d.x")
+dy = Z3.Real("d.y")
+
+a_c = Z3.Real("|a-c|")
+b_d = Z3.Real("|b-d|")
 
 solver.assert(bx == 0)
 solver.assert(by == 0)

data/examples/kakuro_solver

@@ -87,7 +87,7 @@ class Kakuro
   end
 
   def cell_var(x,y)
-    v = Z3::Ast.int("c#{x},#{y}")
+    v = Z3.Int("c#{x},#{y}")
     @solver.assert v >= 1
     @solver.assert v <= 9
     v
@@ -103,8 +103,8 @@ class Kakuro
       y += dy
     end
     return if vs.empty?
-    @solver.assert Z3::Ast.distinct(*vs)
-    @solver.assert Z3::Ast.add(*vs) == sum
+    @solver.assert Z3.Distinct(*vs)
+    @solver.assert Z3.Add(*vs) == sum
   end
 end
 

data/examples/kinematics_problems

@@ -32,9 +32,9 @@ class KinematicsProblem01 < KinematicsProblem
   Determine the distance traveled before takeoff.
   """
   def solve!
-    a = Z3::Ast.real("a")
-    t = Z3::Ast.real("t")
-    d = Z3::Ast.real("d")
+    a = Z3.Real("a")
+    t = Z3.Real("t")
+    d = Z3.Real("d")
     assert a == 3.20
     assert t == 32.8
     assert d == a*t*t/2
@@ -47,9 +47,9 @@ class KinematicsProblem02 < KinematicsProblem
   A car starts from rest and accelerates uniformly over a time of 5.21 seconds for a distance of 110 m. Determine the acceleration of the car.
   """
   def solve!
-    a = Z3::Ast.real("a")
-    t = Z3::Ast.real("t")
-    d = Z3::Ast.real("d")
+    a = Z3.Real("a")
+    t = Z3.Real("t")
+    d = Z3.Real("d")
     assert d == a*t*t/2
     assert t == 5.21
     assert d == 110
@@ -63,10 +63,10 @@ class KinematicsProblem03 < KinematicsProblem
   If Upton free falls for 2.60 seconds, what will be his final velocity and how far will he fall?
   """
   def solve!
-    a = Z3::Ast.real("a")
-    t = Z3::Ast.real("t")
-    v = Z3::Ast.real("v")
-    d = Z3::Ast.real("d")
+    a = Z3.Real("a")
+    t = Z3.Real("t")
+    v = Z3.Real("v")
+    d = Z3.Real("d")
     assert a == 9.81
     assert d == a*t*t/2
     assert v == a*t
@@ -80,11 +80,11 @@ class KinematicsProblem04 < KinematicsProblem
   A race car accelerates uniformly from 18.5 m/s to 46.1 m/s in 2.47 seconds. Determine the acceleration of the car and the distance traveled.
   """
   def solve!
-    a = Z3::Ast.real("a")
-    t = Z3::Ast.real("t")
-    vs= Z3::Ast.real("vs")
-    ve = Z3::Ast.real("ve")
-    d = Z3::Ast.real("d")
+    a = Z3.Real("a")
+    t = Z3.Real("t")
+    vs= Z3.Real("vs")
+    ve = Z3.Real("ve")
+    d = Z3.Real("d")
     assert vs == 18.5
     assert ve == 46.1
     assert t == 2.47
@@ -101,9 +101,9 @@ class KinematicsProblem05 < KinematicsProblem
   Determine the time for the feather to fall to the surface of the moon.
   """
   def solve!
-    a = Z3::Ast.real("a")
-    t = Z3::Ast.real("t")
-    d = Z3::Ast.real("d")
+    a = Z3.Real("a")
+    t = Z3.Real("t")
+    d = Z3.Real("d")
     assert a == 1.67
     assert d == 1.40
     assert t >= 0
@@ -119,10 +119,10 @@ class KinematicsProblem06 < KinematicsProblem
   then what is the acceleration and what is the distance that the sled travels?
   """
   def solve!
-    a = Z3::Ast.real("a")
-    t = Z3::Ast.real("t")
-    d = Z3::Ast.real("d")
-    v = Z3::Ast.real("v")
+    a = Z3.Real("a")
+    t = Z3.Real("t")
+    d = Z3.Real("d")
+    v = Z3.Real("v")
     assert v == 444
     assert t == 1.83
     assert v == a*t
@@ -137,10 +137,10 @@ class KinematicsProblem07 < KinematicsProblem
   Determine the acceleration of the bike.
   """
   def solve!
-    a = Z3::Ast.real("a")
-    t = Z3::Ast.real("t")
-    d = Z3::Ast.real("d")
-    v = Z3::Ast.real("v")
+    a = Z3.Real("a")
+    t = Z3.Real("t")
+    d = Z3.Real("d")
+    v = Z3.Real("v")
     assert v == 7.10
     assert d == 35.4
     assert a*t == v
@@ -157,10 +157,10 @@ class KinematicsProblem08 < KinematicsProblem
   Assuming this minimum acceleration, what is the minimum allowed length for the runway?
   """
   def solve!
-    a = Z3::Ast.real("a")
-    t = Z3::Ast.real("t")
-    d = Z3::Ast.real("d")
-    v = Z3::Ast.real("v")
+    a = Z3.Real("a")
+    t = Z3.Real("t")
+    d = Z3.Real("d")
+    v = Z3.Real("v")
     assert a == 3
     assert v == 65
     assert a*t == v
@@ -175,9 +175,9 @@ class KinematicsProblem09 < KinematicsProblem
   Determine the skidding distance of the car (assume uniform acceleration).
   """
   def solve!
-    t = Z3::Ast.real("t")
-    d = Z3::Ast.real("d")
-    v = Z3::Ast.real("v")
+    t = Z3.Real("t")
+    d = Z3.Real("d")
+    v = Z3.Real("v")
     assert v == 22.4
     assert t == 2.55
     assert d == t*v/2
@@ -191,10 +191,10 @@ class KinematicsProblem10 < KinematicsProblem
   Determine the takeoff speed of the kangaroo.
   """
   def solve!
-    a = Z3::Ast.real("a")
-    t = Z3::Ast.real("t")
-    d = Z3::Ast.real("d")
-    v = Z3::Ast.real("v")
+    a = Z3.Real("a")
+    t = Z3.Real("t")
+    d = Z3.Real("d")
+    v = Z3.Real("v")
     assert d == 2.62
     assert a == -9.81
     assert d == v*t/2

data/examples/letter_connections_solver

@@ -74,29 +74,29 @@ class LetterConnections
         if x == 0
           @solver.assert @dir[[x,y]] != 0
         else
-          @solver.assert Z3::Ast.implies(@dir[[x,y]] == 0, @line[[x,y]] == @line[[x-1,y]])
-          @solver.assert Z3::Ast.implies(@dir[[x,y]] == 0, @dir[[x-1,y]] != 2)
+          @solver.assert Z3.Implies(@dir[[x,y]] == 0, @line[[x,y]] == @line[[x-1,y]])
+          @solver.assert Z3.Implies(@dir[[x,y]] == 0, @dir[[x-1,y]] != 2)
         end
         # Direction Up
         if y == 0
           @solver.assert @dir[[x,y]] != 1
         else
-          @solver.assert Z3::Ast.implies(@dir[[x,y]] == 1, @line[[x,y]] == @line[[x,y-1]])
-          @solver.assert Z3::Ast.implies(@dir[[x,y]] == 1, @dir[[x,y-1]] != 3)
+          @solver.assert Z3.Implies(@dir[[x,y]] == 1, @line[[x,y]] == @line[[x,y-1]])
+          @solver.assert Z3.Implies(@dir[[x,y]] == 1, @dir[[x,y-1]] != 3)
         end
         # Direction Right
         if x == @xsize - 1
           @solver.assert @dir[[x,y]] != 2
         else
-          @solver.assert Z3::Ast.implies(@dir[[x,y]] == 2, @line[[x,y]] == @line[[x+1,y]])
-          @solver.assert Z3::Ast.implies(@dir[[x,y]] == 2, @dir[[x+1,y]] != 0)
+          @solver.assert Z3.Implies(@dir[[x,y]] == 2, @line[[x,y]] == @line[[x+1,y]])
+          @solver.assert Z3.Implies(@dir[[x,y]] == 2, @dir[[x+1,y]] != 0)
         end
         # Direction Down
         if y == @ysize - 1
           @solver.assert @dir[[x,y]] != 3
         else
-          @solver.assert Z3::Ast.implies(@dir[[x,y]] == 3, @line[[x,y]] == @line[[x,y+1]])
-          @solver.assert Z3::Ast.implies(@dir[[x,y]] == 3, @dir[[x,y+1]] != 1)
+          @solver.assert Z3.Implies(@dir[[x,y]] == 3, @line[[x,y]] == @line[[x,y+1]])
+          @solver.assert Z3.Implies(@dir[[x,y]] == 3, @dir[[x,y+1]] != 1)
         end
       end
     end
@@ -128,14 +128,14 @@ class LetterConnections
   end
 
   def line_var(x, y)
-    v = Z3::Ast.int("l#{x},#{y}")
+    v = Z3.Int("l#{x},#{y}")
     @solver.assert v >= 0
     @solver.assert v < @letters.size
     v
   end
 
   def dir_var(x, y)
-    v = Z3::Ast.int("d#{x},#{y}")
+    v = Z3.Int("d#{x},#{y}")
     @solver.assert v >= 0
     @solver.assert v <= 3
     v
@@ -154,7 +154,7 @@ class LetterConnections
 
   # Surely Z3 must have a thing for it
   def condition_exactly_one(conds)
-    @solver.assert Z3::Ast.or(*conds)
+    @solver.assert Z3.Or(*conds)
     (0...conds.size).each do |ci|
       (0...conds.size).each do |cj|
         if ci < cj

data/examples/light_up_solver

@@ -22,7 +22,7 @@ class LightUp
         next if v == "."
         @solver.assert @lamps[[x,y]] == 0
         if ("0".."4").include?(v)
-          @solver.assert Z3::Ast.add(*lamps_next_to_cell(x,y)) == v.to_i
+          @solver.assert Z3.Add(*lamps_next_to_cell(x,y)) == v.to_i
         end
       end
     end
@@ -31,9 +31,9 @@ class LightUp
     # No lamp is in raycast of another lamp
     (0...@ysize).each do |y|
       (0...@xsize).each do |x|
-        raycast = Z3::Ast.add(*raycast_cells(x,y))
-        @solver.assert Z3::Ast.implies(@lamps[[x,y]] == 0, raycast >= 1)
-        @solver.assert Z3::Ast.implies(@lamps[[x,y]] == 1, raycast == 0)
+        raycast = Z3.Add(*raycast_cells(x,y))
+        @solver.assert Z3.Implies(@lamps[[x,y]] == 0, raycast >= 1)
+        @solver.assert Z3.Implies(@lamps[[x,y]] == 1, raycast == 0)
       end
     end
 
@@ -85,7 +85,7 @@ class LightUp
   end
 
   def int01(x,y)
-    v = Z3::Ast.int("l#{x},#{y}")
+    v = Z3.Int("l#{x},#{y}")
     @solver.assert v >= 0
     @solver.assert v <= 1
     v

data/examples/minisudoku_solver

@@ -16,14 +16,14 @@ class MiniSudokuSolver
     end
 
     @cells.each do |row|
-      @solver.assert Z3::Ast.distinct(*row)
+      @solver.assert Z3.Distinct(*row)
     end
     @cells.transpose.each do |column|
-      @solver.assert Z3::Ast.distinct(*column)
+      @solver.assert Z3.Distinct(*column)
     end
     @cells.each_slice(2) do |rows|
       rows.transpose.each_slice(3) do |square|
-        @solver.assert Z3::Ast.distinct(*square.flatten)
+        @solver.assert Z3.Distinct(*square.flatten)
       end
     end
 
@@ -38,7 +38,7 @@ class MiniSudokuSolver
   private
 
   def cell_var(cell, i, j)
-    v = Z3::Ast.int("cell[#{i+1},#{j+1}]")
+    v = Z3.Int("cell[#{i+1},#{j+1}]")
     @solver.assert v >= 1
     @solver.assert v <= 6
     @solver.assert v == cell if cell != nil

data/examples/selfref_solver

@@ -10,12 +10,12 @@ class SelfRefPuzzleSolver
     @q = {}
     @a = {}
     (1..20).each do |i|
-      @q[i] = Z3::Ast.int("q#{i}")
+      @q[i] = Z3.Int("q#{i}")
       assert @q[i] >= 1
       assert @q[i] <= 5
       @a[i] = {}
       (1..5).each do |j|
-        @a[i][j] = Z3::Ast.int("a#{i},#{' ABCDE'[j]}")
+        @a[i][j] = Z3.Int("a#{i},#{' ABCDE'[j]}")
         assert (@a[i][j] == 0) == (@q[i] != j)
         assert (@a[i][j] == 1) == (@q[i] == j)
       end
@@ -27,23 +27,23 @@ class SelfRefPuzzleSolver
   end
 
   def cons_in(*ary)
-    Z3::Ast.or(*ary.map{|i| cons_answers == i})
+    Z3.Or(*ary.map{|i| cons_answers == i})
   end
 
   def solve!
-    @a_answers = Z3::Ast.add(*(1..20).map{|i| @a[i][1]})
-    @b_answers = Z3::Ast.add(*(1..20).map{|i| @a[i][2]})
-    @c_answers = Z3::Ast.add(*(1..20).map{|i| @a[i][3]})
-    @d_answers = Z3::Ast.add(*(1..20).map{|i| @a[i][4]})
-    @e_answers = Z3::Ast.add(*(1..20).map{|i| @a[i][5]})
+    @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]})
+    @d_answers = Z3.Add(*(1..20).map{|i| @a[i][4]})
+    @e_answers = Z3.Add(*(1..20).map{|i| @a[i][5]})
     @cons_answers = b_answers + c_answers + d_answers
 
     # Question 1
     assert (q[1] == 1) == (q[1] == 2)
-    assert (q[1] == 2) == Z3::Ast.and(q[1] != 2, q[2] == 2)
-    assert (q[1] == 3) == Z3::Ast.and(q[1] != 2, q[2] != 2, q[3] == 2)
-    assert (q[1] == 4) == Z3::Ast.and(q[1] != 2, q[2] != 2, q[3] != 2, q[4] == 2)
-    assert (q[1] == 5) == Z3::Ast.and(q[1] != 2, q[2] != 2, q[3] != 2, q[4] != 2, q[5] == 2)
+    assert (q[1] == 2) == Z3.And(q[1] != 2, q[2] == 2)
+    assert (q[1] == 3) == Z3.And(q[1] != 2, q[2] != 2, q[3] == 2)
+    assert (q[1] == 4) == Z3.And(q[1] != 2, q[2] != 2, q[3] != 2, q[4] == 2)
+    assert (q[1] == 5) == Z3.And(q[1] != 2, q[2] != 2, q[3] != 2, q[4] != 2, q[5] == 2)
 
     # Question 2
     assert q[ 1] != q[ 2]
@@ -81,25 +81,25 @@ class SelfRefPuzzleSolver
     assert (a_answers == 8) == (q[4] == 5)
 
     # Question 5
-    assert Z3::Ast.implies(q[5] == 1, q[5] == q[1])
-    assert Z3::Ast.implies(q[5] == 2, q[5] == q[2])
-    assert Z3::Ast.implies(q[5] == 3, q[5] == q[3])
-    assert Z3::Ast.implies(q[5] == 4, q[5] == q[4])
-    assert Z3::Ast.implies(q[5] == 5, q[5] == q[5])
+    assert Z3.Implies(q[5] == 1, q[5] == q[1])
+    assert Z3.Implies(q[5] == 2, q[5] == q[2])
+    assert Z3.Implies(q[5] == 3, q[5] == q[3])
+    assert Z3.Implies(q[5] == 4, q[5] == q[4])
+    assert Z3.Implies(q[5] == 5, q[5] == q[5])
 
     # Question 6
     assert (q[17] == 3) == (q[6] == 1)
     assert (q[17] == 4) == (q[6] == 2)
     assert (q[17] == 5) == (q[6] == 3)
-    assert Z3::Ast.or(q[17] == 1, q[17] == 2) == (q[6] == 4)
+    assert Z3.Or(q[17] == 1, q[17] == 2) == (q[6] == 4)
     assert q[6] != 5
 
     # Question 7
-    assert Z3::Ast.or(q[7] - q[8] == 4, q[8] - q[7] == 4) == (q[7] == 1)
-    assert Z3::Ast.or(q[7] - q[8] == 3, q[8] - q[7] == 3) == (q[7] == 2)
-    assert Z3::Ast.or(q[7] - q[8] == 2, q[8] - q[7] == 2) == (q[7] == 3)
-    assert Z3::Ast.or(q[7] - q[8] == 1, q[8] - q[7] == 1) == (q[7] == 4)
-    assert Z3::Ast.or(q[7] - q[8] == 0, q[8] - q[7] == 0) == (q[7] == 5)
+    assert Z3.Or(q[7] - q[8] == 4, q[8] - q[7] == 4) == (q[7] == 1)
+    assert Z3.Or(q[7] - q[8] == 3, q[8] - q[7] == 3) == (q[7] == 2)
+    assert Z3.Or(q[7] - q[8] == 2, q[8] - q[7] == 2) == (q[7] == 3)
+    assert Z3.Or(q[7] - q[8] == 1, q[8] - q[7] == 1) == (q[7] == 4)
+    assert Z3.Or(q[7] - q[8] == 0, q[8] - q[7] == 0) == (q[7] == 5)
 
     # Question 8
     assert (a_answers + e_answers == 4) == (q[8] == 1)
@@ -110,10 +110,10 @@ class SelfRefPuzzleSolver
 
     # Question 9
     assert (q[10] == q[9]) == (q[9] == 1)
-    assert Z3::Ast.and(q[10] != q[9], q[11] == q[9]) == (q[9] == 2)
-    assert Z3::Ast.and(q[10] != q[9], q[11] != q[9], q[12] == q[9]) == (q[9] == 3)
-    assert Z3::Ast.and(q[10] != q[9], q[11] != q[9], q[12] != q[9], q[13] == q[9]) == (q[9] == 4)
-    assert Z3::Ast.and(q[10] != q[9], q[11] != q[9], q[12] != q[9], q[13] != q[9], q[14] == q[9]) == (q[9] == 5)
+    assert Z3.And(q[10] != q[9], q[11] == q[9]) == (q[9] == 2)
+    assert Z3.And(q[10] != q[9], q[11] != q[9], q[12] == q[9]) == (q[9] == 3)
+    assert Z3.And(q[10] != q[9], q[11] != q[9], q[12] != q[9], q[13] == q[9]) == (q[9] == 4)
+    assert Z3.And(q[10] != q[9], q[11] != q[9], q[12] != q[9], q[13] != q[9], q[14] == q[9]) == (q[9] == 5)
 
     # Question 10
     assert (q[16] == 4) == (q[10] == 1)
@@ -123,7 +123,7 @@ class SelfRefPuzzleSolver
     assert (q[16] == 3) == (q[10] == 5)
 
     # Question 11
-    prec_b_answers = Z3::Ast.add(*(1..10).map{|i| @a[i][2]})
+    prec_b_answers = Z3.Add(*(1..10).map{|i| @a[i][2]})
     assert (prec_b_answers == 0) == (q[11] == 1)
     assert (prec_b_answers == 1) == (q[11] == 2)
     assert (prec_b_answers == 2) == (q[11] == 3)
@@ -131,11 +131,11 @@ class SelfRefPuzzleSolver
     assert (prec_b_answers == 4) == (q[11] == 5)
 
     # Question 12
-    assert Z3::Ast.implies(q[12] == 1, cons_in(2,4,6,8,10,12,14,16,18,20))
-    assert Z3::Ast.implies(q[12] == 2, cons_in(1,3,5,7,9,11,13,15,17,19))
-    assert Z3::Ast.implies(q[12] == 3, cons_in(1,4,9,16))
-    assert Z3::Ast.implies(q[12] == 4, cons_in(2,3,5,7,11,13,17,19))
-    assert Z3::Ast.implies(q[12] == 5, cons_in(5,10,15,20))
+    assert Z3.Implies(q[12] == 1, cons_in(2,4,6,8,10,12,14,16,18,20))
+    assert Z3.Implies(q[12] == 2, cons_in(1,3,5,7,9,11,13,15,17,19))
+    assert Z3.Implies(q[12] == 3, cons_in(1,4,9,16))
+    assert Z3.Implies(q[12] == 4, cons_in(2,3,5,7,11,13,17,19))
+    assert Z3.Implies(q[12] == 5, cons_in(5,10,15,20))
 
     # Question 13
     assert q[1] != 1
@@ -170,7 +170,7 @@ class SelfRefPuzzleSolver
     assert (q[6] == 3) == (q[17] == 1)
     assert (q[6] == 4) == (q[17] == 2)
     assert (q[6] == 5) == (q[17] == 3)
-    assert Z3::Ast.and(q[6] != 3, q[6] != 4, q[6] != 5) == (q[17] == 4)
+    assert Z3.And(q[6] != 3, q[6] != 4, q[6] != 5) == (q[17] == 4)
     assert q[17] != 5
 
     # Question 18
@@ -178,7 +178,7 @@ class SelfRefPuzzleSolver
     assert (a_answers == c_answers) == (q[18] == 2)
     assert (a_answers == d_answers) == (q[18] == 3)
     assert (a_answers == e_answers) == (q[18] == 4)
-    assert Z3::Ast.and(
+    assert Z3.And(
       a_answers != b_answers,
       a_answers != c_answers,
       a_answers != d_answers,

data/examples/sudoku_solver

@@ -16,14 +16,14 @@ class SudokuSolver
     end
 
     @cells.each do |row|
-      @solver.assert Z3::Ast.distinct(*row)
+      @solver.assert Z3.Distinct(*row)
     end
     @cells.transpose.each do |column|
-      @solver.assert Z3::Ast.distinct(*column)
+      @solver.assert Z3.Distinct(*column)
     end
     @cells.each_slice(3) do |rows|
       rows.transpose.each_slice(3) do |square|
-        @solver.assert Z3::Ast.distinct(*square.flatten)
+        @solver.assert Z3.Distinct(*square.flatten)
       end
     end
 
@@ -38,7 +38,7 @@ class SudokuSolver
   private
 
   def cell_var(cell, i, j)
-    v = Z3::Ast.int("cell[#{i+1},#{j+1}]")
+    v = Z3.Int("cell[#{i+1},#{j+1}]")
     @solver.assert v >= 1
     @solver.assert v <= 9
     @solver.assert v == cell if cell != nil