Curry-Howard e programmi da prove non costruttive

Questa è una domanda di follow-up a

Qual è la differenza tra prove e programmi (o tra proposizioni e tipi)?

Quale programma corrisponderebbe a una dimostrazione non costruttiva (classica) della forma $\forall k \ T(e,k) \lor \lnot \forall k \ T(e,k)$ ? (Supponiamo che $T$ sia una relazione decidibile interessante, ad esempio $e$ -th TM non si ferma in $k$ passi.)

(ps: sto postando questa domanda in parte perché sono interessato a saperne di più su ciò che Neel intende per " la traduzione Godel-Gentzen è una trasformazione che passa di seguito" nel suo commento .)

lo.logic pl.programming-languages proof-theory

— Kaveh
fonte

Risposta parziale a pagina 2 di queste note di lezione . È un po 'enigmatico; Proverò a scavare qualcosa di più completo.

— Dave Clarke

Mi ci vuole un po 'più del previsto per scrivere la mia risposta, dal momento che ho fatto l'errore di decidere di provare le cose che sapevo piuttosto che affermarle. :)

— Neel Krishnaswami il

La JSL più recente aveva questo articolo . L'essenza è che il contenuto computazionale delle prove classiche può dipendere fortemente da come hai scelto di estrarlo. Non l'ho ancora digerito, ma ho pensato di buttarlo lì.

— Mark Reitblatt

Ma hai specificato che T è una relazione decidibile , quindi ne consegue che ci sono prove costruttive della tua proposizione. La logica classica è un sottoinsieme della logica intuizionista e hai specificato che T appartiene a quel sottoinsieme chiamandolo decidibile.

— scricciolo romano

wren, questo è quello che ho pensato anche all'inizio! Ma la proposizione P nell'esempio P \ / ~ P nella domanda se effettivamente quantificata su tutto k, e questa quantificazione di T non è necessariamente decidibile.

— jbapple

Risposte:

Questa è una domanda interessante. Ovviamente non ci si può aspettare di avere un programma che decida per ogni se valga o meno, poiché ciò determinerebbe il problema dell'arresto. Come già accennato, esistono diversi modi per interpretare le prove in modo computazionale: estensioni di Curry-Howard, realizzabilità, dialettica e così via. Ma tutti interpreterebbero computazionalmente il teorema che hai citato più o meno nel modo seguente. $e$ $\forall k T(e, k)$

Per semplicità considera l'equivalente teorema classico

(1) $\exists i \forall j (\neg T(e, j) \to \neg T(e, i))$

Questo è (costruttivamente) equivalente a quello menzionato perché dato possiamo decidere se vale o meno semplicemente controllando il valore di . Se vale quindi e quindi . Se d'altra parte $i$ $\forall k T(e, k)$ $\neg T(e, i)$ $\neg T(e, i)$ $\exists i \neg T(e, i)$ $\neg \forall i T(e, i)$ non regge quindi da (1) abbiamo che implica . $\neg T(e, i)$ $\forall j (\neg T(e, j) \to \bot)$ $\forall j T(e, j)$

Ora, di nuovo, non possiamo calcolare in (1) per ogni data perché risolveremmo nuovamente il problema di Halting. Ciò che farebbero tutte le interpretazioni sopra menzionate è guardare al teorema equivalente $i$ $e$

(2) $\forall f \exists i' (\neg T(e, f(i')) \to \neg T(e, i'))$

La funzione è chiamata funzione Herbrand. Cerca di calcolare un contro esempio per ogni dato testimone potenziale . È chiaro che (1) e (2) sono equivalenti. Da sinistra a destra questo è costruttivo, basta prendere in (2), dove è il presunto testimone di (1). Da destra a sinistra bisogna ragionare in modo classico. Assumere (1) non era vero. Poi, $f$ $j$ $i$ $i' = i$ $i$

(3) $\forall i \exists j \neg (\neg T(e, j) \to \neg T(e, i))$

Lascia che sia una funzione testimone di questo, cioè $f'$

(4) $\forall i \neg (\neg T(e, f'(i)) \to \neg T(e, i))$

Ora, prendi in (2) e abbiamo , per alcuni . Ma prendendo in (4) otteniamo la negazione di ciò, contraddizione. Quindi (2) implica (1). $f = f'$ $(\neg T(e, f'(i')) \to \neg T(e, i'))$ $i'$ $i = i'$

Quindi, abbiamo che (1) e (2) sono classicamente equivalenti. Ma la cosa interessante è che (2) ha ora una testimonianza costruttiva molto semplice. Prendi semplicemente se non regge, perché allora la conclusione di (2) è vera; oppure prendere se vale, perché allora $i' = f(0)$ $T(e, f(0))$ $i' = 0$ $T(e, f(0))$ non regge e la premessa di (2) è falsa, rendendola nuovamente vera. $\neg T(e, f(0))$

Quindi, il modo di interpretare computazionalmente un teorema classico come (1) è guardare a una formulazione (classicamente) equivalente che può essere dimostrata in modo costruttivo, nel nostro caso (2).

Le diverse interpretazioni sopra menzionate differiscono solo nel modo in cui viene visualizzata la funzione . Nel caso della realizzabilità e dell'interpretazione dialettica, ciò è esplicitamente dato dall'interpretazione, quando combinata con una qualche forma di traduzione negativa (come quella di Goedel-Gentzen). Nel caso di estensioni Curry-Howard con operatori chiamata-cc e continuazione della funzione deriva dal fatto che il programma è autorizzato a "sapere" come un certo valore (nel nostro caso verrà utilizzato), quindi è la continuazione del programma intorno al punto in cui è calcolata. $f$ $f$ $i$ $f$ $i$

Un altro punto importante è che vuoi che il passaggio da (1) a (2) sia "modulare", cioè se (1) è usato per provare (1 '), allora la sua interpretazione (2) dovrebbe essere usata in modo simile per dimostrare l'interpretazione di (1 '), dire (2'). Tutte le interpretazioni sopra menzionate lo fanno, inclusa la traduzione negativa di Goedel-Gentzen.

— Paulo
fonte

Benvenuto! È bello vedere qui un teorico della prova esperta.

— Neel Krishnaswami,

Grazie Paulo, la tua risposta ha chiarito una parte dell'immagine in un problema correlato su cui sto lavorando.

— Kaveh,

È abbastanza noto che l'aritmetica classica e intuizionista sono equi e coerenti.

$\phi$

\begin{array}{lcl} G (⊤) & = & \neg \neg ⊤ \\ G (ϕ \land ψ) & = & \neg \neg (G (ϕ) \land G (ψ)) \\ G (⊥) & = & \neg ⊤ \\ G (\neg ϕ) & = & \neg G (ϕ) \\ G (ϕ \lor ψ) & = & \neg (\neg G (ϕ) \land \neg G (ψ)) \\ G (\forall x . ϕ) & = & \forall x . \neg \neg G (ϕ) \\ G (\exists x . ϕ) & = & \neg \forall x . \neg (G (ϕ)) \\ G (P) & = & \neg \neg P \end{array}

$\begin{array}{lcl} G(\top) & = & \lnot\lnot\top \\ G(\phi \land \psi) & = & \lnot\lnot(G(\phi) \land G(\psi)) \\ G(\bot) & = & \lnot\top \\ G(\lnot\phi) & = & \lnot G(\phi) \\ G(\phi \vee \psi) & = & \lnot(\lnot G(\phi) \land \lnot G(\psi)) \\ G(\forall x.\;\phi) & = & \forall x.\; \lnot\lnot G(\phi) \\ G(\exists x.\;\phi) & = & \lnot \forall x.\; \lnot(G(\phi)) \\ G(P) & = & \lnot\lnot P \\ \end{array}$

$G(\phi)$

$G(\phi)$ $\phi$

$\forall, \implies, \land, \lnot$

\begin{array}{lcl} A, B & ::= & \forall x . A (x) | A ⟹ B | A \land B | \neg A | \neg \neg P \end{array}

$\newcommand{\bnfalt}{\;\;|\;\;} \begin{array}{lcl} A,B & ::= & \forall x.\;A(x) \bnfalt A \implies B \bnfalt A \land B \bnfalt \lnot A \bnfalt \lnot\lnot P \end{array}$

$A$ $G(A) \implies A$

Quindi, come dovresti pensarci in modo intuitivo?

$\exists$ $\vee$ $\forall$
$\lnot\lnot\lnot P = \lnot P$

Ora, grazie a Curry-Howard, sappiamo come interpretare le prove nella logica intuizionistica come programmi funzionali. Quindi, una possibile risposta (ma non l'unica) alla domanda "qual è il contenuto costruttivo di una dimostrazione classica?" è il seguente:

Il contenuto computazionale di una prova classica è qualunque sia il contenuto computazionale della traduzione della sua prova (secondo la traduzione negativa).

$G(A \vee \lnot A) = \lnot(\lnot G(A) \land \lnot\lnot G(A))$ $\lnot P$ $\lnot\lnot P$

$\lnot A == A \implies \bot$ $((G(A) \implies \bot) \land ((G(A) \implies \bot) \implies \bot)) \implies \bot$

type bot = Void of bot
type 'a not = 'a -> bot

let excluded_middle : ('a not * 'a not not) not = fun (u, k) -> k u

Cioè, se ottieni non-A e non-non-A, puoi semplicemente passare la prima negazione alla seconda per derivare la contraddizione che desideri.

Ora, che cos'è una continuazione trasformazioni di stile di passaggio?

$\tau$ $\tau$
$3+5$ $C[3+5]$ $3 + 5$
$\tau$ $\tau \to \alpha$ $\alpha$
$e$ $\tau$ $(\tau \to \alpha) \to \alpha$ $e$
Ma dobbiamo farlo in modo ereditario, in modo che ogni sotterfugio del programma abbia reso esplicita la sua continuazione.

Adesso,

$\phi$ $\lnot\lnot\phi$
Tuttavia, mentre la nostra traduzione usa la negazione, non elimina mai realmente la falsa proposizione, quindi la traduzione funziona parametricamente in quella proposizione.
$\bot$ $\alpha$
$\phi$ $(\phi \to \alpha) \to \alpha$
Questa è una trasformazione CPS.

Ho visto una "trasformazione" in CPS, poiché come ho già detto in precedenza, ci sono molte traduzioni negative che ti consentono di dimostrare questo teorema, e ognuna corrisponde a una diversa trasformazione CPS. In termini operativi, ogni trasformazione corrisponde a un diverso ordine di valutazione . Quindi non esiste un'interpretazione computazionale unica della logica classica, dal momento che hai delle scelte da fare e le differenze scelte hanno caratteristiche operative molto diverse.

— Neel Krishnaswami
fonte

Questa è un'ottima risposta Mi ha ricordato il documento di Wadler "Call-by-value è doppio al call-by-name": homepages.inf.ed.ac.uk/wadler/topics/call-by-need.html , che include un aneddoto davvero memorabile nella sezione 4 per spiegare la relazione tra callCC e il centro escluso.

— sclv,

Ci sono intere conferenze sull'argomento delle prove non costruttive come programmi e io non sono un esperto in materia. Sopra, Neel Krishnaswami ha accennato a una risposta più lunga che sta preparando, che, a giudicare dal suo lavoro qui, sarà eccellente. Questo è solo un assaggio di una risposta.

$\forall P, P \lor \lnot P$

Set Implicit Arguments.

Axiom callcc : forall (A B : Set), ((A -> B) -> A) -> A.

Lemma lem : forall (A B:Set), sum A (A -> B).
Proof.
  intros.
  eapply callcc.
  intros H.
  right.
  intros.
  apply H.
  left.
  assumption.
Defined.

Recursive Extraction lem.

dà il codice O'Caml:

type ('a, 'b) sum =
  | Inl of 'a
  | Inr of 'b

(** val callcc : (('a1 -> 'a2) -> 'a1) -> 'a1 **)

let callcc =
  failwith "AXIOM TO BE REALIZED"

(** val lem : ('a1, 'a1 -> no) sum **)

let lem =
    callcc (fun h -> Inr (fun h0 -> h (Inl h0)))

La più chiara introduzione a ciò che ho visto è nella "Nozione di controllo di formule come tipi di controllo" di Tim Griffin .

— jbapple
fonte

Dovresti provare a estrarre in Scheme e dire che la procedura di estrazione dovrebbe estrarre il tuo callccda Scheme callcc. Quindi puoi davvero provare le cose.

— Andrej Bauer,