z3 0.0.20251017 → 0.0.20260727

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eba319d56d6c1d848c4d50a904b5ce6f324589fd10606f8e8233d2118b22ab5b
-  data.tar.gz: 5a38dc72afd6e48f57e712b4db42c78587e532c5605f6c0a3290c255c8f682bf
+  metadata.gz: 2722943f324098ac25b10410d1b4d8b24afab4681ee8b28772824f25daf83ad9
+  data.tar.gz: b6e1b3225862edce94fe37751739467db74e6ebbd432e122f53aa00afff1e0b1
 SHA512:
-  metadata.gz: 8f40bbe4cb4c034313d76071d97c857648da9317bb53eecdae07114981d90576e45a4832fc3df7f508641b70e3b8b8fc03f787c7424b680574f0d6ed57785c13
-  data.tar.gz: 902d5ef0940cda61a31e99899756eaab0d1eb6fc051a3a162aebf1752ca1c00eff685f18931b68849af42920fe08d8eeda4994251d9b7bd8defce256f3d2b59d
+  metadata.gz: 35a9657f906d701f0b433cf209e90280a05f65f7df10c748febcf8f6deeb3cae180fb002572461bce9db63b1c6aedc0ee31e2474c7460f1a3611731121a508fd
+  data.tar.gz: 72343dc4e5bca1b0dd33a0f483a92552390b07ea004759dbbaac413fa2195b5287f047ed701e5ab4bbdf3c368bba66901d064d03231399e1b9f154a3ac3679e3

data/README.md

@@ -1,12 +1,52 @@
-This is Ruby interface for Z3 [ https://github.com/Z3Prover/z3 ].
+# Ruby bindings for Z3
 
-Minimum required version is Z3 4.8.
+This is a Ruby interface for [Z3](https://github.com/Z3Prover/z3).
 
-It's in very early stages of development. Pull requests always welcome.
+Recommended [Z3](https://github.com/Z3Prover/z3) version is 4.16 or newer. Make sure you have it first (e.g. `brew install z3` on MacOS).
 
-### Interface
+```sh
+gem install z3
+```
+
+[API documentation is here](https://taw.github.io/z3/).
+
+## Basic usage
+
+Variables are initialized with `Z3.Bool`, `Z3.Int`, `Z3.Real`, `Z3.Bitvec`.
+
+Constrain and solve with `Z3::Solver` and `Z3::Optimize`.
+
+```ruby
+require 'z3'
+
+# make z3 variables
+a, b = Z3.Int('a'), Z3.Int('b')
+
+# add constraints with expressions
+solver = Z3::Solver.new
+solver.assert(a > 1)
+solver.assert(b > 0)
+solver.assert(a + b == 3)
+
+# check sat, find model
+if solver.satisfiable?
+  model = solver.model
+
+  # convert z3 model to ruby types
+  hash = model.to_h do |zvar, zvalue|
+    [zvar.to_s, zvalue.to_i]
+  end
+
+  p hash
+  # {"a" => 2, "b" => 1}
+end
+```
+
+## Interface
+
+The public interface is various methods in `Z3` module, and on objects created by it.
 
-The public interface is various methods in `Z3` module, and on objects created by it. `examples/` directory is probably the best place to start.
+The [`examples/`](https://github.com/taw/z3/blob/master/examples) directory is probably the best place to start.
 
 You can use most Ruby operators to construct Z3 expressions, but use `| &` instead of `|| &&` for boolean operators. They unfortunately have wrong operator precedence so you'll need to use some extra parentheses.
 

data/Rakefile

@@ -1,4 +1,5 @@
 require "json"
+require "rdoc/task"
 
 task "default" => "spec"
 task "test" => "spec"
@@ -61,3 +62,13 @@ task "coverage:missing" do
     file.puts missing
   end
 end
+
+RDoc::Task.new do |rdoc|
+  rdoc.main = "README.md"
+  rdoc.rdoc_dir = "docs"
+  rdoc.rdoc_files.include("README.md", "lib/**/*.rb")
+  rdoc.rdoc_files.exclude("lib/z3/hacks.rb")
+  rdoc.rdoc_files.exclude("lib/z3/low_level.rb")
+  rdoc.rdoc_files.exclude("lib/z3/very_low_level.rb")
+  rdoc.rdoc_files.exclude("lib/z3/very_low_level_auto.rb")
+end

data/examples/aquarium

@@ -25,14 +25,12 @@ class Aquarium
 
     # Row sums
     @ysize.times do |y|
-      sum = Z3.Add(*@xsize.times.map{|x| cell_var(x, y).ite(1, 0) })
-      @solver.assert sum == @rows[y]
+      @solver.assert Z3.Exactly(@xsize.times.map{|x| cell_var(x, y) }, @rows[y])
     end
 
     # Col sums
     @xsize.times do |x|
-      sum = Z3.Add(*@ysize.times.map{|y| cell_var(x, y).ite(1, 0) })
-      @solver.assert sum == @cols[x]
+      @solver.assert Z3.Exactly(@ysize.times.map{|y| cell_var(x, y) }, @cols[x])
     end
 
     # Container water flow

data/examples/color_nonogram

@@ -58,8 +58,7 @@ class ColorNonogram
   def constraint_line(color_constraints, line_vars)
     color_constraints.each_with_index do |(expected_total, expected_continuity), color_index|
       correct_color = line_vars.map{|vi| (vi == color_index) }
-      total = Z3.Add(*correct_color.map{|cc| cc.ite(1, 0)})
-      @solver.assert total == expected_total
+      @solver.assert Z3.Exactly(correct_color, expected_total)
       # For 0 / 1 this is all
       if expected_total >= 2
         continuity = continuity_somewhere(correct_color, expected_total)

data/examples/dominosa

@@ -73,7 +73,7 @@ class Dominosa
     end
 
     all.each do |_, vars|
-      @solver.assert Z3.Add(*vars.map{|v| v.ite(1,0) }) == 1
+      @solver.assert Z3.Exactly(vars, 1)
     end
   end
 
@@ -86,7 +86,7 @@ class Dominosa
           left_var(x,y),
           up_var(x,y),
         ].compact
-        @solver.assert Z3.Add(*vars.map{|v| v.ite(1,0) }) == 1
+        @solver.assert Z3.Exactly(vars, 1)
       end
     end
   end

data/examples/kakurasu

@@ -21,7 +21,7 @@ class Kakurasu
     @cvars = {}
     @rvars = {}
     @ysize.times do |y|
-      @ysize.times do |x|
+      @xsize.times do |x|
         b = Z3.Bool("b#{x},#{y}")
         r = Z3.Int("r#{x},#{y}")
         c = Z3.Int("c#{x},#{y}")
@@ -37,12 +37,13 @@ class Kakurasu
       end
     end
 
-    @xsize.times do |x|
-      @solver.assert Z3.Add(*@rvars[x]) == @row_sums[x]
+    # Row sums weight cells by their column index, column sums by their row index
+    @ysize.times do |y|
+      @solver.assert Z3.Add(*@rvars[y]) == @row_sums[y]
     end
 
-    @ysize.times do |y|
-      @solver.assert Z3.Add(*@cvars[y]) == @col_sums[y]
+    @xsize.times do |x|
+      @solver.assert Z3.Add(*@cvars[x]) == @col_sums[x]
     end
 
     if @solver.satisfiable?
@@ -57,7 +58,7 @@ class Kakurasu
 
   def print_board!
     @ysize.times do |y|
-      @ysize.times do |x|
+      @xsize.times do |x|
         if @model[@bvars[[x,y]]].to_b
           print "[X]"
         else

data/examples/kakurasu-2.txt

@@ -0,0 +1,2 @@
+ 4  1  7  4  5  7
+20  9  4 15

data/examples/light_up

@@ -3,6 +3,7 @@
 require "pathname"
 require_relative "../lib/z3"
 
+# Also known as Akari
 class LightUp
   def initialize(path)
     data = Pathname(path).read
@@ -14,29 +15,23 @@ class LightUp
   end
 
   def call
-    @lamps = map_coordinates{|x,y| int01(x,y)}
+    @lamps = map_coordinates{|x,y| Z3.Bool("l#{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.Add(*lamps_next_to_cell(x,y)) == v.to_i
-        end
+    each_cell do |x, y|
+      v = @data[[x,y]]
+      if v == "."
+        # Every white cell must be lit: at least one lamp in its line of sight
+        @solver.assert Z3.AtLeast(line_of_sight(x, y), 1)
+      else
+        # No lamps on walls; numbers count lamps next to node (diagonals don't count)
+        @solver.assert ~@lamps[[x,y]]
+        @solver.assert Z3.Exactly(lamps_next_to_cell(x, y), v.to_i) if ("0".."4").include?(v)
       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.Add(*raycast_cells(x,y))
-        @solver.assert Z3.Implies(@lamps[[x,y]] == 0, raycast >= 1)
-        @solver.assert Z3.Implies(@lamps[[x,y]] == 1, raycast == 0)
-      end
+    # No lamp is in raycast of another: at most one lamp per maximal white run
+    (white_runs(:horizontal) + white_runs(:vertical)).each do |run|
+      @solver.assert Z3.AtMost(run.map{|xy| @lamps[xy]}, 1)
     end
 
     if @solver.satisfiable?
@@ -53,11 +48,11 @@ class LightUp
     [[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 = []
+  # The white cell itself plus every white cell visible from it in a straight line
+  def line_of_sight(x0,y0)
+    result = [@lamps[[x0,y0]]]
     [[1,0],[-1,0],[0,1],[0,-1]].each do |dx,dy|
-      x = x0+dx
-      y = y0+dy
+      x, y = x0+dx, y0+dy
       while @data[[x,y]] == "."
         result << @lamps[[x,y]]
         x += dx
@@ -67,6 +62,22 @@ class LightUp
     result
   end
 
+  # Maximal runs of white cells, broken up by walls, in either direction
+  def white_runs(direction)
+    lines = if direction == :horizontal
+      (0...@ysize).map{|y| (0...@xsize).map{|x| [x,y]}}
+    else
+      (0...@xsize).map{|x| (0...@ysize).map{|y| [x,y]}}
+    end
+    lines.flat_map do |line|
+      line.chunk{|xy| @data[xy] == "."}.select{|white,_| white}.map{|_,run| run}
+    end
+  end
+
+  def each_cell
+    (0...@ysize).each{|y| (0...@xsize).each{|x| yield x, y}}
+  end
+
   def map_coordinates
     Hash[(0...@xsize).to_a.product((0...@ysize).to_a).map{|x,y| [[x,y],yield(x,y)]}]
   end
@@ -76,7 +87,7 @@ class LightUp
       (0...@xsize).each do |x|
         if @data[[x,y]] != "."
           print(@data[[x,y]])
-        elsif @model[@lamps[[x,y]]].to_i == 1
+        elsif @model[@lamps[[x,y]]].to_b
           print("*")
         else
           print(" ")
@@ -85,13 +96,6 @@ class LightUp
       puts "\n"
     end
   end
-
-  def int01(x,y)
-    v = Z3.Int("l#{x},#{y}")
-    @solver.assert v >= 0
-    @solver.assert v <= 1
-    v
-  end
 end
 
 path = ARGV[0] || Pathname(__dir__) + "light_up-1.txt"

data/examples/light_up-2.txt

@@ -0,0 +1,2 @@
+0.
+..

data/examples/nanro

@@ -91,10 +91,7 @@ class Nanro
       @solver.assert (cvar(x,y) != 0).implies(Z3.Or(nvar(x,y) == 0, nvar(x,y) == nval))
     end
 
-    @solver.assert Z3.Add(
-      *enum_for(:each_xy).map{|x,y|
-        (nvar(x,y) == 0).ite(1,0)
-      }) == 1
+    @solver.assert Z3.Exactly(enum_for(:each_xy).map{|x,y| nvar(x,y) == 0 }, 1)
   end
 
   def call

data/examples/regexp_string_matcher.rb

@@ -47,7 +47,7 @@ class RegexpStringMatcher
       ~regexp_match([:seq, anchor[1], [:any_star]], start_idx, @str.size)
     when :lookbehind
       regexp_match([:seq, [:any_star], anchor[1]], 0, start_idx)
-    when :lookbehind
+    when :negative_lookbehind
       ~regexp_match([:seq, [:any_star], anchor[1]], 0, start_idx)
     else
       raise "Unknown anchor type #{anchor[0]}"

data/examples/simple_regexp_parser.rb

@@ -108,7 +108,7 @@ class SimpleRegexpParser
         sequence(repeat(base, min - 1, max), part)
       end
     elsif max == 0 # a{0} -> empty, not really a thing
-      :empty
+      empty
     else
       if min == 0
         # (a){2,3} -> ()|a{1,2}(a)

data/examples/star_battle

@@ -15,20 +15,17 @@ class StarBattle
   def call
     # Each row contains 2 stars
     @size.times do |y|
-      sum = Z3.Add(*@size.times.map{|x| cell_var(x, y).ite(1, 0) })
-      @solver.assert sum == 2
+      @solver.assert Z3.Exactly(@size.times.map{|x| cell_var(x, y) }, 2)
     end
 
     # Each column contains 2 stars
     @size.times do |x|
-      sum = Z3.Add(*@size.times.map{|y| cell_var(x, y).ite(1, 0) })
-      @solver.assert sum == 2
+      @solver.assert Z3.Exactly(@size.times.map{|y| cell_var(x, y) }, 2)
     end
 
     # Each container contains 2 stars
     coords.group_by{|x,y| container_at(x,y) }.each do |name, cells|
-      sum = Z3.Add(*cells.map{|x,y| cell_var(x, y).ite(1, 0) })
-      @solver.assert sum == 2
+      @solver.assert Z3.Exactly(cells.map{|x,y| cell_var(x, y) }, 2)
     end
 
     # Can't be adjacent

data/examples/stitches

@@ -55,20 +55,20 @@ class StitchesSolver
   end
 
   def row_of_cell_vars(y)
-    @xsize.times.map{|x| @cell_vars[[x,y]].ite(1,0) }
+    @xsize.times.map{|x| @cell_vars[[x,y]] }
   end
 
   def col_of_cell_vars(x)
-    @ysize.times.map{|y| @cell_vars[[x,y]].ite(1,0) }
+    @ysize.times.map{|y| @cell_vars[[x,y]] }
   end
 
   def setup_cell_assertions!
     @xsize.times do |x|
-      @solver.assert Z3.Add(*col_of_cell_vars(x)) == @col_counts[x]
+      @solver.assert Z3.Exactly(col_of_cell_vars(x), @col_counts[x])
     end
 
     @ysize.times do |y|
-      @solver.assert Z3.Add(*row_of_cell_vars(y)) == @row_counts[y]
+      @solver.assert Z3.Exactly(row_of_cell_vars(y), @row_counts[y])
     end
   end
 
@@ -110,7 +110,7 @@ class StitchesSolver
 
   def setup_stitch_assertions!
     @stitch_groups.each do |g, vars|
-      @solver.assert Z3.Add(*vars.map{|v| v.ite(1,0)}) == @stitch_count
+      @solver.assert Z3.Exactly(vars, @stitch_count)
     end
   end
 

data/examples/yajilin

@@ -134,7 +134,8 @@ class Yajilin
           raise
         end
 
-        @solver.assert Z3.Add(*stripe.map{|c| c.ite(0,1)}) == count
+        # cvar is true for white, so ~cvar counts the black cells the arrow sees
+        @solver.assert Z3.Exactly(stripe.map{|c| ~c }, count)
       end
     end
   end
@@ -182,10 +183,7 @@ class Yajilin
     end
 
     # only one loop start
-    @solver.assert Z3.Add(
-      *enum_for(:each_xy).map{|x,y|
-        (nvar(x,y) == 0).ite(1,0)
-      }) == 1
+    @solver.assert Z3.Exactly(enum_for(:each_xy).map{|x,y| nvar(x,y) == 0 }, 1)
   end
 
   def call

data/lib/z3/expr/bitvec_expr.rb

@@ -77,10 +77,12 @@ module Z3
     end
 
     def rotate_left(num)
+      raise Z3::Exception, "Rotation amount must be a nonnegative Integer" unless num.is_a?(Integer) and num >= 0
       sort.new(LowLevel.mk_rotate_left(num, self))
     end
 
     def rotate_right(num)
+      raise Z3::Exception, "Rotation amount must be a nonnegative Integer" unless num.is_a?(Integer) and num >= 0
       sort.new(LowLevel.mk_rotate_right(num, self))
     end
 
@@ -95,10 +97,12 @@ module Z3
     end
 
     def zero_ext(size)
+      raise Z3::Exception, "Extension size must be a nonnegative Integer" unless size.is_a?(Integer) and size >= 0
       BitvecSort.new(sort.size + size).new(LowLevel.mk_zero_ext(size, self))
     end
 
     def sign_ext(size)
+      raise Z3::Exception, "Extension size must be a nonnegative Integer" unless size.is_a?(Integer) and size >= 0
       BitvecSort.new(sort.size + size).new(LowLevel.mk_sign_ext(size, self))
     end
 
@@ -106,9 +110,6 @@ module Z3
       raise Z3::Exception, "Use #signed_add_no_overflow? or #unsigned_add_no_overflow? for Bitvec, not #add_no_overflow?"
     end
 
-    def add_no_overflow?(other)
-      raise "Use signed_add_no_overflow? or unsigned_add_no_overflow?"
-    end
     def signed_add_no_overflow?(other)
       BitvecExpr.SignedAddNoOverflow(self, other)
     end
@@ -123,11 +124,11 @@ module Z3
       BitvecExpr.SignedAddNoUnderflow(self, other)
     end
     def unsigned_add_no_underflow?(other)
-      raise "Unsigned + cannot underflow"
+      raise Z3::Exception, "Unsigned + cannot underflow"
     end
 
     def unsigned_neg_no_overflow?
-      raise "There is no unsigned negation"
+      raise Z3::Exception, "There is no unsigned negation"
     end
     def signed_neg_no_overflow?
       BitvecExpr.SignedNegNoOverflow(self)
@@ -137,7 +138,7 @@ module Z3
     end
 
     def mul_no_overflow?(other)
-      raise "Use signed_mul_no_overflow? or unsigned_mul_no_overflow?"
+      raise Z3::Exception, "Use signed_mul_no_overflow? or unsigned_mul_no_overflow?"
     end
     def signed_mul_no_overflow?(other)
       BitvecExpr.SignedMulNoOverflow(self, other)
@@ -153,7 +154,7 @@ module Z3
       BitvecExpr.SignedMulNoUnderflow(self, other)
     end
     def unsigned_mul_no_underflow?(other)
-      raise "Unsigned + cannot underflow"
+      raise Z3::Exception, "Unsigned * cannot underflow"
     end
 
     def div_no_overflow?(other)
@@ -163,7 +164,7 @@ module Z3
       BitvecExpr.SignedDivNoOverflow(self, other)
     end
     def unsigned_div_no_overflow?(other)
-      raise "Unsigned / cannot underflow"
+      raise Z3::Exception, "Unsigned / cannot overflow"
     end
 
     def >>(other)

data/lib/z3/expr/bool_expr.rb

@@ -71,6 +71,32 @@ module Z3
         b, c = coerce_to_same_sort(b, c)
         b.sort.new(LowLevel.mk_ite(a, b, c))
       end
+
+      # Native cardinality constraint: at most k of the given Bool exprs are true
+      def AtMost(args, k)
+        args = cardinality_args(args, k)
+        BoolSort.new.new(LowLevel.mk_atmost(args, k))
+      end
+
+      # Native cardinality constraint: at least k of the given Bool exprs are true
+      def AtLeast(args, k)
+        args = cardinality_args(args, k)
+        BoolSort.new.new(LowLevel.mk_atleast(args, k))
+      end
+
+      # Native cardinality constraint: exactly k of the given Bool exprs are true
+      def Exactly(args, k)
+        args = cardinality_args(args, k)
+        BoolSort.new.new(LowLevel.mk_pbeq(args, [1] * args.size, k))
+      end
+
+      private
+
+      def cardinality_args(args, k)
+        raise Z3::Exception, "Cardinality bound must be a non-negative Integer" unless k.is_a?(Integer) and k >= 0
+        raise Z3::Exception, "Cardinality constraint requires at least one argument" if args.empty?
+        coerce_to_same_bool_sort(*args)
+      end
     end
   end
 end

data/lib/z3/expr/expr.rb

@@ -106,6 +106,7 @@ module Z3
       end
 
       def And(*args)
+        raise Z3::Exception, "And requires at least one argument" if args.empty?
         args = coerce_to_same_sort(*args)
         case args[0]
         when BoolExpr
@@ -120,6 +121,7 @@ module Z3
       end
 
       def Or(*args)
+        raise Z3::Exception, "Or requires at least one argument" if args.empty?
         args = coerce_to_same_sort(*args)
         case args[0]
         when BoolExpr
@@ -134,6 +136,7 @@ module Z3
       end
 
       def Xor(*args)
+        raise Z3::Exception, "Xor requires at least one argument" if args.empty?
         args = coerce_to_same_sort(*args)
         case args[0]
         when BoolExpr
@@ -150,7 +153,7 @@ module Z3
       end
 
       def Add(*args)
-        raise Z3::Exception if args.empty?
+        raise Z3::Exception, "Add requires at least one argument" if args.empty?
         args = coerce_to_same_sort(*args)
         case args[0]
         when ArithExpr
@@ -165,6 +168,7 @@ module Z3
       end
 
       def Sub(*args)
+        raise Z3::Exception, "Sub requires at least one argument" if args.empty?
         args = coerce_to_same_sort(*args)
         case args[0]
         when ArithExpr
@@ -179,6 +183,7 @@ module Z3
       end
 
       def Mul(*args)
+        raise Z3::Exception, "Mul requires at least one argument" if args.empty?
         args = coerce_to_same_sort(*args)
         case args[0]
         when ArithExpr

data/lib/z3/expr/set_expr.rb

@@ -23,7 +23,7 @@ module Z3
     end
 
     def intersection(other)
-      SetExpr.Union(self, other)
+      SetExpr.Intersection(self, other)
     end
 
     def difference(other)

data/lib/z3/func_decl.rb

@@ -23,10 +23,35 @@ module Z3
       Sort.from_pointer(LowLevel::get_range(self))
     end
 
-    # def ast_parameter(i)
-    #   # vs arity ?
-    #   Z3::Ast.new(LowLevel.get_decl_ast_parameter(self, i))
-    # end
+    # Decl parameters are the `_`-part of an indexed decl like
+    # `(_ map or)`, `(_ extract 7 0)`, `(_ zero_extend 8)`.
+    # They have nothing to do with the domain, so they're not counted by #arity.
+    PARAMETER_KINDS = {
+      0 => :int,
+      1 => :double,
+      2 => :rational,
+      3 => :symbol,
+      4 => :sort,
+      5 => :ast,
+      6 => :func_decl,
+      7 => :internal,
+      8 => :zstring,
+    }
+
+    def num_parameters
+      LowLevel.get_decl_num_parameters(self)
+    end
+
+    def parameter_kind(i)
+      raise Z3::Exception, "Trying to access parameter #{i} but decl has #{num_parameters} parameters" if i < 0 or i >= num_parameters
+      k = LowLevel.get_decl_parameter_kind(self, i)
+      PARAMETER_KINDS.fetch(k) { raise Z3::Exception, "Unknown decl parameter kind #{k}" }
+    end
+
+    def func_decl_parameter(i)
+      raise Z3::Exception, "Parameter #{i} is a #{parameter_kind(i)}, not a func decl" unless parameter_kind(i) == :func_decl
+      FuncDecl.new(LowLevel.get_decl_func_decl_parameter(self, i))
+    end
 
     def to_s
       name

data/lib/z3/goal.rb

@@ -1,8 +1,11 @@
 module Z3
   class Goal
+    include ReferenceCounted
+
     attr_reader :_goal
     def initialize(_goal)
       @_goal = _goal
+      inc_ref! :goal, _goal
     end
 
     def assert(ast)
@@ -55,6 +58,10 @@ module Z3
       LowLevel.goal_to_string(self)
     end
 
+    def to_dimacs(include_names=true)
+      LowLevel.goal_to_dimacs_string(self, include_names)
+    end
+
     class << self
       def new(models=false, unsat_cores=false, proofs=false)
         super LowLevel.mk_goal(!!models, !!unsat_cores, !!proofs)