def deduce_number_set(expr, **defaults_config):
'''
Prove that 'expr' is an Expression that represents a number
in a standard number set that is as restrictive as we can
readily know.
'''
from proveit.logic import And, InSet, Equals, NotEquals
from proveit.numbers import Less, LessEq, zero
# Find the first (most restrictive) number set that
# contains 'expr' or something equal to it.
for number_set in sorted_number_sets:
membership = None
for eq_expr in Equals.yield_known_equal_expressions(expr):
if isinstance(eq_expr, ExprRange):
membership = And(
ExprRange(eq_expr.parameter,
InSet(eq_expr.body, number_set),
eq_expr.true_start_index,
eq_expr.true_end_index,
styles=eq_expr.get_styles()))
else:
membership = InSet(eq_expr, number_set)
if membership.proven():
break # found a known number set membership
else:
membership = None
if membership is not None:
membership = InSet(expr, number_set).prove()
break
if hasattr(expr, 'deduce_number_set'):
# Use 'deduce_number_set' method.
try:
deduced_membership = expr.deduce_number_set()
except (UnsatisfiedPrerequisites, ProofFailure):
deduced_membership = None
if deduced_membership is not None:
assert isinstance(deduced_membership, Judgment)
if not isinstance(deduced_membership.expr, InSet):
raise TypeError("'deduce_number_set' expected to prove an "
"InSet type expression")
if deduced_membership.expr.element != expr:
raise TypeError("'deduce_number_set' was expected to prove "
"that %s is in some number set" % expr)
# See if this deduced number set is more restrictive than
# what we had surmised already.
deduced_number_set = deduced_membership.domain
if membership is None:
membership = deduced_membership
number_set = deduced_number_set
elif (deduced_number_set != number_set
and number_set.includes(deduced_number_set)):
number_set = deduced_number_set
membership = deduced_membership
if membership is None:
from proveit import defaults
raise UnsatisfiedPrerequisites(
"Unable to prove any number membership for %s" % expr)
# Already proven to be in some number set,
# Let's see if we can restrict it further.
if Less(zero, expr).proven(): # positive
number_set = pos_number_set.get(number_set, None)
elif Less(expr, zero).proven(): # negative
number_set = neg_number_set.get(number_set, None)
elif LessEq(zero, expr).proven(): # non-negative
number_set = nonneg_number_set.get(number_set, None)
elif LessEq(expr, zero).proven(): # non-positive
number_set = nonpos_number_set.get(number_set, None)
elif NotEquals(expr, zero).proven():
number_set = nonzero_number_set.get(number_set, None)
if number_set is None:
# Just use what we have already proven.
return membership.prove()
return InSet(expr, number_set).prove()
def conclude(self, **defaults_config):
'''
Attempt to conclude that the element is in the domain. First,
see if it is known to be contained in a known subset of the
domain. Next, check if the element has a known simplification;
if so, try to derive membership via this simplification.
If there isn't a known simplification, next try to call
the 'self.domain.membership_object.conclude(..)' method to prove
the membership. If that fails, try simplifying the element
again, this time using automation to push the simplification
through if possible.
'''
from proveit.logic import Equals, SubsetEq, evaluation_or_simplification
# See if the element, or something known to be equal to
# the element, is known to be a member of the domain or a subset
# of the domain.
for elem_sub in Equals.yield_known_equal_expressions(self.element):
same_membership = None # membership in self.domain
eq_membership = None # membership in an equal domain
subset_membership = None # membership in a subset
for known_membership in InClass.yield_known_memberships(elem_sub):
eq_rel = Equals(known_membership.domain, self.domain)
sub_rel = SubsetEq(known_membership.domain, self.domain)
if known_membership.domain == self.domain:
same_membership = known_membership
break # this is the best to use; we are done
elif eq_rel.proven():
eq_membership = known_membership
elif sub_rel.proven():
subset_membership = known_membership
elem_sub_in_domain = None
if same_membership is not None:
elem_sub_in_domain = same_membership
elif eq_membership is not None:
# domains are equal -- just substitute to domain.
eq_rel = Equals(eq_membership.domain, self.domain)
elem_sub_in_domain = eq_rel.sub_right_side_into(
eq_membership.inner_expr().domain)
elif subset_membership is not None:
# S is a superset of R, so now we can prove x in S.
sub_rel = SubsetEq(subset_membership.domain, self.domain)
elem_sub_in_domain = sub_rel.derive_superset_membership(
elem_sub)
if elem_sub_in_domain is not None:
# We found what we are looking for.
if elem_sub == self.element:
return elem_sub_in_domain # done
# Just need to sub in the element for _elem_sub.
Equals(elem_sub, self.element).conclude_via_transitivity()
return elem_sub_in_domain.inner_expr().element.substitute(
self.element)
# Try the standard Relation strategies -- evaluate or
# simplify both sides.
try:
return Relation.conclude(self)
except ProofFailure:
# Both sides are already irreducible or simplified
# or we were unable to simplify either side.
pass
# Unable to simplify the element. Try to conclude via
# the 'membership_object' if there is one.
if hasattr(self, 'membership_object'):
return self.membership_object.conclude()
raise ProofFailure(
self, defaults.assumptions, "Unable to conclude automatically; "
"the domain, %s, has no 'membership_object' "
"method with a strategy for proving "
"membership." % self.domain)
