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 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 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.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.. in S | ..Q(..x..)..} forall_{..y.. in S | ..R(..y..)..}
# P(..x.., ..y..)
hypothesis = Forall(x_etc, Forall(y_etc, Pxy_etc, S, etc_Ry_etc), S,
etc_Qx_etc)
# forall_{..x.., ..y.. in S | ..Q(..x..).., ..R(..y..)..} P(..x.., ..y..)
conclusion = hypothesis.instantiate().instantiate().generalize(
(x_etc, y_etc), S, (etc_Qx_etc, etc_Ry_etc)).proven({hypothesis})
# forall_{P, ..Q.., ..R.., S} [forall_{..x.. in S | ..Q(..x..)..}
# forall_{..y.. in S | ..R(..y..)..} P(..x.., ..y..) => forall_{..x..,
# ..y.. in S | ..Q(..x..).., ..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 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__)
