A syntactic proof system that derives conclusions from premises using formal rules of inference.

Semantic entailment means is true in every model where all of are true. A model (or interpretation) consists of a domain of objects plus assignments of meaning to all constants, functions, predicates, and variables. To verify semantic entailment directly, you’d need to check infinitely many such models.

Sequent calculus provides inference rules: patterns like “if you can prove and you can prove , then you can prove .” These rules depend only on formula structure, not meaning. You build a proof tree by repeatedly applying rules until you reach trivially true statements (axioms).

If the rules are sound (derived sequents are semantically valid) and complete (all semantic entailments are derivable), then:

Soundness

If you can build a valid proof tree from to using the inference rules, then actually holds in every model where all of holds. The rules don’t let you “prove” something that doesn’t follow.

Completeness

If is true in every model satisfying , then there exists some proof tree that derives from . No semantic truth escapes the proof system.

Gödel’s Completeness Theorem: First-order predicate logic has a proof calculus that is both sound and complete. No logic stronger than first-order can have both.

Undecidability

There is no algorithm that takes and , always terminates, and correctly outputs whether . (Related: halting problem, church-turing thesis)

We do get semidecidability: by completeness, if then a proof exists. Systematically enumerate all possible proof trees; if one exists, you eventually find it. But if , the search runs forever. You can’t distinguish “no proof exists” from “haven’t found it yet.”

ResultStatement
Completeness
UndecidabilityNo algorithm decides for all inputs
SemidecidabilityCan confirm , but can’t confirm
IncompletenessSome true arithmetic statements have no proof

Completeness and incompleteness aren’t contradictory: completeness says “every semantic consequence of your axioms is provable,” incompleteness says “in systems rich enough for arithmetic, some statements true in aren’t provable from the axioms.”

Why arithmetic? Because addition and multiplication let you encode formulas and proofs as numbers (Gödel numbering). The system becomes powerful enough to make statements about itself, including “this statement is not provable.” Systems too weak for arithmetic can’t self-reference this way, so they escape the incompleteness trap.


You build a proof tree by applying inference rules that break down complex formulas into simpler components. The goal is to reach axioms or trivially true sequents at the leaves.

In words: To prove a property holds for all natural numbers :
: Prove the base case, that holds for the smallest .
: Prove the inductive step, that for any arbitrary , if holds for , then it also holds for .
Then you can conclude holds for all .

The below is not a minimal but a practical set of inference rules; many rules can be derived from others.

Inference Rules

A sequent has the form:

where are the assumptions (what we know) and is the goal (what we want to prove). The turnstile separates them.


1. Closing Rules (rules with no premises - they “close” a branch)

These are your “base cases” - when you can stop and say “done.”

GoalAssum (GA):

If the goal is already among the assumptions, you’re done.

Example: — closed immediately, the goal is an assumption.


ContrAssum (CA):

If you have both and among assumptions, you can prove anything (contradiction).

Example: — closed, we have contradictory assumptions.


FalseAssum:

If (false) is among assumptions, you can prove anything.


2. Structural Rules

Drop:

You can always drop an assumption you don’t need. (Going top-down in your quiz: the premise has fewer assumptions.)


Cut:

To prove , first prove some intermediate statement , then prove using . This requires “an idea” for what should be.


Indirect:

Proof by contradiction: assume , derive a contradiction.


3. Connective Rules

For each connective, there’s typically:

  • A P-rule (prove it as a goal)
  • An A-rule (use it as an assumption)

Negation

P-¬:

To prove : assume and derive a contradiction.

Example: To prove , we’d need to show .


A-¬:

If you know and want to prove : assume and prove .

(This is a bit indirect - essentially a contraposition argument.)


Conjunction

P-∧:

To prove : prove AND prove (two branches).

Example:


A-∧:

If you have as assumption: you can split it into two separate assumptions and .

Example:


Disjunction

P-∨:

To prove : assume and prove . (Or symmetrically, assume and prove .)

Example:


A-∨:

Case distinction: if you know , prove in both cases (two branches).

Example:


Implication

P-→:

To prove : assume and prove .

Example:


A-→:

If you have as assumption: you need to prove (to “trigger” the implication), then you get to use.


Modus Ponens (MP): (common shortcut)

If you have both AND as assumptions, you get as a new assumption. Only one branch!

Example:


Modus Tollens (MT):

If you have and , you get .


Equivalence

P-↔:

To prove equivalence: prove both directions (two branches, each is an implication).


A-↔: (substitution)

If you have as assumption, you can replace occurrences of by (or vice versa) in assumptions or in the goal.


4. Equality Rules

P-=:

Any term equals itself - closed immediately.


A-=: (substitution)

If you have as assumption, you can replace occurrences of by (or vice versa) in assumptions or in the goal.


5. Quantifier Rules

This is where the quiz exercises get tricky. There are four rules, and the key distinction is:

GoalAssumption
Universal Skolemize (new constant)Instantiate (pick a term)
Existential Instantiate (pick a witness)Skolemize (new constant)

Notation: means “substitute for in ”. If and , then .


P-∀: (Skolemization)

where is a fresh Skolem constant not appearing anywhere else.

To prove “for all , holds”: introduce a new arbitrary constant and prove for that .

Example:

The is “arbitrary but fixed” - you can’t assume anything about it.


A-∀: (Instantiation)

where is some term built from available symbols.

If you have as assumption, you can instantiate it with any specific term to get as a new assumption. The stays available for more instantiations.

Example:

Here we instantiated with .


P-∃: (Instantiation - need a witness)

where is some term built from available symbols.

To prove : find a specific witness term and prove .

Example:

We “witnessed” the existence with .


A-∃: (Skolemization)

where is a fresh Skolem constant not appearing anywhere else (including in !).

If you have as assumption: introduce a new constant representing “some that satisfies ”, and add as assumption. The existential disappears (you can only skolemize it once).

Example:


RuleWhen to useEffect
GAGoal is an assumptionClose branch
CA and both assumptionsClose branch
P-∧Goal is Split into two branches
A-∧Assumption is Get both and
P-∨Goal is Assume , prove
A-∨Assumption is Case split (two branches)
P-→Goal is Assume , prove
MPHave and Get
P-∀Goal is New constant , prove
A-∀Assumption is Pick term , get
P-∃Goal is Pick witness , prove
A-∃Assumption is New constant , get