z3 0.0.20180629 → 0.0.20181126

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b62645ba88a89cc0c81a5f2088f4b919953d778d99f52af3798cd6b9f130e61
-  data.tar.gz: 97269d402d845d9192c558c271c2448cdc420d3c93d6bf2f3e2afb0238b039cc
+  metadata.gz: 4c93f27f8597c24344b97bcb79677cb1c91d92d626e457600ab36e355db41586
+  data.tar.gz: a85deb034bee0faeb6a6c4283e85657cf394ae7ec2643b91f4d8d249ac337748
 SHA512:
-  metadata.gz: 2bc073a01310b704b5e64d5d6bd26f31b1b061e38f9d9edb3a0fed0e2e2db2989fbac863c35c7213d5f81ba0a74ec2d95c16c440ad8d0550d5ce842d1b843c64
-  data.tar.gz: 390f2516225de2bf7887ed42597587e53f3ec0c3ebe89d85c2aa43c54717e4dee3cb485c5d62199c94467866c776491de4ea758fec6f1b80f32689b577da7cb7
+  metadata.gz: 34781021336dab28fe7969b707638461bd8da2bb1b331038ca10e0c7eb015582c478360f0264c2174b517807e99bbf7598431dd985b39b3d0472fea8b550d23f
+  data.tar.gz: e382c7d4caa935adda0172436e4d3f7e6499dd46c4dcb0f2a95ee641ac1487c2bb06035a7fe6c6d40f35a1d9d664a3948cd26fac856d890833f0ec8c85eb6b71

data/README.md

@@ -1,6 +1,6 @@
 This is Ruby interface for Z3 [ https://github.com/Z3Prover/z3 ].
 
-Minimum required version is Z3 4.6.
+Minimum required version is Z3 4.8.
 
 It's in very early stages of development. Pull requests always welcome.
 

data/Rakefile

@@ -7,43 +7,43 @@ task "test:unit" => "spec:unit"
 
 desc "Regenerate API"
 task "api" do
-  system "./api/gen_api api/definitions.h"
+  sh "./api/gen_api api/definitions.h"
 end
 
 desc "Clean up"
 task "clean" do
-  system "trash z3-*.gem coverage"
+  sh "trash z3-*.gem coverage"
 end
 
 desc "Run tests"
 task "spec" do
-  system "rspec"
+  sh "rspec"
 end
 
 desc "Run unit tests"
 task "spec:unit" do
-  system "rspec spec/*_spec.rb"
+  sh "rspec spec/*_spec.rb"
 end
 
 desc "Run integration tests"
 task "spec:integration" do
-  system "rspec spec/integration/*_spec.rb"
+  sh "rspec spec/integration/*_spec.rb"
 end
 
 desc "Build gem"
 task "gem:build" do
-  system "gem build z3.gemspec"
+  sh "gem build z3.gemspec"
 end
 
 desc "Upload gem"
 task "gem:push" => "gem:build" do
   gem_file = Dir["z3-*.gem"][-1] or raise "No gem found"
-  system "gem", "push", gem_file
+  sh "gem", "push", gem_file
 end
 
 desc "Report missing APIs"
 task "coverage:missing" do
-  system "COVERAGE=1 rake test"
+  sh "COVERAGE=1 rake test"
   data = JSON.load(open("coverage/.resultset.json"))["RSpec"]["coverage"]
   lla_path = data.keys.find{|k| k.end_with?("lib/z3/low_level_auto.rb")}
   coverage = data[lla_path].zip(File.readlines(lla_path).map(&:strip))
@@ -53,4 +53,4 @@ task "coverage:missing" do
   open("missing_apis.txt", "w") do |file|
     file.puts missing
   end
-end
+end

data/examples/simple_regexp_parser.rb

@@ -15,7 +15,7 @@ class SimpleRegexpParser
   end
 
   def sequence(*parts)
-    parts = parts.select{|x| x[0] != :empty}
+    parts = parts.select { |x| x[0] != :empty }
     case parts.size
     when 0
       [:empty]
@@ -46,9 +46,9 @@ class SimpleRegexpParser
   # 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}
+    codes = (0..127).select { |c| c.chr =~ char_rx }
     # This is mostly here to make debugging easier
-    if codes.size > 127-codes.size
+    if codes.size > 127 - codes.size
       [:neg_set, (0..127).to_a - codes]
     else
       [:set, codes]
@@ -64,7 +64,7 @@ class SimpleRegexpParser
   end
 
   def literal(chars)
-    sequence(*chars.map{|c| character_type(c)})
+    sequence(*chars.map { |c| character_type(c) })
   end
 
   def star(part)
@@ -85,10 +85,10 @@ class SimpleRegexpParser
 
   def repeat(part, min, max)
     if max == -1
-      sequence(star(part), *([part]*min))
+      sequence(star(part), *([part] * min))
     else
       maybe_part = alternative([:empty], part)
-      sequence(*([part]*min), *([maybe_part] * (max-min)))
+      sequence(*([part] * min), *([maybe_part] * (max - min)))
     end
   end
 
@@ -105,7 +105,7 @@ class SimpleRegexpParser
           sequence(repeat(base, min, max), part)
         )
       else # (a){2,} -> a{1,}(a)
-        sequence(repeat(base, min-1, max), part)
+        sequence(repeat(base, min - 1, max), part)
       end
     elsif max == 0 # a{0} -> empty, not really a thing
       :empty
@@ -115,10 +115,10 @@ class SimpleRegexpParser
         # with same group id for both ()s
         alternative(
           [:group, group, empty],
-          sequence(repeat(base, min, max-1), part)
+          sequence(repeat(base, min, max - 1), part)
         )
       else # (a){2,3} -> a{1,2}(a)
-        sequence(repeat(base, min-1, max-1), part)
+        sequence(repeat(base, min - 1, max - 1), part)
       end
     end
   end
@@ -131,58 +131,60 @@ class SimpleRegexpParser
   # * empty
   # * backref - \1
   # * group - (a)
-  def parse(node=@tree)
+  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
+             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::CharacterSet
+               character_set(node.negative?, node.expressions)
+             when Regexp::Expression::Subexpression
+               # It's annoyingly subtypes a lot
+               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)
+                 raise "Don't know how to deal with #{node.class}"
+               end
+               sequence(*node.expressions.map { |n| parse(n) })
+             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
+                 repeat_group(result, min, max)
+               else
+                 repeat(result, min, max)
+               end
     end
 
     result

data/lib/z3/expr/expr.rb

@@ -1,10 +1,11 @@
 module Z3
   class Expr < AST
     attr_reader :sort
+
     def initialize(_ast, sort)
       super(_ast)
       @sort = sort
-      raise Z3::Exception, "Values must have AST kind numeral or app" unless [:numeral, :app].include?(ast_kind)
+      raise Z3::Exception, "Values must have AST kind numeral, app, or quantifier" unless [:numeral, :app, :quantifier].include?(ast_kind)
     end
 
     def inspect
@@ -22,7 +23,7 @@ module Z3
     class << self
       def coerce_to_same_sort(*args)
         # This will raise exception unless one of the sorts is highest
-        max_sort = args.map{|a| a.is_a?(Expr) ? a.sort : Expr.sort_for_const(a)}.max
+        max_sort = args.map { |a| a.is_a?(Expr) ? a.sort : Expr.sort_for_const(a) }.max
         args.map do |a|
           max_sort.cast(a)
         end
@@ -110,7 +111,7 @@ module Z3
         when BoolExpr
           BoolSort.new.new(Z3::LowLevel.mk_and(args))
         when BitvecExpr
-          args.inject do |a,b|
+          args.inject do |a, b|
             a.sort.new(Z3::LowLevel.mk_bvand(a, b))
           end
         else
@@ -124,7 +125,7 @@ module Z3
         when BoolExpr
           BoolSort.new.new(Z3::LowLevel.mk_or(args))
         when BitvecExpr
-          args.inject do |a,b|
+          args.inject do |a, b|
             a.sort.new(Z3::LowLevel.mk_bvor(a, b))
           end
         else
@@ -136,11 +137,11 @@ module Z3
         args = coerce_to_same_sort(*args)
         case args[0]
         when BoolExpr
-          args.inject do |a,b|
+          args.inject do |a, b|
             BoolSort.new.new(Z3::LowLevel.mk_xor(a, b))
           end
         when BitvecExpr
-          args.inject do |a,b|
+          args.inject do |a, b|
             a.sort.new(Z3::LowLevel.mk_bvxor(a, b))
           end
         else
@@ -155,8 +156,8 @@ module Z3
         when ArithExpr
           args[0].sort.new(LowLevel.mk_add(args))
         when BitvecExpr
-          args.inject do |a,b|
-            a.sort.new(LowLevel.mk_bvadd(a,b))
+          args.inject do |a, b|
+            a.sort.new(LowLevel.mk_bvadd(a, b))
           end
         else
           raise Z3::Exception, "Can't perform logic operations on #{args[0].sort} exprs, only Int/Real/Bitvec"
@@ -169,8 +170,8 @@ module Z3
         when ArithExpr
           args[0].sort.new(LowLevel.mk_sub(args))
         when BitvecExpr
-          args.inject do |a,b|
-            a.sort.new(LowLevel.mk_bvsub(a,b))
+          args.inject do |a, b|
+            a.sort.new(LowLevel.mk_bvsub(a, b))
           end
         else
           raise Z3::Exception, "Can't perform logic operations on #{args[0].sort} values, only Int/Real/Bitvec"
@@ -183,8 +184,8 @@ module Z3
         when ArithExpr
           args[0].sort.new(LowLevel.mk_mul(args))
         when BitvecExpr
-          args.inject do |a,b|
-            a.sort.new(LowLevel.mk_bvmul(a,b))
+          args.inject do |a, b|
+            a.sort.new(LowLevel.mk_bvmul(a, b))
           end
         else
           raise Z3::Exception, "Can't perform logic operations on #{args[0].sort} values, only Int/Real/Bitvec"

data/lib/z3/low_level.rb

@@ -9,7 +9,7 @@ module Z3
         b = FFI::MemoryPointer.new(:int)
         c = FFI::MemoryPointer.new(:int)
         d = FFI::MemoryPointer.new(:int)
-        Z3::VeryLowLevel.Z3_get_version(a,b,c,d)
+        Z3::VeryLowLevel.Z3_get_version(a, b, c, d)
         [a.get_uint(0), b.get_uint(0), c.get_uint(0), d.get_uint(0)]
       end
 
@@ -63,6 +63,10 @@ module Z3
         Z3::VeryLowLevel.Z3_mk_set_intersect(_ctx_pointer, asts.size, asts_vector(asts))
       end
 
+      def optimize_check(optimize, asts)
+        Z3::VeryLowLevel.Z3_optimize_check(_ctx_pointer, optimize._optimize, asts.size, asts_vector(asts))
+      end
+
       # Should be private
 
       def unpack_ast_vector(_ast_vector)
@@ -96,7 +100,7 @@ module Z3
       private
 
       def asts_vector(args)
-        raise if args.empty?
+        # raise if args.empty?
         c_args = FFI::MemoryPointer.new(:pointer, args.size)
         c_args.write_array_of_pointer args.map(&:_ast)
         c_args

data/lib/z3/low_level_auto.rb

@@ -77,10 +77,6 @@ module Z3
         VeryLowLevel.Z3_algebraic_sub(_ctx_pointer, ast1._ast, ast2._ast)
       end
 
-      def apply_result_convert_model(apply_result, num, model) #=> :model_pointer
-        VeryLowLevel.Z3_apply_result_convert_model(_ctx_pointer, apply_result._apply_result, num, model._model)
-      end
-
       def apply_result_dec_ref(apply_result) #=> :void
         VeryLowLevel.Z3_apply_result_dec_ref(_ctx_pointer, apply_result._apply_result)
       end
@@ -213,6 +209,10 @@ module Z3
         VeryLowLevel.Z3_enable_trace(str)
       end
 
+      def eval_smtlib2_string(str) #=> :string
+        VeryLowLevel.Z3_eval_smtlib2_string(_ctx_pointer, str)
+      end
+
       def finalize_memory #=> :void
         VeryLowLevel.Z3_finalize_memory()
       end
@@ -581,10 +581,6 @@ module Z3
         VeryLowLevel.Z3_get_index_value(_ctx_pointer, ast._ast)
       end
 
-      def get_interpolant(ast1, ast2, params) #=> :ast_vector_pointer
-        VeryLowLevel.Z3_get_interpolant(_ctx_pointer, ast1._ast, ast2._ast, params._params)
-      end
-
       def get_num_probes #=> :uint
         VeryLowLevel.Z3_get_num_probes(_ctx_pointer)
       end
@@ -605,10 +601,6 @@ module Z3
         VeryLowLevel.Z3_get_numerator(_ctx_pointer, ast._ast)
       end
 
-      def get_parser_error #=> :string
-        VeryLowLevel.Z3_get_parser_error(_ctx_pointer)
-      end
-
       def get_pattern(pattern, num) #=> :ast_pointer
         VeryLowLevel.Z3_get_pattern(_ctx_pointer, pattern._ast, num)
       end
@@ -725,6 +717,10 @@ module Z3
         VeryLowLevel.Z3_goal_assert(_ctx_pointer, goal._goal, ast._ast)
       end
 
+      def goal_convert_model(goal, model) #=> :model_pointer
+        VeryLowLevel.Z3_goal_convert_model(_ctx_pointer, goal._goal, model._model)
+      end
+
       def goal_dec_ref(goal) #=> :void
         VeryLowLevel.Z3_goal_dec_ref(_ctx_pointer, goal._goal)
       end
@@ -769,6 +765,10 @@ module Z3
         VeryLowLevel.Z3_goal_size(_ctx_pointer, goal._goal)
       end
 
+      def goal_to_dimacs_string(goal) #=> :string
+        VeryLowLevel.Z3_goal_to_dimacs_string(_ctx_pointer, goal._goal)
+      end
+
       def goal_to_string(goal) #=> :string
         VeryLowLevel.Z3_goal_to_string(_ctx_pointer, goal._goal)
       end
@@ -781,10 +781,6 @@ module Z3
         VeryLowLevel.Z3_inc_ref(_ctx_pointer, ast._ast)
       end
 
-      def interpolation_profile #=> :string
-        VeryLowLevel.Z3_interpolation_profile(_ctx_pointer)
-      end
-
       def interrupt #=> :void
         VeryLowLevel.Z3_interrupt(_ctx_pointer)
       end
@@ -813,10 +809,18 @@ module Z3
         VeryLowLevel.Z3_is_eq_sort(_ctx_pointer, sort1._ast, sort2._ast)
       end
 
+      def is_lambda(ast) #=> :bool
+        VeryLowLevel.Z3_is_lambda(_ctx_pointer, ast._ast)
+      end
+
       def is_numeral_ast(ast) #=> :bool
         VeryLowLevel.Z3_is_numeral_ast(_ctx_pointer, ast._ast)
       end
 
+      def is_quantifier_exists(ast) #=> :bool
+        VeryLowLevel.Z3_is_quantifier_exists(_ctx_pointer, ast._ast)
+      end
+
       def is_quantifier_forall(ast) #=> :bool
         VeryLowLevel.Z3_is_quantifier_forall(_ctx_pointer, ast._ast)
       end
@@ -1349,14 +1353,6 @@ module Z3
         VeryLowLevel.Z3_mk_int_to_str(_ctx_pointer, ast._ast)
       end
 
-      def mk_interpolant(ast) #=> :ast_pointer
-        VeryLowLevel.Z3_mk_interpolant(_ctx_pointer, ast._ast)
-      end
-
-      def mk_interpolation_context(config) #=> :ctx_pointer
-        VeryLowLevel.Z3_mk_interpolation_context(config._config)
-      end
-
       def mk_is_int(ast) #=> :ast_pointer
         VeryLowLevel.Z3_mk_is_int(_ctx_pointer, ast._ast)
       end
@@ -1605,6 +1601,10 @@ module Z3
         VeryLowLevel.Z3_model_to_string(_ctx_pointer, model._model)
       end
 
+      def model_translate(model, context) #=> :model_pointer
+        VeryLowLevel.Z3_model_translate(_ctx_pointer, model._model, context._context)
+      end
+
       def optimize_assert(optimize, ast) #=> :void
         VeryLowLevel.Z3_optimize_assert(_ctx_pointer, optimize._optimize, ast._ast)
       end
@@ -1613,10 +1613,6 @@ module Z3
         VeryLowLevel.Z3_optimize_assert_soft(_ctx_pointer, optimize._optimize, ast._ast, str, sym)
       end
 
-      def optimize_check(optimize) #=> :int
-        VeryLowLevel.Z3_optimize_check(_ctx_pointer, optimize._optimize)
-      end
-
       def optimize_dec_ref(optimize) #=> :void
         VeryLowLevel.Z3_optimize_dec_ref(_ctx_pointer, optimize._optimize)
       end
@@ -1665,6 +1661,10 @@ module Z3
         VeryLowLevel.Z3_optimize_get_statistics(_ctx_pointer, optimize._optimize)
       end
 
+      def optimize_get_unsat_core(optimize) #=> :ast_vector_pointer
+        VeryLowLevel.Z3_optimize_get_unsat_core(_ctx_pointer, optimize._optimize)
+      end
+
       def optimize_get_upper(optimize, num) #=> :ast_pointer
         VeryLowLevel.Z3_optimize_get_upper(_ctx_pointer, optimize._optimize, num)
       end
@@ -1941,6 +1941,10 @@ module Z3
         VeryLowLevel.Z3_solver_check(_ctx_pointer, solver._solver)
       end
 
+      def solver_cube(solver, ast_vector, num) #=> :ast_vector_pointer
+        VeryLowLevel.Z3_solver_cube(_ctx_pointer, solver._solver, ast_vector, num)
+      end
+
       def solver_dec_ref(solver) #=> :void
         VeryLowLevel.Z3_solver_dec_ref(_ctx_pointer, solver._solver)
       end
@@ -1969,6 +1973,10 @@ module Z3
         VeryLowLevel.Z3_solver_get_model(_ctx_pointer, solver._solver)
       end
 
+      def solver_get_non_units(solver) #=> :ast_vector_pointer
+        VeryLowLevel.Z3_solver_get_non_units(_ctx_pointer, solver._solver)
+      end
+
       def solver_get_num_scopes(solver) #=> :uint
         VeryLowLevel.Z3_solver_get_num_scopes(_ctx_pointer, solver._solver)
       end
@@ -1989,10 +1997,18 @@ module Z3
         VeryLowLevel.Z3_solver_get_statistics(_ctx_pointer, solver._solver)
       end
 
+      def solver_get_units(solver) #=> :ast_vector_pointer
+        VeryLowLevel.Z3_solver_get_units(_ctx_pointer, solver._solver)
+      end
+
       def solver_get_unsat_core(solver) #=> :ast_vector_pointer
         VeryLowLevel.Z3_solver_get_unsat_core(_ctx_pointer, solver._solver)
       end
 
+      def solver_import_model_converter(solver1, solver2) #=> :void
+        VeryLowLevel.Z3_solver_import_model_converter(_ctx_pointer, solver1._solver, solver2._solver)
+      end
+
       def solver_inc_ref(solver) #=> :void
         VeryLowLevel.Z3_solver_inc_ref(_ctx_pointer, solver._solver)
       end

data/lib/z3/optimize.rb

@@ -1,6 +1,7 @@
 module Z3
   class Optimize
     attr_reader :_optimize
+
     def initialize
       @_optimize = LowLevel.mk_optimize
       LowLevel.optimize_inc_ref(self)
@@ -27,9 +28,9 @@ module Z3
       LowLevel.optimize_assert_soft(self, ast)
     end
 
-    def check
+    def check(*args)
       reset_model!
-      result = check_sat_results(LowLevel.optimize_check(self))
+      result = check_sat_results(LowLevel.optimize_check(self, args))
       @has_model = true if result == :sat
       result
     end
@@ -81,7 +82,7 @@ module Z3
       case check
       when :sat
         puts "Counterexample exists"
-        model.each do |n,v|
+        model.each do |n, v|
           puts "* #{n} = #{v}"
         end
       when :unknown
@@ -95,7 +96,6 @@ module Z3
       pop
     end
 
-
     def reason_unknown
       LowLevel.optimize_get_reason_unknown(self)
     end

data/lib/z3/very_low_level.rb

@@ -1,6 +1,5 @@
 # Seriously do not use this directly in your code
-
-require 'ffi'
+require "ffi"
 
 module Z3
   module VeryLowLevel
@@ -10,8 +9,7 @@ module Z3
     class << self
       # Aliases defined just to make APIs below look nicer
       def attach_function(name, arg_types, return_type)
-
-        arg_types = arg_types.map{|t| map_type(t)}
+        arg_types = arg_types.map { |t| map_type(t) }
         return_type = map_type(return_type)
         super(name, arg_types, return_type)
       end
@@ -40,5 +38,6 @@ module Z3
     attach_function :Z3_mk_set_union, [:ctx_pointer, :int, :pointer], :ast_pointer
     attach_function :Z3_mk_set_intersect, [:ctx_pointer, :int, :pointer], :ast_pointer
     attach_function :Z3_mk_distinct, [:ctx_pointer, :int, :pointer], :ast_pointer
+    attach_function :Z3_optimize_check, [:ctx_pointer, :optimize_pointer, :int, :pointer], :int
   end
 end

data/lib/z3/very_low_level_auto.rb

@@ -19,7 +19,6 @@ module Z3
     attach_function :Z3_algebraic_root, [:ctx_pointer, :ast_pointer, :uint], :ast_pointer
     attach_function :Z3_algebraic_sign, [:ctx_pointer, :ast_pointer], :int
     attach_function :Z3_algebraic_sub, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
-    attach_function :Z3_apply_result_convert_model, [:ctx_pointer, :apply_result_pointer, :uint, :model_pointer], :model_pointer
     attach_function :Z3_apply_result_dec_ref, [:ctx_pointer, :apply_result_pointer], :void
     attach_function :Z3_apply_result_get_num_subgoals, [:ctx_pointer, :apply_result_pointer], :uint
     attach_function :Z3_apply_result_get_subgoal, [:ctx_pointer, :apply_result_pointer, :uint], :goal_pointer
@@ -53,6 +52,7 @@ module Z3
     attach_function :Z3_del_context, [:ctx_pointer], :void
     attach_function :Z3_disable_trace, [:string], :void
     attach_function :Z3_enable_trace, [:string], :void
+    attach_function :Z3_eval_smtlib2_string, [:ctx_pointer, :string], :string
     attach_function :Z3_finalize_memory, [], :void
     attach_function :Z3_fixedpoint_add_cover, [:ctx_pointer, :fixedpoint_pointer, :int, :func_decl_pointer, :ast_pointer], :void
     attach_function :Z3_fixedpoint_add_invariant, [:ctx_pointer, :fixedpoint_pointer, :func_decl_pointer, :ast_pointer], :void
@@ -145,13 +145,11 @@ module Z3
     attach_function :Z3_get_full_version, [], :string
     attach_function :Z3_get_func_decl_id, [:ctx_pointer, :func_decl_pointer], :uint
     attach_function :Z3_get_index_value, [:ctx_pointer, :ast_pointer], :uint
-    attach_function :Z3_get_interpolant, [:ctx_pointer, :ast_pointer, :ast_pointer, :params_pointer], :ast_vector_pointer
     attach_function :Z3_get_num_probes, [:ctx_pointer], :uint
     attach_function :Z3_get_num_tactics, [:ctx_pointer], :uint
     attach_function :Z3_get_numeral_decimal_string, [:ctx_pointer, :ast_pointer, :uint], :string
     attach_function :Z3_get_numeral_string, [:ctx_pointer, :ast_pointer], :string
     attach_function :Z3_get_numerator, [:ctx_pointer, :ast_pointer], :ast_pointer
-    attach_function :Z3_get_parser_error, [:ctx_pointer], :string
     attach_function :Z3_get_pattern, [:ctx_pointer, :pattern_pointer, :uint], :ast_pointer
     attach_function :Z3_get_pattern_num_terms, [:ctx_pointer, :pattern_pointer], :uint
     attach_function :Z3_get_probe_name, [:ctx_pointer, :uint], :string
@@ -181,6 +179,7 @@ module Z3
     attach_function :Z3_global_param_reset_all, [], :void
     attach_function :Z3_global_param_set, [:string, :string], :void
     attach_function :Z3_goal_assert, [:ctx_pointer, :goal_pointer, :ast_pointer], :void
+    attach_function :Z3_goal_convert_model, [:ctx_pointer, :goal_pointer, :model_pointer], :model_pointer
     attach_function :Z3_goal_dec_ref, [:ctx_pointer, :goal_pointer], :void
     attach_function :Z3_goal_depth, [:ctx_pointer, :goal_pointer], :uint
     attach_function :Z3_goal_formula, [:ctx_pointer, :goal_pointer, :uint], :ast_pointer
@@ -192,10 +191,10 @@ module Z3
     attach_function :Z3_goal_precision, [:ctx_pointer, :goal_pointer], :uint
     attach_function :Z3_goal_reset, [:ctx_pointer, :goal_pointer], :void
     attach_function :Z3_goal_size, [:ctx_pointer, :goal_pointer], :uint
+    attach_function :Z3_goal_to_dimacs_string, [:ctx_pointer, :goal_pointer], :string
     attach_function :Z3_goal_to_string, [:ctx_pointer, :goal_pointer], :string
     attach_function :Z3_goal_translate, [:ctx_pointer, :goal_pointer, :ctx_pointer], :goal_pointer
     attach_function :Z3_inc_ref, [:ctx_pointer, :ast_pointer], :void
-    attach_function :Z3_interpolation_profile, [:ctx_pointer], :string
     attach_function :Z3_interrupt, [:ctx_pointer], :void
     attach_function :Z3_is_algebraic_number, [:ctx_pointer, :ast_pointer], :bool
     attach_function :Z3_is_app, [:ctx_pointer, :ast_pointer], :bool
@@ -203,7 +202,9 @@ module Z3
     attach_function :Z3_is_eq_ast, [:ctx_pointer, :ast_pointer, :ast_pointer], :bool
     attach_function :Z3_is_eq_func_decl, [:ctx_pointer, :func_decl_pointer, :func_decl_pointer], :bool
     attach_function :Z3_is_eq_sort, [:ctx_pointer, :sort_pointer, :sort_pointer], :bool
+    attach_function :Z3_is_lambda, [:ctx_pointer, :ast_pointer], :bool
     attach_function :Z3_is_numeral_ast, [:ctx_pointer, :ast_pointer], :bool
+    attach_function :Z3_is_quantifier_exists, [:ctx_pointer, :ast_pointer], :bool
     attach_function :Z3_is_quantifier_forall, [:ctx_pointer, :ast_pointer], :bool
     attach_function :Z3_is_well_sorted, [:ctx_pointer, :ast_pointer], :bool
     attach_function :Z3_mk_array_default, [:ctx_pointer, :ast_pointer], :ast_pointer
@@ -337,8 +338,6 @@ module Z3
     attach_function :Z3_mk_int_sort, [:ctx_pointer], :sort_pointer
     attach_function :Z3_mk_int_symbol, [:ctx_pointer, :int], :symbol_pointer
     attach_function :Z3_mk_int_to_str, [:ctx_pointer, :ast_pointer], :ast_pointer
-    attach_function :Z3_mk_interpolant, [:ctx_pointer, :ast_pointer], :ast_pointer
-    attach_function :Z3_mk_interpolation_context, [:config_pointer], :ctx_pointer
     attach_function :Z3_mk_is_int, [:ctx_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_ite, [:ctx_pointer, :ast_pointer, :ast_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_le, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
@@ -401,9 +400,9 @@ module Z3
     attach_function :Z3_model_has_interp, [:ctx_pointer, :model_pointer, :func_decl_pointer], :bool
     attach_function :Z3_model_inc_ref, [:ctx_pointer, :model_pointer], :void
     attach_function :Z3_model_to_string, [:ctx_pointer, :model_pointer], :string
+    attach_function :Z3_model_translate, [:ctx_pointer, :model_pointer, :ctx_pointer], :model_pointer
     attach_function :Z3_optimize_assert, [:ctx_pointer, :optimize_pointer, :ast_pointer], :void
     attach_function :Z3_optimize_assert_soft, [:ctx_pointer, :optimize_pointer, :ast_pointer, :string, :symbol_pointer], :uint
-    attach_function :Z3_optimize_check, [:ctx_pointer, :optimize_pointer], :int
     attach_function :Z3_optimize_dec_ref, [:ctx_pointer, :optimize_pointer], :void
     attach_function :Z3_optimize_from_file, [:ctx_pointer, :optimize_pointer, :string], :void
     attach_function :Z3_optimize_from_string, [:ctx_pointer, :optimize_pointer, :string], :void
@@ -416,6 +415,7 @@ module Z3
     attach_function :Z3_optimize_get_param_descrs, [:ctx_pointer, :optimize_pointer], :param_descrs_pointer
     attach_function :Z3_optimize_get_reason_unknown, [:ctx_pointer, :optimize_pointer], :string
     attach_function :Z3_optimize_get_statistics, [:ctx_pointer, :optimize_pointer], :stats_pointer
+    attach_function :Z3_optimize_get_unsat_core, [:ctx_pointer, :optimize_pointer], :ast_vector_pointer
     attach_function :Z3_optimize_get_upper, [:ctx_pointer, :optimize_pointer, :uint], :ast_pointer
     attach_function :Z3_optimize_get_upper_as_vector, [:ctx_pointer, :optimize_pointer, :uint], :ast_vector_pointer
     attach_function :Z3_optimize_inc_ref, [:ctx_pointer, :optimize_pointer], :void
@@ -485,6 +485,7 @@ module Z3
     attach_function :Z3_solver_assert, [:ctx_pointer, :solver_pointer, :ast_pointer], :void
     attach_function :Z3_solver_assert_and_track, [:ctx_pointer, :solver_pointer, :ast_pointer, :ast_pointer], :void
     attach_function :Z3_solver_check, [:ctx_pointer, :solver_pointer], :int
+    attach_function :Z3_solver_cube, [:ctx_pointer, :solver_pointer, :ast_vector_pointer, :uint], :ast_vector_pointer
     attach_function :Z3_solver_dec_ref, [:ctx_pointer, :solver_pointer], :void
     attach_function :Z3_solver_from_file, [:ctx_pointer, :solver_pointer, :string], :void
     attach_function :Z3_solver_from_string, [:ctx_pointer, :solver_pointer, :string], :void
@@ -492,12 +493,15 @@ module Z3
     attach_function :Z3_solver_get_consequences, [:ctx_pointer, :solver_pointer, :ast_vector_pointer, :ast_vector_pointer, :ast_vector_pointer], :int
     attach_function :Z3_solver_get_help, [:ctx_pointer, :solver_pointer], :string
     attach_function :Z3_solver_get_model, [:ctx_pointer, :solver_pointer], :model_pointer
+    attach_function :Z3_solver_get_non_units, [:ctx_pointer, :solver_pointer], :ast_vector_pointer
     attach_function :Z3_solver_get_num_scopes, [:ctx_pointer, :solver_pointer], :uint
     attach_function :Z3_solver_get_param_descrs, [:ctx_pointer, :solver_pointer], :param_descrs_pointer
     attach_function :Z3_solver_get_proof, [:ctx_pointer, :solver_pointer], :ast_pointer
     attach_function :Z3_solver_get_reason_unknown, [:ctx_pointer, :solver_pointer], :string
     attach_function :Z3_solver_get_statistics, [:ctx_pointer, :solver_pointer], :stats_pointer
+    attach_function :Z3_solver_get_units, [:ctx_pointer, :solver_pointer], :ast_vector_pointer
     attach_function :Z3_solver_get_unsat_core, [:ctx_pointer, :solver_pointer], :ast_vector_pointer
+    attach_function :Z3_solver_import_model_converter, [:ctx_pointer, :solver_pointer, :solver_pointer], :void
     attach_function :Z3_solver_inc_ref, [:ctx_pointer, :solver_pointer], :void
     attach_function :Z3_solver_pop, [:ctx_pointer, :solver_pointer, :uint], :void
     attach_function :Z3_solver_push, [:ctx_pointer, :solver_pointer], :void

data/spec/integration/oneofus_spec.rb

@@ -1,19 +1,11 @@
+# This puzzle is ambiguous and different z3 versions return different result,
+# so just checking that it doesn't crash
+
 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
+  let(:binary) { Pathname(__dir__) + "../../examples/oneofus" }
 
-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
+  it do
+    output = `#{binary}`.chomp
+    expect(output.lines.size).to eq(13)
   end
 end

data/spec/optimize_spec.rb

@@ -43,14 +43,14 @@ module Z3
     # This is a very simple example of unknown satisfiablity
     # so we might need more complex one in the future
     # Unlike Z3::Solver, this is unknown even 4.6.0
-    it "third way" do
+    it "unknown satisfiability" do
       optimize.assert a**3 == a
       expect(optimize.check).to eq(:unknown)
       expect{optimize.satisfiable?}.to raise_error("Satisfiability unknown")
       expect{optimize.unsatisfiable?}.to raise_error("Satisfiability unknown")
     end
 
-    it "third way" do
+    it "unknown satisfiability" do
       optimize.assert a**a == a
       expect(optimize.check).to eq(:unknown)
       expect{optimize.satisfiable?}.to raise_error("Satisfiability unknown")
@@ -65,7 +65,7 @@ module Z3
       expect(optimize.model[a].to_i).to eq 9
     end
 
-    it "maximize" do
+    it "minimize" do
       optimize.assert a > 0
       optimize.assert a < 10
       optimize.minimize a

data/spec/set_expr_spec.rb

@@ -25,9 +25,9 @@ module Z3
           b.include?(3),
           c == a.union(b),
         ]).to have_solution(
-          a => "store(store(const(false), 1, true), 2, true)",
-          b => "store(store(const(false), 3, true), 2, true)",
-          c => "store(store(store(const(false), 1, true), 3, true), 2, true)",
+          a => "(lambda ((x!1 Int)) (or (= x!1 1) (= x!1 2)))",
+          b => "(lambda ((x!1 Int)) (or (= x!1 3) (= x!1 2)))",
+          c => "(lambda ((x!1 Int)) (or (= x!1 1) (= x!1 3) (= x!1 2)))",
         )
       end
 
@@ -41,9 +41,9 @@ module Z3
           b.include?(3),
           c == a.difference(b),
         ]).to have_solution(
-          a => "store(store(const(false), 1, true), 2, true)",
-          b => "store(const(true), 1, false)",
-          c => "store(const(false), 1, true)",
+          a => "(lambda ((x!1 Int)) (or (= x!1 1) (= x!1 2)))",
+          b => "(lambda ((x!1 Int)) (not (= x!1 1)))",
+          c => "(lambda ((x!1 Int)) (= x!1 1))",
         )
       end
 
@@ -55,9 +55,9 @@ module Z3
           b.include?(3),
           c == a.intersection(b),
         ]).to have_solution(
-          a => "store(store(const(false), 1, true), 2, true)",
-          b => "store(store(const(false), 3, true), 2, true)",
-          c => "store(store(store(const(false), 1, true), 3, true), 2, true)",
+          a => "(lambda ((x!1 Int)) (or (= x!1 1) (= x!1 2)))",
+          b => "(lambda ((x!1 Int)) (or (= x!1 3) (= x!1 2)))",
+          c => "(lambda ((x!1 Int)) (or (= x!1 1) (= x!1 3) (= x!1 2)))",
         )
       end
     end

data/spec/solver_spec.rb

@@ -45,14 +45,14 @@ module Z3
     # 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
+      it "unknown satisfiability (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
+      it "unknown satisfiability (until 4.6 fix)" do
         solver.assert a**3 == a
         expect(solver.check).to eq(:unknown)
         expect{solver.satisfiable?}.to raise_error("Satisfiability unknown")
@@ -60,7 +60,7 @@ module Z3
       end
     end
 
-    it "third way" do
+    it "unknown satisfiability" do
       solver.assert a**a == a
       expect(solver.check).to eq(:unknown)
       expect{solver.satisfiable?}.to raise_error("Satisfiability unknown")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: z3
 version: !ruby/object:Gem::Version
-  version: 0.0.20180629
+  version: 0.0.20181126
 platform: ruby
 authors:
 - Tomasz Wegrzanowski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-29 00:00:00.000000000 Z
+date: 2018-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -30,70 +30,70 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '12'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.8'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.16'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.16'
 - !ruby/object:Gem::Dependency
   name: regexp_parser
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: ffi
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.9'
 description: Ruby bindings for Z3 Constraint Solver
 email: Tomasz.Wegrzanowski@gmail.com
 executables: []
@@ -267,9 +267,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
-- z3 library
+- z3 library (4.8+)
 rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Z3 Constraint Solver