def conclude(self, assumptions):
'''
Attempt to conclude that the element is in the domain.
First, see if it is not contained in a superset of the domain.
Next, check if the element has a known simplification; if so,
try to derive non-membership via this simplification.
If there isn't a known simplification, next try to call
the 'self.domain.nonmembership_object.conclude(..)' method to prove
the non-membership. If that fails, try simplifying the element
again, this time using automation to push the simplification through
if possible.
As a last resort, try 'conclude_as_folded'.
'''
from proveit.logic import SubsetEq, InSet
from proveit import ProofFailure
from proveit.logic import SimplificationError
# See if the membership is already known.
if self.element in NotInSet.known_nonmemberships:
for known_nonmembership in NotInSet.known_nonmemberships[
self.element]:
if known_nonmembership.is_sufficient(assumptions):
# x not in R is known to be true; if we know that
# S subset_eq R, we are done.
rel = SubsetEq(self.domain, known_nonmembership.domain)
if rel.proven(assumptions):
# S is a subset of R, so now we can prove
# x not in S.
return rel.derive_subset_nonmembership(
self.element, assumptions)
# No known membership works. Let's see if there is a known
# simplification of the element before trying anything else.
try:
elem_simplification = self.element.simplification(assumptions,
automation=True)
if elem_simplification.lhs == elem_simplification.rhs:
elem_simplification = None # reflection doesn't count
except SimplificationError:
elem_simplification = None
# If the element simplification succeeded, prove the membership
# via the simplified form of the element.
if elem_simplification is not None:
simple_elem = elem_simplification.rhs
simple_nonmembership = NotInSet(simple_elem,
self.domain).prove(assumptions)
inner_expr = simple_nonmembership.inner_expr().element
return elem_simplification.sub_left_side_into(
inner_expr, assumptions)
else:
# If it has a 'nonmembership_object', try to conclude
# nonmembership using that.
if hasattr(self, 'nonmembership_object'):
return self.nonmembership_object.conclude(assumptions)
else:
# Otherwise, attempt to conclude via Not(x in S)
return self.conclude_as_folded(assumptions=assumptions)
def conclude(self, **defaults_config):
'''
Attempt to conclude that the the NotInSet object is true ---
i.e. that the element is not in the domain.
First, see if it is not contained in a superset of the domain.
Next, check if the element has a known simplification; if so,
try to derive non-membership via this simplification.
If there isn't a known simplification, next try to call
the 'self.domain.nonmembership_object.conclude(..)' method to
prove the non-membership. If that fails, try simplifying the
element again, this time using automation to push the
simplification through if possible.
As a last resort, try 'conclude_as_folded'.
'''
from proveit import ProofFailure
from proveit.logic import SubsetEq, evaluation_or_simplification
if self.negated().disproven():
return self.conclude_as_folded()
# See if the element, or something known to be equal to
# the element, is known to be a nonmember of the domain or a
# superset of the domain.
if self.element in NotInClass.known_nonmemberships:
for known_nonmembership in \
NotInClass.known_nonmemberships[self.element]:
if known_nonmembership.is_applicable():
# x not in R is known to be true; if we know that
# S subset_eq R, we are done.
rel = SubsetEq(self.domain, known_nonmembership.domain)
if rel.proven():
# S is a subset of R, so now we can prove
# x not in S.
return rel.derive_subset_nonmembership(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
# If it has a 'nonmembership_object', try to conclude
# nonmembership using that.
if hasattr(self, 'nonmembership_object'):
return self.nonmembership_object.conclude()
else:
# Otherwise, attempt to conclude via Not(x in S)
return self.conclude_as_folded()
