z3 0.0.0

data/lib/z3/sort.rb

@@ -0,0 +1,33 @@
+class Z3::Sort
+  attr_reader :_sort
+  # Do not use .new directly
+  def initialize(_sort)
+    @_sort = _sort
+  end
+
+  def ==(other)
+    other.is_a?(Z3::Sort) and @_sort == other._sort
+  end
+
+  def to_s
+    Z3::LowLevel.sort_to_string(self)
+  end
+
+  def inspect
+    "Z3::Sort<#{to_s}>"
+  end
+
+  class << self
+    def bool
+      Z3::Sort.new(Z3::LowLevel.mk_bool_sort)
+    end
+
+    def int
+      Z3::Sort.new(Z3::LowLevel.mk_int_sort)
+    end
+
+    def real
+      Z3::Sort.new(Z3::LowLevel.mk_real_sort)
+    end
+  end
+end

data/lib/z3/very_low_level.rb

@@ -0,0 +1,89 @@
+# Seriously do not use this directly in your code
+
+require 'ffi'
+
+module Z3::VeryLowLevel
+  extend FFI::Library
+  ffi_lib "z3"
+  # Aliases defined just to make APIs below look nicer
+  ctx_pointer = :pointer
+  solver_pointer = :pointer
+  ast_pointer = :pointer
+  sort_pointer = :pointer
+  symbol = :pointer
+  model_pointer = :pointer
+  func_decl_pointer = :pointer
+  z3_bool = :int
+
+  # Common API
+  callback :error_handler, [ctx_pointer, :int], :void
+
+  attach_function :Z3_get_version, [:pointer, :pointer, :pointer, :pointer], :void
+  attach_function :Z3_set_error_handler, [ctx_pointer, :error_handler], :void
+  attach_function :Z3_global_param_set, [:string, :string], :void
+
+  # Context API
+  attach_function :Z3_mk_context, [], ctx_pointer
+
+  # Symbol API
+  attach_function :Z3_mk_string_symbol, [ctx_pointer, :string], symbol
+  attach_function :Z3_get_symbol_string, [ctx_pointer, symbol], :string
+
+  # Sort API
+  attach_function :Z3_mk_bool_sort, [ctx_pointer], sort_pointer
+  attach_function :Z3_mk_int_sort, [ctx_pointer], sort_pointer
+  attach_function :Z3_mk_real_sort, [ctx_pointer], sort_pointer
+  attach_function :Z3_sort_to_string, [ctx_pointer, sort_pointer], :string
+
+  # Solver API
+  attach_function :Z3_mk_solver, [ctx_pointer], solver_pointer
+  attach_function :Z3_solver_push, [ctx_pointer, solver_pointer], :void
+  attach_function :Z3_solver_pop, [ctx_pointer, solver_pointer, :int], :void
+  attach_function :Z3_solver_reset, [ctx_pointer, solver_pointer], :void
+  attach_function :Z3_solver_assert, [ctx_pointer, solver_pointer, ast_pointer], :void
+  attach_function :Z3_solver_check, [ctx_pointer, solver_pointer], z3_bool
+  attach_function :Z3_solver_inc_ref, [ctx_pointer, solver_pointer], :void
+
+  # Model API
+  attach_function :Z3_solver_get_model, [ctx_pointer, solver_pointer], model_pointer
+  attach_function :Z3_model_get_num_consts, [ctx_pointer, model_pointer], :int
+  attach_function :Z3_model_get_num_funcs, [ctx_pointer, model_pointer], :int
+  attach_function :Z3_model_get_num_sorts, [ctx_pointer, model_pointer], :int
+  attach_function :Z3_model_eval, [ctx_pointer, model_pointer, ast_pointer, :bool, :pointer], :int
+  attach_function :Z3_model_get_const_decl, [ctx_pointer, model_pointer, :int], func_decl_pointer
+  attach_function :Z3_model_get_const_interp, [ctx_pointer, model_pointer, func_decl_pointer], ast_pointer
+
+  # FuncDecl API
+  attach_function :Z3_func_decl_to_ast, [ctx_pointer, func_decl_pointer], ast_pointer
+  attach_function :Z3_get_decl_name, [ctx_pointer, func_decl_pointer], symbol
+  attach_function :Z3_get_arity, [ctx_pointer, func_decl_pointer], :uint
+  attach_function :Z3_get_decl_ast_parameter, [ctx_pointer, func_decl_pointer, :uint], ast_pointer
+
+  # AST API
+  attach_function :Z3_mk_true, [ctx_pointer], ast_pointer
+  attach_function :Z3_mk_false, [ctx_pointer], ast_pointer
+  attach_function :Z3_mk_eq, [ctx_pointer, ast_pointer, ast_pointer], ast_pointer
+  attach_function :Z3_mk_ge, [ctx_pointer, ast_pointer, ast_pointer], ast_pointer
+  attach_function :Z3_mk_gt, [ctx_pointer, ast_pointer, ast_pointer], ast_pointer
+  attach_function :Z3_mk_le, [ctx_pointer, ast_pointer, ast_pointer], ast_pointer
+  attach_function :Z3_mk_lt, [ctx_pointer, ast_pointer, ast_pointer], ast_pointer
+  attach_function :Z3_mk_power, [ctx_pointer, ast_pointer, ast_pointer], ast_pointer
+  attach_function :Z3_mk_rem, [ctx_pointer, ast_pointer, ast_pointer], ast_pointer
+  attach_function :Z3_mk_mod, [ctx_pointer, ast_pointer, ast_pointer], ast_pointer
+  attach_function :Z3_mk_div, [ctx_pointer, ast_pointer, ast_pointer], ast_pointer
+  attach_function :Z3_mk_not, [ctx_pointer, ast_pointer], ast_pointer
+  attach_function :Z3_mk_const, [ctx_pointer, symbol, sort_pointer], ast_pointer
+  attach_function :Z3_mk_and, [ctx_pointer, :int, :pointer], ast_pointer
+  attach_function :Z3_mk_or, [ctx_pointer, :int, :pointer], ast_pointer
+  attach_function :Z3_mk_iff, [ctx_pointer, ast_pointer, ast_pointer], ast_pointer
+  attach_function :Z3_mk_implies, [ctx_pointer, ast_pointer, ast_pointer], ast_pointer
+  attach_function :Z3_mk_add, [ctx_pointer, :int, :pointer], ast_pointer
+  attach_function :Z3_mk_sub, [ctx_pointer, :int, :pointer], ast_pointer
+  attach_function :Z3_mk_mul, [ctx_pointer, :int, :pointer], ast_pointer
+  attach_function :Z3_mk_distinct, [ctx_pointer, :int, :pointer], ast_pointer
+  attach_function :Z3_ast_to_string, [ctx_pointer, ast_pointer], :string
+  attach_function :Z3_get_sort, [ctx_pointer, ast_pointer], sort_pointer
+  attach_function :Z3_mk_int2real, [ctx_pointer, ast_pointer], ast_pointer
+  attach_function :Z3_mk_numeral, [ctx_pointer, :string, sort_pointer], ast_pointer
+  attach_function :Z3_mk_unary_minus, [ctx_pointer, ast_pointer], ast_pointer
+end

data/lib/z3.rb

@@ -0,0 +1,43 @@
+module Z3
+  class <<self
+    def version
+      Z3::LowLevel.get_version.join(".")
+    end
+
+    def set_param(k,v)
+      Z3::LowLevel.global_param_set(k,v)
+    end
+  end
+end
+
+class Z3::Exception < StandardError
+end
+
+require_relative "z3/very_low_level"
+require_relative "z3/low_level"
+require_relative "z3/context"
+require_relative "z3/solver"
+require_relative "z3/sort"
+require_relative "z3/ast"
+require_relative "z3/model"
+require_relative "z3/func_decl"
+
+Z3::LowLevel.set_error_handler do |ctx, error|
+  error_codes_enum = %W[
+    Z3_OK
+    Z3_SORT_ERROR
+    Z3_IOB
+    Z3_INVALID_ARG
+    Z3_PARSER_ERROR
+    Z3_NO_PARSER
+    Z3_INVALID_PATTERN
+    Z3_MEMOUT_FAIL
+    Z3_FILE_ACCESS_ERROR
+    Z3_INTERNAL_FATAL
+    Z3_INVALID_USAGE
+    Z3_DEC_REF_ERROR
+    Z3_EXCEPTION
+  ]
+  error = error_codes_enum[error] || error
+  raise Z3::Exception, "Z3 library failed with error #{error}"
+end

data/spec/ast_spec.rb

@@ -0,0 +1,172 @@
+describe Z3::Ast do
+  let(:a) { Z3::Ast.int("a") }
+  let(:b) { Z3::Ast.int("b") }
+  let(:c) { Z3::Ast.bool("c") }
+  let(:d) { Z3::Ast.bool("d") }
+  let(:e) { Z3::Ast.real("e") }
+  let(:f) { Z3::Ast.real("f") }
+
+  it "#sort returns Sort object" do
+    expect(a.sort).to eq(Z3::Sort.int)
+    expect(c.sort).to eq(Z3::Sort.bool)
+    expect(e.sort).to eq(Z3::Sort.real)
+  end
+
+  it "#to_s" do
+    expect(a.to_s).to eq("a")
+  end
+
+  it "#inspect" do
+    expect(a.inspect).to eq("Z3::Ast<a :: Int>")
+    expect((e+f).inspect).to eq("Z3::Ast<(+ e f) :: Real>")
+  end
+
+  describe "#~" do
+    it "allows negating boolean variables" do
+      expect((~c).to_s).to eq("(not c)")
+    end
+
+    it "raises exception if type cast is not possible" do
+      expect{~a}.to raise_error(Z3::Exception)
+      expect{~e}.to raise_error(Z3::Exception)
+    end
+  end
+
+  describe "#&" do
+    it "allows and of boolean variables" do
+      expect((c & d).to_s).to eq("(and c d)")
+    end
+
+    it "raises exception if type cast is not possible" do
+      expect{a&b}.to raise_error(Z3::Exception)
+      expect{e&f}.to raise_error(Z3::Exception)
+      expect{a&c}.to raise_error(Z3::Exception)
+      expect{e&c}.to raise_error(Z3::Exception)
+      expect{c&a}.to raise_error(Z3::Exception)
+      expect{c&e}.to raise_error(Z3::Exception)
+    end
+  end
+
+  describe "#|" do
+    it "allows or of boolean variables" do
+      expect((c | d).to_s).to eq("(or c d)")
+    end
+
+    it "raises exception if type cast is not possible" do
+      expect{a|b}.to raise_error(Z3::Exception)
+      expect{e|f}.to raise_error(Z3::Exception)
+      expect{a|c}.to raise_error(Z3::Exception)
+      expect{e|c}.to raise_error(Z3::Exception)
+      expect{c|a}.to raise_error(Z3::Exception)
+      expect{c|e}.to raise_error(Z3::Exception)
+    end
+  end
+
+  %W[+ - * <= < >= >].each do |op|
+    describe "#{op} arithmetic operator" do
+      it "allows + of int or real variables" do
+        expect((a.send op, b).to_s).to eq "(#{op} a b)"
+        expect((e.send op, f).to_s).to eq "(#{op} e f)"
+      end
+
+      it "casts to correct type if possible" do
+        expect((a.send op, e).to_s).to eq "(#{op} (to_real a) e)"
+        expect((e.send op, a).to_s).to eq "(#{op} e (to_real a))"
+        expect((a.send op, 42).to_s).to eq "(#{op} a 42)"
+        expect((42.send op, a).to_s).to eq "(#{op} 42 a)"
+        expect((a.send op, 42.5).to_s).to eq "(#{op} (to_real a) (/ 85.0 2.0))"
+        expect((42.5.send op, a).to_s).to eq "(#{op} (/ 85.0 2.0) (to_real a))"
+        expect((e.send op, 42).to_s).to eq "(#{op} e 42.0)"
+        expect((42.send op, e).to_s).to eq "(#{op} 42.0 e)"
+        expect((e.send op, 42.5).to_s).to eq "(#{op} e (/ 85.0 2.0))"
+        expect((42.5.send op, e).to_s).to eq "(#{op} (/ 85.0 2.0) e)"
+      end
+
+      it "raises exception if type cast is not possible" do
+        expect{a.send op, c}.to raise_error(Z3::Exception)
+        expect{c.send op, a}.to raise_error(Z3::Exception)
+        expect{e.send op, c}.to raise_error(Z3::Exception)
+        expect{c.send op, e}.to raise_error(Z3::Exception)
+        expect{c.send op, d}.to raise_error(Z3::Exception)
+        expect{a.send op, true}.to raise_error(Z3::Exception)
+        expect{c.send op, true}.to raise_error(Z3::Exception)
+        expect{e.send op, true}.to raise_error(Z3::Exception)
+        expect{a.send op, false}.to raise_error(Z3::Exception)
+        expect{c.send op, false}.to raise_error(Z3::Exception)
+        expect{e.send op, false}.to raise_error(Z3::Exception)
+      end
+    end
+  end
+
+  describe "#==" do
+    it "allows == of variables of same sort" do
+      expect((a == b).to_s).to eq "(= a b)"
+      expect((c == d).to_s).to eq "(= c d)"
+      expect((e == f).to_s).to eq "(= e f)"
+    end
+
+    it "casts to correct type if possible" do
+      expect((a == 42).to_s).to eq "(= a 42)"
+      expect((42 == a).to_s).to eq "(= a 42)"
+      expect((a == e).to_s).to eq "(= (to_real a) e)"
+      expect((e == a).to_s).to eq "(= e (to_real a))"
+      expect((c == true).to_s).to eq "(= c true)"
+      expect((c == false).to_s).to eq "(= c false)"
+      expect((a == 42.5).to_s).to eq "(= (to_real a) (/ 85.0 2.0))"
+      expect((42.5 == a).to_s).to eq "(= (to_real a) (/ 85.0 2.0))"
+      expect((e == 42.5).to_s).to eq "(= e (/ 85.0 2.0))"
+      expect((42.5 == e).to_s).to eq "(= e (/ 85.0 2.0))"
+      # expect((true == c).to_s).to eq "(= true c)"
+      # expect((false == c).to_s).to eq "(= false c)"
+    end
+
+    it "raises exception if type cast is not possible" do
+      expect{a == c}.to raise_error(Z3::Exception)
+      expect{e == c}.to raise_error(Z3::Exception)
+      expect{a == true}.to raise_error(Z3::Exception)
+      expect{e == true}.to raise_error(Z3::Exception)
+      # expect{true == a}.to raise_error(Z3::Exception)
+      # expect{true == e}.to raise_error(Z3::Exception)
+      expect{c == 42}.to raise_error(Z3::Exception)
+      expect{c == 42.5}.to raise_error(Z3::Exception)
+      expect{42 == c}.to raise_error(Z3::Exception)
+      expect{42.5 == c}.to raise_error(Z3::Exception)
+    end
+  end
+
+  describe "#!=" do
+    it "allows != of variables of same sort" do
+      expect((a != b).to_s).to eq "(distinct a b)"
+      expect((c != d).to_s).to eq "(distinct c d)"
+      expect((e != f).to_s).to eq "(distinct e f)"
+    end
+
+    it "casts to correct type if possible" do
+      expect((a != 42).to_s).to eq "(distinct a 42)"
+      # expect((42 != a).to_s).to eq "(distinct a 42)"
+      expect((a != e).to_s).to eq "(distinct (to_real a) e)"
+      expect((e != a).to_s).to eq "(distinct e (to_real a))"
+      expect((c != true).to_s).to eq "(distinct c true)"
+      expect((c != false).to_s).to eq "(distinct c false)"
+      expect((a != 42.5).to_s).to eq "(distinct (to_real a) (/ 85.0 2.0))"
+      # expect((42.5 != a).to_s).to eq "(distinct (to_real a) (/ 85.0 2.0))"
+      expect((e != 42.5).to_s).to eq "(distinct e (/ 85.0 2.0))"
+      # expect((42.5 != e).to_s).to eq "(distinct e (/ 85.0 2.0))"
+      # expect((true != c).to_s).to eq "(distinct true c)"
+      # expect((false != c).to_s).to eq "(distinct false c)"
+    end
+
+    it "raises exception if type cast is not possible" do
+      expect{a != c}.to raise_error(Z3::Exception)
+      expect{e != c}.to raise_error(Z3::Exception)
+      expect{a != true}.to raise_error(Z3::Exception)
+      expect{e != true}.to raise_error(Z3::Exception)
+      # expect{true != a}.to raise_error(Z3::Exception)
+      # expect{true != e}.to raise_error(Z3::Exception)
+      expect{c != 42}.to raise_error(Z3::Exception)
+      expect{c != 42.5}.to raise_error(Z3::Exception)
+      # expect{42 != c}.to raise_error(Z3::Exception)
+      # expect{42.5 != c}.to raise_error(Z3::Exception)
+    end
+  end
+end

data/spec/integration/algebra_problems_spec.rb

@@ -0,0 +1,30 @@
+describe "Algebra Problems" do
+  let(:executable) { "#{__dir__}/../../examples/algebra_problems" }
+  it "can solve algebra puzzles" do
+    expect(IO.popen(executable).read).to eq <<EOF
+Solution to problem 01:
+Solution to problem 03:
+* x = (- 22.0)
+* |-6| = 6.0
+* |x-2| = 24.0
+Solution to problem 04:
+* ax = (- 4.0)
+* ay = (- 5.0)
+* bx = (- 1.0)
+* by = (- 1.0)
+* |a-b| = 5.0
+Solution to problem 05:
+* x = (/ 9.0 2.0)
+* y = 0.0
+Solution to problem 06:
+* answer = 6.0
+* x1 = 1.0
+* x2 = 2.0
+* y1 = 7.0
+* y2 = 13.0
+Solution to problem 10:
+* x = 1.0
+* |-2x + 2| = 0.0
+EOF
+  end
+end

data/spec/integration/bagic_int_math_spec.rb

@@ -0,0 +1,14 @@
+describe "Basic Int Math" do
+  let(:executable) { "#{__dir__}/../../examples/basic_int_math" }
+  it "can solve basic integer math problems" do
+    expect(IO.popen(executable).read).to eq <<EOF
+Checking if (a+b)(a-b)==a*a-b*b
+Proven
+Checking if a+b >= a
+Counterexample exists
+* b = (- 1)
+Checking if a+b >= a if a,b >= 0
+Proven
+EOF
+  end
+end

data/spec/integration/basic_logic_spec.rb

@@ -0,0 +1,15 @@
+describe "Basic Logic" do
+  let(:executable) { "#{__dir__}/../../examples/basic_logic" }
+  it "can solve basic logic problems" do
+    expect(IO.popen(executable).read).to eq <<EOF
+Checking if true == true
+Proven
+Checking if true == false
+Counterexample exists
+Proving ~(a & b) == (~a | ~b)
+Proven
+Proving ~(a | b) == (~a & ~b)
+Proven
+EOF
+  end
+end

data/spec/integration/geometry_problem_spec.rb

@@ -0,0 +1,17 @@
+describe "Geometry Problem" do
+  let(:executable) { "#{__dir__}/../../examples/geometry_problem" }
+  it "can solve verbal arithmetic puzzles" do
+    expect(IO.popen(executable).read).to eq <<EOF
+* a.x = 0.0
+* a.y = (root-obj (+ (^ x 2) (- 300)) 1)
+* b.x = 0.0
+* b.y = 0.0
+* c.x = 10.0
+* c.y = 0.0
+* d.x = 10.0
+* d.y = (root-obj (+ (^ x 2) (- 300)) 1)
+* |a-c| = (- 20.0)
+* |b-d| = 20.0
+EOF
+  end
+end

data/spec/integration/kinematics_problems_spec.rb

@@ -0,0 +1,54 @@
+describe "Kinematics Problems" do
+  let(:executable) { "#{__dir__}/../../examples/kinematics_problems" }
+  it "can solve kinematics problems" do
+    expect(IO.popen(executable).read).to eq <<EOF
+Solution to problem 01:
+* a = (/ 16.0 5.0)
+* d = (/ 215168.0 125.0)
+* t = (/ 164.0 5.0)
+Solution to problem 02:
+* a = (/ 2200000.0 271441.0)
+* d = 110.0
+* t = (/ 521.0 100.0)
+Solution to problem 03:
+* a = (/ 981.0 100.0)
+* d = (/ 165789.0 5000.0)
+* t = (/ 13.0 5.0)
+* v = (/ 12753.0 500.0)
+Solution to problem 04:
+* a = (/ 2760.0 247.0)
+* d = (/ 79781.0 1000.0)
+* t = (/ 247.0 100.0)
+* ve = (/ 461.0 10.0)
+* vs = (/ 37.0 2.0)
+Solution to problem 05:
+* a = (/ 167.0 100.0)
+* d = (/ 7.0 5.0)
+* t = (root-obj (+ (* 167 (^ x 2)) (- 280)) 2)
+Solution to problem 06:
+* a = (/ 14800.0 61.0)
+* d = (/ 20313.0 50.0)
+* t = (/ 183.0 100.0)
+* v = 444.0
+Solution to problem 07:
+* a = (/ 5041.0 7080.0)
+* d = (/ 177.0 5.0)
+* t = (/ 708.0 71.0)
+* v = (/ 71.0 10.0)
+Solution to problem 08:
+* a = 3.0
+* d = (/ 4225.0 6.0)
+* t = (/ 65.0 3.0)
+* v = 65.0
+Solution to problem 09:
+* d = (/ 714.0 25.0)
+* t = (/ 51.0 20.0)
+* v = (/ 112.0 5.0)
+Solution to problem 10:
+* a = (- (/ 981.0 100.0))
+* d = (/ 131.0 50.0)
+* t = (root-obj (+ (* 981 (^ x 2)) (- 524)) 2)
+* v = (root-obj (+ (* 2500 (^ x 2)) (- 128511)) 2)
+EOF
+  end
+end

data/spec/integration/light_up_spec.rb

@@ -0,0 +1,14 @@
+describe "LightUp" do
+  let(:executable) { "#{__dir__}/../../examples/light_up_solver" }
+  it "can solve light up puzzle" do
+    expect(IO.popen(executable).read.gsub(/ *$/, "")).to eq <<EOF
+  * 0
+*
+x 2*x
+  *3  *
+* x*x*3
+      *
+ *1 *
+EOF
+  end
+end

data/spec/integration/minisudoku_spec.rb

@@ -0,0 +1,13 @@
+describe "MiniSudoku" do
+  let(:executable) { "#{__dir__}/../../examples/minisudoku_solver" }
+  it "can solve minisudoku" do
+    expect(IO.popen(executable).read).to eq <<EOF
+2 1 5 4 3 6
+3 6 4 1 2 5
+1 3 6 5 4 2
+4 5 2 3 6 1
+5 2 3 6 1 4
+6 4 1 2 5 3
+EOF
+  end
+end

data/spec/integration/selfref_spec.rb

@@ -0,0 +1,27 @@
+describe "Self-Referential Aptitude Test" do
+  let(:executable) { "#{__dir__}/../../examples/selfref_solver" }
+  it "can solve minisudokus" do
+    expect(IO.popen(executable).read).to eq <<EOF
+Q 1: D
+Q 2: A
+Q 3: D
+Q 4: B
+Q 5: E
+Q 6: D
+Q 7: D
+Q 8: E
+Q 9: D
+Q10: A
+Q11: B
+Q12: A
+Q13: D
+Q14: B
+Q15: A
+Q16: D
+Q17: B
+Q18: A
+Q19: B
+Q20: E
+EOF
+  end
+end

data/spec/integration/sudoku_spec.rb

@@ -0,0 +1,16 @@
+describe "Sudoku" do
+  let(:executable) { "#{__dir__}/../../examples/sudoku_solver" }
+  it "can solve sudoku" do
+    expect(IO.popen(executable).read).to eq <<EOF
+8 6 3 5 7 9 2 4 1
+9 2 5 3 1 4 8 7 6
+4 7 1 8 2 6 9 5 3
+7 1 4 6 8 3 5 2 9
+6 8 9 7 5 2 3 1 4
+3 5 2 4 9 1 6 8 7
+1 3 6 2 4 5 7 9 8
+2 4 8 9 3 7 1 6 5
+5 9 7 1 6 8 4 3 2
+EOF
+  end
+end

data/spec/integration/verbal_arithmetic_spec.rb

@@ -0,0 +1,10 @@
+describe "Verbal Arithmetic" do
+  let(:executable) { "#{__dir__}/../../examples/verbal_arithmetic" }
+  it "can solve verbal arithmetic puzzles" do
+    expect(IO.popen(executable).read).to eq <<EOF
+[["S", 9], ["E", 5], ["N", 6], ["D", 7]]
+[["M", 1], ["O", 0], ["R", 8], ["E", 5]]
+[["M", 1], ["O", 0], ["N", 6], ["E", 5], ["Y", 2]]
+EOF
+  end
+end

data/spec/model_spec.rb

@@ -0,0 +1,37 @@
+# Solver and Model specs are codependent, so half of functionality of each is tested in other class's tests
+describe Z3::Model do
+  let(:solver) { Z3::Solver.new }
+  let(:a) { Z3::Ast.int("a") }
+  let(:b) { Z3::Ast.int("b") }
+  let(:c) { Z3::Ast.int("c") }
+  let(:model) { solver.model }
+
+  it "knows how many variables are in the model" do
+    solver.assert(a == 2)
+    solver.assert(b == a+2)
+    expect(solver.check).to eq(:sat)
+    expect(model.num_consts).to eq(2)
+    expect(model.num_funcs).to eq(0)
+    expect(model.num_sorts).to eq(0)
+  end
+
+  it "can evaluate variables" do
+    solver.assert(a == 2)
+    solver.assert(b == a+2)
+    expect(solver.check).to eq(:sat)
+    expect(model.model_eval(a).inspect).to eq("Z3::Ast<2 :: Int>")
+    expect(model.model_eval(b).inspect).to eq("Z3::Ast<4 :: Int>")
+    expect(model.model_eval(c).inspect).to eq("Z3::Ast<c :: Int>")
+    expect(model.model_eval(a, true).inspect).to eq("Z3::Ast<2 :: Int>")
+    expect(model.model_eval(b, true).inspect).to eq("Z3::Ast<4 :: Int>")
+    expect(model.model_eval(c, true).inspect).to eq("Z3::Ast<0 :: Int>")
+  end
+
+  it "#to_s" do
+    solver.assert(a == 2)
+    solver.assert(b == a+2)
+    expect(solver.check).to eq(:sat)
+    expect(model.to_s).to eq("Z3::Model<a=2, b=4>")
+    expect(model.inspect).to eq("Z3::Model<a=2, b=4>")
+  end
+end

data/spec/solver_spec.rb

@@ -0,0 +1,22 @@
+# Solver and Model specs are codependent, so half of functionality of each is tested in other class's tests
+describe Z3::Solver do
+  let(:solver) { Z3::Solver.new }
+  let(:a) { Z3::Ast.int("a") }
+  let(:b) { Z3::Ast.int("b") }
+
+  it "basic functionality" do
+    solver.assert(a == b)
+    expect(solver.check).to eq(:sat)
+    solver.assert(a != b)
+    expect(solver.check).to eq(:unsat)
+  end
+
+  it "push/pop" do
+    solver.assert(a == b)
+    solver.push
+    solver.assert(a != b)
+    expect(solver.check).to eq(:unsat)
+    solver.pop
+    expect(solver.check).to eq(:sat)
+  end
+end

data/spec/sort_spec.rb

@@ -0,0 +1,22 @@
+describe Z3::Sort do
+  it "#bool creates Bool sort" do
+    expect(Z3::Sort.bool.to_s).to eq("Bool")
+    expect(Z3::Sort.bool.inspect).to eq("Z3::Sort<Bool>")
+  end
+
+  it "#int creates Int sort" do
+    expect(Z3::Sort.int.to_s).to eq("Int")
+    expect(Z3::Sort.int.inspect).to eq("Z3::Sort<Int>")
+  end
+
+  it "#real creates Real sort" do
+    expect(Z3::Sort.real.to_s).to eq("Real")
+    expect(Z3::Sort.real.inspect).to eq("Z3::Sort<Real>")
+  end
+
+  it "supports ==" do
+    expect(Z3::Sort.bool).to eq(Z3::Sort.bool)
+    expect(Z3::Sort.int).to eq(Z3::Sort.int)
+    expect(Z3::Sort.bool).to_not eq(Z3::Sort.int)
+  end
+end