def get_inverses(sequent):
'''
Given a sequent A |- B, return set of sequents ~A |- ~B,
dealing with multiple antecedents and succedents. For example
A, B |- C, D
yields the set
A, ~B |- ~C, ~D
~A, B |- ~C, ~D
'''
result = set()
neg_succedents = union(try_get_negated(s) for s in sequent.succedents)
pos_antecedents = set(sequent.antecedents)
for pos_antecedent in pos_antecedents:
try:
negated = try_get_negated(pos_antecedent)
except NotNegatable:
negated = set()
for neg_antecedent in negated:
neg_antecedents = set_without(pos_antecedents, pos_antecedent)
neg_antecedents = set_with(neg_antecedents, neg_antecedent)
result.add(Sequent(neg_antecedents, neg_succedents))
return result
def all_consistent(completed):
negated = set()
for p in completed:
try:
negated.update(try_get_negated(p))
except NotNegatable:
pass
return negated.isdisjoint(completed)
def get_contrapositives(seq):
"""Given multiple antecedents and succedents, return a set of sequents with
various antecedents or succedents negated such that each result sequent
corresponds has a succedent set corresponding to exactly one of the
original antecedents or succedents. For example.
A, B |- C, D
yields the set
B, ~C, ~D |- ~A
A, ~C, ~D |- ~B
A, B, ~D |- C
A, B, ~C |- D
"""
ante_succ_pairs = []
for succedent in map(weaken_sequent, seq.succedents):
try:
antecedents = try_get_negated(succedent)
except NotNegatable:
antecedents = set()
ante_succ_pairs.append((antecedents, set([succedent])))
for antecedent in map(weaken_sequent, seq.antecedents):
try:
succedents = try_get_negated(antecedent)
except NotNegatable:
succedents = set()
ante_succ_pairs.append((set([antecedent]), succedents))
result = set()
for _, succedents in ante_succ_pairs:
if succedents:
succedent = iter(succedents).next()
antecedents_product = []
for other_antecedents, other_succedents in ante_succ_pairs:
if other_succedents != succedents:
antecedents_product.append(other_antecedents)
for antecedents in itertools.product(*antecedents_product):
if succedent in antecedents:
continue
try:
antecedents = try_simplify_antecedents(set(antecedents))
except Inconsistent:
continue
result.add(Sequent(antecedents, succedents))
return result
