z3 0.0.20171020 → 0.0.20180203

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f60c524dca681eab09bf92ff91d055060c806c80
-  data.tar.gz: e93747a1a7d10f62d1f8384f625c005651eeaf2e
+SHA256:
+  metadata.gz: 82ddc6984f24ee79d2dcd7fba162818c0bce9959f6f7c4daad11305b09ac84b8
+  data.tar.gz: 977d33cbd061672c85297e19dba7612c2f67bc0b5785ab1a67da828f17678b65
 SHA512:
-  metadata.gz: c7282273ba2bc89bd26e7096104fde50487956994300765957495a0c123ca0f06897103512c01ab9121e3349715fe9bf02e71832a3a73a7d9664ae33d8a2c5a5
-  data.tar.gz: a44bdce9868882fee77cfc502d9c1e977dce11df27648025d06172512396c2c35ddd4b7b56ecefcd60a04d9012cd9db74e1f0eb06e2fdffc1cd2a416c89ddce5
+  metadata.gz: 49db1f83e829f4b982abb5aea5014f9b64f6e558ee945a3d4d451227004fbd562cc5cddda955b3148582bedc73e2d8e251bf1198f87454145fe22e889bb9eaba
+  data.tar.gz: edcd476f98a22595b6a60a11606aec007b7852b7447904413c57388f3a8d6d06c5a058cc72d115f85ce61ebcb57d02c51c66535928b30a6f7de78f5a94ccc852

data/README.md

@@ -20,6 +20,8 @@ To use it, you'll need to install `z3`. On OSX that would be:
 
 On other systems use appropriate package manager.
 
+*NB: On Linux, since FFI will look for `libz3.so`, you might need to install `libz3-dev`using your usual package manager.*
+
 ### Known Issues
 
 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.

data/examples/zebra_puzzle

@@ -0,0 +1,146 @@
+#!/usr/bin/env ruby
+
+# https://en.wikipedia.org/wiki/Zebra_Puzzle
+
+require_relative "../lib/z3"
+
+class ZebraPuzzle
+  def initialize
+    @solver = Z3::Solver.new
+  end
+
+  def traits
+    [:color, :nationality, :drink, :cigarettes, :pet]
+  end
+  
+  def color
+    ["red", "yellow", "green", "blue", "ivory"]
+  end
+  
+  def nationality
+    ["Englishman", "Spaniard", "Norwegian", "Ukrainian", "Japanese"]
+  end
+  
+  def drink
+    ["water", "coffee", "tea", "milk", "orange juice"]
+  end
+  
+  def pet
+    ["zebra", "dog", "snails", "fox", "horse"]
+  end
+  
+  def cigarettes
+    ["Parliaments", "Old Gold", "Lucky Strike", "Kools", "Chesterfields"]
+  end
+  
+  def trait_index(trait, name)
+    send(trait).index(name) or raise "Bad value #{name.inspect} for trait #{trait.inspect}"
+  end
+
+  def trait_value(trait, index)
+    send(trait)[index] or raise "Bad index #{index.inspect} for trait #{trait.inspect}"
+  end
+
+  # House I has TRAIT value X
+  def variable(trait, i)
+    Z3.Int("#{trait}-#{i}")
+  end
+
+  def setup_variables(trait)
+    vars = (0..4).map{|i| variable(trait, i) }
+    @solver.assert Z3.Distinct(*vars)
+    vars.each do |v|
+      @solver.assert v >= 0
+      @solver.assert v <= 4
+    end
+  end
+
+
+  def house_has_trait_value(i, trait, value)
+    index = trait_index(trait, value)
+    (variable(trait, i) == index)
+  end
+
+  def same_house(t1,v1,t2,v2)
+    (0..4).each do |i|
+      @solver.assert house_has_trait_value(i,t1,v1) == house_has_trait_value(i,t2,v2)
+    end
+  end
+  
+  def left_rigth_house(t1,v1,t2,v2)
+    (0..3).each do |i|
+      @solver.assert house_has_trait_value(i,t1,v1) == house_has_trait_value(i+1,t2,v2)
+    end
+  end
+
+  def next_house(t1,v1,t2,v2)
+    (0..4).each do |i|
+      opts = [i+1,i-1].grep(0..4).map{|j| house_has_trait_value(i,t1,v1) == house_has_trait_value(j,t2,v2) }
+      @solver.assert Z3.Or(*opts)
+    end
+  end
+
+  def call
+    traits.each do |trait|
+      setup_variables(trait)
+    end
+
+    same_house(:nationality, "Englishman", :color, "red")
+    same_house(:nationality, "Spaniard", :pet, "dog")
+    same_house(:drink, "coffee", :color, "green")
+    same_house(:nationality, "Ukrainian", :drink, "tea")
+    same_house(:pet, "snails", :cigarettes, "Old Gold")
+    same_house(:cigarettes, "Kools", :color, "yellow")
+    same_house(:cigarettes, "Lucky Strike", :drink, "orange juice")
+    same_house(:nationality, "Japanese", :cigarettes, "Parliaments")
+
+    next_house(:nationality, "Norwegian", :color, "blue")
+    next_house(:cigarettes, "Chesterfields", :pet, "fox")
+    next_house(:cigarettes, "Kools", :pet, "horse")
+
+    left_rigth_house(:color, "ivory", :color, "green")
+
+    @solver.assert house_has_trait_value(2, :drink, "milk")
+    @solver.assert house_has_trait_value(0, :nationality, "Norwegian")
+    
+    if @solver.satisfiable?
+      print_solution
+    else
+      puts "No solution"
+    end
+  end
+  
+  def print_solution
+    model = @solver.model
+    (0..4).each do |i|
+      print "House #{i}:"
+      traits.each do |trait|
+        j = model[variable(trait, i)].to_s.to_i
+        t = trait_value(trait, j)
+        print " #{t}"
+      end
+      print "\n"
+    end
+  end
+end
+
+ZebraPuzzle.new.call
+
+__END__
+
+There are five houses.
+The Englishman lives in the red house.
+The Spaniard owns the dog.
+Coffee is drunk in the green house.
+The Ukrainian drinks tea.
+The green house is immediately to the right of the ivory house.
+The Old Gold smoker owns snails.
+Kools are smoked in the yellow house.
+Milk is drunk in the middle house.
+The Norwegian lives in the first house.
+The man who smokes Chesterfields lives in the house next to the man with the fox.
+Kools are smoked in the house next to the house where the horse is kept.
+The Lucky Strike smoker drinks orange juice.
+The Japanese smokes Parliaments.
+The Norwegian lives next to the blue house.
+Now, who drinks water? Who owns the zebra?

data/lib/z3/low_level_auto.rb

@@ -581,42 +581,6 @@ module Z3
         VeryLowLevel.Z3_get_relation_column(_ctx_pointer, sort._ast, num)
       end
 
-      def get_smtlib_assumption(num) #=> :ast_pointer
-        VeryLowLevel.Z3_get_smtlib_assumption(_ctx_pointer, num)
-      end
-
-      def get_smtlib_decl(num) #=> :func_decl_pointer
-        VeryLowLevel.Z3_get_smtlib_decl(_ctx_pointer, num)
-      end
-
-      def get_smtlib_error #=> :string
-        VeryLowLevel.Z3_get_smtlib_error(_ctx_pointer)
-      end
-
-      def get_smtlib_formula(num) #=> :ast_pointer
-        VeryLowLevel.Z3_get_smtlib_formula(_ctx_pointer, num)
-      end
-
-      def get_smtlib_num_assumptions #=> :uint
-        VeryLowLevel.Z3_get_smtlib_num_assumptions(_ctx_pointer)
-      end
-
-      def get_smtlib_num_decls #=> :uint
-        VeryLowLevel.Z3_get_smtlib_num_decls(_ctx_pointer)
-      end
-
-      def get_smtlib_num_formulas #=> :uint
-        VeryLowLevel.Z3_get_smtlib_num_formulas(_ctx_pointer)
-      end
-
-      def get_smtlib_num_sorts #=> :uint
-        VeryLowLevel.Z3_get_smtlib_num_sorts(_ctx_pointer)
-      end
-
-      def get_smtlib_sort(num) #=> :sort_pointer
-        VeryLowLevel.Z3_get_smtlib_sort(_ctx_pointer, num)
-      end
-
       def get_sort(ast) #=> :sort_pointer
         VeryLowLevel.Z3_get_sort(_ctx_pointer, ast._ast)
       end

data/lib/z3/very_low_level_auto.rb

@@ -145,15 +145,6 @@ module Z3
     attach_function :Z3_get_range, [:ctx_pointer, :func_decl_pointer], :sort_pointer
     attach_function :Z3_get_relation_arity, [:ctx_pointer, :sort_pointer], :uint
     attach_function :Z3_get_relation_column, [:ctx_pointer, :sort_pointer, :uint], :sort_pointer
-    attach_function :Z3_get_smtlib_assumption, [:ctx_pointer, :uint], :ast_pointer
-    attach_function :Z3_get_smtlib_decl, [:ctx_pointer, :uint], :func_decl_pointer
-    attach_function :Z3_get_smtlib_error, [:ctx_pointer], :string
-    attach_function :Z3_get_smtlib_formula, [:ctx_pointer, :uint], :ast_pointer
-    attach_function :Z3_get_smtlib_num_assumptions, [:ctx_pointer], :uint
-    attach_function :Z3_get_smtlib_num_decls, [:ctx_pointer], :uint
-    attach_function :Z3_get_smtlib_num_formulas, [:ctx_pointer], :uint
-    attach_function :Z3_get_smtlib_num_sorts, [:ctx_pointer], :uint
-    attach_function :Z3_get_smtlib_sort, [:ctx_pointer, :uint], :sort_pointer
     attach_function :Z3_get_sort, [:ctx_pointer, :ast_pointer], :sort_pointer
     attach_function :Z3_get_sort_id, [:ctx_pointer, :sort_pointer], :uint
     attach_function :Z3_get_sort_kind, [:ctx_pointer, :sort_pointer], :uint

data/spec/expr_spec.rb

@@ -113,15 +113,16 @@ module Z3
 
       it "casts to correct type if possible" do
         expect((a == 42).sexpr).to eq "(= a 42)"
-        expect((42 == a).sexpr).to eq "(= a 42)"
+        # https://bugs.ruby-lang.org/issues/14437
+        #expect((42 == a).sexpr).to eq "(= a 42)"
         expect((a == e).sexpr).to eq "(= (to_real a) e)"
         expect((e == a).sexpr).to eq "(= e (to_real a))"
         expect((c == true).sexpr).to eq "(= c true)"
         expect((c == false).sexpr).to eq "(= c false)"
         expect((a == 42.5).sexpr).to eq "(= (to_real a) (/ 85.0 2.0))"
-        expect((42.5 == a).sexpr).to eq "(= (to_real a) (/ 85.0 2.0))"
+        # expect((42.5 == a).sexpr).to eq "(= (to_real a) (/ 85.0 2.0))"
         expect((e == 42.5).sexpr).to eq "(= e (/ 85.0 2.0))"
-        expect((42.5 == e).sexpr).to eq "(= e (/ 85.0 2.0))"
+        # expect((42.5 == e).sexpr).to eq "(= e (/ 85.0 2.0))"
         # expect((true == c).sexpr).to eq "(= true c)"
         # expect((false == c).sexpr).to eq "(= false c)"
       end
@@ -149,6 +150,7 @@ module Z3
 
       it "casts to correct type if possible" do
         expect((a != 42).sexpr).to eq "(distinct a 42)"
+        # https://bugs.ruby-lang.org/issues/14437
         # expect((42 != a).sexpr).to eq "(distinct a 42)"
         expect((a != e).sexpr).to eq "(distinct (to_real a) e)"
         expect((e != a).sexpr).to eq "(distinct e (to_real a))"

data/spec/integration/knights_puzzle_spec.rb

@@ -1,3 +1,5 @@
+# There are multiple solutions, so this test is nondeterministic
+# Changing it to one returned by z3 4.6.0, but perhaps it needs some serious fixing
 describe "Knights Swap Puzzle" do
   it do
     expect("knights_puzzle").to have_output <<EOF
@@ -7,84 +9,84 @@ bbb.
 xbxw
 ..ww
 x.xw
-b: 1,1 -> 3,0
+b: 0,0 -> 1,2
 
 State 1:
-bbbb
-x.xw
-..ww
+.bb.
+xbxw
+.bww
 x.xw
-w: 3,2 -> 1,1
+w: 2,2 -> 3,0
 
 State 2:
-bbbb
-xwxw
-..w.
+.bbw
+xbxw
+.b.w
 x.xw
-b: 2,0 -> 3,2
+b: 1,0 -> 2,2
 
 State 3:
-bb.b
-xwxw
-..wb
+..bw
+xbxw
+.bbw
 x.xw
-w: 3,3 -> 1,2
+w: 3,1 -> 1,0
 
 State 4:
-bb.b
-xwxw
-.wwb
-x.x.
-w: 1,2 -> 2,0
+.wbw
+xbx.
+.bbw
+x.xw
+b: 1,2 -> 3,1
 
 State 5:
-bbwb
-xwxw
-..wb
-x.x.
-b: 0,0 -> 1,2
+.wbw
+xbxb
+..bw
+x.xw
+w: 3,3 -> 1,2
 
 State 6:
-.bwb
-xwxw
-.bwb
+.wbw
+xbxb
+.wbw
 x.x.
-b: 1,2 -> 3,3
+w: 1,2 -> 0,0
 
 State 7:
-.bwb
-xwxw
-..wb
-x.xb
-w: 3,1 -> 1,2
+wwbw
+xbxb
+..bw
+x.x.
+b: 2,0 -> 1,2
 
 State 8:
-.bwb
-xwx.
-.wwb
-x.xb
-b: 1,0 -> 3,1
+ww.w
+xbxb
+.bbw
+x.x.
+w: 3,2 -> 2,0
 
 State 9:
-..wb
-xwxb
-.wwb
-x.xb
-w: 2,2 -> 1,0
+wwww
+xbxb
+.bb.
+x.x.
+b: 1,1 -> 3,2
 
 State 10:
-.wwb
-xwxb
-.w.b
+wwww
 x.xb
-b: 3,0 -> 2,2
+.bbb
+x.x.
+b: 1,2 -> 3,3
 
 State 11:
-.ww.
-xwxb
-.wbb
+wwww
 x.xb
-w: 1,2 -> 0,0
+..bb
+x.xb
+w: 3,0 -> 1,1
 
 State 12:
 www.

data/spec/integration/zebra_puzzle_spec.rb

@@ -0,0 +1,11 @@
+describe "Zebra Puzzle" do
+  it do
+    expect("zebra_puzzle").to have_output <<EOF
+House 0: yellow Norwegian water Kools fox
+House 1: blue Ukrainian tea Chesterfields horse
+House 2: red Englishman milk Old Gold snails
+House 3: ivory Spaniard orange juice Lucky Strike dog
+House 4: green Japanese coffee Parliaments zebra
+EOF
+  end
+end

data/spec/set_expr_spec.rb

@@ -35,6 +35,8 @@ module Z3
         expect([
           a.include?(1),
           a.include?(2),
+          !a.include?(3),
+          !b.include?(1),
           b.include?(2),
           b.include?(3),
           c == a.difference(b),

data/spec/solver_spec.rb

@@ -37,13 +37,31 @@ module Z3
       solver.assert b >= 2
       solver.assert Z3.Or(a == 2, a == -2)
       stats = solver.statistics
-      expect(stats.keys).to match_array(["rlimit count", "max memory", "memory", "num allocs"])
+      # "mk bool var" added in 4.6.0
+      expect(stats.keys).to match_array(["rlimit count", "max memory", "memory", "num allocs", "mk bool var"])
     end
 
     # This is a very simple example of unknown satisfiablity
     # so we might need more complex one in the future
+    # This is now satisfiable in 4.6.0
+    if Z3.version >= "4.6"
+      it "third way (until 4.6 fix)" do
+        solver.assert a**3 == a
+        expect(solver.check).to eq(:sat)
+        expect(solver).to be_satisfiable
+        expect(solver).to_not be_unsatisfiable
+      end
+    else
+      it "third way (until 4.6 fix)" do
+        solver.assert a**3 == a
+        expect(solver.check).to eq(:unknown)
+        expect{solver.satisfiable?}.to raise_error("Satisfiability unknown")
+        expect{solver.unsatisfiable?}.to raise_error("Satisfiability unknown")
+      end
+    end
+
     it "third way" do
-      solver.assert a**3 == a
+      solver.assert a**a == a
       expect(solver.check).to eq(:unknown)
       expect{solver.satisfiable?}.to raise_error("Satisfiability unknown")
       expect{solver.unsatisfiable?}.to raise_error("Satisfiability unknown")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: z3
 version: !ruby/object:Gem::Version
-  version: 0.0.20171020
+  version: 0.0.20180203
 platform: ruby
 authors:
 - Tomasz Wegrzanowski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-20 00:00:00.000000000 Z
+date: 2018-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -156,6 +156,7 @@ files:
 - examples/sudoku
 - examples/sudoku-1.txt
 - examples/verbal_arithmetic
+- examples/zebra_puzzle
 - lib/z3.rb
 - lib/z3/ast.rb
 - lib/z3/context.rb
@@ -228,6 +229,7 @@ files:
 - spec/integration/selfref_spec.rb
 - spec/integration/sudoku_spec.rb
 - spec/integration/verbal_arithmetic_spec.rb
+- spec/integration/zebra_puzzle_spec.rb
 - spec/model_spec.rb
 - spec/printer_spec.rb
 - spec/probe_spec.rb
@@ -263,7 +265,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements:
 - z3 library
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: Z3 Constraint Solver