def shallow_simplification(self,
*,
must_evaluate=False,
**defaults_config):
'''
If the left side has a 'not_equal' method, use that for
evalaution. Otherwise, if appropriate (must_evaluate is TRUE
or the answer is already known) apply the definition to
perform the evaluation: A ≠ B via ￢(A = B).
'''
from proveit import ProofFailure
from proveit.logic import evaluate_truth
if self.lhs != self.rhs and hasattr(self.lhs, 'not_equal'):
try:
# If there is a 'not_equal' method, try to use that.
neq = self.lhs.not_equal(self.rhs, automation=must_evaluate)
return evaluate_truth(neq)
except ProofFailure:
pass
eq = Equals(self.lhs, self.rhs)
if must_evaluate or eq.proven() or eq.disproven():
# Evaluate A ≠ B via evaluating ￢(A = B),
definition_equality = self.definition()
unfolded_evaluation = definition_equality.rhs.evaluation(
automation=must_evaluate)
return definition_equality.apply_transitivity(unfolded_evaluation)
return Operation.shallow_simplification(self)
def shallow_simplification(self,
*,
must_evaluate=False,
**defaults_config):
if must_evaluate and hasattr(self.operand, 'compute_norm'):
return self.evaluation()
return Operation.shallow_simplification(self)
def shallow_simplification(self, *, must_evaluate=False,
**defaults_config):
'''
Simplify via inner product linearity:
<a x, y> = a <x, y>
<x, y> = <x, a y>
<x + y, z> = <x, z> + <y, z>
<x, y + z> = <x, y> + <x, z>
'''
from proveit.linear_algebra import VecSpaces, ScalarMult, VecAdd
from proveit.linear_algebra.inner_products import (
inner_prod_scalar_mult_left, inner_prod_scalar_mult_right,
inner_prod_vec_add_left, inner_prod_vec_add_right)
_u, _v = self.operands
try:
vec_space = VecSpaces.common_known_vec_space((_u, _v))
except UnsatisfiedPrerequisites:
# No known common vectors space for the operands, so
# we have no specific shallow_simplication we can do here.
return Operation.shallow_simplification(
self, must_evaluate=must_evaluate)
field = VecSpaces.known_field(vec_space)
simp = None
if isinstance(_u, ScalarMult):
simp = inner_prod_scalar_mult_left.instantiate(
{K:field, H:vec_space, a:_u.scalar, x:_u.scaled, y:_v})
if isinstance(_v, ScalarMult):
simp = inner_prod_scalar_mult_right.instantiate(
{K:field, H:vec_space, a:_v.scalar, x:_u, y:_v.scaled})
if isinstance(_u, VecAdd):
simp = inner_prod_vec_add_left.instantiate(
{K:field, H:vec_space, x:_u.terms[0], y:_u.terms[1], z:_v})
if isinstance(_v, VecAdd):
simp = inner_prod_vec_add_right.instantiate(
{K:field, H:vec_space, x:_u, y:_v.terms[0], z:_v.terms[1]})
if simp is None:
return Operation.shallow_simplification(
self, must_evaluate=must_evaluate)
if must_evaluate and not is_irreducible_value(simp.rhs):
return simp.inner_expr().rhs.evaluate()
return simp
def shallow_simplification(self,
*,
must_evaluate=False,
**defaults_config):
'''
If the function is a Lambda map, simplify the Image via
its definition.
'''
if isinstance(self.elem_function, Lambda):
return self.definition()
return Operation.shallow_simplification(self,
must_evaluate=must_evaluate)
def shallow_simplification(self,
*,
must_evaluate=False,
**defaults_config):
'''
Returns a proven simplification equation for this Len
expression assuming. Performs the "computation" of the
Len expression and then simplifies the right side.
'''
if must_evaluate:
return self.computation(auto_simplify=True)
else:
return Operation.shallow_simplification(self)
def shallow_simplification(self, *, must_evaluate=False,
**defaults_config):
'''
If the operands that to TRUE or FALSE, we can
evaluate this expression as TRUE or FALSE.
'''
# IMPORTANT: load in truth-table evaluations
from . import implies_t_t, implies_t_f, implies_f_t, implies_f_f
try:
return Operation.shallow_simplification(
self, must_evaluate=must_evaluate)
except NotImplementedError:
# Should have been able to do the evaluation from the
# loaded truth table.
# If it can't we are unable to evaluate it.
from proveit.logic import EvaluationError
raise EvaluationError(self)
def shallow_simplification(self, *, must_evaluate=False,
**defaults_config):
'''
Given operands that evaluate to TRUE or FALSE, derive and
return the equality of this expression with TRUE or FALSE.
'''
from proveit.logic import TRUE, FALSE
# load in truth-table evaluations
from . import implies_t_f, implies_t_t, implies_f_t, implies_f_f
if must_evaluate:
start_over = False
for operand in self.operands:
if operand not in (TRUE, FALSE):
# The simplification of the operands may not have
# worked hard enough. Let's work harder if we
# must evaluate.
operand.evaluation()
start_over = True
if start_over: return self.evaluation()
# May now be able to evaluate via loaded truth tables.
return Operation.shallow_simplification(
self, must_evaluate=must_evaluate)
def shallow_simplification(self,
*,
must_evaluate=False,
**defaults_config):
from proveit.logic import TRUE, FALSE, EvaluationError, evaluate_truth
from proveit.logic.booleans.negation import (negation_intro,
falsified_negation_intro)
from . import not_t, not_f # load in truth-table evaluations
if self.operand == TRUE:
return not_t
elif self.operand == FALSE:
return not_f
elif self.operand.proven():
# evaluate to FALSE via falsified_negation_intro
return falsified_negation_intro.instantiate({A: self.operand})
elif self.operand.disproven():
# evaluate to TRUE via falsified_negation_intro
return evaluate_truth(negation_intro.instantiate({A:
self.operand}))
elif must_evaluate:
# The simplification of the operands may not have
# worked hard enough. Let's work harder if we must
# evaluate.
evaluated = self.operand.evaluation().rhs
if evaluated in (TRUE, FALSE):
# All the pieces should be there now.
return self.evaluation(automation=True)
raise EvaluationError(self)
if hasattr(self.operand, 'shallow_simplification_of_negation'):
# If the operand has a 'shallow_simplification_of_negation',
# use that.
return self.operand.shallow_simplification_of_negation()
# May now be able to evaluate via loaded truth tables.
return Operation.shallow_simplification(self)
