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)
from proveit.basiclogic.boolean.theorems import trueInBool
from proveit.basiclogic import TRUE, inBool, Implies, Equals
from proveit.common import A, X
# hypothesis = (A=TRUE)
hypothesis = Equals(A, TRUE)
# inBool(TRUE)
trueInBool.proven()
# inBool(A) assuming hypothesis
conclusion = hypothesis.subLeftSideInto(inBool(X), X).proven({hypothesis})
# forall_{A} A=TRUE => inBool(A)
Implies(hypothesis, conclusion).generalize(A).qed(__file__)
from proveit.basiclogic.boolean.axioms import boolsDef
from proveit.basiclogic.set.axioms import singletonDef
from proveit.basiclogic import Implies, In, inBool, 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
singletonDef.specialize({
x: A,
y: FALSE
}).subLeftSideInto(Or(Equals(A, TRUE), X), X).proven({hypothesis})
# (A in {TRUE}) or (A in {FALSE}) assuming hypothesis
singletonDef.specialize({
x: A,
y: TRUE
}).subLeftSideInto(Or(X, In(A, Singleton(FALSE))), X).proven({hypothesis})
# [A in ({TRUE} union {FALSE})] assuming hypothesis
In(A, Union(Singleton(TRUE), Singleton(FALSE))).concludeAsFolded()
# (A in BOOLEANS) assuming hypothesis
boolsDef.subLeftSideInto(In(A, X), X).proven({hypothesis})
# forall_{A} (A=TRUE or A=FALSE) => inBool(A)
Implies(hypothesis, inBool(A)).generalize(A).qed(__file__)
from proveit.basiclogic import Implies, BOOLEANS, FALSE, inBool, compose, NotEquals
from proveit.common import A
# AnotF = (A != FALSE)
AnotF = NotEquals(A, FALSE)
# notAeqF = Not(A = FALSE)
notAeqF = AnotF.unfold()
# (A=TRUE or A=FALSE) assuming inBool(A)
AeqT_or_AeqF = inBool(A).unfold()
AeqT = AeqT_or_AeqF.operands[0]
# Not(A=FALSE) and (A=TRUE or A=FALSE) assuming each
compose(notAeqF, AeqT_or_AeqF).proven({AnotF, AeqT_or_AeqF})
# inBool(A=TRUE)
AeqT.deduceInBool()
# A assuming inBool(A), Not(A=FALSE)
AeqT_or_AeqF.deriveLeftIfNotRight().deriveViaBooleanEquality().proven(
{inBool(A), AnotF})
# forall_{A in BOOLEANS} Not(A=FALSE) => A
Implies(AnotF, A).generalize(A, domain=BOOLEANS).qed(__file__)
from proveit.basiclogic import Forall, Or, Not, Equals, TRUE, FALSE, BOOLEANS, inBool
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).proveByEval().specialize().proven({inBool(A)})
# forall_{A in BOOLEANS} Not(A) in BOOLEANS
inBool(Not(A)).concludeAsFolded().generalize(A, domain=BOOLEANS).qed(__file__)
from proveit.basiclogic.boolean.axioms import orFT, falseNotTrue
from proveit.basiclogic.boolean.theorems import falseEqFalse
from proveit.basiclogic import FALSE, inBool, Or, Equals, deriveStmtEqTrue
from proveit.common import X
# [FALSE or TRUE]
orFT.deriveViaBooleanEquality().proven()
# [FALSE or FALSE=FALSE] via [FALSE or TRUE] and FALSE=FALSE
deriveStmtEqTrue(falseEqFalse).subLeftSideInto(Or(FALSE, X), X).proven()
# [FALSE=TRUE or FALSE=FALSE] via [FALSE or FALSE=FALSE] and Not(FALSE=TRUE)
falseNotTrue.unfold().equateNegatedToFalse().subLeftSideInto(
Or(X, Equals(FALSE, FALSE)), X).proven()
# inBool(FALSE) via [FALSE=TRUE or FALSE=FALSE]
inBool(FALSE).concludeAsFolded().qed(__file__)
from proveit.basiclogic.boolean.theorems import doubleNegateConclusion
from proveit.basiclogic import Implies, Not, BOOLEANS, inBool
from proveit.common import A, B
# [Not(B) => Not(Not(A))] => [Not(A) => B)] assuming inBool(B)
toConclusion = Implies(Not(B), Not(Not(A))).transposition()
# [Not(B) => A] => [Not(B) => Not(Not(A))] assuming inBool(A)
fromHyp = doubleNegateConclusion.specialize({
A: Not(B),
B: A
}).proven({inBool(A)})
# [Not(B) => A] => [Not(A)=>B] assuming inBool(A) and inBool(B)
transpositionExpr = fromHyp.applySyllogism(toConclusion).proven(
{inBool(A), inBool(B)})
# forall_{A, B in BOOLEANS} [Not(B) => A] => [Not(A)=>B]
transpositionExpr.generalize((A, B), domain=BOOLEANS).qed(__file__)
from proveit.basiclogic.boolean.axioms import orTF from proveit.basiclogic.boolean.theorems import trueNotFalse, trueEqTrue from proveit.basiclogic import TRUE, FALSE, inBool, Or, Equals, deriveStmtEqTrue from proveit.common import X # [TRUE or FALSE] orTF.deriveViaBooleanEquality().proven() # [TRUE or TRUE=FALSE] via [TRUE or FALSE] and TRUE != FALSE trueNotFalse.unfold().equateNegatedToFalse().subLeftSideInto(Or(TRUE, X), X).proven() # [TRUE=TRUE or TRUE=FALSE] via [TRUE or TRUE=FALSE] and TRUE=TRUE deriveStmtEqTrue(trueEqTrue).subLeftSideInto(Or(X, Equals(TRUE, FALSE)), X).proven() # inBool(TRUE) via [TRUE=TRUE or TRUE=FALSE] inBool(TRUE).concludeAsFolded().qed(__file__)
from proveit.basiclogic.boolean.axioms import notT
from proveit.basiclogic import BOOLEANS, FALSE, inBool, Implies, And, Or, Not, deriveStmtEqTrue
from proveit.common import A, B, C, X
AorB = Or(A, B)
hypothesis = And(Implies(A, C), Implies(B, C))
ABCareBool = {inBool(A), inBool(B), inBool(C)}
# A=>C, B=>C assuming (A=>C and B=>C)
AimplC, _ = hypothesis.decompose()
# Not(A) assuming inBool(A), inBool(B), (A=>C and B=>C), Not(C)
AimplC.transpose().deriveConclusion().proven(
{inBool(A), inBool(C), hypothesis,
Not(C)})
# B assuming inBool(A, B, C), (A=>C and B=>C), (A or B), Not(C)
AorB.deriveRightIfNotLeft().proven(ABCareBool | {hypothesis, AorB, Not(C)})
# Not(TRUE) assuming inBool(A, B, C), (A=>C and B=>C), (A or B), Not(C)
deriveStmtEqTrue(C).subRightSideInto(
Not(X), X).proven(ABCareBool | {hypothesis, AorB, Not(C)})
# FALSE assuming inBool(A, B, C), (A=>C and B=>C), (A or B), Not(C)
notT.deriveRightViaEquivalence().proven(
ABCareBool | {hypothesis, AorB, Not(C)})
# Contradiction proof of C assuming (A=>C and B=>C), (A or B), inBool(A), and inBool(B)
Implies(Not(C),
FALSE).deriveViaContradiction().proven(ABCareBool | {hypothesis, AorB})
# forall_{A, B, C in BOOLEANS} (A=>C and B=>C) => ((A or B) => C)
Implies(hypothesis, Implies(AorB, C)).generalize((A, B, C),
domain=BOOLEANS).qed(__file__)
from proveit.basiclogic.boolean.theorems import orContradiction
from proveit.basiclogic import Implies, Not, Or, FALSE, inBool
from proveit.common import A, B
# (A or B) => FALSE assuming Not(A), Not(B)
orContradiction.specialize().proven({Not(A), Not(B)})
# By contradiction: B assuming inBool(B), (A or B), Not(A)
Implies(Not(B),
FALSE).deriveViaContradiction().proven({inBool(B),
Or(A, B),
Not(A)})
# forall_{A, B | Not(A), inBool(B)} (A or B) => B
Implies(Or(A, B), B).generalize((A, B),
conditions=(Not(A), inBool(B))).qed(__file__)
from proveit.basiclogic import BOOLEANS, TRUE, FALSE, inBool, Implies, And, deriveStmtEqTrue, 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)
# inBool(A=TRUE), inBool(A=FALSE), inBool(P(A) = TRUE)
AeqT = Equals(A, TRUE)
AeqF = Equals(A, FALSE)
PofAeqT = Equals(PofA, TRUE)
for eqExpr in (AeqT, AeqF, PofAeqT):
eqExpr.deduceInBool()
# P(TRUE), P(FALSE) assuming hypothesis
for case in hypothesis.decompose(): case.proven({hypothesis})
# A=TRUE => P(A)=TRUE assuming hypothesis
Implies(AeqT, deriveStmtEqTrue(AeqT.subLeftSideInto(PofA, A))).proven({hypothesis})
# A=FALSE => P(A)=TRUE assuming hypothesis
Implies(AeqF, deriveStmtEqTrue(AeqF.subLeftSideInto(PofA, A))).proven({hypothesis})
# P(A) assuming hypothesis, (A in BOOLEANS)
inBool(A).unfold().deriveCommonConclusion(PofAeqT).deriveViaBooleanEquality().proven({hypothesis, inBool(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.boolean.axioms import contradictoryValidation
from proveit.basiclogic import Implies, Not, FALSE, inBool, BOOLEANS
from proveit.common import A
# inBool(Not(A)) assuming inBool(A)
Not(A).deduceInBool().proven({inBool(A)})
# [Not(Not(A)) => FALSE] => Not(A) assuming inBool(A)
contradictoryValidation.specialize({A:Not(A)}).proven({inBool(A)})
# A assuming Not(Not(A)) and inBool(A)
Not(Not(A)).deriveViaDoubleNegation().proven({inBool(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.equality.axioms import notEqualsDef
from proveit.basiclogic import Not, Equals, inBool
from proveit.common import x, y, X
# Not(x = y) in BOOLEANS
Not(Equals(x, y)).deduceInBool().proven()
# forall_{x, y} (x != y) in BOOLEANS
notEqualsDef.specialize().subLeftSideInto(inBool(X), X).generalize(
(x, y)).qed(__file__)
from proveit.basiclogic import Implies, Not, FALSE, inBool, Equals, NotEquals
from proveit.common import A, B, X
# inBool(B=FALSE)
Equals(B, FALSE).deduceInBool()
# [Not(B=FALSE) => Not(A)] => [A => (B=FALSE)], using inBool(B=FALSE)
midPointBackHalf = Implies(Not(Equals(B, FALSE)), Not(A)).transposition()
# [(B != FALSE) => Not(A)] => [Not(B=FALSE) => Not(A)]
midPointFrontHalf = NotEquals(B, FALSE).definition().rhsStatementSubstitution(Implies(X, Not(A)), X).proven()
# [(B != FALSE) => Not(A)] => [A => (B=FALSE)]
midPoint = midPointFrontHalf.applySyllogism(midPointBackHalf).proven()
# B assuming (B != FALSE) and inBool(B)
notBeqF = NotEquals(B, FALSE)
notBeqF.deriveViaDoubleNegation().proven({notBeqF, inBool(B)})
# [B => Not(A)] => [(B != FALSE) => Not(A)] assuming inBool(B)
fromHyp = Implies(Implies(B, Not(A)), Implies(notBeqF, Not(A))).proven({inBool(B)})
# Not(B) assuming B=FALSE
BeqF = Equals(B, FALSE)
BeqF.deriveViaBooleanEquality().proven({BeqF})
# [A => (B=FALSE)] => [A => Not(B)] assuming inBool(B)
toConclusion = Implies(Implies(A, BeqF), Implies(A, Not(B))).proven({inBool(B)})
# [B => Not(A)] => [A=>Not(B)] assuming inBool(B)
transpositionExpr = fromHyp.applySyllogism(midPoint).applySyllogism(toConclusion).proven({inBool(B)})
# forall_{A, B | inBool(B)} [B => Not(A)] => [A=>Not(B)]
transpositionExpr.generalize((A, B), conditions=inBool(B)).qed(__file__)
from proveit.basiclogic.boolean.theorems import doubleNegateConclusion
from proveit.basiclogic import Implies, Not, BOOLEANS, inBool
from proveit.common import A, B
# [B => Not(Not(A))] => [Not(A)=>Not(B)] assuming inBool(A), inBool(B)
toConclusion = Implies(B, Not(Not(A))).transposition()
# [B => A] => [B => Not(Not(A))] assuming inBool(A)
fromHyp = doubleNegateConclusion.specialize({A: B, B: A}).proven({inBool(A)})
# [B => A] => [Not(A)=>Not(B)] assuming inBool(A), inBool(B)
transpositionExpr = fromHyp.applySyllogism(toConclusion).proven(
{inBool(A), inBool(B)})
# forall_{A, B in BOOLEANS} [B=>A] => [Not(A) => Not(B)]
transpositionExpr.generalize((A, B), domain=BOOLEANS).qed(__file__)
from proveit.basiclogic.boolean.axioms import boolsDef
from proveit.basiclogic.set.axioms import singletonDef
from proveit.basiclogic import Implies, In, inBool, Singleton, Equals, TRUE, FALSE, Or
from proveit.common import x, y, A, X
# [A in ({TRUE} union {FALSE})] assuming inBool(A)
AinTunionF = boolsDef.subRightSideInto(In(A, X), X).proven({inBool(A)})
# (A in {TRUE}) or (A in {FALSE}) assuming inBool(A)
AinTunionF.unfold().proven({inBool(A)})
# A=TRUE or (A in {FALSE}) assuming inBool(A)
singletonDef.specialize({x:A, y:TRUE}).subRightSideInto(Or(X, In(A, Singleton(FALSE))), X).proven({inBool(A)})
# A=TRUE or A=FALSE assuming inBool(A)
conclusion = singletonDef.specialize({x:A, y:FALSE}).subRightSideInto(Or(Equals(A, TRUE), X), X).proven({inBool(A)})
# forall_{A} inBool(A) => (A=TRUE or A=FALSE)
Implies(inBool(A), conclusion).generalize(A).qed(__file__)
from proveit.basiclogic import Implies, Not, FALSE, inBool
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).equateNegatedToFalse().proven({hypothesis, Not(B)})
# FALSE assuming Not(B)=>Not(A), Not(B), and A
AeqF.deriveRightViaEquivalence().proven({hypothesis, Not(B), A})
# B assuming inBool(B), (Not(B)=>Not(A)), A
Implies(Not(B), FALSE).deriveViaContradiction().proven({inBool(B), hypothesis, A})
# [Not(B) => Not(A)] => [A => B] by nested hypothetical reasoning assuming inBool(B)
transpositionExpr = Implies(hypothesis, Implies(A, B)).proven({inBool(B)})
# forall_{A, B | inBool(B)} [A => B] => [Not(B) => Not(A)]
transpositionExpr.generalize((A, B), conditions=inBool(B)).qed(__file__)
from proveit.basiclogic.boolean.theorems import doubleNegation, fromDoubleNegation
from proveit.basiclogic import BOOLEANS, inBool, Not, Iff
from proveit.common import A
# A => Not(Not(A))
doubleNegationImplied = doubleNegation.specialize().proven()
# Not(Not(A)) => A
impliesDoubleNegation = fromDoubleNegation.specialize().proven()
# [A => Not(Not(A))] in BOOLEANS if A in BOOLEANS
doubleNegationImplied.deduceInBool().proven({inBool(A)})
# [Not(Not(A)) => A] in BOOLEANS if A in BOOLEANS
impliesDoubleNegation.deduceInBool().proven({inBool(A)})
# forall_{A} A = Not(Not(A))
Iff(A, Not(Not(A))).concludeViaComposition().deriveEquality().generalize(
A, domain=BOOLEANS).qed(__file__)
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.basiclogic import Implies, Not, inBool
from proveit.common import A, B
# Not(Not(B)) assuming B and inBool(B)
notNotB = Not(Not(B)).concludeViaDoubleNegation()
# [A=>B] => [A => Not(Not(B))] assuming inBool(B)
innerExpr = Implies(Implies(A, B), Implies(A, notNotB)).proven({inBool(B)})
# forall_{A, B | inBool(B)} [A=>B] => [A => Not(Not(B))]
innerExpr.generalize((A, B), conditions=inBool(B)).qed(__file__)