Interface:Intuitionistic propositional logic

Well-formed formulas
We first introduce the kind of well-formed formulas and a few variables for this kind.  kind (formula) var (formula p q r s) 

Logical connectives
There are five standard logical connectives in the propositional calculus, negation,  term (formula (¬ formula))  implication,  term (formula (→ formula formula))  disjunction,  term (formula (∨ formula formula))  conjunction,  term (formula (∧ formula formula))  and, finally, the biconditional,  term (formula (↔ formula formula))  In addition, one can also consider the constant formulas (or nullary connectives) "the true",  term (formula (⊤))  and "the false",  term (formula (⊥)) 

Simple statements
Here are the statements which do not require any hypotheses.

Negation and implication
Double negation can be introduced but not eliminated, but triple negation is equivalent to single negation.  stmt (DoubleNegationIntroduction  (p → (¬ (¬ p)))) stmt (TripleNegation  ((¬ (¬ (¬ p))) ↔ (¬ p))) </jh> Double negation is of great importance partly due to a metatheorem which states that  is provable in intuitionistic logic if and only if   is provable in classical logic. Here are two theorems relating to double negation; the converse of  does not hold.  stmt (DoubleNegatedConjunction  (((¬ (¬ p)) ∧ (¬ (¬ q))) ↔ (¬ (¬ (p ∧ q))))) stmt (DoubleNegatedDisjunction  (((¬ (¬ p)) ∨ (¬ (¬ q))) → (¬ (¬ (p ∨ q))))) </jh> Implication is reflexive. Sometimes, this is called "Identity" or "Tautology".  stmt (ImplicationReflexivity  (p → p)) </jh> Introduction of an antecedent. Whitehead and Russell call this "Simplification" :  stmt (AntecedentIntroduction  (p → (q → p))) </jh> Syllogism can be stated in several ways, all of which hold in intuitionistic logic. This form is perhaps the most familiar:  stmt (ImplicationTransitivity  (((p → q) ∧ (q → r)) → (p → r))) </jh> There are many theorems we could state in forms with a common antecedent; here is one:  stmt (SyllogismInConsequent  ((p → (q → r)) → ((p → (r → s)) → (p → (q → s))))) </jh>

If the consequent of an implication is an implication itself, its antecedent can be distributed over antecedent and consequent of the consequent, and vice versa.  stmt (AntecedentDistribution  ((p → (q → r)) ↔ ((p → q) → (p → r)))) </jh> Transposition merely holds in one direction, not as a biconditional.  stmt (TranspositionIntroduction  ((p → q) → ((¬ q) → (¬ p)))) </jh>

Disjunction and conjunction
Idempotence:  stmt (DisjunctionIdempotence  (p ↔ (p ∨ p))) stmt (ConjunctionIdempotence  (p ↔ (p ∧ p))) </jh>

Associativity:  stmt (DisjunctionAssociativity  (((p ∨ q) ∨ r) ↔ (p ∨ (q ∨ r)))) stmt (ConjunctionAssociativity  (((p ∧ q) ∧ r) ↔ (p ∧ (q ∧ r)))) </jh>

Commutativity:  stmt (DisjunctionCommutativity  ((p ∨ q) ↔ (q ∨ p))) stmt (ConjunctionCommutativity  ((p ∧ q) ↔ (q ∧ p))) </jh>

Distributivity:  stmt (DisjunctionLeftDistribution  ((p ∨ (q ∧ r)) ↔ ((p ∨ q) ∧ (p ∨ r)))) stmt (DisjunctionRightDistribution  (((p ∧ q) ∨ r) ↔ ((p ∨ r) ∧ (q ∨ r)))) stmt (ConjunctionLeftDistribution  ((p ∧ (q ∨ r)) ↔ ((p ∧ q) ∨ (p ∧ r)))) stmt (ConjunctionRightDistribution  (((p ∨ q) ∧ r) ↔ ((p ∧ r) ∨ (q ∧ r)))) </jh>

De Morgan's laws
De Morgan's laws do not hold, in general, but some of them are available, often as implications rather than biconditionals. The naming convention is based on  for non-negated,   for negated,   for disjunction, and   for conjunction. Collection refers to a formula which is negated on the right hand side; distribution refers to a formula which is negated on the left hand side.  stmt (NegationCollectionPCP  ((p ∧ q) → (¬ ((¬ p) ∨ (¬ q))))) stmt (NegationCollectionPDP  ((p ∨ q) → (¬ ((¬ p) ∧ (¬ q))))) stmt (NegationCollectionNDN  (((¬ p) ∨ (¬ q)) → (¬ (p ∧ q)))) stmt (NegationCollectionNCNDistributionPDP  (((¬ p) ∧ (¬ q)) ↔ (¬ (p ∨ q)))) </jh>

Other statements containing negation, implication, disjunction and conjunction
The following importation/exportation principle applies as in classical logic:  stmt (Transportation  ((p → (q → r)) ↔ ((p ∧ q) → r))) </jh> Modus ponens holds and the ability to introduce transposition also gives us modus tollens.  stmt (ModusPonens  ((p ∧ (p → q)) → q)) stmt (ModusTollens  (((¬ q) ∧ (p → q)) → (¬ p))) </jh> Introduction principle for disjunction:  stmt (DisjunctionLeftIntroduction  (p → (q ∨ p))) stmt (DisjunctionRightIntroduction  (p → (p ∨ q))) </jh> Introduction and elimination principles for conjunction: <jh> stmt (ConjunctionLeftIntroduction  (p → (q → (q ∧ p)))) stmt (ConjunctionRightIntroduction  (p → (q → (p ∧ q)))) stmt (ConjunctionLeftElimination  ((p ∧ q) → q)) stmt (ConjunctionRightElimination  ((p ∧ q) → p)) </jh> Case by case elimination. We provide a version with disjunctions, but this is rather weaker than the classical version. <jh> stmt (DisjunctiveCaseElimination  (((p ∨ q) ∧ ((¬ p) ∨ q)) → q)) </jh> Composition for disjunction and conjunction: <jh> stmt (DisjunctionComposition  (((p → r) ∧ (q → r)) ↔ ((p ∨ q) → r))) stmt (ConjunctionComposition  (((p → q) ∧ (p → r)) ↔ (p → (q ∧ r)))) </jh> Summation for disjunction. We use the suffixes,  ,   and   to indicate if the summands were added to the left or the right of antecedent or consequent, respectively. <jh> stmt (DisjunctionSummationLL  ((p → q) → ((r ∨ p) → (r ∨ q)))) stmt (DisjunctionSummationLR  ((p → q) → ((r ∨ p) → (q ∨ r)))) stmt (DisjunctionSummationRL  ((p → q) → ((p ∨ r) → (r ∨ q)))) stmt (DisjunctionSummationRR  ((p → q) → ((p ∨ r) → (q ∨ r)))) stmt (DisjunctionSummation  (((p → q) ∧ (r → s)) → ((p ∨ r) → (q ∨ s)))) </jh> Multiplication for conjunction, with the same suffixes as above. <jh> stmt (ConjunctionMultiplicationLL  ((p → q) → ((r ∧ p) → (r ∧ q)))) stmt (ConjunctionMultiplicationLR  ((p → q) → ((r ∧ p) → (q ∧ r)))) stmt (ConjunctionMultiplicationRL  ((p → q) → ((p ∧ r) → (r ∧ q)))) stmt (ConjunctionMultiplicationRR  ((p → q) → ((p ∧ r) → (q ∧ r)))) stmt (ConjunctionMultiplication  (((p → q) ∧ (r → s)) → ((p ∧ r) → (q ∧ s)))) </jh> Adding a common antecedent to an implication, or adding a common consequent and reversing the direction of the implication: <jh> stmt (CommonAntecedentAddition  ((q → r) → ((p → q) → (p → r)))) stmt (CommonConsequentAddition  ((p → q) → ((q → r) → (p → r)))) </jh>

Equivalence relation
As in classical logic, the biconditional can be thought of as creating an equivalence relation among formulas. <jh> stmt (BiconditionalReflexivity  (p ↔ p)) stmt (BiconditionalSymmetry  ((p ↔ q) ↔ (q ↔ p))) stmt (BiconditionalTransitivity  (((p ↔ q) ∧ (q ↔ r)) → (p ↔ r))) </jh> The  (law of excluded middle) does not hold. We can have  and   from Interface:Classical propositional calculus, as long as we rephrase the former to refer to another theorem rather than the. <jh> stmt (TautologyId  ((p → p) ↔ (⊤))) stmt (Contradiction  ((p ∧ (¬ p)) ↔ (⊥))) </jh>

In intuitionistic logic, the following theorems from Interface:Classical propositional calculus might be better termed "proved" and "disproved" (or "valid" and "invalid", or some such terminology) rather than  and , but they do hold as stated. <jh> stmt (True  (⊤)) stmt (NotFalse  (¬ (⊥))) </jh>

Weakenings
A biconditional makes a strong statement. Often, we only need a weaker statement. For introductions, see the section on truth function interdependencies.

The naming convention here is that when we think of  as consisting of two implications, we call   the forward one and   the reverse one. <jh> stmt (BiconditionalForwardElimination  ((p ↔ q) → (q → p))) stmt (BiconditionalReverseElimination  ((p ↔ q) → (p → q))) </jh>

Interface:Classical propositional calculus has a similar set of weakenings to disjunctions, but they do not apply in intuitionistic logic.

Builders
We are able to build formulas as in classical logic. The naming is mostly from Interface:Classical propositional calculus even though the concept of "truth function" doesn't apply the same way. is only an implication (rather than the biconditional in classical logic), so we give that one a different name. <jh> stmt (NegationBuilder  ((p ↔ q) → ((¬ p) ↔ (¬ q)))) stmt (ImplicationFunction  (((p ↔ q) ∧ (r ↔ s)) → ((p → r) ↔ (q → s)))) stmt (DisjunctionFunction  (((p ↔ q) ∧ (r ↔ s)) → ((p ∨ r) ↔ (q ∨ s)))) stmt (ConjunctionFunction  (((p ↔ q) ∧ (r ↔ s)) → ((p ∧ r) ↔ (q ∧ s)))) stmt (BiconditionalFunction  (((p ↔ q) ∧ (r ↔ s)) → ((p ↔ r) ↔ (q ↔ s)))) </jh>

Connective interdependencies
Although the connectives are interrelated in intuitionistic logic, most of the classical theorems expressing those relationships only hold as implications, rather than biconditionals. We have already seen that for De Morgan's laws. Here are some more.

The biconditional is related to implication and conjunction as in classical logic. <jh> stmt (BiconditionalImplication  ((p ↔ q) ↔ ((p → q) ∧ (q → p)))) </jh>

In a nutshell, disjunction makes a stronger statement than implication, but the details depend on where the negations are placed. In classical logic, by contrast,  is equivalent to   and likewise for other placements of the negations. <jh> stmt (DisjunctionImplicationForward  ((p ∨ q) → ((¬ p) → q))) stmt (ImplicationDisjunctionReverse  (((¬ p) ∨ q) → (p → q))) stmt (NotImplicationDisjunction  ((¬ (p → q)) → (¬ ((¬ p) ∨ q)))) stmt (NotDisjunctionImplication  ((¬ (p ∨ q)) ↔ (¬ ((¬ p) → q)))) </jh>

We do not have  from Interface:Classical propositional calculus, and   only in one direction. <jh> stmt (BiconditionalConjunctionReverse  ((((¬ p) ∨ q) ∧ (p ∨ (¬ q))) → (p ↔ q))) </jh>

Negation as implication. This one holds as in classical logic. <jh> stmt (NegationImplication  ((¬ p) ↔ (p → (⊥)))) </jh>

Antecedent distribution
Here is a version of  with one of the implications replaced by a biconditional. <jh> stmt (ImplicationDistributionOverBiconditional  ((p → (q ↔ r)) ↔ ((p → q) ↔ (p → r)))) </jh>

Biconditional and conjunction
A true conjunct does not affect the truth of a proposition. <jh> stmt (BiconditionalConjunct  (q → (p ↔ (p ∧ q)))) </jh>

Rules
Here we supply rules corresponding to many of the theorems above, including those rules from Interface:Principia Mathematica propositional logic theorems which hold intuitionistically.

Negation and implication: <jh> stmt (introduceDoubleNegation (p) (¬ (¬ p))) stmt (eliminateTripleNegation ((¬ (¬ (¬ p)))) (¬ p)) stmt (introduceAntecedent (p) (q → p)) stmt (applySyllogism ((p → q) (q → r)) (p → r)) stmt (applySyllogismInConsequent ((p → (q → r)) (p → (r → s))) (p → (q → s))) stmt (distributeAntecedent ((p → (q → r))) ((p → q) → (p → r))) stmt (collectAntecedent (((p → q) → (p → r))) (p → (q → r))) stmt (introduceTransposition ((p → q)) ((¬ q) → (¬ p))) </jh> Disjunction and conjunction: <jh> stmt (cloneAsDisjunction (p) (p ∨ p)) stmt (conflateDisjunction ((p ∨ p)) p) stmt (cloneAsConjunction  (p) (p ∧ p)) stmt (conflateConjunction ((p ∧ p)) p) stmt (groupDisjunctionLeft  ((p ∨ (q ∨ r))) ((p ∨ q) ∨ r)) stmt (groupDisjunctionRight (((p ∨ q) ∨ r)) (p ∨ (q ∨ r))) stmt (groupConjunctionLeft ((p ∧ (q ∧ r))) ((p ∧ q) ∧ r)) stmt (groupConjunctionRight (((p ∧ q) ∧ r)) (p ∧ (q ∧ r))) stmt (swapDisjunction ((p ∨ q)) (q ∨ p)) stmt (swapConjunction ((p ∧ q)) (q ∧ p)) stmt (distributeLeftDisjunction ((p ∨ (q ∧ r))) ((p ∨ q) ∧ (p ∨ r))) stmt (collectLeftDisjunction (((p ∨ q) ∧ (p ∨ r))) (p ∨ (q ∧ r))) stmt (distributeRightDisjunction (((p ∧ q) ∨ r)) ((p ∨ r) ∧ (q ∨ r))) stmt (collectRightDisjunction (((p ∨ r) ∧ (q ∨ r))) ((p ∧ q) ∨ r)) stmt (distributeLeftConjunction ((p ∧ (q ∨ r))) ((p ∧ q) ∨ (p ∧ r))) stmt (collectLeftConjunction (((p ∧ q) ∨ (p ∧ r))) (p ∧ (q ∨ r))) stmt (distributeRightConjunction (((p ∨ q) ∧ r)) ((p ∧ r) ∨ (q ∧ r))) stmt (collectRightConjunction (((p ∧ r) ∨ (q ∧ r))) ((p ∨ q) ∧ r)) </jh> De Morgan's laws: <jh> stmt (collectNegationPCP ((p ∧ q)) (¬ ((¬ p) ∨ (¬ q)))) stmt (collectNegationPDP ((p ∨ q)) (¬ ((¬ p) ∧ (¬ q)))) stmt (collectNegationNDN (((¬ p) ∨ (¬ q))) (¬ (p ∧ q))) stmt (collectNegationNCN (((¬ p) ∧ (¬ q))) (¬ (p ∨ q))) stmt (distributeNegationPDP ((¬ (p ∨ q))) ((¬ p) ∧ (¬ q))) </jh> Other rules containing negation, implication, disjunction and conjunction: <jh> stmt (import ((p → (q → r))) ((p ∧ q) → r)) stmt (export (((p ∧ q) → r)) (p → (q → r))) stmt (applyModusPonens (p (p → q)) q) stmt (applyModusTollens  ((¬ q) (p → q)) (¬ p)) stmt (introduceLeftDisjunction (p) (q ∨ p)) stmt (introduceRightDisjunction (p) (p ∨ q)) stmt (introduceConjunction (p q) (p ∧ q)) stmt (eliminateLeftConjunct ((p ∧ q)) q) stmt (eliminateRightConjunct  ((p ∧ q)) p) stmt (composeDisjunction  ((p → r) (q → r)) ((p ∨ q) → r)) stmt (extractLeftDisjunction (((p ∨ q) → r)) (p → r)) stmt (extractRightDisjunction (((p ∨ q) → r)) (q → r)) stmt (composeConjunction ((p → q) (p → r)) (p → (q ∧ r))) stmt (extractLeftConjunction ((p → (q ∧ r))) (p → q)) stmt (extractRightConjunction ((p → (q ∧ r))) (p → r)) stmt (disjoinLL ((p → q)) ((r ∨ p) → (r ∨ q))) stmt (disjoinLR ((p → q)) ((r ∨ p) → (q ∨ r))) stmt (disjoinRL ((p → q)) ((p ∨ r) → (r ∨ q))) stmt (disjoinRR ((p → q)) ((p ∨ r) → (q ∨ r))) stmt (disjoin ((p → q) (r → s)) ((p ∨ r) → (q ∨ s))) stmt (conjoinLL ((p → q)) ((r ∧ p) → (r ∧ q))) stmt (conjoinLR ((p → q)) ((r ∧ p) → (q ∧ r))) stmt (conjoinRL ((p → q)) ((p ∧ r) → (r ∧ q))) stmt (conjoinRR ((p → q)) ((p ∧ r) → (q ∧ r))) stmt (conjoin ((p → q) (r → s)) ((p ∧ r) → (q ∧ s))) stmt (addCommonAntecedent ((q → r)) ((p → q) → (p → r))) stmt (addCommonConsequent ((p → q)) ((q → r) → (p → r))) </jh> Biconditional: <jh> stmt (swapBiconditional ((p ↔ q)) (q ↔ p)) stmt (applyBiconditionalTransitivity ((p ↔ q) (q ↔ r)) (p ↔ r)) stmt (eliminateBiconditionalForward ((p ↔ q)) (q → p)) stmt (eliminateBiconditionalReverse ((p ↔ q)) (p → q)) stmt (addNegation ((p ↔ q)) ((¬ p) ↔ (¬ q))) stmt (buildImplication ((p ↔ q) (r ↔ s)) ((p → r) ↔ (q → s))) stmt (buildDisjunction ((p ↔ q) (r ↔ s)) ((p ∨ r) ↔ (q ∨ s))) stmt (buildConjunction ((p ↔ q) (r ↔ s)) ((p ∧ r) ↔ (q ∧ s))) stmt (buildBiconditional ((p ↔ q) (r ↔ s)) ((p ↔ r) ↔ (q ↔ s))) stmt (convertFromBiconditionalToImplications ((p ↔ q)) ((p → q) ∧ (q → p))) stmt (convertToBiconditionalFromImplications (((p → q) ∧ (q → p))) (p ↔ q)) stmt (introduceBiconditionalFromImplications ((p → q) (q → p)) (p ↔ q)) stmt (convertToBiconditionalFromConjunction ((((¬ p) ∨ q) ∧ (p ∨ (¬ q)))) (p ↔ q)) stmt (introduceBiconditionalFromDisjunctions (((¬ p) ∨ q) (p ∨ (¬ q))) (p ↔ q)) stmt (convertFromDisjunctionToImplication ((p ∨ q)) ((¬ p) → q)) stmt (convertToImplicationFromDisjunction (((¬ p) ∨ q)) (p → q)) stmt (convertFromNegationToImplication ((¬ p)) (p → (⊥))) stmt (convertToNegationFromImplication ((p → (⊥))) (¬ p)) stmt (distributeImplicationOverBiconditional ((p → (q ↔ r))) ((p → q) ↔ (p → r))) </jh>

Additional builders
<jh> var (formula antecedent consequent common p0 q0 p1 q1)

stmt (DisjunctionBuilderLL  ((p ↔ q) → ((common ∨ p) ↔ (common ∨ q)))) stmt (buildDisjunctionLL ((p ↔ q)) ((common ∨ p) ↔ (common ∨ q))) stmt (DisjunctionBuilderRR  ((p ↔ q) → ((p ∨ common) ↔ (q ∨ common)))) stmt (buildDisjunctionRR ((p ↔ q)) ((p ∨ common) ↔ (q ∨ common)))

stmt (buildConjunctionLL ((p ↔ q)) ((r ∧ p) ↔ (r ∧ q))) stmt (buildConjunctionRR ((p ↔ q)) ((p ∧ r) ↔ (q ∧ r))) stmt (BiconditionalBuilderRR  ((p ↔ q) → ((p ↔ common) ↔ (q ↔ common)))) stmt (buildBiconditionalLL ((p ↔ q)) ((common ↔ p) ↔ (common ↔ q)))

stmt (ImplicationBuilderRR  ((p ↔ q) → ((p → common) ↔ (q → common)))) stmt (ImplicationBuilderConsequent  ((p ↔ q) → ((p → common) ↔ (q → common)))) stmt (buildImplicationConsequent ((p ↔ q)) ((p → common) ↔ (q → common))) stmt (buildImplicationAntecedent ((p ↔ q)) ((common → p) ↔ (common → q)))

stmt (addNegationInConsequent ((antecedent → (p ↔ q))) (antecedent → ((¬ p) ↔ (¬ q)))) stmt (buildConjunctionRRInConsequent  ((antecedent → (p ↔ q)))  (antecedent → ((p ∧ common) ↔ (q ∧ common)))) stmt (buildConjunctionLLInConsequent  ((antecedent → (p ↔ q)))  (antecedent → ((common ∧ p) ↔ (common ∧ q)))) stmt (buildDisjunctionRRInConsequent ((antecedent → (p ↔ q))) (antecedent → ((p ∨ common) ↔ (q ∨ common)))) stmt (buildDisjunctionLLInConsequent ((antecedent → (p ↔ q))) (antecedent → ((common ∨ p) ↔ (common ∨ q)))) stmt (buildConjunctionInConsequent  ((antecedent → (p0 ↔ q0)) (antecedent → (p1 ↔ q1))) (antecedent → ((p0 ∧ p1) ↔ (q0 ∧ q1)))) stmt (buildDisjunctionInConsequent  ((antecedent → (p0 ↔ q0)) (antecedent → (p1 ↔ q1))) (antecedent → ((p0 ∨ p1) ↔ (q0 ∨ q1))))

stmt (buildCommonAntecedentInConsequent  ((antecedent → (p ↔ q)))  (antecedent → ((common → p) ↔ (common → q)))) stmt (buildCommonConsequentInConsequent  ((antecedent → (p ↔ q)))  (antecedent → ((p → common) ↔ (q → common)))) stmt (buildImplicationInConsequent  ((antecedent → (p0 ↔ q0)) (antecedent → (p1 ↔ q1))) (antecedent → ((p0 → p1) ↔ (q0 → q1)))) stmt (buildBiconditionalInConsequent  ((antecedent → (p0 ↔ q0)) (antecedent → (p1 ↔ q1))) (antecedent → ((p0 ↔ p1) ↔ (q0 ↔ q1)))) stmt (buildBiconditionalLLInConsequent ((antecedent → (p ↔ q))) (antecedent → ((common ↔ p) ↔ (common ↔ q)))) stmt (buildBiconditionalRRInConsequent ((antecedent → (p ↔ q))) (antecedent → ((p ↔ common) ↔ (q ↔ common)))) </jh>

Various theorems in the consequent
<jh> stmt (introduceBiconditionalFromImplicationsInConsequent ((antecedent → (p → q)) (antecedent → (q → p))) (antecedent → (p ↔ q))) stmt (eliminateBiconditionalReverseInConsequent ((antecedent → (p ↔ q))) (antecedent → (p → q))) stmt (eliminateBiconditionalForwardInConsequent ((antecedent → (p ↔ q))) (antecedent → (q → p))) stmt (applyModusPonensInConsequent ((antecedent → p) (antecedent → (p → q))) (antecedent → q)) stmt (applyBiconditionalTransitivityInConsequent  ((antecedent → (p ↔ q)) (antecedent → (q ↔ r))) (antecedent → (p ↔ r))) stmt (introduceAntecedentInConsequent ((antecedent → p)) (antecedent → (q → p))) stmt (importInConsequent  ((antecedent → (p → (q → r))))  (antecedent → ((p ∧ q) → r))) stmt (exportInConsequent  ((antecedent → ((p ∧ q) → r)))  (antecedent → (p → (q → r))) )

stmt (eliminateLeftConjunctInConsequent ((antecedent → (p ∧ q))) (antecedent → q)) stmt (eliminateRightConjunctInConsequent ((antecedent → (p ∧ q))) (antecedent → p))

stmt (introduceTranspositionInConsequent  ((antecedent → (p → q)))  (antecedent → ((¬ q) → (¬ p)))) </jh>

Theorems partly in the consequent
We can have a theorem not in the consequent (for example,  derives   from hypotheses   and  ). We can have a theorem entirely in the consequent–that is, all hypotheses have a common antecedent (for example,  derives   from   and  ). In this section we have some theorems in which some, but not all, hypotheses have a common antecedent which also figures in the conclusion. <jh> stmt (introduceLeftConjunctToConsequent ((antecedent → p) q) (antecedent → (q ∧ p))) stmt (introduceRightConjunctToConsequent ((antecedent → p) q) (antecedent → (p ∧ q))) </jh>

Theorems in the antecedent
There are more cases where it is convenient to have a rule that operates in the consequent than in the antecedent. But there are a few for the latter. <jh> stmt (importInAntecedent  (((p → (q → r)) → consequent))  (((p ∧ q) → r) → consequent)) stmt (exportInAntecedent  ((((p ∧ q) → r) → consequent))  ((p → (q → r)) → consequent)) </jh>

Detachment
These are analogues to modus ponens, but where some other portion of the formula, other than a single antecedent, is detached. <jh> stmt (detach1of2 (p ((p ∧ q) → r)) (q → r)) stmt (detach2of2 (q ((p ∧ q) → r)) (p → r))

stmt (detach1of3 (p (((p ∧ q) ∧ r) → consequent)) ((q ∧ r) → consequent)) stmt (detach2of3 (q (((p ∧ q) ∧ r) → consequent)) ((p ∧ r) → consequent))
 * 1) Invoke detach2of2 to detach the third of three antecedents

stmt (detach1of4 (p ((((p ∧ q) ∧ r) ∧ s) → consequent)) (((q ∧ r) ∧ s) → consequent))
 * 1) Invoke detach2of3 to detach the third of four antecedents
 * 2) Invoke detach2of2 to detach the fourth of four antecedents

stmt (detachImplicationBiconditional (q (p → (q ↔ r))) (p → r)) stmt (detachImplicationBiconditionalRight (r (p → (q ↔ r))) (p → q)) stmt (detachImplicationImplication (p (antecedent → (p → q))) (antecedent → q)) </jh>

Negated detachment
These are variants of modus tollens where we detach a portion of a formula which is more complicated than just a single implication. <jh> stmt (negatedDetachImplicationBiconditionalRight ((¬ r) (p → (q ↔ r))) (p → (¬ q))) stmt (negatedDetachImplicationBiconditional ((¬ q) (p → (q ↔ r))) (p → (¬ r))) stmt (negatedDetachImplicationImplication ((¬ r) (p → (q → r))) (p → (¬ q))) </jh>

Commutation of antecedents
This result is a consequence of import/export and conjunction commutativity. <jh> stmt (applyComm ((p → (q → r))) (q → (p → r))) </jh>

Transformation
By "transforming", we mean applying a biconditional to replace part of a formula. <jh> stmt (transformAntecedent ((p → q) (p ↔ r)) (r → q)) stmt (transformImplicationImplicationConsequent ((antecedent → (p → q)) (q ↔ r)) (antecedent → (p → r))) stmt (transformImplicationImplicationAntecedent ((antecedent → (p → q)) (p ↔ r)) (antecedent → (r → q))) stmt (transformImplicationBiconditionalLeft ((antecedent → (p ↔ q)) (p ↔ r)) (antecedent → (r ↔ q))) stmt (transformImplicationBiconditionalRight ((antecedent → (p ↔ q)) (q ↔ r)) (antecedent → (p ↔ r))) stmt (transformImplicationDisjunctionLeft ((antecedent → (p ∨ q)) (p ↔ r)) (antecedent → (r ∨ q))) stmt (transformDisjunctionRight ((p ∨ q) (q ↔ r)) (p ∨ r)) </jh>

Additional relationships between connectives
<jh> </jh>
 * 1) stmt (NegationBiconditional  ((¬ p) ↔ (p ↔ (⊥))))

Combinations of commutativity and associativity
Commutativity and associativity might be combined in any number of ways, but a few patterns turn out to be common. <jh> stmt (Disjunction4  (((p ∨ q) ∨ (r ∨ s)) ↔ ((p ∨ r) ∨ (q ∨ s)))) stmt (swap23ofDisjunction4 (((p ∨ q) ∨ (r ∨ s))) ((p ∨ r) ∨ (q ∨ s))) stmt (swap23ofDisjunction3 (((p ∨ q) ∨ r)) ((p ∨ r) ∨ q))

stmt (Conjunction4  (((p ∧ q) ∧ (r ∧ s)) ↔ ((p ∧ r) ∧ (q ∧ s)))) </jh>

Cited works

 * Heyting, A. (1966), Intuitionism: An introduction, second edition, North-Holland publishing company, Amsterdam