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