Logic and the Structure of Formal Inference

Last Updated May 30, 2026

Logic is the study of valid reasoning. In mathematics, logic gives structure to inference: it clarifies how statements relate, how assumptions support conclusions, how quantifiers shape claims, and how proof systems make reasoning explicit. Mathematical logic does not replace mathematical imagination, but it disciplines it. It asks whether a conclusion follows from premises, what rules justify the transition, and which assumptions are doing the work.

Formal inference is the organized movement from statements to statements according to accepted rules. It appears in elementary proofs, symbolic logic, set theory, proof theory, model theory, type theory, computer science, formal verification, programming language design, proof assistants, and the foundations of mathematics. Every proof depends on some logic, whether that logic is informal, classical, constructive, modal, type-theoretic, or machine-checked.

This article examines logic as the architecture of formal inference. It explains propositions, predicates, quantifiers, implication, equivalence, rules of inference, proof systems, soundness, validity, consistency, completeness, formal languages, symbolic representation, proof trees, sequent reasoning, natural deduction, and the relationship between logic, computation, and mathematical justification.

What Logic Means in Mathematics

Logic is the study of consequence. It asks when a conclusion follows from premises, what rules justify the movement from one claim to another, and how reasoning can be represented so that its structure is visible. In mathematics, logic provides the grammar of proof. It tells us how definitions, assumptions, quantifiers, implications, equivalences, and inference rules combine into justified argument.

Mathematical logic does not concern itself only with whether isolated statements are true. It is concerned with relations among statements. If certain assumptions hold, what else must hold? If a theorem depends on a hypothesis, what happens when that hypothesis is removed? If two statements are equivalent, can either one be used in place of the other? If a proof reaches contradiction, what does that contradiction establish?

This relation between assumptions and conclusion is central. A mathematical theorem is rarely an isolated assertion. It has a logical environment. It depends on definitions, axioms, inference rules, and prior results. Logic makes that environment explicit.

At the most basic level, logic distinguishes valid form from persuasive content. An argument may sound convincing but be invalid. Another argument may be abstract but valid because its conclusion follows from its premises by a recognized rule. Mathematics depends on this distinction. It is not enough for a statement to seem right; the structure of inference must support it.

Logic is therefore not a separate ornament added to mathematics after the fact. It is the structure through which mathematical justification becomes inspectable.

Back to top ↑

Statements, Propositions, and Truth Conditions

A proposition is a statement that can be evaluated as true or false within a given logical setting. “Every even integer is divisible by two” is a proposition. “\(7\) is prime” is a proposition. “\(x\) is positive” is not yet a proposition unless \(x\) has been assigned a value or placed under a quantifier. Logic begins by distinguishing complete statements from open expressions.

Mathematics often works with statements that are precise enough to enter proof. A vague sentence may express an intuition, but formal reasoning requires a statement whose structure is clear. This is why definitions matter. They make propositions meaningful enough to evaluate.

Truth conditions specify what must be the case for a proposition to be true. In elementary propositional logic, a statement is treated as true or false. In predicate logic, truth depends on objects, predicates, quantifiers, and domains. In model theory, truth is evaluated inside a structure. In proof theory, attention shifts from truth in a model to derivability in a proof system.

These perspectives are related but distinct. A statement may be true in one structure and false in another. For example, a claim about order may hold in the natural numbers but fail in a different ordered structure. A proposition may be derivable from one set of axioms but not another. Mathematical logic helps identify the setting in which a claim is being evaluated.

Formal inference requires statements that can carry logical burden. A proof cannot be stronger than the clarity of the statements it connects.

Back to top ↑

Predicates, Variables, and Quantifiers

Much of mathematics depends on predicates and quantifiers. A predicate is a property or relation that becomes a proposition when its variables are assigned values or bound by quantifiers. For example, \(P(x)\) might mean “\(x\) is prime.” The expression \(P(7)\) is a proposition. The expression \(\forall x\,P(x)\) is also a proposition, though usually false if the domain is all natural numbers.

Quantifiers determine the scope and strength of mathematical claims. The universal quantifier \(\forall\) means “for all.” The existential quantifier \(\exists\) means “there exists.” Many mathematical errors come from misunderstanding these quantifiers or reversing their order.

The difference between these two forms is enormous. In analysis, algebra, topology, probability, and computer science, quantifier order often determines the meaning of the theorem. Uniform convergence, continuity, compactness, limits, existence, uniqueness, and algorithmic correctness all depend on precise quantifier structure.

Consider the logic of continuity. The informal phrase “nearby inputs produce nearby outputs” becomes mathematically rigorous only when quantifiers are placed correctly:

Quantifiers make mathematical claims exact. They also make them fragile: changing the order, domain, or scope can change the theorem entirely.

Back to top ↑

Logical Connectives and Compound Claims

Logical connectives build compound claims from simpler statements. The major connectives are conjunction, disjunction, negation, implication, and equivalence. They appear constantly in mathematical writing, often beneath ordinary language.

Conjunction means “and.” Disjunction means “or,” often inclusive in mathematics unless stated otherwise. Negation reverses a claim. Implication expresses conditional consequence. Equivalence expresses two-way implication. Understanding these connectives is essential for reading definitions, proving theorems, and constructing counterexamples.

Implication is especially important because many mathematical statements are conditional. A theorem may say: if an object satisfies certain hypotheses, then it has a certain property. To prove such a theorem, one assumes the hypotheses and derives the conclusion. To refute it, one must find an object satisfying the hypotheses but failing the conclusion.

Equivalence is stronger. \(P \Leftrightarrow Q\) means both \(P \Rightarrow Q\) and \(Q \Rightarrow P\). Many definitions are equivalences. Many theorems are “if and only if” statements, requiring proof in both directions.

Many proof errors come from mishandling connectives: proving only one direction of an equivalence, confusing a statement with its converse, treating “or” as exclusive without justification, or negating a compound claim incorrectly. Formal logic prevents these errors by making the structure explicit.

Back to top ↑

Formal Inference and Rules of Reasoning

Formal inference is the movement from premises to conclusion according to rules. An inference rule specifies a valid pattern of reasoning. The most famous example is modus ponens: if \(P\Rightarrow Q\) and \(P\), then \(Q\).

Inference rules are abstract. They do not depend on the subject matter of \(P\) or \(Q\). The same rule applies whether \(P\) means “\(n\) is even,” “\(f\) is continuous,” “\(G\) is connected,” or “the algorithm terminates.” This abstraction is what makes logic portable across mathematics.

Other rules include conjunction introduction, conjunction elimination, disjunction introduction, proof by cases, universal instantiation, existential introduction, contradiction, contraposition, and induction. In ordinary mathematical writing, these rules are often used implicitly. In formal proof systems, they may be explicit steps.

The structure of formal inference matters because it makes proof auditable. A reader can ask: which rule is being applied? Are the premises available? Does the conclusion actually follow? Has the rule been used within its proper scope?

Back to top ↑

Validity, Soundness, and Truth Preservation

Validity concerns the structure of an argument. An argument is valid if the conclusion must be true whenever the premises are true. Validity does not require that the premises actually are true. It concerns whether the conclusion follows from them.

Soundness adds truth. An argument is sound when it is valid and its premises are true. In mathematics, one often distinguishes between a valid inference form and a theorem that has been established within a particular system.

This distinction protects reasoning from a common error. A logically valid argument can still be useless if its premises are false. Conversely, a conclusion may be true even if a particular argument for it is invalid. Logic evaluates the relationship between premises and conclusion, not merely the truth of the final sentence.

In formal logic, soundness also has a technical meaning: a proof system is sound if everything derivable in the system is semantically valid. In other words, the system does not prove statements that fail in the intended interpretations. Completeness, by contrast, asks whether every semantically valid statement can be derived in the proof system. These ideas connect proof theory to model theory.

Validity, soundness, completeness, and consistency are not merely technical terms. They express the standards by which formal systems are trusted.

Back to top ↑

Proof Systems: Natural Deduction, Sequents, and Axioms

A proof system is a formal framework for deriving conclusions from assumptions. Different proof systems organize inference in different ways. Natural deduction emphasizes introduction and elimination rules for logical connectives. Sequent calculus emphasizes relations between collections of assumptions and conclusions. Hilbert-style systems use axioms and a small number of inference rules. Type theory represents propositions and proofs through types and terms.

These systems differ in style, but they share a goal: to make inference explicit. A proof system tells us which expressions are well-formed, which initial statements are allowed, and which rules can be used to derive new statements.

Natural deduction is often close to how mathematicians reason informally. To prove \(P\Rightarrow Q\), assume \(P\) and derive \(Q\). To prove \(P\land Q\), prove \(P\) and prove \(Q\). To use \(P\land Q\), extract whichever component is needed. This gives logical connectives a procedural meaning.

Sequent calculus makes structural features of inference especially visible. It tracks assumptions, conclusions, weakening, contraction, exchange, and cut. It is important in proof theory because it exposes the architecture of derivations and the flow of logical resources.

Different proof systems illuminate different aspects of inference. Natural deduction highlights how claims are built and used. Sequent calculus highlights structural control. Type theory connects logic to computation. Automated proof systems connect inference to search.

Back to top ↑

Quantifier Logic and the Shape of Mathematical Claims

Quantifier logic is essential to mathematical precision. Many mathematical statements are not just about single propositions, but about all objects, some objects, unique objects, or objects depending on other objects. Quantifier structure determines the shape of the theorem.

For example, the statement “every nonzero real number has a multiplicative inverse” has the form:

A uniqueness claim adds another layer:

Quantifier negation is another major source of proof strategy. The negation of “for all \(x\), \(P(x)\)” is “there exists \(x\) such that not \(P(x)\).” This is the logic of counterexample. The negation of “there exists \(x\) such that \(P(x)\)” is “for all \(x\), not \(P(x)\).” This is the logic of nonexistence.

Quantifier logic is the difference between vague generality and exact mathematical claim. It tells the proof what burden it must carry.

Back to top ↑

Equivalence, Implication, and Logical Form

Logical form often matters more than surface language. Two statements may look different but be logically equivalent. A theorem may be easier to prove through its contrapositive. A definition may be expressed through an “if and only if” statement. A proof may require splitting an equivalence into two implications.

Implication has a direction. \(P\Rightarrow Q\) is not the same as \(Q\Rightarrow P\). The reverse implication is called the converse. A common error is proving the converse when the theorem asks for the original implication, or proving the original implication when an equivalence requires both directions.

The contrapositive, however, is logically equivalent in classical logic:

Logical equivalences allow mathematicians to transform statements into more useful forms. De Morgan’s laws, quantifier negations, contraposition, distributive laws, and equivalence transformations are not merely symbolic tricks. They are ways of revealing proof strategy.

Formal inference depends on recognizing these forms. A proof is not only about the content of the statements; it is about their logical shape.

Back to top ↑

Inference Structure and Proof Architecture

Inference has architecture. A proof may be linear, branching, nested, recursive, modular, or dependent on multiple lemmas. Formal logic allows that architecture to be represented explicitly.

A proof tree is one way to visualize inference. Leaves represent assumptions or axioms. Internal nodes represent derived statements. The root represents the conclusion. Each branch is governed by inference rules. This makes proof structure visible: what depends on what, where assumptions are introduced, where cases split, and where conclusions merge.

Proof architecture matters because complex mathematical arguments often fail at the dependency level. A lemma may require a stronger assumption than the theorem provides. A case split may omit a possibility. A proof by contradiction may negate the conclusion incorrectly. A use of induction may fail to prove the inductive step for an arbitrary case. Formal inference makes these structural weaknesses easier to detect.

In large mathematical systems, proof architecture becomes knowledge architecture. Theorems depend on definitions, lemmas, inference rules, and prior theories. Formal inference provides a way to inspect that dependency structure rather than relying on memory or authority.

Back to top ↑

Consistency, Completeness, and Limits of Formal Systems

Formal systems bring precision to reasoning, but they also reveal limits. A system is consistent if it does not derive a contradiction. In classical logic, inconsistency is catastrophic because from contradiction, anything can follow. A system is complete in one sense if every semantically valid statement in its language can be derived by its proof rules. A system is sound if everything derivable by its proof rules is semantically valid.

These are technical ideas, but they express a basic concern: can the system be trusted, and what can it prove?

Modern logic also teaches that formal systems have boundaries. Some systems cannot prove their own consistency if they are sufficiently strong and consistent. Some truths may not be derivable from a given axiom system. Some computational questions are undecidable. These results do not weaken mathematics; they deepen it by showing that formal reasoning itself has structure and limitation.

The structure of formal inference therefore includes its own self-understanding. Logic studies reasoning, but it also studies what formal reasoning can and cannot do.

Back to top ↑

Logic, Computation, and Formal Verification

Logic and computation are deeply connected. Formal inference can be represented as symbolic manipulation. Proof search can be treated algorithmically. Type systems can encode logical constraints. Programs can be verified against specifications. Proof assistants can check formal derivations. Automated theorem provers can search for proofs or contradictions.

The connection is especially clear in the relationship between proofs and programs. In constructive type theory, a proposition can be viewed as a type, and a proof as a term inhabiting that type. This means that proving existence often corresponds to constructing an object. Logical structure becomes computational structure.

Formal verification applies logical inference to software, hardware, protocols, algorithms, and mathematical libraries. It asks whether a system satisfies a specification. This can be powerful, but it also clarifies a crucial distinction: verification proves correctness relative to a specification. If the specification is incomplete, unjust, unsafe, or mismatched to real-world needs, formal proof alone cannot fix that problem.

Logic gives computation a language of correctness. Computation gives logic new tools for scale, checking, search, and reproducibility. Together, they shape modern mathematics, programming languages, AI systems, verification workflows, and proof-assistant ecosystems.

Back to top ↑

A Mathematical Lens: Premise, Rule, Derivation, Conclusion

A useful lens for understanding formal inference is the sequence: premise, rule, derivation, conclusion. This lens applies to elementary logic, mathematical proofs, formal verification, proof assistants, and theorem metadata.

A premise is a statement available for use. A rule specifies a valid transformation from available statements to new statements. A derivation is a sequence or tree of rule applications. A conclusion is the statement reached by that derivation.

This lens is especially useful for computational representation. A theorem can be stored as a claim. Assumptions can be stored as structured premises. Inference rules can be cataloged. Proof steps can be represented as nodes. Dependencies can be represented as edges. Counterexamples can be linked to the claims they refute. Formalization plans can identify which definitions and lemmas must be translated into a proof assistant.

This framework supports the companion repository for this article. The repository can model formal inference as structured data, executable audits, proof graphs, rule metadata, and reproducible examples across multiple programming languages.

Back to top ↑

Computational Companion Examples

The companion repository for this article should extend the Mathematical Thinking codebase with examples focused on formal inference, logical connectives, quantifier patterns, proof-rule metadata, derivation graphs, truth tables, counterexample records, and proof-system scaffolds. The examples below are compact article-level previews; the repository can expand them into richer professional workflows.

Python: Truth Tables and Inference Rules

from itertools import product
from dataclasses import dataclass

def implies(p: bool, q: bool) -> bool:
    return (not p) or q

def equivalent(p: bool, q: bool) -> bool:
    return p == q

def truth_table_implication():
    rows = []
    for p, q in product([False, True], repeat=2):
        rows.append({
            "P": p,
            "Q": q,
            "P_implies_Q": implies(p, q),
            "contrapositive": implies(not q, not p),
            "equivalent_to_contrapositive": equivalent(implies(p, q), implies(not q, not p))
        })
    return rows

@dataclass(frozen=True)
class InferenceRule:
    name: str
    premises: tuple[str, ...]
    conclusion: str

modus_ponens = InferenceRule(
    name="modus_ponens",
    premises=("P -> Q", "P"),
    conclusion="Q"
)

print(truth_table_implication())
print(modus_ponens)

R: Quantifier and Counterexample Audit

is_even <- function(n) n %% 2 == 0
square_is_even <- function(n) (n * n) %% 2 == 0

domain <- -20:20

audit <- data.frame(
  n = domain,
  premise_even = sapply(domain, is_even),
  conclusion_square_even = sapply(domain, square_is_even),
  implication_holds = (!sapply(domain, is_even)) | sapply(domain, square_is_even)
)

print(audit)

if (all(audit$implication_holds)) {
  cat("Finite audit found no counterexample in the tested domain.\n")
  cat("Interpretation: this supports the claim but does not replace a direct proof.\n")
}

Julia: Modus Ponens and Contrapositive Equivalence

implies(p::Bool, q::Bool) = (!p) || q
equivalent(p::Bool, q::Bool) = p == q

println("Truth table for implication and contrapositive")
for p in [false, true]
    for q in [false, true]
        original = implies(p, q)
        contrapositive = implies(!q, !p)
        println((P=p, Q=q, implication=original, contrapositive=contrapositive,
                 equivalent=equivalent(original, contrapositive)))
    end
end

function modus_ponens(implication_holds::Bool, antecedent_holds::Bool)
    return implication_holds && antecedent_holds
end

println("Modus ponens demo: ", modus_ponens(true, true))

SQL: Formal Inference Metadata

CREATE TABLE proposition (
  proposition_id TEXT PRIMARY KEY,
  label TEXT NOT NULL,
  statement TEXT NOT NULL,
  proposition_type TEXT NOT NULL
);

CREATE TABLE inference_rule (
  rule_id TEXT PRIMARY KEY,
  name TEXT NOT NULL,
  formal_pattern TEXT NOT NULL,
  description TEXT NOT NULL
);

CREATE TABLE derivation_step (
  step_id TEXT PRIMARY KEY,
  derivation_id TEXT NOT NULL,
  step_order INTEGER NOT NULL,
  proposition_id TEXT NOT NULL,
  rule_id TEXT,
  justification TEXT NOT NULL,
  FOREIGN KEY (proposition_id) REFERENCES proposition(proposition_id),
  FOREIGN KEY (rule_id) REFERENCES inference_rule(rule_id)
);

CREATE TABLE counterexample (
  counterexample_id TEXT PRIMARY KEY,
  proposition_id TEXT NOT NULL,
  object_description TEXT NOT NULL,
  failure_mode TEXT NOT NULL,
  FOREIGN KEY (proposition_id) REFERENCES proposition(proposition_id)
);

Haskell: Typed Propositions, Inference Rules, and Derivation Records

{-# OPTIONS_GHC -Wall #-}

module Main where

data TruthValue
  = TrueValue
  | FalseValue
  | Unknown
  deriving (Eq, Show)

data PropositionKind
  = Atomic
  | Conditional
  | Biconditional
  | Universal
  | Existential
  | Negated
  deriving (Eq, Show)

data InferenceRule
  = ModusPonens
  | Contrapositive
  | UniversalInstantiation
  | ExistentialIntroduction
  | ConjunctionIntroduction
  | ConjunctionElimination
  | ProofByCases
  deriving (Eq, Show)

data Proposition = Proposition
  { propositionId :: String
  , propositionKind :: PropositionKind
  , statement :: String
  , truthStatus :: TruthValue
  } deriving (Eq, Show)

data DerivationStep = DerivationStep
  { stepId :: String
  , premises :: [String]
  , ruleUsed :: InferenceRule
  , conclusion :: String
  , auditNote :: String
  } deriving (Eq, Show)

propositions :: [Proposition]
propositions =
  [ Proposition
      "p_even"
      Atomic
      "n is even"
      Unknown
  , Proposition
      "p_square_even"
      Atomic
      "n squared is even"
      Unknown
  , Proposition
      "imp_even_square"
      Conditional
      "If n is even, then n squared is even."
      Unknown
  , Proposition
      "universal_even_square"
      Universal
      "For every integer n, if n is even, then n squared is even."
      Unknown
  ]

derivation :: [DerivationStep]
derivation =
  [ DerivationStep
      "step_1"
      ["imp_even_square", "p_even"]
      ModusPonens
      "p_square_even"
      "The consequent follows only if the implication and antecedent are both available."
  , DerivationStep
      "step_2"
      ["universal_even_square"]
      UniversalInstantiation
      "imp_even_square"
      "The universal theorem is applied to an arbitrary integer n."
  , DerivationStep
      "step_3"
      ["imp_even_square"]
      Contrapositive
      "If n squared is not even, then n is not even."
      "In classical logic, an implication is equivalent to its contrapositive."
  ]

main :: IO ()
main = do
  putStrLn "Propositions:"
  mapM_ print propositions

  putStrLn "\nDerivation steps:"
  mapM_ print derivation

These examples show how formal inference can be represented computationally without reducing logic to code. The purpose is to make reasoning inspectable: statements, rules, derivations, counterexamples, and proof-status records can be organized as reproducible artifacts.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-thinking workspace focused on formal inference, logical connectives, quantifier patterns, truth tables, inference rules, derivation graphs, counterexample records, proof-system metadata, and formalization planning.

Back to top ↑

Logic, Formal Systems, and Responsible Use

Formal logic gives powerful tools for precision, verification, and accountability. But formal validity does not automatically guarantee real-world adequacy. A conclusion may follow from premises, while the premises themselves may be incomplete, biased, unjustified, or ethically inadequate. A system may satisfy a formal specification while the specification fails to protect affected people or communities.

This distinction matters in artificial intelligence, algorithmic governance, risk modeling, economics, engineering, medicine, public policy, and institutional decision-making. Formal inference can tell us what follows from encoded rules. It cannot by itself tell us whether the rules are fair, whether the variables are appropriate, whether the model captures lived reality, or whether the resulting decision is legitimate.

Responsible use of formal logic requires asking not only whether inference is valid, but whether the formalization is adequate:

• What assumptions have been encoded?
• What assumptions have been omitted?
• Does the formal system match the real-world context?
• Who is affected by the conclusions?
• Can the reasoning be inspected, challenged, or corrected?
• What uncertainty remains outside the formal model?

Logic should strengthen responsibility, not replace it. The discipline of formal inference teaches an important civic lesson: conclusions should be traceable, assumptions should be visible, and systems of reasoning should remain open to scrutiny.

Back to top ↑

Why Formal Inference Matters

Formal inference matters because it makes reasoning accountable. It clarifies what follows, what does not follow, what assumptions are being used, and which rules justify each step. In mathematics, this is the foundation of proof. In computer science, it supports programming languages, verification, type systems, and theorem proving. In philosophy, it clarifies argument. In AI, it offers tools for structured reasoning and evaluation. In public life, it provides a model of transparent justification.

The value of logic is not that it makes human judgment unnecessary. The value of logic is that it makes one part of judgment inspectable. When reasoning is formalized, we can examine its premises, rules, derivations, and conclusions. We can identify hidden assumptions, invalid transitions, missing cases, and unsupported claims. We can separate disagreement about facts from disagreement about inference.

Logic also teaches humility. Formal systems are powerful, but they have boundaries. Valid inference depends on premises. Verification depends on specifications. Proof systems depend on rules. Models depend on representation. A logically correct derivation can still be irrelevant if it answers the wrong question or formalizes the wrong reality.

Mathematical thinking requires both formal discipline and interpretive wisdom. Logic gives mathematics its structure of inference. Proof gives that structure its role in justification. Computation gives new tools for representing and checking formal systems. Responsibility ensures that formal clarity does not become moral blindness.

Logic is therefore one of the deep architectures of mathematical thought: the structure by which assumptions become conclusions, claims become theorems, and reasoning becomes accountable to form.

Back to top ↑

Related Articles

• What Is Mathematical Thinking? Pattern, Proof, Architecture, and Reason
• Proof and the Logic of Mathematical Justification
• Mathematics as the Science of Patterns
• Abstraction and the Power of Generalization
• Patterns, Structure, and the Mathematical Imagination
• Symbols, Language, and Mathematical Representation
• Algorithms, Proof, and Formal Reasoning
• Mathematical Thinking for Computer Science
• Mathematical Thinking and Proof Assistants
• Mathematical Thinking and AI-Assisted Discovery

Further Reading

• Barwise, J. and Etchemendy, J. (1999) Language, Proof and Logic. Stanford: CSLI Publications. Available at: https://web.stanford.edu/group/cslipublications/cslipublications/site/157586374X.shtml
• Enderton, H.B. (2001) A Mathematical Introduction to Logic. 2nd edn. Burlington, MA: Academic Press. Available at: https://www.elsevier.com/books/a-mathematical-introduction-to-logic/enderton/978-0-12-238452-3
• Hammack, R. (2018) Book of Proof. 3rd edn. Available at: https://www.people.vcu.edu/~rhammack/BookOfProof/
• Huth, M. and Ryan, M. (2004) Logic in Computer Science: Modelling and Reasoning about Systems. 2nd edn. Cambridge: Cambridge University Press. Available at: https://www.cambridge.org/highereducation/books/logic-in-computer-science/2F4D23E0C79E8F0E9FE7C6A3D2B6E3B4
• Troelstra, A.S. and Schwichtenberg, H. (2000) Basic Proof Theory. 2nd edn. Cambridge: Cambridge University Press. Available at: https://www.cambridge.org/core/books/basic-proof-theory/7B7AF49C98E55E3F81B69E6C981DE1DD
• Velleman, D.J. (2019) How to Prove It: A Structured Approach. 3rd edn. Cambridge: Cambridge University Press. Available at: https://www.cambridge.org/highereducation/books/how-to-prove-it/6D2965D625C6836CD4A785A2C843B3DA

Back to top ↑

References

• Barwise, J. and Etchemendy, J. (1999) Language, Proof and Logic. Stanford: CSLI Publications. Available at: https://web.stanford.edu/group/cslipublications/cslipublications/site/157586374X.shtml
• Enderton, H.B. (2001) A Mathematical Introduction to Logic. 2nd edn. Burlington, MA: Academic Press. Available at: https://www.elsevier.com/books/a-mathematical-introduction-to-logic/enderton/978-0-12-238452-3
• Girard, J.-Y., Lafont, Y. and Taylor, P. (1989) Proofs and Types. Cambridge: Cambridge University Press. Available at: https://www.paultaylor.eu/stable/prot.pdf
• Hammack, R. (2018) Book of Proof. 3rd edn. Available at: https://www.people.vcu.edu/~rhammack/BookOfProof/
• Huth, M. and Ryan, M. (2004) Logic in Computer Science: Modelling and Reasoning about Systems. 2nd edn. Cambridge: Cambridge University Press. Available at: https://www.cambridge.org/highereducation/books/logic-in-computer-science/2F4D23E0C79E8F0E9FE7C6A3D2B6E3B4
• Troelstra, A.S. and Schwichtenberg, H. (2000) Basic Proof Theory. 2nd edn. Cambridge: Cambridge University Press. Available at: https://www.cambridge.org/core/books/basic-proof-theory/7B7AF49C98E55E3F81B69E6C981DE1DD
• Velleman, D.J. (2019) How to Prove It: A Structured Approach. 3rd edn. Cambridge: Cambridge University Press. Available at: https://www.cambridge.org/highereducation/books/how-to-prove-it/6D2965D625C6836CD4A785A2C843B3DA

Back to top ↑