oakproof 0.7.1 → 0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f15b0ead7b7f0d5f1dade59eb2a777769b8bc50f006e976fe99befea8aeae4b9
-  data.tar.gz: f49f7228719fa47a580bfeef65c3b1139f721afbd24f059d7ede21e6e2a6447b
+  metadata.gz: 41f24b1c7255008c0d60800dfd0b24dd4e886edbd283eaa91232a2b15bcf389e
+  data.tar.gz: ac82cddd55a371da32407fa2a580a2290f784f1c780d60569b6a2601877a65aa
 SHA512:
-  metadata.gz: 9a57aedc97b65aef33feae93b2afd8e3bba209fd8f7ab6a012dd316fec287c086279caa676fd293432a4d57e7df819a4d223543a763eae14fefaf8ab5a8abbd0
-  data.tar.gz: c0091be99a7d8f7370b4f61c2d5b965a8076a4bb1d09f1661fab8cef4e7a3db818c4e5aa63f522c32d25e769d419747ee041bdbbb2f4cde50299ebd84720e6a9
+  metadata.gz: 65fe47bde399dcb72ebd4f79f5af85b4820cb1a6e0b0b7bce35d847aeb55166344d27b18e5d7898aed65dd07555954078f7ef42eda63d4c3f6c7cc9a4e58d362
+  data.tar.gz: 8576b1f0c310fb511f0886af61ac3b850c6f195aae6bcad32a393d2f40ed120e74387b39021c33f53295cd6b5a593f1cccd6071b9c27cb3b23e876e19f913fbc

data/src/bindings.rb

@@ -93,25 +93,36 @@ class Bindings
 			@tie_ins[starter] << node
 		end
 
-		# Tie-ins that are part of bindings only apply to the variables being bound,
-		# so their position in the tree is handled by the "uses" logic above.  For
-		# other tie-ins, we cannot easily tell (due to their mutually recursive
-		# nature) whether they apply to the line being added or not.  If they do, we
-    # need to call shift_under_node to put the line in their scope.  If they
-    # don't, we should leave the line out of their scope, so that it will not be
-    # deactivated along with the tie-in.  We use the following heuristic to make
-    # this decision:
-    #   * If the line is a schema, it doesn't need tie-ins, and also it can't be
-    #     cited if it is inactive, so we had better not deactivate it too soon.
-    #     So we leave it out of the tie-in scope.
-    #   * Otherwise, if the line doesn't bind anything, then hopefully it won't
-    #     matter if it gets deactivated early, so we shift it under the tie-in.
-    #   * Otherwise, we leave it out of the tie-in scope.
-		if line and line.binds.empty? and not line.schema
-			@tie_ins.each {|starter, tie_ins|
-				tie_ins.each {|tie_in| shift_under_node tie_in}
-			}
-		end
+    # For tie-ins that apply to the line being added, we need to call
+    # shift_under_node to put the line in their scope.  For those that don't,
+    # we should leave the line out of their scope, so that when they are
+    # deactivated, they do not prematurely deactivate the line (which can cause
+    # errors if blocks are in play, or otherwise inconvenience the user).
+    # Unfortunately, due to the mutually recursive nature of tie-ins, checking
+    # this is complicated and slow (caused a 10% performance decrease).  As a
+    # substitute, we use the following heuristic:
+
+    #   * If the line is a schema, it doesn't need tie-ins, and also it can't
+    # be cited if it is inactive, so we had better not deactivate it too soon.
+    # So we leave it out of the tie-in scope.
+
+    #   * Otherwise, for tie-ins that are part of bindings, if the line uses
+    # the bound variable, it would have been shifted by the "uses" logic
+    # above.  If it does not, maybe/hopefully it doesn't need the tie-in, so we
+    # leave it alone.
+
+    #   * Otherwise, for tie-ins that are not part of bindings, we shift the
+    # line under them, since these tie-ins are less likely to be suddenly
+    # deactivated.
+
+		if line and not line.schema
+      @tie_ins.each {|starter, tie_in_nodes|
+        tie_in_nodes.each {|tie_in_node|
+          next unless tie_in_node.line.binds.empty?
+          shift_under_node tie_in_node
+        }
+      }
+    end
 
 		@node_for_line[line] = node if line
 		@blocks << node if not line or line.definition?
@@ -179,23 +190,33 @@ class Bindings
 		elsif self_implication? tree
 			tree = tree_for_true # make things easy for external prover
 			return {:tree => tree}
-		end
+		elsif instantiation_implication? tree
+			tree = tree_for_true # make things easy for external prover
+			return {:tree => tree}
+    end
 
 		# finally, handle tie-ins
 		cited = cited_tree cited_lines, true
 		tree = nil
-		if content.body
+    binds, body = content.binds, content.body
+		if body
+      # thesis does not create a binding within the proof, but we need to check
+      # it as if it does, so its body will get tie-ins, just as with end block
+      if body.operator == :for_some and binds.empty?
+        binds = body.subtrees[0].operator
+        body = body.subtrees[1]
+      end
 			# apply active tie-ins to the body, as long as they do not use or bind
 			# vars which content is rebinding
 			tie_ins = @tie_ins.values.flatten.select {|tie_in|
 				uses_or_binds = tie_in.line.uses + tie_in.line.binds
-				(uses_or_binds & content.binds).empty?
+				(uses_or_binds & binds).empty?
 			}
-			tied_in = tied_in_for content.body, tie_ins
+			tied_in = tied_in_for body, tie_ins
 			tied_in = tied_in.collect {|match, used| match}
-			tree = implication_tree tied_in, content.body
+			tree = implication_tree tied_in, body
 		end
-		tree = bind_variables content.binds, tree, :for_some
+		tree = bind_variables binds, tree, :for_some
 		tree = implication_tree [cited], tree
 		tree = deduplicate tree
 		{:tree => tree}

data/src/commands.rb

@@ -28,7 +28,7 @@ class Proof
 	def initialize manager, options = {}
 		@lines = []
 		@active_suppositions = []
-		@active_contexts = [[]]
+		@active_buffers = [[]]
 		@scopes = []
 		@theses = []
 		@label_stack = [[]]
@@ -85,7 +85,9 @@ class Proof
 	def derive content, reasons = [], id = nil
     return assume content, id if assuming?
 		line_numbers, question_mark = process_reasons reasons
-		derive_internal content, line_numbers, question_mark, id
+		check_admission content
+		derive_internal content, line_numbers, question_mark
+		add content, :derivation, id
 	end
 
 	def end_assume
@@ -109,7 +111,7 @@ class Proof
 			raise ProofException, '"begin assume" must end with "end assume"'
 		end
 		last_scope = @scopes.pop
-		last_context = @active_contexts.pop
+		last_buffer = @active_buffers.pop
 		last_thesis = @theses.pop
 		if last_scope.is_a? Array # end of proof block
 			@label_stack[-1].each {|label|
@@ -118,20 +120,26 @@ class Proof
 			}
 			@label_stack.pop
 
-			@bindings.end_block
-
 			content, id = last_scope
       if assuming? then
+			  @bindings.end_block
         assume content, id
       else
-        derive_internal content, last_context, false, id
+        # check content without bindings while in proof block
+		    check_admission Content.new content.sentence
+        # derive before ending block, to use active variables
+        derive_internal content, last_buffer, false
+        # now end the block and re-check content with bindings
+			  @bindings.end_block
+		    check_admission content
+		    add content, :derivation, id
       end
 		else
 			if last_scope == :suppose
 				@active_suppositions.pop
 				@bindings.end_block
 			end
-			@active_contexts.last.concat last_context
+			@active_buffers.last.concat last_buffer
 		end
 	end
 
@@ -146,13 +154,13 @@ class Proof
 
 	def now
 		@scopes << :now
-		@active_contexts << []
+		@active_buffers << []
 		@theses << @theses[-1] # inherit thesis if it exists
 	end
 
 	def proof content, id = nil
 		@scopes << [content, id]
-		@active_contexts << []
+		@active_buffers << []
 		@theses << content
 		@label_stack << []
 
@@ -161,26 +169,28 @@ class Proof
 
 	def so content, reasons = [], id = nil
     return so_assume content, id if assuming?
-		if @active_contexts[-1].empty?
+		if @active_buffers[-1].empty?
 			raise ProofException, 'nothing for "so" to use'
 		end
 		line_numbers, question_mark = process_reasons reasons
-		line_numbers.concat @active_contexts[-1]
-		@active_contexts[-1] = []
-		derive_internal content, line_numbers, question_mark, id
+		line_numbers.concat @active_buffers[-1]
+		@active_buffers[-1] = []
+		check_admission content
+		derive_internal content, line_numbers, question_mark
+		add content, :derivation, id
 	end
 
 	def so_assume content, id = nil
-		if @active_contexts[-1].empty?
+		if @active_buffers[-1].empty?
 			raise ProofException, 'nothing for "so" to use'
 		end
-		@active_contexts[-1] = []
+		@active_buffers[-1] = []
 		assume content, id
 	end
 
 	def suppose content, id = nil
 		@scopes << :suppose
-		@active_contexts << []
+		@active_buffers << []
 		@theses << @theses[-1] # inherit thesis if it exists
 		check_admission content
 		@active_suppositions << @lines.size
@@ -200,8 +210,7 @@ class Proof
 			end
 		end
 
-		# puts 'checking tree:'
-		# tree.pretty_print
+		# puts "\nchecking tree:\n#{tree.pretty_to_s}"
 
 		result = ExternalProver.valid_e? tree
 
@@ -291,15 +300,13 @@ class Proof
 			@label_stack[-1] << label
 			@line_numbers_by_label[label] = n
 		elsif content.tie_ins.empty? or not content.binds.empty?
-			@active_contexts[-1] << n
+			@active_buffers[-1] << n
 		end
     n
   end
 
-	def derive_internal content, line_numbers, question_mark, id
-		check_admission content
+	def derive_internal content, line_numbers, question_mark
     @manager.derive self, content, line_numbers, question_mark
-		add content, :derivation, id
 	end
 
 	def process_reasons reasons

data/src/grammar rules.rb

@@ -134,9 +134,7 @@ def grammar_rules
 	[:exp0b, :prefix0, :end],
 	[:exp0b, :prefix_, :end],
 
-	[:prefix1, :not, :end],
-
-	[:exp1, :prefix1, :end],
+	# [:exp1, :prefix1, :end],
 	[:exp1, :exp2, :exp1a],
 	[:exp1a, :and, :and1],
 		[:and, /\s*and\b/i, :end],
@@ -153,10 +151,11 @@ def grammar_rules
 	[:exp1a, :else, :end],
 	[:exp1b, :exp2, :end],
 	[:exp1b, :else, :exp1c],
-	[:exp1c, :prefix1, :end],
+	# [:exp1c, :prefix1, :end],
 	[:exp1c, :prefix0, :end],
 	[:exp1c, :prefix_, :end],
 
+	[:prefix2, :not, :end],
 	[:prefix2, :every, :end],
 	[:prefix2, :no, :end],
 	[:prefix2, :some, :end],
@@ -226,16 +225,37 @@ def grammar_rules
 	[:atom_list2, [/\s*and\b/i, :atom_block], :atom_list2],
 	[:atom_list2, :else, :end],
 
+  # this is a bit tricky:
+  #   there is a prefix of zero or more words (space-separated)
+  #   followed by one or more definables (comma-separated)
+  #   then a preposition is allowed if the prefix was non-empty
+  #   then an optional condition
+
 	[:atom_block, :word, :atom_block2],
-	[:atom_block, :else, :atom_list_adjacent],
-	[:atom_block2, :word_same_line, :atom_block2],
+	[:atom_block, :definable, :atom_block2a],
+
+	[:atom_block2, :word_same_line, :atom_block3],
 	[:atom_block2, :condition, :end, :catch],
-	[:atom_block2, :definable_same_line, :atom_list_adjacent2],
-	[:atom_block2, :else, :atom_list_adjacent2],
+	[:atom_block2, :definable_same_line, :atom_block3a],
+	[:atom_block2, :else, :atom_block2a],
+
+	[:atom_block2a, [/,/, :definable_raw,], :atom_block2a, :catch],
+	[:atom_block2a, :else, :atom_block4],
+
+	[:atom_block3, :word_same_line, :atom_block3],
+	[:atom_block3, :condition, :end, :catch],
+	[:atom_block3, :definable_same_line, :atom_block3a],
+	[:atom_block3, :else, :atom_block3a],
+
+	[:atom_block3a, [/,/, :definable_raw,], :atom_block3a, :catch],
+	[:atom_block3a, :preposition, :atom_block4],
+	[:atom_block3a, :else, :atom_block4],
+
+	[:atom_block4, :condition, :end],
+	[:atom_block4, :else, :end],
 
 	[:atom_list_adjacent, :definable, :atom_list_adjacent2],
 	[:atom_list_adjacent2, [/,/, :definable_raw,], :atom_list_adjacent2, :catch],
-	[:atom_list_adjacent2, :condition, :end],
 	[:atom_list_adjacent2, :else, :end],
 
 	[:universal, /\s*for (all|any|each|every) meta\b/i, :null],
@@ -304,10 +324,10 @@ def grammar_rules
 	[:is_in, /\s*is in\b/i, :end],
 	[:is_not_in, /\s*is not in\b/i, :end],
 
-	[:preposition, /\s*(of|on)\b/i, :end],
+	[:preposition, [/\s*(of|on)\b/i, :exp3], :end],
 
 	[:category, :word, :category2],
-	[:category2, [:preposition, :exp3], :end],
+	[:category2, :preposition, :end],
 	[:category2, :word_same_line, :category2],
 	[:category2, :else, :end],
 
@@ -419,7 +439,7 @@ def grammar_rules
 
 	[:definable_same_line, [/[ \t]*/, :definable_raw], :end, :catch],
 
-  [:definable_raw, /\+|\-|\*|\÷|\/|\^|⊆|⊊|⊂|\|\||{}|\[\]|∪|∩|</, :end],
+  [:definable_raw, /in|\+|\-|\*|\÷|\/|\^|⊆|⊊|⊂|\|\||{}|\[\]|∪|∩|</, :end],
   [:definable_raw, :atom, :end],
 
 	[:atom, /for (all|any|at least one|at most one)\b/i, :null],

data/src/oak.rb

@@ -1,6 +1,6 @@
 require_relative 'proof.rb'
 
-name_version = 'Oak version 0.7.1'
+name_version = 'Oak version 0.8'
 issues_url = 'https://github.com/timlabs/oak/issues'
 
 options = {}
@@ -22,6 +22,10 @@ if ARGV.delete '-m'
 	options[:marker] = true
 end
 
+if ARGV.delete '-p'
+	options[:print_failed_tree] = true
+end
+
 if ARGV.delete '-w'
 	options[:wait] = true
 end
@@ -32,11 +36,12 @@ if options[:fix] and options[:wait]
 end
 
 if ARGV.size != 1 or ARGV[0].start_with? '-'
-	puts 'usage: oak [-v] [-c] [-f] [-m] [-w] <filename>'
+	puts 'usage: oak [-v] [-c] [-f] [-m] [-p] [-w] <filename>'
   puts '  -v  print the version number of Oak'
   puts '  -c  check for unneeded citations'
   puts '  -f  look for a fix'
   puts '  -m  assume until marker'
+  puts '  -p  if a derivation fails, print its full tree'
   puts '  -w  wait for validity (does not change proof outcome)'
 	exit
 end

data/src/parser.rb

@@ -196,20 +196,25 @@ class Parser
 				switched = true
 			end
 		}
-		condition = node.branches.last if node.branches.last.value == :condition
-		process_conditions properties, variables, condition
+    preposition = node.branches.find {|branch| branch.value == :preposition}
+    condition = node.branches.find {|branch| branch.value == :condition}
+		process_atom_block_parts properties, variables, preposition, condition
 	end
 
-	def process_conditions properties, variables, condition
+	def process_atom_block_parts properties, variables, preposition, condition
 		variable_trees = variables.collect {|node| tree_from_grammar node}
 		property_trees = properties.collect {|node| tree_from_grammar node}
-		right_side = tree_from_grammar condition.branches[1] if condition
+		preposition_right_side = tree_from_grammar preposition.branches[1] if preposition
+		condition_right_side = tree_from_grammar condition.branches[1] if condition
 		conditions = variable_trees.collect {|variable_tree|
 			trees = property_trees.collect {|property_tree|
 				Tree.new :predicate, [property_tree, variable_tree]
 			}
+      if preposition
+        trees[-1] = Tree.new :predicate, [*trees[-1].subtrees, preposition_right_side]
+      end
 			if condition
-				trees << apply_condition(condition, right_side, variable_tree)
+				trees << apply_condition(condition, condition_right_side, variable_tree)
 			end
 			conjunction_tree trees
 		}
@@ -382,13 +387,11 @@ class Parser
 			when :quantified then node.branches[1].branches
 			when :word then [node]
 		end
-		if subtrees.length >= 2 and subtrees[-2].value == :preposition
-			predicate = tree_from_grammar subtrees[-3]
-			other = tree_from_grammar subtrees[-1]
-			preposition_tree = Tree.new :predicate, [
-				predicate, subject, other
-			]
-			subtrees = subtrees[0...-3]
+		if subtrees[-1].value == :preposition
+			predicate = tree_from_grammar subtrees[-2]
+			other = tree_from_grammar subtrees[-1].branches[1]
+			preposition_tree = Tree.new :predicate, [predicate, subject, other]
+			subtrees = subtrees[0...-2]
 		end
 		subtrees = subtrees.collect {|subtree|
 			predicate = tree_from_grammar subtree
@@ -420,7 +423,10 @@ class Parser
 						next unless subtree.subtrees.empty? and i > 0 # atom
 						prev = node.branches[(i-1)*2]
 						is = false
-						is = true if prev.branches[0].value == :prefix2
+            tags = [:every, :no, :some, :at_most_one]
+            if tags.include? prev.branches[0].branches[0].value
+              is = true
+            end
 						tags = [:is, :is_not, :is_in, :is_not_in]
 						if prev.branches.size >= 2 and tags.include? prev.branches[1].value
 							is = true
@@ -603,7 +609,8 @@ class Parser
 					subtrees.collect! {|subtree| tree_from_grammar subtree}
 				end
 =end
-			when :word, :word_same_line, :definable, :definable_raw, :atom
+      when :word, :word_same_line, :definable, :definable_same_line,
+           :definable_raw, :atom
 				operator = standardize_operator node.text
 				subtrees = []
 			when :boolean
@@ -668,7 +675,7 @@ class Parser
 						raise ParseException, '"with" not allowed in negative quantifier' if with
 						tree = conjunction_tree [conditions_tree, such_that, body].compact
 						tree = Tree.new :for_some, [variables_tree, tree].compact
-						tree = Tree.new :not, [tree]
+						Tree.new :not, [tree]
 					when :existential, :define, :take
 						tie_ins = []
 						[variables, conditions].transpose.each {|variable, condition|
@@ -708,9 +715,7 @@ class Parser
 				metas = []
 				if node.branches[5]
 					metas, conditions = process_atom_block node.branches[5]
-					if not conditions.compact.empty?
-						raise ParseException, 'tie-in variables cannot have conditions'
-					end
+          raise if not conditions.compact.empty?
 				end
 				return TieIn.new metas, pattern, body
 		end
@@ -827,14 +832,12 @@ class Tree
 		result
 	end
 
-	def pretty_print level = 0
+	def pretty_to_s level = 0
 		s = '  ' * level + to_s
-		if s.length < 80
-			puts s
-		else
-			puts '  ' * level << @operator.to_s
-			@subtrees.each {|subtree|	subtree.pretty_print level+1}
-		end
+    return s if s.length < ConsoleWidth
+		s = '  ' * level + @operator.to_s
+		parts = @subtrees.map {|subtree| subtree.pretty_to_s level+1}
+    [s, *parts].join "\n"
 	end
 
 	Quantifiers = [:for_all, :for_some, :for_at_most_one]

data/src/proof.rb

@@ -53,9 +53,7 @@ class Proof
 				status = :exited
 				break
 			end
-			if content.is_a? Content
-				content = process_content content, proof.theses[-1]
-			end
+			content = process_content content, proof.theses if content.is_a? Content
 			# puts "content for line #{fileline} is: #{content.inspect}"
 			id = {label: label, filename: filename, fileline: fileline}
 			case action
@@ -99,15 +97,15 @@ class Proof
   def self.finalize proof, status, addons, options
 		printer, tracker = addons.values_at :printer, :tracker
 
-    if not proof.scopes.empty?
+		if options[:marker] and proof.assuming?
+      message = '-m option used without marker'
+    elsif not proof.scopes.empty?
       message = case proof.scopes.last
         when :suppose then 'active supposition'
         when :now then 'active "now" block'
         when Array then 'active "proof" block'
         when :assume then 'active assume block'
       end
-		elsif options[:marker] and proof.assuming?
-      message = '-m option used without marker'
     end
     raise EndException, message if message
 
@@ -136,8 +134,8 @@ class Proof
     end
   end
 
-	def self.process_content content, thesis
-		if not thesis
+	def self.process_content content, theses
+		if not theses[-1]
 			return content unless content.uses.include? 'thesis'
 			raise ProofException, 'thesis used outside of proof block'
 		elsif content.uses.include? 'thesis'
@@ -149,14 +147,18 @@ class Proof
 				raise ProofException, "cannot use thesis in tie-in"
 			end
 			begin # content was just a Tree
-				tree = substitute content.sentence, {'thesis' => thesis.sentence}
+				tree = substitute content.sentence, {'thesis' => theses[-1].sentence}
 			rescue SubstituteException => e
 				message = "cannot quantify variable #{e}: conflicts with thesis"
 				raise ProofException, message
 			end
 			return Content.new tree
 		else
-			conflict = (thesis.uses & content.binds).first
+      conflict = nil
+      theses.reverse_each.find {|thesis|
+        next if not thesis # may be nil due to placeholders at beginning
+        conflict = (thesis.uses & content.binds).first
+      }
 			return content unless conflict
 			raise ProofException, "cannot bind variable #{conflict}: part of thesis"
 		end
@@ -169,7 +171,8 @@ end
 class DerivationManager
   def initialize printer, options
     @printer = printer
-    @fix, @reduce, @wait_on_unknown = options.values_at :fix, :reduce, :wait
+    @fix, @reduce, @wait_on_unknown, @print_failed_tree =
+      options.values_at :fix, :reduce, :wait, :print_failed_tree
   end
 
   def derive proof, content, line_numbers, question_mark
@@ -202,6 +205,10 @@ class DerivationManager
         end
       end
     else
+      if @print_failed_tree
+        message = "full tree below\n\n#{checked.pretty_to_s}\n"
+        @printer.option_message '-p', message
+      end
 			message = case result
 				when :invalid then 'invalid derivation'
 				when :unknown then 'could not determine validity of derivation'

data/src/utilities.rb

@@ -1,9 +1,11 @@
 require 'io/console'
 
+ConsoleWidth = IO.console.winsize[1] - 1 # subtract 1 for portability
+
 class WordWrapper
 	def initialize
     @indent = 2
-		@width = IO.console.winsize[1] - 1 # subtract 1 for portability
+		@width = ConsoleWidth
 		@position = 0
 	end
 
@@ -94,15 +96,16 @@ def equal_up_to_variable_names? tree1, tree2, refs1 = {}, refs2 = {}, level = 0
 		case tree1.operator
 			when *Tree::Quantifiers
 				last1, last2 = {}, {}
-				zipped = tree1.subtrees[0].operator.zip tree2.subtrees[0].operator
-				zipped.each_with_index {|(var1, var2), i|
+        vars1, vars2 = tree1.subtrees[0].operator, tree2.subtrees[0].operator
+        return false unless vars1.size == vars2.size
+				vars1.zip(vars2).each_with_index {|(var1, var2), i|
 					refs1[var1], last1[var1] = [level,i], refs1[var1]
 					refs2[var2], last2[var2] = [level,i], refs2[var2]
 				}
 				result = pairs[1..-1].all? {|subtree1, subtree2|
 					equal_up_to_variable_names? subtree1, subtree2, refs1, refs2, level+1
 				}
-				zipped.each_with_index {|(var1, var2), i|
+				vars1.zip(vars2).each_with_index {|(var1, var2), i|
 					last1[var1] ? (refs1[var1] = last1[var1]) : (refs1.delete var1)
 					last2[var2] ? (refs2[var2] = last2[var2]) : (refs2.delete var2)
 				}
@@ -126,6 +129,70 @@ def equal_up_to_variable_names? tree1, tree2, refs1 = {}, refs2 = {}, level = 0
 	end
 end
 
+def instantiated_by? tree1, tree2, refs1 = {}, refs2 = {}, level = 0
+	if tree1.operator.is_a? Symbol
+		return false unless tree1.operator == tree2.operator
+		return false unless tree1.subtrees.size == tree2.subtrees.size
+		pairs = [tree1.subtrees, tree2.subtrees].transpose
+		case tree1.operator
+			when *Tree::Quantifiers
+				last1, last2 = {}, {}
+        vars1, vars2 = tree1.subtrees[0].operator, tree2.subtrees[0].operator
+        return false unless vars1.size == vars2.size
+				vars1.zip(vars2).each_with_index {|(var1, var2), i|
+					refs1[var1], last1[var1] = [level,i], refs1[var1]
+					refs2[var2], last2[var2] = [level,i], refs2[var2]
+				}
+				result = pairs[1..-1].all? {|subtree1, subtree2|
+					instantiated_by? subtree1, subtree2, refs1, refs2, level+1
+				}
+				vars1.zip(vars2).each_with_index {|(var1, var2), i|
+					last1[var1] ? (refs1[var1] = last1[var1]) : (refs1.delete var1)
+					last2[var2] ? (refs2[var2] = last2[var2]) : (refs2.delete var2)
+				}
+				result
+			when :not, :and, :or, :implies, :iff, :equals, :predicate
+				pairs.all? {|subtree1, subtree2|
+					instantiated_by? subtree1, subtree2, refs1, refs2, level+1
+				}
+			else raise
+		end
+  elsif tree1.operator.is_a? String
+    if refs1[tree1.operator] == :pending
+      # instantiation must be a term
+      return false if tree2.boolean?
+      # the pending binding occurred at the top, so its instantiation cannot
+      # make use of any subsequent bindings
+      return false unless (refs2.keys & tree2.free_variables).empty?
+      refs1[tree1.operator] = tree2
+      true
+    elsif refs1[tree1.operator].is_a? Tree
+      # reference is a term and has no bindings (checked earlier), so the tree
+      # cannot have any bindings either, and must match exactly
+      return false unless (refs2.keys & tree2.free_variables).empty?
+      refs1[tree1.operator].eql? tree2
+    elsif refs1[tree1.operator] and refs2[tree2.operator]
+      refs1[tree1.operator] == refs2[tree2.operator] # both variables
+    elsif refs1[tree1.operator] or refs2[tree2.operator]
+			false # one is a constant, the other is a variable
+    else
+      tree1.operator == tree2.operator # both constants
+    end
+  else
+		raise
+	end
+end
+
+def instantiation_implication? tree
+  return false unless tree.operator == :implies
+  return false unless tree.subtrees[0].operator == :for_all
+  vars = tree.subtrees[0].subtrees[0].operator
+  pending = vars.map {|v| [v, :pending]}.to_h
+  pattern = tree.subtrees[0].subtrees[1]
+  instance = tree.subtrees[1]
+  instantiated_by? pattern, instance, pending
+end
+
 def first_orderize tree, by_arity = false
 	subtrees = tree.subtrees.collect {|subtree| first_orderize subtree, by_arity}
 	if tree.operator == :predicate
@@ -267,14 +334,16 @@ end
 def find_minimal_subsets input_array
 	# find the minimal subsets for which yield returns true, assuming that if it
 	# returns false for a given set, it will return false for all of its subsets,
-	# and that order and duplicates do not matter
+	# that order and duplicates do not matter, and that the input yields true
 	input_array = input_array.uniq
 	pending, results = [input_array], {}
 	until pending.empty?
 		array = pending.shift
 		set = array.to_set
 		next if results.has_key? set
-		if results.any? {|key, result| result == false and set.subset? key}
+    if results.empty?
+      results[set] = true # input array is assumed to yield true
+		elsif results.any? {|key, result| result == false and set.subset? key}
 			results[set] = false
 		else
 			results[set] = yield array

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: oakproof
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: '0.8'
 platform: ruby
 authors:
 - Tim Smith
 autorequire:
 bindir: "."
 cert_chain: []
-date: 2024-06-21 00:00:00.000000000 Z
+date: 2026-03-03 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -32,10 +32,13 @@ files:
 - src/proof.rb
 - src/schema.rb
 - src/utilities.rb
-homepage: http://oakproof.org/
+homepage: https://oakproof.org/
 licenses:
 - AGPL-3.0
-metadata: {}
+metadata:
+  homepage_uri: https://oakproof.org/
+  source_code_uri: https://github.com/timlabs/oak
+  documentation_uri: https://oakproof.org/tutorial.html
 post_install_message:
 rdoc_options: []
 require_paths: