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