Lezione 2: Proposizioni, dimostrazioni e regole logiche

Registrazione video della Lezione 2

1. Scopo della lezione

Questa lezione riprende il ruolo del kernel e del typechecker, poi introduce il modo in cui Lean legge proposizioni e dimostrazioni. Il punto centrale è la corrispondenza tra proposizioni e tipi: una proposizione P : Prop è un tipo, e una dimostrazione di P è un termine che abita quel tipo Theorem Proving in Lean 4, Propositions and Proofs.

Valuteremo esempi minimali per osservare, nel proof state, le regole di introduzione ed eliminazione dei connettivi logici e di alcuni costrutti specifici:

implicazione P → Q;
congiunzione P ∧ Q;
disgiunzione P ∨ Q;
negazione ¬P;
False.

2. Kernel e typechecker

Abbiamo visto che Lean permette di costruire dimostrazioni con tattiche, supporto di librerie, e tramite interfacce interattive. Questi strumenti aiutano l'utente, ma in ultima analisi, il kernel controlla l'oggetto formale prodotto e verifica che abbia il tipo richiesto de Moura and Ullrich, Lean 4.

Il typechecker controlla se un termine ha un certo tipo. Nelle dimostrazioni, il tipo atteso è la proposizione che vogliamo dimostrare. Un teorema viene accettato quando Lean riesce a controllare il termine di dimostrazione rispetto all'enunciato. Per questo, dal punto di vista del sistema, dimostrare significa costruire un termine ben tipato.

Questa prospettiva spiega perché il proof state è così utile. Il goal mostra il tipo che dobbiamo abitare. Le assunzioni mostrano i termini già disponibili nel contesto. Una tattica è un modo interattivo per trasformare questa situazione fino a chiudere tutti i goal.

3. Proposizioni come tipi

In Lean, P : Prop dice che P è una proposizione. Se nel contesto compare hP : P, allora hP è una dimostrazione di P. Non è solo un'etichetta informale: è un oggetto formale che può essere usato per costruire altre dimostrazioni.

L'implicazione è l'esempio più diretto. Un termine di tipo P → Q si comporta come una funzione: prende una dimostrazione di P e restituisce una dimostrazione di Q. Se abbiamo

hPQ : P → Q
hP : P

allora hPQ hP è una dimostrazione di Q.

4. Regole di introduzione ed eliminazione

Per ogni connettivo logico distinguiamo due domande.

La regola di introduzione spiega come costruire una dimostrazione della proposizione composta.
La regola di eliminazione spiega come usare una dimostrazione della proposizione composta per ottenerne delle componenti.

Guardare il goal significa chiedersi quale regola di introduzione può costruirlo. Guardare le assunzioni significa chiedersi quale regola di eliminazione può usarle. Questa terminologia segue la presentazione standard delle regole di deduzione naturale Logic and Proof, Natural Deduction Rules.

5. Implicazione

Per introdurre P → Q, assumiamo temporaneamente P e costruiamo Q.

-- Leggere i connettivi attraverso le loro regole di introduzione ed eliminazione.

-- Introduzione dell'implicazione.
-- Per dimostrare `P → Q`, assumiamo temporaneamente `P` e costruiamo `Q`.
-- Regola: se assumendo P riusciamo a dimostrare Q, allora abbiamo P → Q.
theorem lecture02_imp_intro (P Q : Prop) (hQ : Q) :
    P → Q := byP:PropQ:ProphQ:Q⊢ P → Q
  intro hPP:PropQ:ProphQ:QhP:P⊢ Q
  -- hP : P è l'assunzione temporanea introdotta dalla regola.
  exact hQAll goals completed! 🐙

La riga intro hP introduce l'assunzione temporanea hP : P. In questo esempio la conclusione Q è già disponibile come hQ, quindi possiamo chiudere il goal con exact hQ.

Per eliminare P → Q, applichiamo l'implicazione a una dimostrazione di P.

-- Eliminazione dell'implicazione.
-- Regola: da P → Q e P otteniamo Q. Questo è il modus ponens.
theorem lecture02_imp_elim (P Q : Prop) :
    (P → Q) → P → Q := byP:PropQ:Prop⊢ (P → Q) → P → Q
  intro hPQP:PropQ:ProphPQ:P → Q⊢ P → Q
  intro hPP:PropQ:ProphPQ:P → QhP:P⊢ Q
  have hQ := hPQ hPP:PropQ:ProphPQ:P → QhP:PhQ:Q⊢ Q
  exact hQAll goals completed! 🐙

Qui hPQ hP è applicazione di funzione: da P → Q e P otteniamo Q. Siamo di nuovo al modus ponens!

6. Congiunzione

Una congiunzione P ∧ Q contiene entrambe le informazioni. Per introdurla, dobbiamo fornire una dimostrazione di entrambe le componenti (qui sotto le abbiamo inserite come assunzioni nell'enunciato).


theorem lecture02_and_intro (P Q : Prop) (hP : P) (hQ : Q) :
    P ∧ Q := byP:PropQ:ProphP:PhQ:Q⊢ P ∧ Q
  -- Regola di introduzione: da P e Q otteniamo P ∧ Q.
  have hPAndQ := And.intro hP hQP:PropQ:ProphP:PhQ:QhPAndQ:P ∧ Q⊢ P ∧ Q
  exact hPAndQAll goals completed! 🐙

La stessa regola And.intro può essere usata come tattica. Il goal P ∧ Q si divide in due subgoal, uno per P e uno per Q.

theorem lecture02_and_intro_with_apply (P Q : Prop) (hP : P) (hQ : Q) :
    P ∧ Q := byP:PropQ:ProphP:PhQ:Q⊢ P ∧ Q
  -- Stessa regola, usando esplicitamente il costruttore come tattica. Notare qui la creazione di più subgoals.
  apply And.introleftP:PropQ:ProphP:PhQ:Q⊢ PrightP:PropQ:ProphP:PhQ:Q⊢ Q
  ·leftP:PropQ:ProphP:PhQ:Q⊢ P exact hPAll goals completed! 🐙
  ·rightP:PropQ:ProphP:PhQ:Q⊢ Q exact hQAll goals completed! 🐙

Per eliminare una congiunzione usiamo le sue componenti, e preleviamo il congiunto sulla sinistra/destra.

theorem lecture02_and_elim_left (P Q : Prop) :
    P ∧ Q → P := byP:PropQ:Prop⊢ P ∧ Q → P
  intro hPAndQP:PropQ:ProphPAndQ:P ∧ Q⊢ P
  -- Regola di eliminazione sinistra: da P ∧ Q otteniamo P.
  exact hPAndQ.leftAll goals completed! 🐙

theorem lecture02_and_elim_right (P Q : Prop) :
    P ∧ Q → Q := byP:PropQ:Prop⊢ P ∧ Q → Q
  intro hPAndQP:PropQ:ProphPAndQ:P ∧ Q⊢ Q
  -- Regola di eliminazione destra: da P ∧ Q otteniamo Q.
  exact hPAndQ.rightAll goals completed! 🐙

7. Disgiunzione

Una disgiunzione P ∨ Q contiene una delle due informazioni. Per introdurla, basta fornire uno dei due lati (con Or.inl/inr: injection left/right).


theorem lecture02_or_intro_left (P Q : Prop) :
    P → P ∨ Q := byP:PropQ:Prop⊢ P → P ∨ Q
  intro hPP:PropQ:ProphP:P⊢ P ∨ Q
  -- Regola di introduzione sinistra: da P otteniamo P ∨ Q.
  exact Or.inl hPAll goals completed! 🐙

theorem lecture02_or_intro_right (P Q : Prop) :
    Q → P ∨ Q := byP:PropQ:Prop⊢ Q → P ∨ Q
  intro hQP:PropQ:ProphQ:Q⊢ P ∨ Q
  -- Regola di introduzione destra: da Q otteniamo P ∨ Q.
  exact Or.inr hQAll goals completed! 🐙

Per eliminare una disgiunzione dobbiamo ragionare per casi. Se abbiamo P ∨ Q, non sappiamo in generale quale lato sia disponibile (in altri termini, non sappiamo se la disgiunzione sia vera per via di P o di Q). Per ottenere una conclusione dobbiamo produrla in entrambi i rami: se riusciamo a concludere la stessa proposizione sia nel caso in cui sia P a essere vero, sia nel caso in cui lo sia Q, allora possiamo eliminare la disgiunzione. In questo caso, vogliamo concludere che Q ∨ P da P ∨ Q: dobbiamo quindi ragionare valutando i due casi, P è vero oppure Q è vero, e per entrambi dimostrare che riusciamo a concludere Q ∨ P.

theorem lecture02_or_elim (P Q : Prop) :
    P ∨ Q → Q ∨ P := byP:PropQ:Prop⊢ P ∨ Q → Q ∨ P
  intro hPOrQP:PropQ:ProphPOrQ:P ∨ Q⊢ Q ∨ P
  -- Regola di eliminazione: da P ∨ Q dobbiamo trattare il caso P e il caso Q. In ciascuno di questi due casi dobbiamo dimostrare lo stesso goal (Q ∨ P nella fattispecie).
  cases hPOrQ with
  | inl hP =>inlP:PropQ:ProphP:P⊢ Q ∨ P
      -- Caso 1: abbiamo una dimostrazione di P.
      exact Or.inr hPAll goals completed! 🐙
  | inr hQ =>inrP:PropQ:ProphQ:Q⊢ Q ∨ P
      -- Caso 2: abbiamo una dimostrazione di Q.
      exact Or.inl hQAll goals completed! 🐙

La stessa struttura si può scrivere con Or.elim.

theorem lecture02_or_elim_with_or_elim (P Q : Prop) :
    P ∨ Q → Q ∨ P := byP:PropQ:Prop⊢ P ∨ Q → Q ∨ P
  intro hPOrQP:PropQ:ProphPOrQ:P ∨ Q⊢ Q ∨ P
  -- `Or.elim` è la stessa regola: una dimostrazione per il caso P e una per il caso Q. Notare come si modifica il goal.
  apply Or.elim hPOrQleftP:PropQ:ProphPOrQ:P ∨ Q⊢ P → Q ∨ PrightP:PropQ:ProphPOrQ:P ∨ Q⊢ Q → Q ∨ P
  ·leftP:PropQ:ProphPOrQ:P ∨ Q⊢ P → Q ∨ P intro hPleftP:PropQ:ProphPOrQ:P ∨ QhP:P⊢ Q ∨ P
    exact Or.inr hPAll goals completed! 🐙
  ·rightP:PropQ:ProphPOrQ:P ∨ Q⊢ Q → Q ∨ P intro hQrightP:PropQ:ProphPOrQ:P ∨ QhQ:Q⊢ Q ∨ P
    exact Or.inl hQAll goals completed! 🐙

8. False e negazione

False rappresenta uno stato contraddittorio. Se abbiamo una dimostrazione di False, possiamo chiudere qualunque goal.

theorem lecture02_false_elim (P : Prop) :
    False → P := byP:Prop⊢ False → P
  intro hFalseP:ProphFalse:False⊢ P
  -- Stessa regola, usando `exact`.
  exact False.elim hFalseAll goals completed! 🐙

In Lean la negazione è definita come implicazione verso False: ¬P significa P → False. Per eliminare una negazione, la applichiamo a una dimostrazione positiva di P.

-- Vediamo ora la forma che la negazione assume in Lean. Come dimostriamo che P e la sua negazione producono una contraddizione?
theorem lecture02_not_elim (P : Prop) :
    P → ¬P → False := byP:Prop⊢ P → ¬P → False
  intro hPP:ProphP:P⊢ ¬P → False
  intro hNonPP:ProphP:PhNonP:¬P⊢ False
  -- Regola di eliminazione: P e ¬P producono False.
  exact hNonP hPAll goals completed! 🐙

Per introdurre ¬P, assumiamo temporaneamente P e deriviamo False. Il seguente esempio è lo schema di ragionamento del modus tollens. intro hP svolge la seguente funzione: per dimostrare ¬P, assumiamo P e deriviamo False (una contraddizione). Osservate come cambia il goal:

-- Come è fatto ¬P? Equivale a P → False. Vediamolo con un esempio:
theorem lecture02_not_intro (P Q : Prop) :
    (P → Q) → ¬Q → ¬P := byP:PropQ:Prop⊢ (P → Q) → ¬Q → ¬P
  intro hPQP:PropQ:ProphPQ:P → Q⊢ ¬Q → ¬P
  intro hNonQP:PropQ:ProphPQ:P → QhNonQ:¬Q⊢ ¬P
  -- Regola di introduzione: per dimostrare ¬P, assumiamo P e deriviamo False (una contraddizione). Osservare come cambia il goal
  intro hPP:PropQ:ProphPQ:P → QhNonQ:¬QhP:P⊢ False
  have hQ := hPQ hPP:PropQ:ProphPQ:P → QhNonQ:¬QhP:PhQ:Q⊢ False
  exact hNonQ hQAll goals completed! 🐙

9. Tattiche, comandi e scorciatoie

In questa lezione abbiamo usato soprattutto tattiche che corrispondono alle regole di introduzione ed eliminazione dei connettivi.

intro: introduce un'assunzione temporanea quando il goal è un'implicazione o una negazione;
exact: chiude il goal fornendo un termine del tipo richiesto;
have: introduce un risultato intermedio nel contesto;
apply: applica una regola, un teorema o un costruttore al goal corrente;
cases: distingue i casi di una disgiunzione.

Abbiamo inoltre usato alcuni costruttori ed eliminatori espliciti:

And.intro, .left, .right per la congiunzione;
Or.inl, Or.inr, Or.elim per la disgiunzione;
False.elim per usare una contraddizione.

10. Esercizi e soluzioni

Trovate i file con esercizi e soluzioni (Exercises.lean e Solutions.lean) sul sito di riferimento.

11. Fonti e letture

Jeremy Avigad, Leonardo de Moura, Soonho Kong, Sebastian Ullrich, Theorem Proving in Lean 4, capitolo "Propositions and Proofs": https://lean-lang.org/theorem_proving_in_lean4/Propositions-and-Proofs/.
Jeremy Avigad, Robert Y. Lewis, Floris van Doorn, Logic and Proof, appendice "Natural Deduction Rules": https://leanprover.github.io/logic_and_proof_lean3/nd_quickref.html.
Leonardo de Moura and Sebastian Ullrich, "The Lean 4 Theorem Prover and Programming Language": https://lean-lang.org/papers/lean4.pdf.