Struttura della lezione

• Riprendiamo la dimostrazione per induzione della Lezione 6.
• Dimostriamo proprietà generali della somma.
• Introduciamo il semplificatore simp.
• Combiniamo induzione, riscrittura e semplificazione.
• Applichiamo questi strumenti alla verifica di un algoritmo.

Ripasso: definizioni e risultati disponibili

Usiamo nuovamente il tipo Naturale, la somma ricorsiva sul secondo argomento e il doppio.

Dalla Lezione 6 abbiamo:

• somma m zero = m.
• somma m (succ n) = succ (somma m n).
• doppio (succ n) = succ (succ (doppio n)).
• somma zero n = n.

Esercizio: il successore nella somma

Vogliamo dimostrare:

lecture07_succ_somma (m n : Naturale) :

somma (succ m) n = succ (somma m n).

• Su quale argomento ricorre la definizione di somma?
• Su quale variabile conviene quindi fare induzione?

Associatività

L'associatività dice che il modo di raggruppare tre addendi non cambia il risultato:

lecture07_somma_assoc (a b c : Naturale) :

somma (somma a b) c = somma a (somma b c).

Scegliamo c perché occupa il secondo argomento della somma esterna a sinistra.

Risultati disponibili per le dimostrazioni

Possiamo ora usare con rw:

• lecture07_somma_zero_destra (m : Naturale) : somma m zero = m.
• lecture07_somma_succ_destra (m n : Naturale) : somma m (succ n) = succ (somma m n).
• lecture07_zero_somma (n : Naturale) : somma zero n = n.
• lecture07_succ_somma (m n : Naturale) : somma (succ m) n = succ (somma m n).
• lecture07_doppio_succ (n : Naturale) : doppio (succ n) = succ (succ (doppio n)).

Commutatività

La commutatività dice che scambiare i due addendi non cambia il risultato:

lecture07_somma_comm (a b : Naturale) : somma a b = somma b a.

Facciamo induzione su b. A sinistra è il secondo argomento di somma, mentre a destra è il primo. Useremo quindi anche succ_somma.

Che cosa fa simp?

simp semplifica applicando equazioni orientate e svolgendo computazioni elementari.

• rw indica una precisa riscrittura.
• simp only [lemmi] usa soltanto i lemmi elencati.
• simp [lemmi] aggiunge quei lemmi alle regole standard.

Controllare il simp-set

Il simp-set è l'insieme delle regole disponibili al semplificatore.

• simp [lemma] aggiunge una regola per quel comando.
• attribute [local simp] lemma la rende disponibile nella sezione corrente.
• @[simp] la registra per il resto del modulo.

Associatività e commutatività non indicano da sole una forma più semplice. Quando servono, le applichiamo con rw nella direzione desiderata.

Risultati per la dimostrazione conclusiva

Useremo:

• somma m (succ n) = succ (somma m n).
• doppio (succ n) = succ (succ (doppio n)).

Esercizio conclusivo

Vogliamo dimostrare che il doppio di una somma è la somma dei doppi:

lecture07_doppio_somma (m n : Naturale) :

doppio (somma m n) = somma (doppio m) (doppio n).

• Su quale variabile conviene fare induzione?

Dalla matematica alla verifica del software

Un programma riceve un input e produce un output. Per verificarlo:

• definiamo con precisione il programma.
• formuliamo una proprietà attesa del risultato, cioè la specifica formale.
• dimostriamo che la proprietà vale per ogni input possibile.

Gli esempi non bastano: possono mostrare un errore, ma non coprono tutti gli input. Una dimostrazione universale fornisce invece una garanzia generale.

Un tipo induttivo per le liste

Una lista di elementi di tipo α può essere costruita in due modi:

• vuota: la lista senza elementi.
• cons x xs: un elemento x seguito da una lista xs.

inductive Lista (α : Type) where

| vuota

| cons (testa : α) (coda : Lista α)

Fonti

Avigad, de Moura, Kong e Ullrich, Theorem Proving in Lean 4, Inductive Types

Avigad, de Moura, Kong e Ullrich, Theorem Proving in Lean 4, Induction and Recursion

Avigad, de Moura, Kong e Ullrich, Theorem Proving in Lean 4, Tactics

Christiansen, Functional Programming in Lean, Datatypes and Patterns

Lean project, The Lean Language Reference, Recursive Definitions

Buzzard e Eugster, Natural Number Game

VU Amsterdam, Logical Verification

Huisman e Wijs, Concise Guide to Software Verification: From Model Checking to Annotation Checking

Chockler, Halpern e Kupferman, What Causes a System to Satisfy a Specification?