z3 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9155c71b227576436cf55fe332fb04748bf8a2ed
+  data.tar.gz: bf1c5200d857ed21311d2f5cb468e8cceac2f627
+SHA512:
+  metadata.gz: 67c4b499c50f0c288900667f13bcdcca543629d55332a6247011c8e135b1d9b41a4865f9900e2884155aa28844492c3fcb1d5aacad775e1b556e3d1a6a265d3a
+  data.tar.gz: 88e74e1966920896bc2ca0ec8a2712c8180aeb79a97be8551aceb69b21016df907a579091fded5b688f8ebc8bdd3ad4ede8037f6a4458b7fa1831081b5f2bcee

data/README.md

@@ -0,0 +1,27 @@
+This is Ruby interface for Z3 [ https://github.com/Z3Prover/z3 ].
+
+It's in extremely 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 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 ASTs, but use `~ | &` instead of `! || &&` for boolean operators.
+
+As for API internals, attributes starting with `_` are FFI internals you shouldn't touch, other attributes are generally legitimate Ruby objects.
+
+### Requirements
+
+To use it, you'll need to install `z3`. On OSX that would be:
+
+    brew install z3
+
+On other systems use appropriate package manager.
+
+### Known Bugs
+
+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.
+
+Memory will leak a good deal. Generally avoid in long running processes.

data/examples/algebra_problems

@@ -0,0 +1,148 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/z3"
+
+class AlgebraProblem
+  attr_reader :solver
+  def initialize
+    @solver = Z3::Solver.new
+  end
+
+  def print_solution!(number)
+    puts("Solution to problem %s:" % number)
+    if @solver.check() == :sat
+      @solver.model.each do |n,v|
+        puts "* #{n} = #{v}"
+      end
+    else
+      puts "* Can't solve the problem"
+    end
+  end
+end
+
+class AlgebraProblem01 < AlgebraProblem
+  def solve!
+    x = Z3::Ast.real("x")
+    solver.assert 5*(-3*x - 2) - (x - 3) == -4*(4*x + 5) + 13
+    print_solution! "01"
+    # No nice way to say x is unconstrained
+  end
+end
+
+class AlgebraProblem03 < AlgebraProblem
+  def declare_abs(var, expr)
+    solver.assert Z3::Ast.or(
+      Z3::Ast.and(var == expr,  expr >= 0),
+      Z3::Ast.and(var == -expr, expr <= 0)
+    )
+  end
+
+  def solve!
+    x = Z3::Ast.real("x")
+    xm2abs = Z3::Ast.real("|x-2|")
+    declare_abs(xm2abs, x-2)
+    m6abs = Z3::Ast.real("|-6|")
+    declare_abs(m6abs, -6)
+    solver.assert x < 2
+    solver.assert xm2abs == 4*m6abs
+    print_solution! "03"
+  end
+end
+
+class AlgebraProblem04 < AlgebraProblem
+  def declare_distance(a_b, ax, ay, bx, by)
+    solver.assert a_b >= 0
+    solver.assert a_b**2 == (ax-bx)**2 + (ay-by)**2
+  end
+
+  def solve!
+    ax = Z3::Ast.real("ax")
+    ay = Z3::Ast.real("ay")
+    bx = Z3::Ast.real("bx")
+    by = Z3::Ast.real("by")
+    a_b = Z3::Ast.real("|a-b|")
+    declare_distance(a_b, ax, ay, bx, by)
+    solver.assert ax == -4
+    solver.assert ay == -5
+    solver.assert bx == -1
+    solver.assert by == -1
+    print_solution! "04"
+  end
+end
+
+class AlgebraProblem05 < AlgebraProblem
+  def solve!
+    x = Z3::Ast.real("x")
+    y = Z3::Ast.real("y")
+    solver.assert 2*x - 4*y == 9
+    solver.assert y == 0
+    print_solution! "05"
+  end
+end
+
+class AlgebraProblem06 < AlgebraProblem
+  def declare_f(x,y)
+    solver.assert y == 6*x + 1
+  end
+
+  def solve!
+    x1 = Z3::Ast.real("x1")
+    y1 = Z3::Ast.real("y1")
+    x2 = Z3::Ast.real("x2")
+    y2 = Z3::Ast.real("y2")
+    answer = Z3::Ast.real("answer")
+    solver.assert x2 == 2
+    solver.assert x1 == 1
+    declare_f(x1, y1)
+    declare_f(x2, y2)
+    solver.assert answer == y2 - y1
+    print_solution! "06"
+  end
+end
+
+class AlgebraProblem10 < AlgebraProblem
+  def declare_abs(var, expr)
+    solver.assert Z3::Ast.or(
+      Z3::Ast.and(var == expr,  expr >= 0),
+      Z3::Ast.and(var == -expr, expr <= 0)
+    )
+  end
+
+  def solve!
+    x = Z3::Ast.real("x")
+    y = Z3::Ast.real("|-2x + 2|")
+    declare_abs(y, -2*x + 2)
+    solver.assert y - 3 == -3
+    print_solution! "10"
+  end
+end
+
+AlgebraProblem01.new.solve!
+AlgebraProblem03.new.solve!
+AlgebraProblem04.new.solve!
+AlgebraProblem05.new.solve!
+AlgebraProblem06.new.solve!
+AlgebraProblem10.new.solve!
+
+"""
+http://www.analyzemath.com/Algebra1/Algebra1.html
+
+
+Problem 1: Solve the equation
+  5(-3x - 2) - (x - 3) = -4(4x + 5) + 13
+
+Problem 3: If x <2, simplify
+  |x - 2| = 4|-6|
+(actually I misread original, whatever)
+
+Problem 4: Find the distance between the points (-4 , -5) and (-1 , -1).
+
+Problem 5: Find the x intercept of the graph of the equation
+  2x - 4y = 9
+
+Problem 6: Evaluate f(2) - f(1)
+  f(x) = 6x + 1
+
+Problem 10: Solve the equation
+  |-2x + 2| -3 = -3
+"""

data/examples/basic_int_math

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/z3"
+
+def check_multiplication_laws_1
+  a = Z3::Ast.int("a")
+  b = Z3::Ast.int("b")
+  solver = Z3::Solver.new
+  puts "Checking if (a+b)(a-b)==a*a-b*b"
+  solver.prove!(
+    (a+b)*(a-b) == (a*a - b*b)
+  )
+end
+
+def check_inequalities
+  a = Z3::Ast.int("a")
+  b = Z3::Ast.int("b")
+  solver = Z3::Solver.new
+  puts "Checking if a+b >= a"
+  solver.prove!(a+b >= a)
+
+  solver = Z3::Solver.new
+  solver.assert(a >= 0)
+  solver.assert(b >= 0)
+  puts "Checking if a+b >= a if a,b >= 0"
+  solver.prove!(a+b >= a)
+end
+
+check_multiplication_laws_1
+check_inequalities

data/examples/basic_logic

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/z3"
+
+def check_if_true_is_true
+  a = Z3::Ast.true
+  b = Z3::Ast.true
+  solver = Z3::Solver.new
+  puts "Checking if true == true"
+  solver.prove!(a == b)
+end
+
+def check_if_true_is_false
+  a = Z3::Ast.true
+  b = Z3::Ast.false
+  solver = Z3::Solver.new
+  puts "Checking if true == false"
+  solver.prove!(a==b)
+end
+
+# We prove it by checking that negation is unsatisfiable
+def check_de_morgan_law_1
+  a = Z3::Ast::bool("a")
+  b = Z3::Ast::bool("b")
+  solver = Z3::Solver.new
+  puts "Proving ~(a & b) == (~a | ~b)"
+  solver.prove!(~(a & b) == (~a | ~b))
+end
+
+def check_de_morgan_law_2
+  a = Z3::Ast::bool("a")
+  b = Z3::Ast::bool("b")
+  solver = Z3::Solver.new
+  puts "Proving ~(a | b) == (~a & ~b)"
+  solver.prove!(~(a | b) == (~a & ~b))
+end
+
+check_if_true_is_true
+check_if_true_is_false
+check_de_morgan_law_1
+check_de_morgan_law_2

data/examples/geometry_problem

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+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|")
+
+solver.assert(bx == 0)
+solver.assert(by == 0)
+solver.assert(cx == 10)
+solver.assert(cy == 0)
+solver.assert(dx == cx)
+solver.assert(ay == dy)
+solver.assert(ax == 0)
+
+# BD is on the circle
+solver.assert(b_d**2 == (bx-dx)**2 + (by-dy)**2)
+solver.assert(b_d == 20)
+
+solver.assert(a_c**2 == (ax-cx)**2 + (ay-cy)**2)
+
+if solver.check == :sat
+  model = solver.model
+  model.each do |n,v|
+    puts "* #{n} = #{v}"
+  end
+else
+  puts "Can't solve the problem"
+end

data/examples/kinematics_problems

@@ -0,0 +1,219 @@
+#!/usr/bin/env ruby
+
+# Problems from: http://www.physicsclassroom.com/class/1DKin/Lesson-6/Sample-Problems-and-Solutions
+
+require_relative "../lib/z3"
+
+class KinematicsProblem
+  attr_reader :solver
+  def initialize
+    @solver = Z3::Solver.new
+  end
+
+  def assert(ast)
+    @solver.assert(ast)
+  end
+
+  def print_solution!(number)
+    puts("Solution to problem %s:" % number)
+    if @solver.check() == :sat
+      @solver.model.each do |n,v|
+        puts "* #{n} = #{v}"
+      end
+    else
+      puts "* Can't solve the problem"
+    end
+  end
+end
+
+class KinematicsProblem01 < KinematicsProblem
+  """
+  An airplane accelerates down a runway at 3.20 m/s2 for 32.8 s until is finally lifts off the ground.
+  Determine the distance traveled before takeoff.
+  """
+  def solve!
+    a = Z3::Ast.real("a")
+    t = Z3::Ast.real("t")
+    d = Z3::Ast.real("d")
+    assert a == 3.20
+    assert t == 32.8
+    assert d == a*t*t/2
+    print_solution! "01"
+  end
+end
+
+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")
+    assert d == a*t*t/2
+    assert t == 5.21
+    assert d == 110
+    print_solution! "02"
+  end
+end
+
+class KinematicsProblem03 < KinematicsProblem
+  """
+  Upton Chuck is riding the Giant Drop at Great America.
+  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")
+    assert a == 9.81
+    assert d == a*t*t/2
+    assert v == a*t
+    assert t == 2.60
+    print_solution! "03"
+  end
+end
+
+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")
+    assert vs == 18.5
+    assert ve == 46.1
+    assert t == 2.47
+    assert a == (ve-vs)/t
+    assert d == (vs+ve)/2*t
+    print_solution! "04"
+  end
+end
+
+class KinematicsProblem05 < KinematicsProblem
+  """
+  A feather is dropped on the moon from a height of 1.40 meters.
+  The acceleration of gravity on the moon is 1.67 m/s2.
+  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")
+    assert a == 1.67
+    assert d == 1.40
+    assert t >= 0
+    assert d == a*t*t/2
+    print_solution! "05"
+  end
+end
+
+class KinematicsProblem06 < KinematicsProblem
+  """
+  Rocket-powered sleds are used to test the human response to acceleration.
+  If a rocket-powered sled is accelerated to a speed of 444 m/s in 1.83 seconds,
+  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")
+    assert v == 444
+    assert t == 1.83
+    assert v == a*t
+    assert d == a*t*t/2
+    print_solution! "06"
+  end
+end
+
+class KinematicsProblem07 < KinematicsProblem
+  """
+  A bike accelerates uniformly from rest to a speed of 7.10 m/s over a distance of 35.4 m.
+  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")
+    assert v == 7.10
+    assert d == 35.4
+    assert a*t == v
+    assert t*v/2 == d
+    print_solution! "07"
+  end
+end
+
+class KinematicsProblem08 < KinematicsProblem
+  """
+  An engineer is designing the runway for an airport.
+  Of the planes that will use the airport, the lowest acceleration rate is likely to be 3 m/s2.
+  The takeoff speed for this plane will be 65 m/s.
+  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")
+    assert a == 3
+    assert v == 65
+    assert a*t == v
+    assert t*v/2 == d
+    print_solution! "08"
+  end
+end
+
+class KinematicsProblem09 < KinematicsProblem
+  """
+  A car traveling at 22.4 m/s skids to a stop in 2.55 s.
+  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")
+    assert v == 22.4
+    assert t == 2.55
+    assert d == t*v/2
+    print_solution! "09"
+  end
+end
+
+class KinematicsProblem10 < KinematicsProblem
+  """
+  A kangaroo is capable of jumping to a height of 2.62 m.
+  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")
+    assert d == 2.62
+    assert a == -9.81
+    assert d == v*t/2
+    assert v + a*t == 0
+    assert t >= 0
+    print_solution! "10"
+  end
+end
+
+# This is actually param for Python Z3 printer, can't work until we get that
+# Z3.set_param("rational_to_decimal", true)
+
+KinematicsProblem01.new.solve!
+KinematicsProblem02.new.solve!
+KinematicsProblem03.new.solve!
+KinematicsProblem04.new.solve!
+KinematicsProblem05.new.solve!
+KinematicsProblem06.new.solve!
+KinematicsProblem07.new.solve!
+KinematicsProblem08.new.solve!
+KinematicsProblem09.new.solve!
+KinematicsProblem10.new.solve!

data/examples/light_up_solver

@@ -0,0 +1,105 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/z3"
+
+class LightUp
+  def initialize(data)
+    data = data.split.map{|line| line.strip.chars}
+    @xsize = data[0].size
+    @ysize = data.size
+    @data  = map_coordinates{|x,y| data[y][x]}
+    @solver = Z3::Solver.new
+  end
+
+  def solve!
+    @lamps = map_coordinates{|x,y| int01(x,y)}
+
+    # No lamps on walls
+    # Numbers count lamps next to node (diagonals don't count)
+    (0...@ysize).each do |y|
+      (0...@xsize).each do |x|
+        v = @data[[x,y]]
+        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
+        end
+      end
+    end
+
+    # Every cell is in raycast of a lamp
+    # 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)
+      end
+    end
+
+    if @solver.check == :sat
+      @model = @solver.model
+      print_answer!
+    else
+      puts "failed to solve"
+    end
+  end
+
+  private
+
+  def lamps_next_to_cell(x0,y0)
+    [[x0-1,y0],[x0+1,y0],[x0,y0-1],[x0,y0+1]].map{|x,y| @lamps[[x,y]]}.compact
+  end
+
+  def raycast_cells(x0,y0)
+    result = []
+    [[1,0],[-1,0],[0,1],[0,-1]].each do |dx,dy|
+      x = x0+dx
+      y = y0+dy
+      while @data[[x,y]] == "."
+        result << @lamps[[x,y]]
+        x += dx
+        y += dy
+      end
+    end
+    result
+  end
+
+  def map_coordinates
+    Hash[(0...@xsize).to_a.product((0...@ysize).to_a).map{|x,y| [[x,y],yield(x,y)]}]
+  end
+
+  def print_answer!
+    (0...@ysize).each do |y|
+      (0...@xsize).each do |x|
+        if @data[[x,y]] != "."
+          print(@data[[x,y]])
+        elsif @model[@lamps[[x,y]]].to_s == "1"
+          print("*")
+        else
+          print(" ")
+        end
+      end
+      puts "\n"
+    end
+  end
+
+  def int01(x,y)
+    v = Z3::Ast.int("l#{x},#{y}")
+    @solver.assert v >= 0
+    @solver.assert v <= 1
+    v
+  end
+end
+
+LightUp.new(
+"""
+....0..
+.......
+x.2.x..
+...3...
+..x.x.3
+.......
+..1....
+"""
+).solve!

data/examples/minisudoku_solver

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/z3"
+
+class MiniSudokuSolver
+  def initialize(data)
+    @data = data
+    @solver = Z3::Solver.new
+  end
+
+  def solve!
+    @cells = (0..5).map do |j|
+      (0..5).map do |i|
+        cell_var(@data[j][i], i, j)
+      end
+    end
+
+    @cells.each do |row|
+      @solver.assert Z3::Ast.distinct(*row)
+    end
+    @cells.transpose.each do |column|
+      @solver.assert Z3::Ast.distinct(*column)
+    end
+    @cells.each_slice(2) do |rows|
+      rows.transpose.each_slice(3) do |square|
+        @solver.assert Z3::Ast.distinct(*square.flatten)
+      end
+    end
+
+    if @solver.check == :sat
+      @model = @solver.model
+      print_answer!
+    else
+      puts "failed to solve"
+    end
+  end
+
+  private
+
+  def cell_var(cell, i, j)
+    v = Z3::Ast.int("cell[#{i+1},#{j+1}]")
+    @solver.assert v >= 1
+    @solver.assert v <= 6
+    @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
+
+_ = nil
+minisudoku = MiniSudokuSolver.new([
+  [_, _, _, 4, _, _],
+  [_, _, 4, 1, 2, _],
+  [_, _, 6, 5, 4, _],
+  [_, 5, 2, 3, _, _],
+  [_, 2, 3, 6, _, _],
+  [_, _, 1, _, _, _],
+])
+minisudoku.solve!