z3 0.0.20220828 → 0.0.20230107

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94779e8d2fdaee7a213640164c8113fee96135e5247d9dc161d02dae87da6e94
-  data.tar.gz: d11a1326c693216fe857b436460d63176b466cc8b9927378940fc5543506a02e
+  metadata.gz: f5369c721ea50477790661ac8975e9c66104028450d4a73a2916eac046633380
+  data.tar.gz: 713374dddd23a82e7a22ec32e60964288182306201ef6e3e212e17b8d25c7a06
 SHA512:
-  metadata.gz: 5282dc961ae5f4f9dbe08c3f0e225ad3e8849522d5f0f7de7deaa233463479197498c91327dc8e6455478ee4469cbec660f6c278a45b09218a45e3d3d8f5736d
-  data.tar.gz: b884d26fb02ec6714d5ff54e862cbe5dccec2853b4ebcdda84410ccda65fc7693428e163b390a7d71b741a538d5ef9e0c5aac365d8709ff301e0344bb7bd8880
+  metadata.gz: 22d87abcdc1c5b8570bb0c52db0a0086185336bba84092666b010de0504cfa15e9973073d0ca1fa0ac5cb2eb448b2e9ae6da1ba5f7f807255fbbb91e573c42cf
+  data.tar.gz: cc3527b80fd35db96b1dd6cf2fde3511f97cc94316f76c507e8c7ded6f6fef1b122fdc477a043870a15acd7bf76a87e6884f3e6d502998c762315b3732d14023

data/lib/z3/expr/arith_expr.rb

@@ -40,6 +40,26 @@ module Z3
       sort.new(LowLevel.mk_unary_minus(self))
     end
 
+    def zero?
+      self == 0
+    end
+
+    def nonzero?
+      self != 0
+    end
+
+    def positive?
+      self > 0
+    end
+
+    def negative?
+      self < 0
+    end
+
+    def abs
+      (self < 0).ite(-self, self)
+    end
+
     # Recast so 1 + x:Float
     # is:  (+ 1.0 x)
     # not: (+ (to_real 1) x)

data/lib/z3/expr/array_expr.rb

@@ -1,5 +1,25 @@
 module Z3
   class ArrayExpr < Expr
     public_class_method :new
+
+    def key_sort
+      sort.key_sort
+    end
+
+    def value_sort
+      sort.value_sort
+    end
+
+    def store(key, value)
+      sort.new LowLevel.mk_store(self, key_sort.cast(key), value_sort.cast(value))
+    end
+
+    def select(key)
+      sort.value_sort.new LowLevel.mk_select(self, key_sort.cast(key))
+    end
+
+    def [](key)
+      select(key)
+    end
   end
 end

data/lib/z3/expr/bitvec_expr.rb

@@ -246,6 +246,26 @@ module Z3
       BitvecExpr.UnsignedLe(self, other)
     end
 
+    def zero?
+      self == 0
+    end
+
+    def nonzero?
+      self != 0
+    end
+
+    def positive?
+      self.signed_gt 0
+    end
+
+    def negative?
+      self.signed_lt 0
+    end
+
+    def abs
+      self.negative?.ite(-self, self)
+    end
+
     def coerce(other)
       other_sort = Expr.sort_for_const(other)
       max_sort = [sort, other_sort].max

data/lib/z3/expr/float_expr.rb

@@ -81,6 +81,10 @@ module Z3
       BoolSort.new.new LowLevel.mk_fpa_is_zero(self)
     end
 
+    def nonzero?
+      Z3.And(~zero?, ~nan?)
+    end
+
     def max(other)
       FloatExpr.Max(self, other)
     end

data/lib/z3/interface.rb

@@ -72,6 +72,10 @@ module Z3
     LowLevel.get_version.join(".")
   end
 
+  def version_at_least?(a, b=0, c=0, d=0)
+    (LowLevel.get_version <=> [a, b, c, d]) >= 0
+  end
+
   def set_param(k,v)
     LowLevel.global_param_set(k,v)
   end

data/spec/array_expr_spec.rb

@@ -4,7 +4,9 @@ module Z3
     let(:a) { sort.var("a") }
     let(:b) { sort.var("b") }
     let(:c) { sort.var("c") }
-    let(:x) { Z3::Bool("x") }
+    let(:x) { Z3::Int("x") }
+    let(:y) { Z3::Int("y") }
+    let(:z) { Z3::Int("z") }
 
     # TODO: Formatting is dreadful
     it "== and !=" do
@@ -14,5 +16,35 @@ module Z3
         c => "const(0)",
       )
     end
+
+    it "select" do
+      expect([a.select(10) == 20]).to have_solution(
+        a => "const(20)",
+      )
+      expect([a[10] == 20]).to have_solution(
+        a => "const(20)",
+      )
+      expect([a[x] == 10, a[y] == 20]).to have_solution(
+        a => "store(const(10), 3, 20)",
+        x => "2",
+        y => "3",
+      )
+    end
+
+    it "store" do
+      expect([a == b.store(10, 20), x == a.select(10)]).to have_solution(
+        x => 20,
+      )
+      expect([a == b.store(10, 20), x == a[10]]).to have_solution(
+        x => 20,
+      )
+      expect([a == b.store(10, 20), x == a[y], y == 10]).to have_solution(
+        x => 20,
+      )
+      expect([a == b.store(10, 20), x == a[y], x == 20]).to have_solution(
+        x => 20,
+        y => 10,
+      )
+    end
   end
 end

data/spec/array_sort_spec.rb

@@ -1,7 +1,7 @@
 module Z3
   describe ArraySort do
-    let(:int_int_array)   { ArraySort.new(IntSort.new, IntSort.new) }
-    let(:int_real_array)  { ArraySort.new(IntSort.new, RealSort.new) }
+    let(:int_int_array)  { ArraySort.new(IntSort.new, IntSort.new) }
+    let(:int_real_array) { ArraySort.new(IntSort.new, RealSort.new) }
 
     it "can instantiate variables" do
       expect(int_int_array.var("a").inspect).to eq("Array(Int, Int)<a>")

data/spec/bitvec_expr_spec.rb

@@ -231,5 +231,38 @@ module Z3
       expect([a == 0b0101_0110, e == 0b1101, d == a.concat(e)]).to have_solution(d => 0b0101_0110_1101)
       expect([a == 0b0101_0110, e == 0b1101, d == e.concat(a)]).to have_solution(d => 0b1101_0101_0110)
     end
+
+    it "zero?" do
+      expect([a == 0, x == a.zero?]).to have_solution(x => true)
+      expect([a == 100, x == a.zero?]).to have_solution(x => false)
+      expect([a == 200, x == a.zero?]).to have_solution(x => false)
+    end
+
+    it "nonzero?" do
+      expect([a == 0, x == a.nonzero?]).to have_solution(x => false)
+      expect([a == 100, x == a.nonzero?]).to have_solution(x => true)
+      expect([a == 200, x == a.nonzero?]).to have_solution(x => true)
+    end
+
+    # Inherently signed
+    it "positive?" do
+      expect([a == 0, x == a.positive?]).to have_solution(x => false)
+      expect([a == 100, x == a.positive?]).to have_solution(x => true)
+      expect([a == 200, x == a.positive?]).to have_solution(x => false)
+    end
+
+    # Inherently signed
+    it "negative?" do
+      expect([a == 0, x == a.negative?]).to have_solution(x => false)
+      expect([a == 100, x == a.negative?]).to have_solution(x => false)
+      expect([a == 200, x == a.negative?]).to have_solution(x => true)
+    end
+
+    # Inherently signed
+    it "abs" do
+      expect([a == 0, b == a.abs]).to have_solution(b => 0)
+      expect([a == 100, b == a.abs]).to have_solution(b => 100)
+      expect([a == 200, b == a.abs]).to have_solution(b => 56)
+    end
   end
 end

data/spec/float_expr_spec.rb

@@ -102,8 +102,9 @@ module Z3
       expect(positive_infinity.to_s).to eq("+oo")
       expect(negative_infinity.to_s).to eq("-oo")
       expect(nan.to_s).to eq("NaN")
+
       # Denormals changed
-      if Z3.version >= '4.5'
+      if Z3.version_at_least?(4, 6)
         expect(float_double.from_const(1234 * 0.5**1040).to_s).to eq("0.00470733642578125B-1022")
         expect(float_single.from_const(1234 * 0.5**136).to_s).to eq("1.205078125B-126")
         # This is what we get, all of these are wrong, by a lot:
@@ -128,6 +129,17 @@ module Z3
       expect([x == nan.zero?]).to have_solution(x => false)
     end
 
+    # Same as positive or negative
+    # +0, -0, and NaN are all false
+    it "nonzero?" do
+      expect([x == positive_zero.nonzero?]).to have_solution(x => false)
+      expect([x == negative_zero.nonzero?]).to have_solution(x => false)
+      expect([x == positive_infinity.nonzero?]).to have_solution(x => true)
+      expect([x == negative_infinity.nonzero?]).to have_solution(x => true)
+      expect([x == float_double.from_const(1.5).nonzero?]).to have_solution(x => true)
+      expect([x == nan.nonzero?]).to have_solution(x => false)
+    end
+
     it "infinite?" do
       expect([x == positive_zero.infinite?]).to have_solution(x => false)
       expect([x == positive_infinity.infinite?]).to have_solution(x => true)
@@ -178,5 +190,28 @@ module Z3
       expect([x == float_double.from_const(-1.5).negative?]).to have_solution(x => true)
       expect([x == nan.negative?]).to have_solution(x => false)
     end
+
+    # We can't simply do have_solution(b => positive_zero)
+    # as positive_zero == negative_zero
+    it "abs" do
+      expect([a == positive_zero, b == a.abs]).to have_solution(a.abs => positive_zero)
+      expect([a == negative_zero, b == a.abs]).to have_solution(a.abs => positive_zero)
+      expect([a == positive_infinity, b == a.abs]).to have_solution(b => positive_infinity)
+      expect([a == negative_infinity, b == a.abs]).to have_solution(b => positive_infinity)
+      expect([a == float_double.from_const(1.5), b == a.abs]).to have_solution(b => float_double.from_const(1.5))
+      expect([a == float_double.from_const(-1.5), b == a.abs]).to have_solution(b => float_double.from_const(1.5))
+      expect([a == nan, b == a.abs]).to have_no_solution
+    end
+
+    # This means you need to be extra careful when using Z3::Float
+    # as == means something else on them than mathematical ==
+    #
+    # Also have_solutions helper doesn't work as it relies on ==
+    it "zeroes" do
+      expect([a == positive_zero, b == a, b.positive?]).to have_solution(b => positive_zero)
+      expect([a == negative_zero, b == a, b.negative?]).to have_solution(b => negative_zero)
+      expect([a == positive_zero, b == a, b.positive?]).to have_solution(b => positive_zero)
+      expect([a == negative_zero, b == a, b.negative?]).to have_solution(b => negative_zero)
+    end
   end
 end

data/spec/int_expr_spec.rb

@@ -81,6 +81,36 @@ module Z3
       expect([a == 3, b == -a]).to have_solution(b => -3)
     end
 
+    it "zero?" do
+      expect([a == 0, x == a.zero?]).to have_solution(x => true)
+      expect([a == 100, x == a.zero?]).to have_solution(x => false)
+      expect([a == -200, x == a.zero?]).to have_solution(x => false)
+    end
+
+    it "nonzero?" do
+      expect([a == 0, x == a.nonzero?]).to have_solution(x => false)
+      expect([a == 100, x == a.nonzero?]).to have_solution(x => true)
+      expect([a == -200, x == a.nonzero?]).to have_solution(x => true)
+    end
+
+    it "positive?" do
+      expect([a == 0, x == a.positive?]).to have_solution(x => false)
+      expect([a == 100, x == a.positive?]).to have_solution(x => true)
+      expect([a == -200, x == a.positive?]).to have_solution(x => false)
+    end
+
+    it "negative?" do
+      expect([a == 0, x == a.negative?]).to have_solution(x => false)
+      expect([a == 100, x == a.negative?]).to have_solution(x => false)
+      expect([a == -200, x == a.negative?]).to have_solution(x => true)
+    end
+
+    it "abs" do
+      expect([a == 3, b == 2, c == (a - b).abs]).to have_solution(c => 1)
+      expect([a == 2, b == 3, c == (a - b).abs]).to have_solution(c => 1)
+      expect([a == 2, b == 2, c == (a - b).abs]).to have_solution(c => 0)
+    end
+
     it "simplify" do
       a = Z3.Const(5)
       b = Z3.Const(3)

data/spec/integration/examples/knights_puzzle-4.txt

@@ -0,0 +1,90 @@
+Solved
+State 0:
+bbb.
+xbxw
+..ww
+x.xw
+w: 3,3 -> 1,2
+
+State 1:
+bbb.
+xbxw
+.www
+x.x.
+b: 1,1 -> 3,0
+
+State 2:
+bbbb
+x.xw
+.www
+x.x.
+w: 3,2 -> 1,1
+
+State 3:
+bbbb
+xwxw
+.ww.
+x.x.
+b: 2,0 -> 3,2
+
+State 4:
+bb.b
+xwxw
+.wwb
+x.x.
+w: 1,2 -> 2,0
+
+State 5:
+bbwb
+xwxw
+..wb
+x.x.
+b: 0,0 -> 1,2
+
+State 6:
+.bwb
+xwxw
+.bwb
+x.x.
+b: 1,2 -> 3,3
+
+State 7:
+.bwb
+xwxw
+..wb
+x.xb
+w: 3,1 -> 1,2
+
+State 8:
+.bwb
+xwx.
+.wwb
+x.xb
+b: 1,0 -> 3,1
+
+State 9:
+..wb
+xwxb
+.wwb
+x.xb
+w: 2,2 -> 1,0
+
+State 10:
+.wwb
+xwxb
+.w.b
+x.xb
+b: 3,0 -> 2,2
+
+State 11:
+.ww.
+xwxb
+.wbb
+x.xb
+w: 1,2 -> 0,0
+
+State 12:
+www.
+xwxb
+..bb
+x.xb

data/spec/integration/examples/knights_puzzle-5.txt

@@ -0,0 +1,90 @@
+Solved
+State 0:
+bbb.
+xbxw
+..ww
+x.xw
+b: 0,0 -> 1,2
+
+State 1:
+.bb.
+xbxw
+.bww
+x.xw
+w: 2,2 -> 3,0
+
+State 2:
+.bbw
+xbxw
+.b.w
+x.xw
+b: 1,0 -> 2,2
+
+State 3:
+..bw
+xbxw
+.bbw
+x.xw
+w: 3,1 -> 1,0
+
+State 4:
+.wbw
+xbx.
+.bbw
+x.xw
+b: 1,2 -> 3,1
+
+State 5:
+.wbw
+xbxb
+..bw
+x.xw
+w: 3,3 -> 1,2
+
+State 6:
+.wbw
+xbxb
+.wbw
+x.x.
+w: 1,2 -> 0,0
+
+State 7:
+wwbw
+xbxb
+..bw
+x.x.
+b: 2,0 -> 1,2
+
+State 8:
+ww.w
+xbxb
+.bbw
+x.x.
+b: 1,2 -> 3,3
+
+State 9:
+ww.w
+xbxb
+..bw
+x.xb
+w: 3,2 -> 2,0
+
+State 10:
+wwww
+xbxb
+..b.
+x.xb
+b: 1,1 -> 3,2
+
+State 11:
+wwww
+x.xb
+..bb
+x.xb
+w: 3,0 -> 1,1
+
+State 12:
+www.
+xwxb
+..bb
+x.xb

data/spec/real_expr_spec.rb

@@ -64,6 +64,36 @@ module Z3
       expect([a == 81, b == 0.25, c == (a ** b)]).to have_solution(c => 3)
     end
 
+    it "zero?" do
+      expect([a == 0, x == a.zero?]).to have_solution(x => true)
+      expect([a == 100, x == a.zero?]).to have_solution(x => false)
+      expect([a == -200, x == a.zero?]).to have_solution(x => false)
+    end
+
+    it "nonzero?" do
+      expect([a == 0, x == a.nonzero?]).to have_solution(x => false)
+      expect([a == 100, x == a.nonzero?]).to have_solution(x => true)
+      expect([a == -200, x == a.nonzero?]).to have_solution(x => true)
+    end
+
+    it "positive?" do
+      expect([a == 0, x == a.positive?]).to have_solution(x => false)
+      expect([a == 100, x == a.positive?]).to have_solution(x => true)
+      expect([a == -200, x == a.positive?]).to have_solution(x => false)
+    end
+
+    it "negative?" do
+      expect([a == 0, x == a.negative?]).to have_solution(x => false)
+      expect([a == 100, x == a.negative?]).to have_solution(x => false)
+      expect([a == -200, x == a.negative?]).to have_solution(x => true)
+    end
+
+    it "abs" do
+      expect([a == 3, b == 2, c == (a - b).abs]).to have_solution(c => 1)
+      expect([a == 2, b == 3, c == (a - b).abs]).to have_solution(c => 1)
+      expect([a == 2, b == 2, c == (a - b).abs]).to have_solution(c => 0)
+    end
+
     it "unary -" do
       expect([a == 3, b == -a]).to have_solution(b => -3)
       expect([a == 0, b == -a]).to have_solution(b => 0)

data/spec/set_expr_spec.rb

@@ -17,7 +17,7 @@ module Z3
       )
     end
 
-    if Z3.version >= "4.5"
+    if Z3.version_at_least?(4, 5)
       # Only works in z3 4.5, 4.4 (like on Ubuntu) returns bad stuff
       it "union" do
         expect([

data/spec/solver_spec.rb

@@ -43,7 +43,7 @@ module Z3
     # 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"
+    if Z3.version_at_least?(4, 6)
       it "unknown satisfiability (until 4.6 fix)" do
         solver.assert a**3 == a
         expect(solver.check).to eq(:sat)

data/spec/spec_helper.rb

@@ -155,3 +155,22 @@ RSpec::Matchers.define :have_solutions do |expected|
     end
   end
 end
+
+RSpec::Matchers.define :have_no_solution do
+  match do |asts|
+    solver = setup_solver(asts)
+    !solver.satisfiable?
+  end
+
+  failure_message do |asts|
+    "expected #{asts.inspect} to have no solutions, but solution found"
+  end
+
+  def setup_solver(asts)
+    Z3::Solver.new.tap do |solver|
+      asts.each do |ast|
+        solver.assert ast
+      end
+    end
+  end
+end

data/spec/z3_spec.rb

@@ -2,4 +2,14 @@ describe Z3 do
   it "#version return version number of Z3 library" do
     expect(Z3.version).to match(/\A\d+\.\d+\.\d+\.\d+\z/)
   end
+
+  it "#version_at_least return if version matches" do
+    version = Z3.version.split(".").map(&:to_i)
+    expect(Z3.version_at_least?(*version)).to eq(true)
+    expect(Z3.version_at_least?(*version[0,2])).to eq(true)
+    expect(Z3.version_at_least?(*version[0,1])).to eq(true)
+    expect(Z3.version_at_least?(version[0])).to eq(true)
+    expect(Z3.version_at_least?(*version[0,2], 999)).to eq(false)
+    expect(Z3.version_at_least?(999)).to eq(false)
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: z3
 version: !ruby/object:Gem::Version
-  version: 0.0.20220828
+  version: 0.0.20230107
 platform: ruby
 authors:
 - Tomasz Wegrzanowski
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-28 00:00:00.000000000 Z
+date: 2023-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -287,6 +287,8 @@ files:
 - spec/integration/examples/knights_puzzle-1.txt
 - spec/integration/examples/knights_puzzle-2.txt
 - spec/integration/examples/knights_puzzle-3.txt
+- spec/integration/examples/knights_puzzle-4.txt
+- spec/integration/examples/knights_puzzle-5.txt
 - spec/integration/four_hackers_puzzle_spec.rb
 - spec/integration/futoshiki_spec.rb
 - spec/integration/geometry_problem_spec.rb