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)