def doReducedSimplification(self):
'''
For the trivial case a nested scalar product, derive and return this scalar product
expression equated with a simplified form.
'''
from theorems import doublyScaledAsSinglyScaled
if isinstance(self.scaled, ScalarProd):
eq = Equation()
expr = self
'''
try:
# try to simplify it more with recursion
innerSimpl = self.scaled.simplication()
dummyVar = self.safeDummyVar()
eq.update(innerSimpl.substitution(ScalarProd(self.scalar, dummyVar), dummyVar))
expr = eq.eqExpr.rhs
except:
pass
'''
eq.update(
doublyScaledAsSinglyScaled.specialize({
x: expr.scaled.scaled
}).specialize({
alpha: expr.scalar,
beta: expr.scaled.scalar
}))
return eq.eqExpr
else:
raise ValueError(
'Only trivial simplification is implemented (nested scalar products)'
)
def factor(self, scalar):
'''
Factor the given scalar from the scaled quantity, combining it with the other scalar as multiplication.
'''
eq = Equation()
# pull the factor from the "scaled" quantity
scaledFactoring = self.scaled.factor(scalar)
dummyVar = self.safeDummyVar()
eq.update(scaledFactoring.substitution(ScalarProd(self.scalar, dummyVar), dummyVar))
# simplify the nested ScaledProd
expr = eq.eqExpr.rhs
eq.update(expr.simplification())
return eq.eqExpr
from proveit.basiclogic.booleans.axioms import iff_def, and_f_t, implies_t_f
from proveit.basiclogic.booleans.theorems import implies_f_t
from proveit.basiclogic import TRUE, FALSE, Implies, And, Equation
from proveit.common import A, B, X
# (TRUE <=> FALSE) = [(TRUE => FALSE) and (FALSE => TRUE)]
eqn = Equation(iff_def.instantiate({A: TRUE, B: FALSE})).proven()
# (TRUE <=> FALSE) = [FALSE and (FALSE => TRUE)]
eqn.update(implies_t_f.substitution(eqn.eq_expr.rhs)).proven()
# (TRUE <=> FALSE) = (FALSE and TRUE)
eqn.update(implies_f_t.substitution(eqn.eq_expr.rhs)).proven()
# (TRUE <=> FALSE) = FALSE
eqn.update(and_f_t).qed(__file__)
from proveit.basiclogic.boolean.axioms import iffDef, andTF, impliesTF
from proveit.basiclogic.boolean.theorems import impliesFT
from proveit.basiclogic import TRUE, FALSE, Implies, And, Equation
from proveit.common import A, B, X
# (FALSE <=> TRUE) = [(FALSE => TRUE) and (TRUE => FALSE)]
eqn = Equation(iffDef.specialize({A:FALSE, B:TRUE})).proven()
# (FALSE <=> TRUE) = [TRUE and (TRUE => FALSE)]
eqn.update(impliesFT.substitution(eqn.eqExpr.rhs)).proven()
# (FALSE <=> TRUE) = (TRUE and FALSE)
eqn.update(impliesTF.substitution(eqn.eqExpr.rhs)).proven()
# (FALSE <=> TRUE) = FALSE
eqn.update(andTF).qed(__file__)