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)
