def deduce_in_number_set(expr, number_set, **defaults_config): ''' Prove that 'expr' is an Expression that respresents a number in the given 'number_set'. ''' from proveit.logic import InSet membership = InSet(expr, number_set) if membership.proven(): # Already proven. We're done. return membership.prove() if hasattr(expr, 'deduce_in_number_set'): # Use 'deduce_in_number_set' method. return expr.deduce_in_number_set(number_set) # Try prove(). return membership.prove()
def conclude(self, **defaults_config): ''' Try to deduce that the given element is in the number set under the given assumptions. ''' from proveit.numbers import deduce_number_set element = self.element ''' # Maybe let's not simplify first. If # See if we can simplify the element first. if hasattr(element, 'simplification'): simplification = element.simplification(assumptions=assumptions) element = simplification.rhs if element != self.element: # Prove membersip for the simplified element elem_in_set = InSet(element, self.number_set).prove(assumptions) # Substitute into the original. return simplification.sub_left_side_into(elem_in_set, assumptions) ''' try: deduce_number_set(element) except (ProofFailure, UnsatisfiedPrerequisites): pass membership = InSet(element, self.number_set) if membership.proven(): return membership.prove() # Try the 'deduce_in_number_set' method. if hasattr(element, 'deduce_in_number_set'): try: return element.deduce_in_number_set(self.number_set) except (NotImplementedError, UnsatisfiedPrerequisites) as e: if hasattr(self, 'conclude_as_last_resort'): return self.conclude_as_last_resort() raise ProofFailure(InSet(self.element, self.number_set), defaults.assumptions, str(e)) else: if hasattr(self, 'conclude_as_last_resort'): return self.conclude_as_last_resort() msg = str(element) + " has no 'deduce_in_number_set' method." raise ProofFailure(InSet(self.element, self.number_set), defaults.assumptions, msg)
def deduce_in_number_set(self, number_set, **defaults_config): ''' Attempt to prove that this exponentiation expression is in the given number set. ''' from proveit.logic import InSet, NotEquals from proveit.numbers.exponentiation import ( exp_complex_closure, exp_natpos_closure, exp_int_closure, exp_rational_closure_nat_power, exp_rational_nonzero_closure, exp_rational_pos_closure, exp_real_closure_nat_power, exp_real_pos_closure, exp_real_non_neg_closure, exp_complex_closure, exp_complex_nonzero_closure, sqrt_complex_closure, sqrt_real_closure, sqrt_real_pos_closure, sqrt_real_non_neg_closure, sqrd_pos_closure, sqrd_non_neg_closure) from proveit.numbers import zero deduce_number_set(self.exponent) if number_set == NaturalPos: return exp_natpos_closure.instantiate( {a: self.base, b: self.exponent}) elif number_set == Natural: # Use the NaturalPos closure which applies for # any Natural base and exponent. self.deduce_in_number_set(NaturalPos) return InSet(self, Natural).prove() elif number_set == Integer: return exp_int_closure.instantiate( {a: self.base, b: self.exponent}) elif number_set == Rational: power_is_nat = InSet(self.exponent, Natural) if not power_is_nat.proven(): # Use the RationalNonZero closure which works # for negative exponents as well. self.deduce_in_number_set(RationalNonZero) return InSet(self, Rational).prove() return exp_rational_closure_nat_power.instantiate( {a: self.base, b: self.exponent}) elif number_set == RationalNonZero: return exp_rational_nonzero_closure.instantiate( {a: self.base, b: self.exponent}) elif number_set == RationalPos: return exp_rational_pos_closure.instantiate( {a: self.base, b: self.exponent}) elif number_set == Real: if self.exponent == frac(one, two): return sqrt_real_closure.instantiate( {a: self.base, b: self.exponent}) else: power_is_nat = InSet(self.exponent, Natural) if not power_is_nat.proven(): # Use the RealPos closure which allows # any real exponent but requires a # non-negative base. self.deduce_in_number_set(RealPos) return InSet(self, Real).prove() return exp_real_closure_nat_power.instantiate( {a: self.base, b: self.exponent}) elif number_set == RealPos: if self.exponent == frac(one, two): return sqrt_real_pos_closure.instantiate({a: self.base}) elif self.exponent == two: return sqrd_pos_closure.instantiate({a: self.base}) else: return exp_real_pos_closure.instantiate( {a: self.base, b: self.exponent}) elif number_set == RealNonNeg: if self.exponent == frac(one, two): return sqrt_real_non_neg_closure.instantiate({a: self.base}) elif self.exponent == two: return sqrd_non_neg_closure.instantiate({a: self.base}) else: return exp_real_non_neg_closure.instantiate( {a: self.base, b: self.exponent}) elif number_set == Complex: if self.exponent == frac(one, two): return sqrt_complex_closure.instantiate( {a: self.base}) else: return exp_complex_closure.instantiate( {a: self.base, b: self.exponent}) elif number_set == ComplexNonZero: return exp_complex_nonzero_closure.instantiate( {a: self.base, b: self.exponent}) raise NotImplementedError( "'Exp.deduce_in_number_set' not implemented for the %s set" % str(number_set))