def _defineAxioms():
# Forall_X [()] in X**
_firstAxiom =\
nullsetInKleene = Forall(X, In(List(), KleeneRepetition(X)))
# Forall_{A**, X} [A**] in X* => [A**, X] in X*
concatenationInKleene = Forall([multiA, X],
Implies(
In(List(multiA), KleeneRepetition(X)),
In(List(multiA, X),
KleeneRepetition(X))))
return _firstAxiom, locals()
def forallBoolEvalFalseDerivation(PofTrueVal, PofFalseVal):
# hypothesis = [P(TRUE) = PofTrueVal] and [P(FALSE) in PofFalseVal]
hypothesis = And(Equals(PofTrue, PofTrueVal),
Equals(PofFalse, PofFalseVal))
# P(TRUE) in BOOLEANS assuming hypothesis
hypothesis.deriveLeft().inBoolViaBooleanEquality().proven({hypothesis})
# P(FALSE) in BOOLEANS assuming hypothesis
hypothesis.deriveRight().inBoolViaBooleanEquality().proven({hypothesis})
# forall_{A in BOOLEANS} P(A) in BOOLEANS assuming hypothesis
Forall(A, inBool(PofA),
domain=BOOLEANS).concludeAsFolded().proven({hypothesis})
if PofTrueVal == FALSE:
# Not(P(TRUE)) assuming hypothesis
hypothesis.deriveLeft().deriveViaBooleanEquality().proven({hypothesis})
example = TRUE
# TRUE in BOOLEANS
trueInBool
elif PofFalseVal == FALSE:
# Not(P(FALSE)) assuming hypothesis
hypothesis.deriveRight().deriveViaBooleanEquality().proven(
{hypothesis})
example = FALSE
# FALSE in BOOLEANS
falseInBool
# [forall_{A in BOOLEANS} P(A)] = FALSE assuming hypothesis
conclusion = Exists(A, Not(PofA), domain=BOOLEANS).concludeViaExample(
example).deriveNegatedForall().equateNegatedToFalse().proven(
{hypothesis})
# forall_{P} [(P(TRUE) = FALSE) and (P(FALSE) in BOOLEANS)] => {[forall_{A in BOOLEANS} P(A)] = FALSE}
return Implies(hypothesis, conclusion).generalize(P)
def _defineTheorems():
# Forall_{A**, B**} ([A**] in X*) and ([B**] in X*) => [A**, B**] in X**
_firstAxiom = combining_in_kleene = Forall([multi_a, X],
Implies(
In(List(multi_a),
KleeneRepetition(X)),
In(List(multi_a, X),
KleeneRepetition(X))))
return None
from proveit.basiclogic import BOOLEANS, Forall, Iff, Implies, Equals
from proveit.common import A, B
# Note that prove_by_eval doesn't work for bundled Forall yet,
# but later we'll be able to do this kind of thing in one step.
# forall_{A in BOOLEANS, B in BOOLEANS} (A <=> B) => (A = B)
nested_version = Forall(A,
Forall(B,
Implies(Iff(A, B), Equals(A, B)),
domain=BOOLEANS),
domain=BOOLEANS).prove_by_eval()
# forall_{A in BOOLEANS, B in BOOLEANS} (A <=> B) => (A = B)
nested_version.instantiate().instantiate().generalize(
(A, B), domain=BOOLEANS).qed(__file__)
from proveit.basiclogic import Forall, Iff, Equals, TRUE, derive_stmt_eq_true
from proveit.common import P, S, x_etc, Px_etc, Qetc, etc_Qx_etc
# forall_px = [forall_{..x.. in S | ..Q(..x..)..} P(..x..)]
forall_px = Forall(x_etc, Px_etc, S, etc_Qx_etc)
# forall_px_eq_t = [forall_{..x.. in S | ..Q(..x..)..} {P(..x..)=TRUE}]
forall_px_eq_t = Forall(x_etc, Equals(Px_etc, TRUE), S, etc_Qx_etc)
# forall_px_eq_t assuming forall_px
derive_stmt_eq_true(forall_px.instantiate()).generalize(
x_etc, S, etc_Qx_etc).proven({forall_px})
# forall_px assuming forall_px_eq_t
forall_px_eq_t.instantiate().derive_via_boolean_equality().generalize(
x_etc, S, etc_Qx_etc).proven({forall_px_eq_t})
# [forall_{..x.. in S | ..Q(..x..)..} P(..x..)] <=> [forall_{..x.. in S | ..Q(..x..)..} {P(..x..)=TRUE}]
iff_foralls = Iff(forall_px,
forall_px_eq_t).conclude_via_composition().proven()
# forall_px in BOOLEANS, forall_px_eq_t in BOOLEANS
for expr in (forall_px, forall_px_eq_t):
expr.deduce_in_bool()
# forall_{P, ..Q.., S} [forall_{..x.. in S | ..Q(..x..)..} P(..x..)] =
# [forall_{..x.. in S | ..Q(..x..)..} {P(..x..)=TRUE}]
iff_foralls.derive_equality().generalize((P, Qetc, S)).qed(__file__)
from proveit.statement import Theorems
from proveit.expression import Lambda, Operation
from proveit.basiclogic import Forall, Equals, Implies, In
from .mapping_ops import Domain
from proveit.common import f, g, x, y, Q, fx, fy, gx, gy, Qx, Qy
from proveit.basiclogic.common import fx_eq_gx
mapping_theorems = Theorems(__package__, locals())
lambda_domain_equality = Forall((f, g, Q),
Equals(Domain(Lambda(x, fx, Qx)),
Domain(Lambda(x, gx, Qx))))
# forall_{f, g, Q} {forall_{x | Q(x)} [f(x) = g(x)]} => {[(y | Q(y)) ->
# f(y)] = [(y | Q(y)) -> g(y)]
map_substitution = Forall((f, g, Q),
Implies(Forall(x, fx_eq_gx, Qx),
Equals(Lambda(y, fy, Qy), Lambda(y, gy,
Qy))))
# forall_{f, g} {forall_{x} [f(x) = g(x)]} => {[y -> f(y)] = [y -> g(y)]
map_over_all_substitution = Forall(
(f, g), Implies(Forall(x, fx_eq_gx), Equals(Lambda(y, fy), Lambda(y, gy))))
mapping_theorems.finish(locals())
from proveit.basiclogic import Forall, Or, Equals, TRUE, FALSE, BOOLEANS, inBool
from proveit.common import A, B
# [(A or B) = TRUE] or [(A or B) = FALSE] assuming A, B in BOOLEANS
Forall(
(A, B),
Or(Equals(Or(A, B), TRUE), Equals(Or(A, B), FALSE)),
domain=BOOLEANS).proveByEval().specialize().proven({inBool(A),
inBool(B)})
# forall_{A in BOOLEANS} (A or B) in BOOLEANS
inBool(Or(A, B)).concludeAsFolded().generalize((A, B),
domain=BOOLEANS).qed(__file__)
from proveit.statement import Axioms
from proveit.basiclogic import Forall, Equals, In, TRUE, Iff, Implies, And
from mappingOps import Domain, CoDomain
from proveit.common import f, g, x, y, Q, fx, fy, gx, Qx, Qy
fxMap = Lambda(x, fx) # x -> f(x)
fxGivenQxMap = Lambda(x, fx, Qx) # x -> f(x) | Q(x)
gxGivenQxMap = Lambda(x, gx, Qx) # x -> g(x) | Q(x)
fDomain_eq_gDomain = Equals(Domain(f), Domain(g)) # Domain(f) = Domain(g)
fx_eq_gx = Equals(fx, gx) # f(x) = g(x)
x_in_fDomain = In(x, Domain(f)) # x in Domain(f)
f_eq_g = Equals(f, g) # f = g
mappingAxioms = Axioms(__package__, locals())
mapApplication = Forall((f, Q),
Forall(y, Equals(Operation(fxGivenQxMap, y), fy), Qy))
# forall_{f} [x -> f(x)] = [x -> f(x) | TRUE]
lambdaOverAllDef = Forall(f, Equals(Lambda(x, fx), Lambda(x, fx, TRUE)))
# forall_{f, Q} forall_{y} y in Domain(x -> f(x) | Q(x)) <=> Q(y)
lambdaDomainDef = Forall((f, Q), Forall(y, Iff(In(y, Domain(fxGivenQxMap)),
Qy)))
# forall_{f, g} [Domain(f) = Domain(g) and forall_{x in Domain(f)} f(x) = g(x)] => (f = g)}
mapIsAsMapDoes = Forall(
(f, g),
Implies(And(fDomain_eq_gDomain, Forall(x, fx_eq_gx, x_in_fDomain)),
f_eq_g))
mappingAxioms.finish(locals())
from proveit.basiclogic.boolean.axioms import existsDef
from proveit.basiclogic import Forall, NotEquals, Implies, TRUE, FALSE, deriveStmtEqTrue, In
from proveit.common import X, P, S, xEtc, yEtc, PxEtc, PyEtc, Qetc, etc_QxEtc, etc_QyEtc
inDomain = In(xEtc, S) # ..x.. in S
# neverPy = [forall_{..y.. in S | ..Q(..y..)..} (P(..y..) != TRUE)]
neverPy = Forall(yEtc, NotEquals(PyEtc, TRUE), S, etc_QyEtc)
# (P(..x..) != TRUE) assuming ..Q(..x..).., neverPy
neverPy.specialize({yEtc: xEtc}).proven({etc_QxEtc, neverPy, inDomain})
# (TRUE != TRUE) assuming ..Q(..x..).., P(..x..), neverPy
trueNotEqTrue = deriveStmtEqTrue(PxEtc).subRightSideInto(
NotEquals(X, TRUE), X).proven({etc_QxEtc, PxEtc, neverPy, inDomain})
# FALSE assuming ..Q(..x..).., P(..x..), neverPy
trueNotEqTrue.evaluation().deriveContradiction().deriveConclusion().proven(
{etc_QxEtc, PxEtc, neverPy, inDomain})
# [forall_{..y.. in S | ..Q(..y..)..} (P(..y..) != TRUE)] in BOOLEANS
neverPy.deduceInBool().proven()
# Not(forall_{..y.. in S | ..Q(..y..)..} (P(..y..) != TRUE) assuming ..Q(..x..).., P(..x..)
Implies(neverPy,
FALSE).deriveViaContradiction().proven({etc_QxEtc, PxEtc, inDomain})
# exists_{..y.. in S | ..Q(..y..)..} P(..y..) assuming Q(..x..), P(..x..)
existence = existsDef.specialize({
xEtc: yEtc
}).deriveLeftViaEquivalence().proven({etc_QxEtc, PxEtc, inDomain})
# forall_{P, ..Q.., S} forall_{..x.. in S | ..Q(..x..)..} [P(..x..) => exists_{..y.. in S | ..Q(..y..)..} P(..y..)]
Implies(PxEtc, existence).generalize(xEtc, S, etc_QxEtc).generalize(
(P, Qetc, S)).qed(__file__)
from proveit.basiclogic import Forall, Equals, In, TRUE, Iff, Implies, And
from .mapping_ops import Domain, CoDomain
from proveit.common import f, g, x, y, Q, fx, fy, gx, Qx, Qy
fx_map = Lambda(x, fx) # x -> f(x)
fx_given_qx_map = Lambda(x, fx, Qx) # x -> f(x) | Q(x)
gx_given_qx_map = Lambda(x, gx, Qx) # x -> g(x) | Q(x)
f_domain_eq_gDomain = Equals(Domain(f), Domain(g)) # Domain(f) = Domain(g)
fx_eq_gx = Equals(fx, gx) # f(x) = g(x)
x_in_f_domain = In(x, Domain(f)) # x in Domain(f)
f_eq_g = Equals(f, g) # f = g
mapping_axioms = Axioms(__package__, locals())
map_application = Forall((f, Q),
Forall(y, Equals(Operation(fx_given_qx_map, y), fy),
Qy))
# forall_{f} [x -> f(x)] = [x -> f(x) | TRUE]
lambda_over_all_def = Forall(f, Equals(Lambda(x, fx), Lambda(x, fx, TRUE)))
# forall_{f, Q} forall_{y} y in Domain(x -> f(x) | Q(x)) <=> Q(y)
lambda_domain_def = Forall((f, Q),
Forall(y, Iff(In(y, Domain(fx_given_qx_map)), Qy)))
# forall_{f, g} [Domain(f) = Domain(g) and forall_{x in Domain(f)} f(x) =
# g(x)] => (f = g)}
map_is_as_map_does = Forall(
(f, g),
Implies(And(f_domain_eq_gDomain, Forall(x, fx_eq_gx, x_in_f_domain)),
f_eq_g))
from proveit.basiclogic.booleans.axioms import exists_def
from proveit.basiclogic import Forall, NotEquals, Implies, TRUE, FALSE, derive_stmt_eq_true, In
from proveit.common import X, P, S, x_etc, y_etc, Px_etc, Py_etc, Qetc, etc_Qx_etc, etc_Qy_etc
in_domain = In(x_etc, S) # ..x.. in S
# never_py = [forall_{..y.. in S | ..Q(..y..)..} (P(..y..) != TRUE)]
never_py = Forall(y_etc, NotEquals(Py_etc, TRUE), S, etc_Qy_etc)
# (P(..x..) != TRUE) assuming ..Q(..x..).., never_py
never_py.instantiate({y_etc: x_etc}).proven({etc_Qx_etc, never_py, in_domain})
# (TRUE != TRUE) assuming ..Q(..x..).., P(..x..), never_py
true_not_eq_true = derive_stmt_eq_true(Px_etc).sub_right_side_into(
NotEquals(X, TRUE), X).proven({etc_Qx_etc, Px_etc, never_py, in_domain})
# FALSE assuming ..Q(..x..).., P(..x..), never_py
true_not_eq_true.evaluation().derive_contradiction().derive_conclusion(
).proven({etc_Qx_etc, Px_etc, never_py, in_domain})
# [forall_{..y.. in S | ..Q(..y..)..} (P(..y..) != TRUE)] in BOOLEANS
never_py.deduce_in_bool().proven()
# Not(forall_{..y.. in S | ..Q(..y..)..} (P(..y..) != TRUE) assuming
# ..Q(..x..).., P(..x..)
Implies(never_py, FALSE).derive_via_contradiction().proven(
{etc_Qx_etc, Px_etc, in_domain})
# exists_{..y.. in S | ..Q(..y..)..} P(..y..) assuming Q(..x..), P(..x..)
existence = exists_def.instantiate({
x_etc: y_etc
}).derive_left_via_equality().proven({etc_Qx_etc, Px_etc, in_domain})
# forall_{P, ..Q.., S} forall_{..x.. in S | ..Q(..x..)..} [P(..x..) =>
# exists_{..y.. in S | ..Q(..y..)..} P(..y..)]
Implies(Px_etc, existence).generalize(x_etc, S, etc_Qx_etc).generalize(
(P, Qetc, S)).qed(__file__)
from proveit.basiclogic.boolean.axioms import existsDef, notExistsDef
from proveit.basiclogic import Forall, Not, NotEquals, TRUE
from proveit.common import X, P, S, xEtc, Qetc, PxEtc, etc_QxEtc
# [exists_{..x.. in S | ..Q(..x..)..} P(..x..)] = not(forall_{..x.. in S | ..Q(..x..)..} (P(..x..) != TRUE))
existsDefSpec = existsDef.specialize().proven()
# notexists_{..x.. in S | ..Q..(..x..)} P(..x..) = not[exists_{..x.. in S | ..Q(..x..)..} P(..x..)]
notExistsDefSpec = notExistsDef.specialize().proven()
# rhs = forall_{..x.. in S | ..Q(..x..)..} (P(..x..) != TRUE)
rhs = Forall(xEtc, NotEquals(PxEtc, TRUE), S, etc_QxEtc)
# [forall_{..x.. in S | ..Q(..x..)..} (P(..x..) != TRUE)] in BOOLEANS
rhs.deduceInBool().proven()
# not(not(forall_{..x.. in S | ..Q(..x..)..} (P(..x..) != TRUE))) = forall_{..x.. in S | ..Q(..x..)..} (P(..x..) != TRUE))
doubleNegatedForall = Not(Not(rhs)).deduceDoubleNegationEquiv().deriveReversed().proven()
# notexists_{..x.. in S | ..Q(..x..)..} P(..x..) = forall_{..x.. in S | ..Q(..x..)..} (P(..x..) != TRUE))
equiv = notExistsDefSpec.applyTransitivity(existsDefSpec.substitution(Not(X), X)).applyTransitivity(doubleNegatedForall).proven()
# forall_{P, ..Q..} [notexists_{..x.. in S | ..Q(..x..)..} P(..x..) = forall_{..x.. in S | ..Q(..x..)..} (P(..x..) != TRUE)]
equiv.generalize((P, Qetc, S)).qed(__file__)
from proveit.basiclogic.boolean.axioms import existsDef
from proveit.basiclogic import Exists, Forall, Not, NotEquals, Implies, In, TRUE, deriveStmtEqTrue
from proveit.common import P, S, X, xEtc, PxEtc, etc_QxEtc, Qetc
inDomain = In(xEtc, S) # ..x.. in S
# existsNot = [exists_{..x.. in S | ..Q(..x..)..} Not(P(..x..))]
existsNot = Exists(xEtc, Not(PxEtc), S, etc_QxEtc)
# [Not(forall_{..x.. in S | ..Q(..x..)..} Not(P(..x..)) != TRUE] assuming existsNot
existsDef.specialize({
PxEtc: Not(PxEtc)
}).deriveRightViaEquivalence().proven({existsNot})
# forall_{..x.. in S | ..Q(..x..)..} P(..x..)
forallPx = Forall(xEtc, PxEtc, S, etc_QxEtc)
# forall_{..x.. in S | ..Q(..x..)..} Not(P(..x..)) != TRUE
forallNotPxNotTrue = Forall(xEtc, NotEquals(Not(PxEtc), TRUE), S, etc_QxEtc)
# forallPx in BOOLEANS, forallNotPxNotTrue in BOOLEANS
for expr in (forallPx, forallNotPxNotTrue):
expr.deduceInBool().proven()
# Not(TRUE) != TRUE
NotEquals(Not(TRUE), TRUE).proveByEval()
# forallNotPxNotTrue assuming forallPx, ..Q(..x..).., In(..x.., S)
deriveStmtEqTrue(forallPx.specialize()).lhsStatementSubstitution(
NotEquals(Not(X), TRUE), X).deriveConclusion().generalize(
xEtc, domain=S, conditions=etc_QxEtc).proven({forallPx, inDomain})
# Not(forallNotPxNotTrue) => Not(forallPx)
Implies(forallPx, forallNotPxNotTrue).transpose().proven()
# forall_{P, ..Q.., S} [exists_{..x.. in S | ..Q(..x..)..} Not(P(..x..))] => [Not(forall_{..x.. in S | ..Q(..x..)..} P(..x..)]
Implies(existsNot, Not(forallPx)).generalize((P, Qetc, S)).qed(__file__)
from proveit.basiclogic.booleans.theorems import exists_not_implies_not_forall
from proveit.basiclogic import Forall, Implies
from proveit.common import P, S, x_etc, Px_etc, Qetc, etc_Qx_etc
# hypothesis = forall_{..x.. in S | ..Q(..x..)..} P(..x..)
hypothesis = Forall(x_etc, Px_etc, S, etc_Qx_etc)
# [exists_{..x.. in S | ..Q(..x..)..} Not(P(..x..))] => [Not(forall_{..x.. in S | ..Q(..x..)..} P(..x..)]
exists_not_implies_not_forall_spec = exists_not_implies_not_forall.instantiate(
).proven()
# exists_{..x.. in S | ..Q(..x..)..} Not(P(..x..)) in BOOLEANS
exists_not_implies_not_forall_spec.hypothesis.deduce_in_bool()
# forall_{..x.. in S | ..Q(..x..)..} P(..x..) in BOOLEANS
exists_not_implies_not_forall_spec.conclusion.operand.deduce_in_bool()
# NotExists_{..x.. in S | ..Q(..x..)..} Not(P(..x..))
conclusion = exists_not_implies_not_forall_spec.transpose().derive_conclusion(
).derive_not_exists().proven({hypothesis})
# forall_{P, ..Q.., S} NotExists_{..x.. in S | ..Q(..x..)..} Not(P(..x..))
# => forall_{..x.. in S | ..Q(..x..)..} P(..x..)
Implies(hypothesis, conclusion).generalize((P, Qetc, S)).qed(__file__)
from proveit.basiclogic.boolean.theorems import trueInBool, falseInBool
from proveit.basiclogic import TRUE, FALSE, BOOLEANS, Implies, Forall, compose
from proveit.common import A, P, PofA
# hypothesis = [forall_{A in BOOLEANS} P(A)]
hypothesis = Forall(A, PofA, domain=BOOLEANS)
# TRUE in BOOLEANS, FALSE in BOOLEANS
trueInBool, falseInBool
# P(TRUE) and P(FALSE) assuming hypothesis
conclusion = compose(hypothesis.specialize({A: TRUE}),
hypothesis.specialize({A: FALSE})).proven({hypothesis})
# forall_{P} [forall_{A in BOOLEANS} P(A)] => [P(TRUE) and P(FALSE)]
Implies(hypothesis, conclusion).generalize(P).qed(__file__)
from proveit.basiclogic import Forall, Or, Equals, TRUE, FALSE, BOOLEANS, in_bool
from proveit.common import A, B
# [(A or B) = TRUE] or [(A or B) = FALSE] assuming A, B in BOOLEANS
Forall((A, B), Or(Equals(Or(A, B), TRUE), Equals(Or(A, B), FALSE)),
domain=BOOLEANS).prove_by_eval().instantiate().proven({in_bool(A), in_bool(B)})
# forall_{A in BOOLEANS} (A or B) in BOOLEANS
in_bool(Or(A, B)).conclude_as_folded().generalize(
(A, B), domain=BOOLEANS).qed(__file__)
from proveit.basiclogic.booleans.axioms import exists_def, not_exists_def
from proveit.basiclogic import Forall, Not, NotEquals, TRUE
from proveit.common import X, P, S, x_etc, Qetc, Px_etc, etc_Qx_etc
# [exists_{..x.. in S | ..Q(..x..)..} P(..x..)] = not(forall_{..x.. in S | ..Q(..x..)..} (P(..x..) != TRUE))
exists_def_spec = exists_def.instantiate().proven()
# notexists_{..x.. in S | ..Q..(..x..)} P(..x..) = not[exists_{..x.. in S
# | ..Q(..x..)..} P(..x..)]
not_exists_def_spec = not_exists_def.instantiate().proven()
# rhs = forall_{..x.. in S | ..Q(..x..)..} (P(..x..) != TRUE)
rhs = Forall(x_etc, NotEquals(Px_etc, TRUE), S, etc_Qx_etc)
# [forall_{..x.. in S | ..Q(..x..)..} (P(..x..) != TRUE)] in BOOLEANS
rhs.deduce_in_bool().proven()
# not(not(forall_{..x.. in S | ..Q(..x..)..} (P(..x..) != TRUE))) =
# forall_{..x.. in S | ..Q(..x..)..} (P(..x..) != TRUE))
double_negated_forall = Not(
Not(rhs)).deduce_double_negation_equiv().derive_reversed().proven()
# notexists_{..x.. in S | ..Q(..x..)..} P(..x..) = forall_{..x.. in S |
# ..Q(..x..)..} (P(..x..) != TRUE))
equiv = not_exists_def_spec.apply_transitivity(
exists_def_spec.substitution(
Not(X), X)).apply_transitivity(double_negated_forall).proven()
# forall_{P, ..Q..} [notexists_{..x.. in S | ..Q(..x..)..} P(..x..) =
# forall_{..x.. in S | ..Q(..x..)..} (P(..x..) != TRUE)]
equiv.generalize((P, Qetc, S)).qed(__file__)
from proveit.statement import Theorems
from proveit.expression import Lambda, Operation
from proveit.basiclogic import Forall, Equals, Implies, In
from .mappingOps import Domain
from proveit.common import f, g, x, y, Q, fx, fy, gx, gy, Qx, Qy
from proveit.basiclogic.common import fx_eq_gx
mappingTheorems = Theorems(__package__, locals())
lambdaDomainEquality = Forall((f, g, Q),
Equals(Domain(Lambda(x, fx, Qx)),
Domain(Lambda(x, gx, Qx))))
# forall_{f, g, Q} {forall_{x | Q(x)} [f(x) = g(x)]} => {[(y | Q(y)) -> f(y)] = [(y | Q(y)) -> g(y)]
mapSubstitution = Forall((f, g, Q),
Implies(Forall(x, fx_eq_gx, Qx),
Equals(Lambda(y, fy, Qy), Lambda(y, gy, Qy))))
# forall_{f, g} {forall_{x} [f(x) = g(x)]} => {[y -> f(y)] = [y -> g(y)]
mapOverAllSubstitution = Forall((f, g),
Implies(Forall(x, fx_eq_gx),
Equals(Lambda(y, fy), Lambda(y, gy))))
mappingTheorems.finish(locals())
from proveit.basiclogic import Forall, Iff, Equals, TRUE, deriveStmtEqTrue
from proveit.common import P, S, xEtc, PxEtc, Qetc, etc_QxEtc
# forallPx = [forall_{..x.. in S | ..Q(..x..)..} P(..x..)]
forallPx = Forall(xEtc, PxEtc, S, etc_QxEtc)
# forallPxEqT = [forall_{..x.. in S | ..Q(..x..)..} {P(..x..)=TRUE}]
forallPxEqT = Forall(xEtc, Equals(PxEtc, TRUE), S, etc_QxEtc)
# forallPxEqT assuming forallPx
deriveStmtEqTrue(forallPx.specialize()).generalize(xEtc, S, etc_QxEtc).proven({forallPx})
# forallPx assuming forallPxEqT
forallPxEqT.specialize().deriveViaBooleanEquality().generalize(xEtc, S, etc_QxEtc).proven({forallPxEqT})
# [forall_{..x.. in S | ..Q(..x..)..} P(..x..)] <=> [forall_{..x.. in S | ..Q(..x..)..} {P(..x..)=TRUE}]
iffForalls = Iff(forallPx, forallPxEqT).concludeViaComposition().proven()
# forallPx in BOOLEANS, forallPxEqT in BOOLEANS
for expr in (forallPx, forallPxEqT):
expr.deduceInBool()
# forall_{P, ..Q.., S} [forall_{..x.. in S | ..Q(..x..)..} P(..x..)] = [forall_{..x.. in S | ..Q(..x..)..} {P(..x..)=TRUE}]
iffForalls.deriveEquality().generalize((P, Qetc, S)).qed(__file__)
from proveit.basiclogic import Forall, Implies
from proveit.common import P, S, x_etc, y_etc, Qetc, Retc, Pxy_etc, etc_Qx_etc, etc_Ry_etc
# forall_{..x.., ..y.. in S | ..Q(..x..).., ..R(..y..)..} P(..x.., ..y..)
hypothesis = Forall((x_etc, y_etc), Pxy_etc, S, (etc_Qx_etc, etc_Ry_etc))
# forall_{..x.. in S | ..Q(..x..)..} forall_{..y.. in S | ..R(..y..)..}
# P(..x.., ..y..)
conclusion = hypothesis.instantiate().generalize(
y_etc, S, etc_Ry_etc).generalize(x_etc, S, etc_Qx_etc).proven({hypothesis})
# forall_{P, ..Q.., ..R.., S} [forall_{..x.., ..y.. in S | ..Q(..x..)..,
# ..R(..y..)..} P(..x.., ..y..) => forall_{..x.. in S | ..Q(..x..)..}
# forall_{..y.. in S | ..R(..y..)..} P(..x.., ..y..)]
Implies(hypothesis, conclusion).generalize((P, Qetc, Retc, S)).qed(__file__)
from proveit.basiclogic import Forall, Implies
from proveit.common import P, S, xEtc, yEtc, Qetc, Retc, PxyEtc, etc_QxEtc, etc_RyEtc
# forall_{..x.., ..y.. in S | ..Q(..x..).., ..R(..y..)..} P(..x.., ..y..)
hypothesis = Forall((xEtc, yEtc), PxyEtc, S, (etc_QxEtc, etc_RyEtc))
# forall_{..x.. in S | ..Q(..x..)..} forall_{..y.. in S | ..R(..y..)..} P(..x.., ..y..)
conclusion = hypothesis.specialize().generalize(yEtc, S, etc_RyEtc).generalize(xEtc, S, etc_QxEtc).proven({hypothesis})
# forall_{P, ..Q.., ..R.., S} [forall_{..x.., ..y.. in S | ..Q(..x..).., ..R(..y..)..} P(..x.., ..y..) => forall_{..x.. in S | ..Q(..x..)..} forall_{..y.. in S | ..R(..y..)..} P(..x.., ..y..)]
Implies(hypothesis, conclusion).generalize((P, Qetc, Retc, S)).qed(__file__)
from proveit.basiclogic.booleans.axioms import exists_def
from proveit.basiclogic import Exists, Forall, Not, NotEquals, Implies, In, TRUE, derive_stmt_eq_true
from proveit.common import P, S, X, x_etc, Px_etc, etc_Qx_etc, Qetc
in_domain = In(x_etc, S) # ..x.. in S
# exists_not = [exists_{..x.. in S | ..Q(..x..)..} Not(P(..x..))]
exists_not = Exists(x_etc, Not(Px_etc), S, etc_Qx_etc)
# [Not(forall_{..x.. in S | ..Q(..x..)..} Not(P(..x..)) != TRUE] assuming exists_not
exists_def.instantiate({
Px_etc: Not(Px_etc)
}).derive_right_via_equality().proven({exists_not})
# forall_{..x.. in S | ..Q(..x..)..} P(..x..)
forall_px = Forall(x_etc, Px_etc, S, etc_Qx_etc)
# forall_{..x.. in S | ..Q(..x..)..} Not(P(..x..)) != TRUE
forall_not_px_not_true = Forall(x_etc, NotEquals(Not(Px_etc), TRUE), S,
etc_Qx_etc)
# forall_px in BOOLEANS, forall_not_px_not_true in BOOLEANS
for expr in (forall_px, forall_not_px_not_true):
expr.deduce_in_bool().proven()
# Not(TRUE) != TRUE
NotEquals(Not(TRUE), TRUE).prove_by_eval()
# forall_not_px_not_true assuming forall_px, ..Q(..x..).., In(..x.., S)
derive_stmt_eq_true(forall_px.instantiate()).lhs_statement_substitution(
NotEquals(Not(X), TRUE), X).derive_conclusion().generalize(
x_etc, domain=S, conditions=etc_Qx_etc).proven({forall_px, in_domain})
# Not(forall_not_px_not_true) => Not(forall_px)
Implies(forall_px, forall_not_px_not_true).transpose().proven()
# forall_{P, ..Q.., S} [exists_{..x.. in S | ..Q(..x..)..} Not(P(..x..))]
# => [Not(forall_{..x.. in S | ..Q(..x..)..} P(..x..)]
Implies(exists_not, Not(forall_px)).generalize((P, Qetc, S)).qed(__file__)
from proveit.basiclogic import BOOLEANS, Forall, Iff, Implies, Equals
from proveit.common import A, B
# Note that proveByEval doesn't work for bundled Forall yet,
# but later we'll be able to do this kind of thing in one step.
# forall_{A in BOOLEANS, B in BOOLEANS} (A <=> B) => (A = B)
nestedVersion = Forall(A, Forall(B, Implies(Iff(A, B), Equals(A, B)), domain=BOOLEANS), domain=BOOLEANS).proveByEval()
# forall_{A in BOOLEANS, B in BOOLEANS} (A <=> B) => (A = B)
nestedVersion.specialize().specialize().generalize((A, B), domain=BOOLEANS).qed(__file__)
