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__)