示例#1
0
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__)
示例#2
0
from proveit.basiclogic.boolean.axioms import iffDef
from proveit.basiclogic.boolean.theorems import impliesFF
from proveit.basiclogic import compose, FALSE, deriveStmtEqTrue
from proveit.common import A, B

# FALSE => FALSE
FimplF = impliesFF.deriveViaBooleanEquality()
# (FALSE => FALSE) and (FALSE => FALSE) = TRUE
FimplFandFimplF_eq_T = deriveStmtEqTrue(compose(FimplF, FimplF))
# (FALSE <=> FALSE) = TRUE
iffDef.specialize({
    A: FALSE,
    B: FALSE
}).applyTransitivity(FimplFandFimplF_eq_T).qed(__file__)
示例#3
0
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.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__)
示例#5
0
from proveit.basiclogic.booleans.axioms import iff_def
from proveit.basiclogic.booleans.theorems import implies_t_t
from proveit.basiclogic import compose, TRUE, derive_stmt_eq_true
from proveit.common import A, B

# TRUE => TRUE
TimplT = implies_t_t.derive_via_boolean_equality()
# (TRUE => TRUE) and (TRUE => TRUE) = TRUE
TimplTandTimplT_eq_T = derive_stmt_eq_true(compose(TimplT, TimplT))
# (TRUE <=> TRUE) = TRUE
iff_def.instantiate({
    A: TRUE,
    B: TRUE
}).apply_transitivity(TimplTandTimplT_eq_T).qed(__file__)
示例#6
0
from proveit.basiclogic.boolean.axioms import iffDef
from proveit.basiclogic.boolean.theorems import impliesTT
from proveit.basiclogic import compose, TRUE, deriveStmtEqTrue
from proveit.common import A, B

# TRUE => TRUE
TimplT = impliesTT.deriveViaBooleanEquality()
# (TRUE => TRUE) and (TRUE => TRUE) = TRUE
TimplTandTimplT_eq_T = deriveStmtEqTrue(compose(TimplT, TimplT))
# (TRUE <=> TRUE) = TRUE
iffDef.specialize({
    A: TRUE,
    B: TRUE
}).applyTransitivity(TimplTandTimplT_eq_T).qed(__file__)
示例#7
0
from proveit.basiclogic.booleans.axioms import iff_def
from proveit.basiclogic.booleans.theorems import implies_f_f
from proveit.basiclogic import compose, FALSE, derive_stmt_eq_true
from proveit.common import A, B

# FALSE => FALSE
FimplF = implies_f_f.derive_via_boolean_equality()
# (FALSE => FALSE) and (FALSE => FALSE) = TRUE
FimplFandFimplF_eq_T = derive_stmt_eq_true(compose(FimplF, FimplF))
# (FALSE <=> FALSE) = TRUE
iff_def.instantiate({
    A: FALSE,
    B: FALSE
}).apply_transitivity(FimplFandFimplF_eq_T).qed(__file__)