from proveit.basiclogic.booleans.theorems import double_negate_conclusion
from proveit.basiclogic import Implies, Not, BOOLEANS, in_bool
from proveit.common import A, B
# [B => Not(Not(A))] => [Not(A)=>Not(B)] assuming in_bool(A), in_bool(B)
to_conclusion = Implies(B, Not(Not(A))).transposition()
# [B => A] => [B => Not(Not(A))] assuming in_bool(A)
from_hyp = double_negate_conclusion.instantiate({
A: B,
B: A
}).proven({in_bool(A)})
# [B => A] => [Not(A)=>Not(B)] assuming in_bool(A), in_bool(B)
transposition_expr = from_hyp.apply_syllogism(to_conclusion).proven(
{in_bool(A), in_bool(B)})
# forall_{A, B in BOOLEANS} [B=>A] => [Not(A) => Not(B)]
transposition_expr.generalize((A, B), domain=BOOLEANS).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 import Implies, BOOLEANS, FALSE, in_bool, compose, NotEquals
from proveit.common import A
# Anot_f = (A != FALSE)
Anot_f = NotEquals(A, FALSE)
# not_aeq_f = Not(A = FALSE)
not_aeq_f = Anot_f.unfold()
# (A=TRUE or A=FALSE) assuming in_bool(A)
AeqT_or_AeqF = in_bool(A).unfold()
AeqT = AeqT_or_AeqF.operands[0]
# Not(A=FALSE) and (A=TRUE or A=FALSE) assuming each
compose(not_aeq_f, AeqT_or_AeqF).proven({Anot_f, AeqT_or_AeqF})
# in_bool(A=TRUE)
AeqT.deduce_in_bool()
# A assuming in_bool(A), Not(A=FALSE)
AeqT_or_AeqF.derive_left_if_not_right().derive_via_boolean_equality().proven(
{in_bool(A), Anot_f})
# forall_{A in BOOLEANS} Not(A=FALSE) => A
Implies(Anot_f, A).generalize(A, domain=BOOLEANS).qed(__file__)
from proveit.basiclogic.booleans.theorems import double_negation, from_double_negation
from proveit.basiclogic import BOOLEANS, in_bool, Not, Iff
from proveit.common import A
# A => Not(Not(A))
double_negation_implied = double_negation.instantiate().proven()
# Not(Not(A)) => A
implies_double_negation = from_double_negation.instantiate().proven()
# [A => Not(Not(A))] in BOOLEANS if A in BOOLEANS
double_negation_implied.deduce_in_bool().proven({in_bool(A)})
# [Not(Not(A)) => A] in BOOLEANS if A in BOOLEANS
implies_double_negation.deduce_in_bool().proven({in_bool(A)})
# forall_{A} A = Not(Not(A))
Iff(A, Not(Not(A))).conclude_via_composition().derive_equality().generalize(
A, domain=BOOLEANS).qed(__file__)
from proveit.basiclogic.equality.axioms import not_equals_def
from proveit.basiclogic import Not, Equals, in_bool
from proveit.common import x, y, X
# Not(x = y) in BOOLEANS
Not(Equals(x, y)).deduce_in_bool().proven()
# forall_{x, y} (x != y) in BOOLEANS
not_equals_def.instantiate().sub_left_side_into(in_bool(X), X).generalize(
(x, y)).qed(__file__)
from proveit.basiclogic.booleans.axioms import not_t
from proveit.basiclogic import BOOLEANS, FALSE, in_bool, Implies, And, Or, Not, derive_stmt_eq_true
from proveit.common import A, B, C, X
AorB = Or(A, B)
hypothesis = And(Implies(A, C), Implies(B, C))
ABCareBool = {in_bool(A), in_bool(B), in_bool(C)}
# A=>C, B=>C assuming (A=>C and B=>C)
AimplC, _ = hypothesis.decompose()
# Not(A) assuming in_bool(A), in_bool(B), (A=>C and B=>C), Not(C)
AimplC.transpose().derive_conclusion().proven(
{in_bool(A), in_bool(C), hypothesis, Not(C)})
# B assuming in_bool(A, B, C), (A=>C and B=>C), (A or B), Not(C)
AorB.derive_right_if_not_left().proven(ABCareBool | {hypothesis, AorB, Not(C)})
# Not(TRUE) assuming in_bool(A, B, C), (A=>C and B=>C), (A or B), Not(C)
derive_stmt_eq_true(C).sub_right_side_into(
Not(X), X).proven(
ABCareBool | {
hypothesis, AorB, Not(C)})
# FALSE assuming in_bool(A, B, C), (A=>C and B=>C), (A or B), Not(C)
not_t.derive_right_via_equality().proven(
ABCareBool | {hypothesis, AorB, Not(C)})
# Contradiction proof of C assuming (A=>C and B=>C), (A or B), in_bool(A),
# and in_bool(B)
Implies(
Not(C),
FALSE).derive_via_contradiction().proven(
ABCareBool | {
hypothesis,
AorB})
# forall_{A, B, C in BOOLEANS} (A=>C and B=>C) => ((A or B) => C)
from proveit.basiclogic import Implies, Not, in_bool
from proveit.common import A, B
# Not(Not(B)) assuming B and in_bool(B)
not_not_b = Not(Not(B)).conclude_via_double_negation()
# [A=>B] => [A => Not(Not(B))] assuming in_bool(B)
inner_expr = Implies(Implies(A, B), Implies(A, not_not_b)).proven({in_bool(B)})
# forall_{A, B | in_bool(B)} [A=>B] => [A => Not(Not(B))]
inner_expr.generalize((A, B), conditions=in_bool(B)).qed(__file__)
from proveit.basiclogic.booleans.axioms import bools_def
from proveit.basiclogic.set.axioms import singleton_def
from proveit.basiclogic import Implies, In, in_bool, Singleton, Union, Equals, TRUE, FALSE, Or
from proveit.common import x, y, A, X
# hypothesis = (A=TRUE or A=FALSE)
hypothesis = Or(Equals(A, TRUE), Equals(A, FALSE))
# (A=TRUE) or (A in {FALSE}) assuming hypothesis
singleton_def.instantiate({
x: A,
y: FALSE
}).sub_left_side_into(Or(Equals(A, TRUE), X), X).proven({hypothesis})
# (A in {TRUE}) or (A in {FALSE}) assuming hypothesis
singleton_def.instantiate({
x: A,
y: TRUE
}).sub_left_side_into(Or(X, In(A, Singleton(FALSE))), X).proven({hypothesis})
# [A in ({TRUE} union {FALSE})] assuming hypothesis
In(A, Union(Singleton(TRUE), Singleton(FALSE))).conclude_as_folded()
# (A in BOOLEANS) assuming hypothesis
bools_def.sub_left_side_into(In(A, X), X).proven({hypothesis})
# forall_{A} (A=TRUE or A=FALSE) => in_bool(A)
Implies(hypothesis, in_bool(A)).generalize(A).qed(__file__)
from proveit.basiclogic.booleans.axioms import or_t_f
from proveit.basiclogic.booleans.theorems import true_not_false, true_eq_true
from proveit.basiclogic import TRUE, FALSE, in_bool, Or, Equals, derive_stmt_eq_true
from proveit.common import X
# [TRUE or FALSE]
or_t_f.derive_via_boolean_equality().proven()
# [TRUE or TRUE=FALSE] via [TRUE or FALSE] and TRUE != FALSE
true_not_false.unfold().equate_negated_to_false().sub_left_side_into(
Or(TRUE, X), X).proven()
# [TRUE=TRUE or TRUE=FALSE] via [TRUE or TRUE=FALSE] and TRUE=TRUE
derive_stmt_eq_true(true_eq_true).sub_left_side_into(
Or(X, Equals(TRUE, FALSE)), X).proven()
# in_bool(TRUE) via [TRUE=TRUE or TRUE=FALSE]
in_bool(TRUE).conclude_as_folded().qed(__file__)
from proveit.basiclogic.booleans.theorems import or_contradiction
from proveit.basiclogic import Implies, Not, Or, FALSE, in_bool
from proveit.common import A, B
# (A or B) => FALSE assuming Not(A), Not(B)
or_contradiction.instantiate().proven({Not(A), Not(B)})
# By contradiction: A assuming in_bool(A), A or B, Not(B)
Implies(Not(A), FALSE).derive_via_contradiction().proven(
{in_bool(A), Or(A, B), Not(B)})
# forall_{A, B | in_bool(A), Not(B)} (A or B) => A
Implies(Or(A, B), A).generalize((A, B),
conditions=(in_bool(A), Not(B))).qed(__file__)
from proveit.basiclogic.booleans.axioms import contradictory_validation
from proveit.basiclogic import Implies, Not, FALSE, in_bool, BOOLEANS
from proveit.common import A
# in_bool(Not(A)) assuming in_bool(A)
Not(A).deduce_in_bool().proven({in_bool(A)})
# [Not(Not(A)) => FALSE] => Not(A) assuming in_bool(A)
contradictory_validation.instantiate({A: Not(A)}).proven({in_bool(A)})
# A assuming Not(Not(A)) and in_bool(A)
Not(Not(A)).derive_via_double_negation().proven({in_bool(A), Not(Not(A))})
# forall_{A in BOOLEANS} [A => FALSE] => Not(A)
Implies(Implies(A, FALSE), Not(A)).generalize(A, domain=BOOLEANS).qed(__file__)
from proveit.basiclogic import Implies, Not, FALSE, in_bool, Equals, NotEquals
from proveit.common import A, B, X
# in_bool(B=FALSE)
Equals(B, FALSE).deduce_in_bool()
# [Not(B=FALSE) => Not(A)] => [A => (B=FALSE)], using in_bool(B=FALSE)
mid_point_back_half = Implies(Not(Equals(B, FALSE)), Not(A)).transposition()
# [(B != FALSE) => Not(A)] => [Not(B=FALSE) => Not(A)]
mid_point_front_half = NotEquals(
B, FALSE).definition().rhs_statement_substitution(Implies(X, Not(A)),
X).proven()
# [(B != FALSE) => Not(A)] => [A => (B=FALSE)]
mid_point = mid_point_front_half.apply_syllogism(mid_point_back_half).proven()
# B assuming (B != FALSE) and in_bool(B)
not_beq_f = NotEquals(B, FALSE)
not_beq_f.derive_via_double_negation().proven({not_beq_f, in_bool(B)})
# [B => Not(A)] => [(B != FALSE) => Not(A)] assuming in_bool(B)
from_hyp = Implies(Implies(B, Not(A)), Implies(not_beq_f,
Not(A))).proven({in_bool(B)})
# Not(B) assuming B=FALSE
BeqF = Equals(B, FALSE)
BeqF.derive_via_boolean_equality().proven({BeqF})
# [A => (B=FALSE)] => [A => Not(B)] assuming in_bool(B)
to_conclusion = Implies(Implies(A, BeqF), Implies(A,
Not(B))).proven({in_bool(B)})
# [B => Not(A)] => [A=>Not(B)] assuming in_bool(B)
transposition_expr = from_hyp.apply_syllogism(mid_point).apply_syllogism(
to_conclusion).proven({in_bool(B)})
# forall_{A, B | in_bool(B)} [B => Not(A)] => [A=>Not(B)]
transposition_expr.generalize((A, B), conditions=in_bool(B)).qed(__file__)
from proveit.basiclogic import BOOLEANS, TRUE, FALSE, in_bool, Implies, And, derive_stmt_eq_true, Equals
from proveit.common import A, P, PofA
from proveit.basiclogic.common import PofTrue, PofFalse
# hypothesis = [P(TRUE) and P(FALSE)]
hypothesis = And(PofTrue, PofFalse)
# in_bool(A=TRUE), in_bool(A=FALSE), in_bool(P(A) = TRUE)
AeqT = Equals(A, TRUE)
AeqF = Equals(A, FALSE)
PofAeqT = Equals(PofA, TRUE)
for eq_expr in (AeqT, AeqF, PofAeqT):
eq_expr.deduce_in_bool()
# P(TRUE), P(FALSE) assuming hypothesis
for case in hypothesis.decompose():
case.proven({hypothesis})
# A=TRUE => P(A)=TRUE assuming hypothesis
Implies(AeqT,
derive_stmt_eq_true(AeqT.sub_left_side_into(PofA,
A))).proven({hypothesis})
# A=FALSE => P(A)=TRUE assuming hypothesis
Implies(AeqF,
derive_stmt_eq_true(AeqF.sub_left_side_into(PofA,
A))).proven({hypothesis})
# P(A) assuming hypothesis, (A in BOOLEANS)
in_bool(A).unfold().derive_common_conclusion(
PofAeqT).derive_via_boolean_equality().proven({hypothesis,
in_bool(A)})
# forall_{P} P(TRUE) and P(FALSE) => forall_{A in BOOLEANS} P(A)
Implies(hypothesis,
PofA.generalize(A, domain=BOOLEANS)).generalize(P).qed(__file__)
from proveit.basiclogic import Forall, Or, Not, Equals, TRUE, FALSE, BOOLEANS, in_bool
from proveit.common import A
# Not(A) = TRUE or Not(A) = FALSE assuming A in BOOLEANS
Forall(A, Or(Equals(Not(A), TRUE), Equals(Not(A), FALSE)),
domain=BOOLEANS).prove_by_eval().instantiate().proven({in_bool(A)})
# forall_{A in BOOLEANS} Not(A) in BOOLEANS
in_bool(Not(A)).conclude_as_folded().generalize(A,
domain=BOOLEANS).qed(__file__)
from proveit.basiclogic import Implies, Not, FALSE, in_bool
from proveit.common import A, B
# hypothesis = [Not(B) => Not(A)]
hypothesis = Implies(Not(B), Not(A))
# A=FALSE assuming Not(B)=>Not(A) and Not(B)
AeqF = Not(A).equate_negated_to_false().proven({hypothesis, Not(B)})
# FALSE assuming Not(B)=>Not(A), Not(B), and A
AeqF.derive_right_via_equality().proven({hypothesis, Not(B), A})
# B assuming in_bool(B), (Not(B)=>Not(A)), A
Implies(Not(B),
FALSE).derive_via_contradiction().proven({in_bool(B), hypothesis, A})
# [Not(B) => Not(A)] => [A => B] by nested hypothetical reasoning assuming in_bool(B)
transposition_expr = Implies(hypothesis, Implies(A, B)).proven({in_bool(B)})
# forall_{A, B | in_bool(B)} [A => B] => [Not(B) => Not(A)]
transposition_expr.generalize((A, B), conditions=in_bool(B)).qed(__file__)
from proveit.basiclogic import Forall, And, Or, Equals, TRUE, FALSE, BOOLEANS, in_bool
from proveit.common import A, B
# [(A and B) = TRUE] or [(A and B) = FALSE] assuming A, B in BOOLEANS
Forall((A, B),
Or(Equals(And(A, B), TRUE), Equals(And(A, B), FALSE)),
domain=BOOLEANS).prove_by_eval().instantiate().proven(
{in_bool(A), in_bool(B)})
# forall_{A, B in BOOLEANS} (A and B) in BOOLEANS
in_bool(And(A, B)).conclude_as_folded().generalize(
(A, B), domain=BOOLEANS).qed(__file__)
from proveit.basiclogic.booleans.theorems import true_is_bool
from proveit.basiclogic import TRUE, in_bool, Implies, Equals
from proveit.common import A, X
# hypothesis = (A=TRUE)
hypothesis = Equals(A, TRUE)
# in_bool(TRUE)
true_is_bool.proven()
# in_bool(A) assuming hypothesis
conclusion = hypothesis.sub_left_side_into(in_bool(X), X).proven({hypothesis})
# forall_{A} A=TRUE => in_bool(A)
Implies(hypothesis, conclusion).generalize(A).qed(__file__)
from proveit.basiclogic.booleans.axioms import or_f_t, false_not_true
from proveit.basiclogic.booleans.theorems import false_eq_false
from proveit.basiclogic import FALSE, in_bool, Or, Equals, derive_stmt_eq_true
from proveit.common import X
# [FALSE or TRUE]
or_f_t.derive_via_boolean_equality().proven()
# [FALSE or FALSE=FALSE] via [FALSE or TRUE] and FALSE=FALSE
derive_stmt_eq_true(false_eq_false).sub_left_side_into(Or(FALSE, X),
X).proven()
# [FALSE=TRUE or FALSE=FALSE] via [FALSE or FALSE=FALSE] and Not(FALSE=TRUE)
false_not_true.unfold().equate_negated_to_false().sub_left_side_into(
Or(X, Equals(FALSE, FALSE)), X).proven()
# in_bool(FALSE) via [FALSE=TRUE or FALSE=FALSE]
in_bool(FALSE).conclude_as_folded().qed(__file__)
