def test_remove_assumption(debug=False): from propositions.some_proofs import prove_and_commutativity for oldp in [ DISJUNCTION_COMMUTATIVITY_PROOF, prove_and_commutativity(), DISJUNCTION_RIGHT_ASSOCIATIVITY_PROOF, DISJUNCTION_ROTATION_PROOF, TRI_AND_PROOF ]: p = oldp assert p.is_valid(), offending_line(p) while (True): rb = None for r in p.rules: if r != MP and len(r.assumptions) > 0: rb = r break if rb is None: break pr = prove_from_encoding(rb) p = inline_proof(p, pr) assert p.is_valid(), offending_line(p) if debug: print("Testing remove_assumption on:", p) pp = remove_assumption(p) if debug: print("Got:", pp) assert pp.statement.assumptions == p.statement.assumptions[:-1] assert pp.statement.conclusion == Formula('->', p.statement.assumptions[-1], p.statement.conclusion) assert pp.rules.issubset(p.rules.union({MP, I0, I1, D})) assert pp.is_valid(), offending_line(pp)
def test_prove_from_encoding(debug=True): from propositions.some_proofs import prove_and_commutativity for p in [ DISJUNCTION_COMMUTATIVITY_PROOF, prove_and_commutativity(), DISJUNCTION_RIGHT_ASSOCIATIVITY_PROOF ]: for r in p.rules: if (debug): print("\nTesting prove_from_encoding on:", r) pp = prove_from_encoding(r) if (debug): print("Got:", pp) assert pp.statement == r newrule = InferenceRule([], encode_as_formula(r)) assert pp.rules == {newrule, MP} assert pp.is_valid(), pp.offending_line()
def test_inline_proof_once(debug=False): from propositions.some_proofs import prove_and_commutativity rule0 = InferenceRule([Formula.parse('((x|y)|z)')], Formula.parse('(x|(y|z))')) # Disjunction commutativity with an unused assumption rule1 = InferenceRule([Formula.parse('(~q|q)'), Formula.parse('(x|y)')], Formula.parse('(y|x)')) rule2 = InferenceRule([], Formula.parse('(~p|p)')) lemma1_proof = Proof(rule1, DISJUNCTION_COMMUTATIVITY_PROOF.rules, [ Proof.Line(Formula.parse('(~x|x)'), R2, []), Proof.Line(Formula.parse('(x|y)')), Proof.Line(Formula.parse('(y|x)'), R1, [1, 0]) ]) lemma2_proof = DISJUNCTION_RIGHT_ASSOCIATIVITY_PROOF assert lemma1_proof.is_valid(), offending_line(lemma1_proof) assert lemma2_proof.is_valid(), offending_line(lemma2_proof) # A proof that uses both disjunction commutativity (lemma 1) and # disjunction right associativity (lemma2), whose proof in turn also uses # disjunction commutativity (lemma 1). proof = Proof( InferenceRule([Formula.parse('((p|q)|r)')], Formula.parse('((r|p)|q)')), {rule0, rule1, rule2}, [ Proof.Line(Formula.parse('((p|q)|r)')), Proof.Line(Formula.parse('(p|(q|r))'), rule0, [0]), Proof.Line(Formula.parse('(~q|q)'), rule2, []), Proof.Line(Formula.parse('((q|r)|p)'), rule1, [2, 1]), Proof.Line(Formula.parse('(q|(r|p))'), rule0, [3]), Proof.Line(Formula.parse('((r|p)|q)'), rule1, [2, 4]) ]) # Test inlining lemma2_proof once into proof assert proof.is_valid(), offending_line(proof) rule = lemma2_proof.statement line_number = first_use_of_rule(proof, rule) if debug: print('Testing inline_proof_once (test 1). In main proof:\n', proof, "Replacing line", line_number, 'with the proof of following lemma proof:\n', str(lemma2_proof)) inlined_proof = inline_proof_once(proof, line_number, lemma2_proof) if debug: print("\nGot:", inlined_proof) assert inlined_proof.statement == proof.statement assert inlined_proof.rules == proof.rules.union(lemma2_proof.rules) newuse = uses_of_rule(inlined_proof, rule) olduse = uses_of_rule(proof, rule) assert newuse == olduse - 1, \ "Uses of rule went from " + str(olduse)+ " to " + str(newuse) assert inlined_proof.is_valid(), offending_line(inlined_proof) # Test inlining lemma2_proof into result of previous inlining proof = inlined_proof assert proof.is_valid(), offending_line(proof) rule = lemma2_proof.statement line_number = first_use_of_rule(proof, rule) if debug: print('Testing inline_proof_once (test 2). In main proof:\n', proof, "Replacing line", line_number, 'with the proof of following lemma proof:\n', str(lemma2_proof)) inlined_proof = inline_proof_once(proof, line_number, lemma2_proof) if debug: print("\nGot:", inlined_proof) assert inlined_proof.statement == proof.statement assert inlined_proof.rules == proof.rules.union(lemma2_proof.rules) newuse = uses_of_rule(inlined_proof, rule) olduse = uses_of_rule(proof, rule) assert newuse == olduse - 1, \ "Uses of rule went from " + str(olduse)+ " to " + str(newuse) assert inlined_proof.is_valid(), offending_line(inlined_proof) for count in range(3): # Test inlining lemma1_proof into result of previous inlining proof = inlined_proof assert proof.is_valid(), offending_line(proof) rule = lemma1_proof.statement assert uses_of_rule(proof, rule) == 3 - count line_number = first_use_of_rule(proof, rule) if debug: print( 'Testing inline_proof_once (test ' + str(3 + count) + '). In main proof:\n', proof, "Replacing line", line_number, 'with the proof of following lemma proof:\n', str(lemma1_proof)) inlined_proof = inline_proof_once(proof, line_number, lemma1_proof) if debug: print("\nGot:", inlined_proof) assert inlined_proof.statement == proof.statement assert inlined_proof.rules == proof.rules.union(lemma1_proof.rules) newuse = uses_of_rule(inlined_proof, rule) olduse = uses_of_rule(proof, rule) assert newuse == olduse - 1, \ "Uses of rule went from " + str(olduse)+ " to " + str(newuse) assert inlined_proof.is_valid(), offending_line(inlined_proof) statement = InferenceRule([Formula.parse('(x&y)'), Formula.parse('(w&z)')], Formula.parse('((y&x)&(z&w))')) RA = InferenceRule( [Formula.parse('p'), Formula.parse('q')], Formula.parse('(p&q)')) RB = InferenceRule([Formula.parse('(p&q)')], Formula.parse('(q&p)')) lines = [ Proof.Line(Formula.parse('(x&y)')), Proof.Line(Formula.parse('(y&x)'), RB, [0]), Proof.Line(Formula.parse('(w&z)')), Proof.Line(Formula.parse('(z&w)'), RB, [2]), Proof.Line(Formula.parse('((y&x)&(z&w))'), RA, [1, 3]) ] proof = Proof(statement, {RA, RB}, lines) lem_proof = prove_and_commutativity() assert proof.is_valid(), offending_line(proof) assert lem_proof.is_valid(), offending_line(lem_proof) line_number = first_use_of_rule(proof, RB) if debug: print('Testing inline_proof_once (final). In main proof:\n', proof, "Replacing line", line_number, 'with the proof of following lemma proof:\n', str(lem_proof)) inlined_proof = inline_proof_once(proof, line_number, lem_proof) if debug: print("\nGot:", inlined_proof) assert inlined_proof.statement == proof.statement assert inlined_proof.rules == proof.rules.union(lem_proof.rules) newuse = uses_of_rule(inlined_proof, RB) olduse = uses_of_rule(proof, RB) assert newuse == olduse - 1, \ "Uses of rule went from " + str(olduse)+ " to " + str(newuse) assert inlined_proof.is_valid(), offending_line(inlined_proof)