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__)