def conclude(self, assumptions): ''' Try to automatically conclude this bi-directional implication by reducing its operands to true/false. ''' from . import iff_t_t, iff_t_f, iff_f_t, iff_f_f, true_iff_true, false_iff_false if self in {true_iff_true, false_iff_false}: # should be proven via one of the imported theorems as a simple # special case try: self.evaluation(assumptions) except BaseException: return self.prove() try: # try to prove the bi-directional implication via evaluation reduction. # if that is possible, it is a relatively straightforward thing to # do. return Operation.conclude(assumptions) except BaseException: pass try: # Use a breadth-first search approach to find the shortest # path to get from one end-point to the other. return TransitiveRelation.conclude(self, assumptions) except BaseException: pass # the last attempt is to introduce the Iff via implications each way, an # essentially direct consequence of the definition. return self.conclude_by_definition(assumptions)
def conclude(self, assumptions): ''' Attempt to conclude the equivalence in various ways: simple reflexivity (A equiv A), via an evaluation (if one side is an irreducible), or via transitivity. IN PROGRESS. NOT YET CLEAR how this applies to the SetEquiv ''' from proveit.logic import TRUE, FALSE, Implies, Iff if self.lhs == self.rhs: # Trivial A = A return self.concludeViaReflexivity(assumptions=assumptions) # if self.lhs or self.rhs in (TRUE, FALSE): # try: # # Try to conclude as TRUE or FALSE. # return self.concludeBooleanEquality(assumptions) # except ProofFailure: # pass # if isIrreducibleValue(self.rhs): # try: # evaluation = self.lhs.evaluation(assumptions) # if evaluation.rhs != self.rhs: # raise ProofFailure(self, assumptions, "Does not match with evaluation: %s"%str(evaluation)) # return evaluation # except SimplificationError as e: # raise ProofFailure(self, assumptions, "Evaluation error: %s"%e.message) # elif isIrreducibleValue(self.lhs): # try: # evaluation = self.rhs.evaluation(assumptions) # if evaluation.rhs != self.lhs: # raise ProofFailure(self, assumptions, "Does not match with evaluation: %s"%str(evaluation)) # return evaluation.deriveReversed() # except SimplificationError as e: # raise ProofFailure(self, assumptions, "Evaluation error: %s"%e.message) # try: # Implies(self.lhs, self.rhs).prove(assumptions, automation=False) # Implies(self.rhs, self.lhs).prove(assumptions, automation=False) # # lhs => rhs and rhs => lhs, so attempt to prove lhs = rhs via lhs <=> rhs # # which works when they can both be proven to be Booleans. # try: # return Iff(self.lhs, self.rhs).deriveEquality(assumptions) # except: # from proveit.logic.boolean.implication._theorems_ import eqFromMutualImpl # return eqFromMutualImpl.specialize({A:self.lhs, B:self.rhs}, assumptions=assumptions) # except ProofFailure: # pass # """ # # Use concludeEquality if available # if hasattr(self.lhs, 'concludeEquality'): # return self.lhs.concludeEquality(assumptions) # if hasattr(self.rhs, 'concludeEquality'): # return self.rhs.concludeEquality(assumptions) # """ # Use a breadth-first search approach to find the shortest # path to get from one end-point to the other. return TransitiveRelation.conclude(self, assumptions)
def conclude(self, assumptions): ''' Try to automatically conclude this implication by reducing its operands to true/false, or by doing a "transitivity" search amongst known true implications whose assumptions are covered by the given assumptions. ''' from ._axioms_ import untrueAntecedentImplication from ._theorems_ import trueImpliesTrue, falseImpliesTrue, falseImpliesFalse, falseAntecedentImplication from proveit.logic import TRUE, FALSE if self.antecedent == self.consequent: return self.concludeSelfImplication() if self in {trueImpliesTrue, falseImpliesTrue, falseImpliesFalse}: # should be proven via one of the imported theorems as a simple special case return self.prove() try: # Try evaluating the consequent. evaluation = self.consequent.evaluation(assumptions) if evaluation.rhs == TRUE: # If the consequent evaluates to true, we can prove trivially via hypothetical reasoning return self.consequent.prove(assumptions).asImplication( self.antecedent) elif evaluation.rhs == FALSE: if self.antecedent.evaluation(assumptions).rhs == FALSE: # Derive A => B given Not(A); it doesn't matter what B is if A is FALSE return falseAntecedentImplication.specialize( { A: self.antecedent, B: self.consequent }, assumptions=assumptions) else: # Derive A => B given (A != TRUE); it doesn't matter what B is if A is not TRUE return untrueAntecedentImplication.specialize( { A: self.antecedent, B: self.consequent }, assumptions=assumptions) except: pass try: # Use a breadth-first search approach to find the shortest # path to get from one end-point to the other. return TransitiveRelation.conclude(self, assumptions) except: pass # try to prove the implication via hypothetical reasoning. return self.consequent.prove(assumptions + (self.antecedent, )).asImplication( self.antecedent)
def conclude(self, assumptions): ''' Attempt to conclude the equality various ways: simple reflexivity (x=x), via an evaluation (if one side is an irreducible), or via transitivity. ''' from proveit.logic import TRUE, FALSE, Implies, Iff if self.lhs == self.rhs: # Trivial x=x return self.concludeViaReflexivity() if self.lhs or self.rhs in (TRUE, FALSE): try: # Try to conclude as TRUE or FALSE. return self.concludeBooleanEquality(assumptions) except ProofFailure: pass if isIrreducibleValue(self.rhs): return self.lhs.evaluation() elif isIrreducibleValue(self.lhs): return self.rhs.evaluation().deriveReversed() try: Implies(self.lhs, self.rhs).prove(assumptions, automation=False) Implies(self.rhs, self.lhs).prove(assumptions, automation=False) # lhs => rhs and rhs => lhs, so attempt to prove lhs = rhs via lhs <=> rhs # which works when they can both be proven to be Booleans. try: return Iff(self.lhs, self.rhs).deriveEquality(assumptions) except: from proveit.logic.boolean.implication._theorems_ import eqFromMutualImpl return eqFromMutualImpl.specialize({ A: self.lhs, B: self.rhs }, assumptions=assumptions) except ProofFailure: pass """ # Use concludeEquality if available if hasattr(self.lhs, 'concludeEquality'): return self.lhs.concludeEquality(assumptions) if hasattr(self.rhs, 'concludeEquality'): return self.rhs.concludeEquality(assumptions) """ # Use a breadth-first search approach to find the shortest # path to get from one end-point to the other. return TransitiveRelation.conclude(self, assumptions)
def conclude(self, **defaults_config): ''' Attempt to conclude the equivalence in various ways: simple reflexivity (A equiv A), via an evaluation (if one side is an irreducible), or via transitivity. IN PROGRESS ''' if self.lhs == self.rhs: try: # Trivial A = A return self.conclude_via_reflexivity() except BaseException: pass # e.g., reflexivity theorem may not be usable try: return self.conclude_as_folded() except ProofFailure: raise ProofFailure( self, defaults.assumptions, "Unable to automatically conclude by " "standard means. To try to prove this via " "transitive implication relations, try " "'conclude_via_transitivity'.") # if self.lhs or self.rhs in (TRUE, FALSE): # try: # # Try to conclude as TRUE or FALSE. # return self.conclude_boolean_equality(assumptions) # except ProofFailure: # pass # if is_irreducible_value(self.rhs): # try: # evaluation = self.lhs.evaluation(assumptions) # if evaluation.rhs != self.rhs: # raise ProofFailure(self, assumptions, "Does not match with evaluation: %s"%str(evaluation)) # return evaluation # except SimplificationError as e: # raise ProofFailure(self, assumptions, "Evaluation error: %s"%e.message) # elif is_irreducible_value(self.lhs): # try: # evaluation = self.rhs.evaluation(assumptions) # if evaluation.rhs != self.lhs: # raise ProofFailure(self, assumptions, "Does not match with evaluation: %s"%str(evaluation)) # return evaluation.derive_reversed() # except SimplificationError as e: # raise ProofFailure(self, assumptions, "Evaluation error: %s"%e.message) # try: # Implies(self.lhs, self.rhs).prove(assumptions, automation=False) # Implies(self.rhs, self.lhs).prove(assumptions, automation=False) # # lhs => rhs and rhs => lhs, so attempt to prove lhs = rhs via lhs <=> rhs # # which works when they can both be proven to be Boolean. # try: # return Iff(self.lhs, self.rhs).derive_equality(assumptions) # except: # from proveit.logic.booleans.implication import eq_from_mutual_impl # return eq_from_mutual_impl.instantiate({A:self.lhs, B:self.rhs}, assumptions=assumptions) # except ProofFailure: # pass # """ # # Use conclude_equality if available # if hasattr(self.lhs, 'conclude_equality'): # return self.lhs.conclude_equality(assumptions) # if hasattr(self.rhs, 'conclude_equality'): # return self.rhs.conclude_equality(assumptions) # """ # Use a breadth-first search approach to find the shortest # path to get from one end-point to the other. return TransitiveRelation.conclude(self)