def conclude(self, assumptions): ''' Attempt to conclude the equality various ways: simple reflexivity (x=x), via an evaluation (if one side is an irreducible), or via transitivity. ''' from proveit.logic import TRUE, FALSE, Implies, Iff if self.lhs == self.rhs: # Trivial x=x return self.concludeViaReflexivity() if self.lhs or self.rhs in (TRUE, FALSE): try: # Try to conclude as TRUE or FALSE. return self.concludeBooleanEquality(assumptions) except ProofFailure: pass if isIrreducibleValue(self.rhs): return self.lhs.evaluation() elif isIrreducibleValue(self.lhs): return self.rhs.evaluation().deriveReversed() try: Implies(self.lhs, self.rhs).prove(assumptions, automation=False) Implies(self.rhs, self.lhs).prove(assumptions, automation=False) # lhs => rhs and rhs => lhs, so attempt to prove lhs = rhs via lhs <=> rhs # which works when they can both be proven to be Booleans. try: return Iff(self.lhs, self.rhs).deriveEquality(assumptions) except: from proveit.logic.boolean.implication._theorems_ import eqFromMutualImpl return eqFromMutualImpl.specialize({ A: self.lhs, B: self.rhs }, assumptions=assumptions) except ProofFailure: pass """ # Use concludeEquality if available if hasattr(self.lhs, 'concludeEquality'): return self.lhs.concludeEquality(assumptions) if hasattr(self.rhs, 'concludeEquality'): return self.rhs.concludeEquality(assumptions) """ # Use a breadth-first search approach to find the shortest # path to get from one end-point to the other. return TransitiveRelation.conclude(self, assumptions)
def conclude(self, assumptions): ''' Attempt to conclude the equality various ways: simple reflexivity (x=x), via an evaluation (if one side is an irreducible). Use conclude_via_transitivity for transitivity cases. ''' from proveit.logic import TRUE, FALSE, Implies, Iff, in_bool if self.lhs == self.rhs: # Trivial x=x return self.conclude_via_reflexivity() if (self.lhs in (TRUE, FALSE)) or (self.rhs in (TRUE, FALSE)): try: # Try to conclude as TRUE or FALSE. return self.conclude_boolean_equality(assumptions) except ProofFailure: pass if is_irreducible_value(self.rhs): try: evaluation = self.lhs.evaluation(assumptions) if evaluation.rhs != self.rhs: raise ProofFailure( self, assumptions, "Does not match with evaluation: %s" % str(evaluation)) return evaluation except EvaluationError as e: raise ProofFailure(self, assumptions, "Evaluation error: %s" % e.message) elif is_irreducible_value(self.lhs): try: evaluation = self.rhs.evaluation(assumptions) if evaluation.rhs != self.lhs: raise ProofFailure( self, assumptions, "Does not match with evaluation: %s" % str(evaluation)) return evaluation.derive_reversed() except EvaluationError as e: raise ProofFailure(self, assumptions, "Evaluation error: %s" % e.message) if (Implies(self.lhs, self.rhs).proven(assumptions) and Implies(self.rhs, self.lhs).proven(assumptions) and in_bool(self.lhs).proven(assumptions) and in_bool(self.rhs).proven(assumptions)): # There is mutual implication both sides are known to be # boolean. Conclude equality via mutual implication. return Iff(self.lhs, self.rhs).derive_equality(assumptions) if hasattr(self.lhs, 'deduce_equality'): # If there is a 'deduce_equality' method, use that. # The responsibility then shifts to that method for # determining what strategies should be attempted # (with the recommendation that it should not attempt # multiple non-trivial automation strategies). eq = self.lhs.deduce_equality(self, assumptions) if eq.expr != self: raise ValueError("'deduce_equality' not implemented " "correctly; must deduce the 'equality' " "that it is given if it can: " "'%s' != '%s'" % (eq.expr, self)) return eq else: ''' If there is no 'deduce_equality' method, we'll try simplifying each side to see if they are equal. ''' # Try to prove equality via simplifying both sides. lhs_simplification = self.lhs.simplification(assumptions) rhs_simplification = self.rhs.simplification(assumptions) simplified_lhs = lhs_simplification.rhs simplified_rhs = rhs_simplification.rhs try: if simplified_lhs != self.lhs or simplified_rhs != self.rhs: simplified_eq = Equals(simplified_lhs, simplified_rhs).prove(assumptions) return Equals.apply_transitivities([ lhs_simplification, simplified_eq, rhs_simplification ], assumptions) except ProofFailure: pass raise ProofFailure( self, assumptions, "Unable to automatically conclude by " "standard means. To try to prove this via " "transitive relations, try " "'conclude_via_transitivity'.")
def deriveIff(self, assumptions=USE_DEFAULTS): r''' From A => B derive and return A <=> B assuming B => A. ''' from proveit.logic import Iff return Iff(self.A, self.B).concludeViaDefinition()
modInIntervalCO absIsNonNeg = Forall(a, GreaterThanEquals(Abs(a), zero), domain=Complexes) absIsNonNeg absNotEqZero = Forall([a], NotEquals(Abs(a), zero), domain=Complexes, conditions=[NotEquals(a, zero)]) absNotEqZero absElim = Forall(x, Equals(Abs(x), x), domain=RealsPos) absElim absIneq = Forall((x, y), Iff(LessThanEquals(Abs(x), y), And(LessThanEquals(Neg(y), x), LessThanEquals(x, y))), domain=Reals, conditions=[GreaterThanEquals(y, zero)]) absIneq triangleInequality = Forall([a, b], LessThanEquals(Abs(Add(a, b)), Add(Abs(a), Abs(b))), domain=Complexes) triangleInequality absProd = Forall(xEtc, Equals(Abs(Mult(xEtc)), Mult(Etcetera(Abs(xMulti)))), domain=Complexes) absProd
conditions=[ NotEquals( a, zero)]) abs_not_eq_zero # transferred by wdc 3/11/2020 abs_elim = Forall(x, Equals(Abs(x), x), domain=RealPos) abs_elim # transferred by wdc 3/11/2020 abs_ineq = Forall( (x, y), Iff( LessThanEquals( Abs(x), y), And( LessThanEquals( Neg(y), x), LessThanEquals( x, y))), domain=Real, conditions=[ GreaterThanEquals( y, zero)]) abs_ineq # transferred by wdc 3/11/2020 triangle_inequality = Forall([a, b], LessThanEquals( Abs(Add(a, b)), Add(Abs(a), Abs(b))), domain=Complex) triangle_inequality # transferred by wdc 3/11/2020 abs_prod = Forall(x_etc, Equals(Abs(Mult(x_etc)), Mult(Etcetera(Abs(x_multi)))),
domain = Reals) inComplexes inRealsPos_inReals = Forall(a, InSet(a,Reals), domain = RealsPos) inRealsPos_inReals inRealsNeg_inReals = Forall(a, InSet(a,Reals), domain = RealsNeg) inRealsNeg_inReals inRealsPos_inComplexes = Forall(a, InSet(a,Complexes), domain = RealsPos) inRealsPos_inComplexes inRealsNeg_inComplexes = Forall(a, InSet(a,Complexes), domain = RealsNeg) inRealsNeg_inComplexes inRealsPos_iff_positive = Forall(a, Iff(InSet(a, RealsPos), GreaterThan(a, zero)), domain=Reals) inRealsPos_iff_positive inRealsNeg_iff_negative = Forall(a, Iff(InSet(a, RealsNeg), LessThan(a, zero)), domain=Reals) inRealsNeg_iff_negative positive_implies_notZero = Forall(a, NotEquals(a, zero), domain=Reals, conditions=[GreaterThan(a, zero)]) positive_implies_notZero negative_implies_notZero = Forall(a, NotEquals(a, zero), domain=Reals, conditions=[LessThan(a, zero)]) negative_implies_notZero allInIntervalOO_InReals = Forall((a, b), Forall(x, InSet(x, Reals), domain=IntervalOO(a, b)), domain=Reals) allInIntervalOO_InReals allInIntervalCO_InReals = Forall((a, b), Forall(x, InSet(x, Reals), domain=IntervalCO(a, b)), domain=Reals)
def derive_iff(self, **defaults_config): r''' From A => B derive and return A <=> B assuming B => A. ''' from proveit.logic import Iff return Iff(self.A, self.B).conclude_via_definition()
from proveit import beginAxioms, endAxioms beginAxioms(locals()) # Define the set of Naturals as, essentially, the minimum set that contains zero and all of its successors; # that is, n is in Naturals iff n is in all sets that contain zero and all successors. naturalsDef = Forall( n, Equals( InSet(n, Naturals), Forall( S, Implies( And(InSet(zero, S), Forall(x, InSet(Add(x, one), S), domain=S)), InSet(n, S))))) # Define the length of an ExpressionList inductively. exprListLengthDef = And( Equals(Len(), zero), Forall((xMulti, y), Equals(Len(xEtc, y), Add(Len(xEtc), one)))) naturalsPosDef = Forall(n, Iff(InSet(n, NaturalsPos), GreaterThanEquals(n, one)), domain=Naturals) naturalsPosDef integersDef = Equals(Integers, Union(Naturals, SetOfAll(n, Neg(n), domain=Naturals))) endAxioms(locals(), __package__)