def evaluateOperands(self, assumptions=USE_DEFAULTS): from proveit.logic import defaultSimplification return defaultSimplification(self, inPlace=True, mustEvaluate=True, operandsOnly=True, assumptions=assumptions)
def simplification(self, assumptions=USE_DEFAULTS): ''' If possible, return a KnownTruth of this expression equal to its irreducible value. Override for other appropriate functionality. ''' from proveit.logic import defaultSimplification return defaultSimplification(self.innerExpr(), inPlace=False, assumptions=assumptions)
def evaluation(self, assumptions=USE_DEFAULTS): ''' If possible, return a KnownTruth of this expression equal to its irreducible value. Checks for an existing evaluation. If it doesn't exist, try some default strategies including a reduction. Attempt the Expression-class-specific "doReducedEvaluation" when necessary. ''' from proveit.logic import Equals, defaultSimplification, SimplificationError from proveit import KnownTruth, ProofFailure from proveit.logic.irreducible_value import isIrreducibleValue method_called = None try: # First try the default tricks. If a reduction succesfully occurs, # evaluation will be called on that reduction. evaluation = defaultSimplification(self.innerExpr(), mustEvaluate=True, assumptions=assumptions) method_called = defaultSimplification except SimplificationError as e: # The default failed, let's try the Expression-class specific version. try: evaluation = self.doReducedEvaluation(assumptions) method_called = self.doReducedEvaluation except NotImplementedError: # We have nothing but the default evaluation strategy to try, and that failed. raise e if not isinstance(evaluation, KnownTruth) or not isinstance( evaluation.expr, Equals): msg = ("%s must return an KnownTruth, " "not %s for %s assuming %s" % (method_called, evaluation, self, assumptions)) raise ValueError(msg) if evaluation.lhs != self: msg = ("%s must return an KnownTruth " "equality with self on the left side, " "not %s for %s assuming %s" % (method_called, evaluation, self, assumptions)) raise ValueError(msg) if not isIrreducibleValue(evaluation.rhs): msg = ("%s must return an KnownTruth " "equality with an irreducible value on the right side, " "not %s for %s assuming %s" % (method_name, evaluation, self, assumptions)) raise ValueError(msg) # Note: No need to store in Equals.evaluations or Equals.simplifications; this # is done automatically as a side-effect for proven equalities with irreducible # right sides. return evaluation
def simplification(self, assumptions=USE_DEFAULTS): ''' If possible, return a KnownTruth of this expression equal to a canonically simplified form. Checks for an existing simplifcation. If it doesn't exist, try some default strategies including a reduction. Attempt the Expression-class-specific "doReducedSimplication" when necessary. ''' from proveit.logic import Equals, defaultSimplification, SimplificationError from proveit import KnownTruth, ProofFailure method_called = None try: # First try the default tricks. If a reduction succesfully occurs, # simplification will be called on that reduction. simplification = defaultSimplification(self.innerExpr(), assumptions=assumptions) method_called = defaultSimplification except SimplificationError as e: # The default did nothing, let's try the Expression-class specific versions of # evaluation and simplification. try: # first try evaluation. that is as simple as it gets. simplification = self.doReducedEvaluation(assumptions) method_called = self.doReducedEvaluation except (NotImplementedError, SimplificationError): try: simplification = self.doReducedSimplification(assumptions) method_called = self.doReducedSimplification except (NotImplementedError, SimplificationError): # Simplification did not work. Just use self-equality. self_eq = Equals(self, self) simplification = self_eq.prove() method_called = self_eq.prove if not isinstance(simplification, KnownTruth) or not isinstance( simplification.expr, Equals): msg = ("%s must return a KnownTruth " "equality, not %s for %s assuming %s" % (method_called, simplification, self, assumptions)) raise ValueError(msg) if simplification.lhs != self: msg = ("%s must return a KnownTruth " "equality with 'self' on the left side, not %s for %s " "assuming %s" % (method_called, simplification, self, assumptions)) raise ValueError(msg) # Remember this simplification for next time: Equals.simplifications.setdefault(self, set()).add(simplification) return simplification
def simplification(self, assumptions=USE_DEFAULTS, automation=True): ''' If possible, return a KnownTruth of this expression equal to its irreducible value. Override for other appropriate functionality. ''' from proveit.logic import defaultSimplification, Equals from proveit import ProofFailure if not automation: # Without automation, we'll just grab an arbitrary simplification that we already know simplifications = Equals.simplifications.get(self, set()) if len(simplifications) == 0: raise ProofFailure( self, assumptions, "No existing simplification; cannot perform 'simplification' without automation" ) return list(simplifications)[0] return defaultSimplification(self.innerExpr(), inPlace=False, assumptions=assumptions)
def evaluation(self, assumptions=USE_DEFAULTS): from proveit.logic import defaultSimplification return defaultSimplification(self, mustEvaluate=True, assumptions=assumptions)
def simplify(self, assumptions=USE_DEFAULTS): from proveit.logic import defaultSimplification return defaultSimplification(self, inPlace=True, assumptions=assumptions)