L'equivalenza eta per le funzioni è compatibile con l'operazione seq di Haskell?

Lemma: Supponendo che eta-equivalenza lo abbiamo (\x -> ⊥) = ⊥ :: A -> B.

Prova: ⊥ = (\x -> ⊥ x)per eta-equivalenza e (\x -> ⊥ x) = (\x -> ⊥)per riduzione sotto la lambda.

Il rapporto Haskell 2010, sezione 6.2 specifica la seqfunzione con due equazioni:

seq :: a -> b -> b
seq ⊥ b = ⊥
seq ab = b, se a ≠ ⊥

Quindi afferma "Di conseguenza, ⊥ non è uguale a \ x -> ⊥, poiché seq può essere usato per distinguerli".

La mia domanda è: è davvero una conseguenza della definizione di seq?

L'argomento implicito sembra essere che seqsarebbe incontestabile se seq (\x -> ⊥) b = ⊥. Tuttavia non sono stato in grado di dimostrare che un simile seqsarebbe impensabile. Mi sembra che seqsia sia monotono, sia continuo, il che lo mette nel regno dell'essere calcolabile.

Un algoritmo che implementa come seq potrebbe funzionare tentando di cercare alcuni xdove f x ≠ ⊥elencando il dominio che finizia con ⊥. Anche se una tale implementazione, anche se possibile, diventa piuttosto pelosa una volta che vogliamo fare seqpolimorfica.

C'è una prova che non v'è calcolabile seqche identifica (\x -> ⊥)con ⊥ :: A -> B? In alternativa, c'è qualche costruzione seqche si identifica (\x -> ⊥)con ⊥ :: A -> B?

Innanzitutto, cerchiamo di essere espliciti su come si seqdistingue da λ x . ⊥ :$\bot$$\lambda x . \bot$

bottom :: a
bottom = bottom

eta :: a -> b
eta x = bottom

-- This terminates
fortytwo = seq eta 42

-- This does not terminate
infinity = seq bottom 42

È quindi un fatto sperimentale che in Haskell e λ x . ⊥ sono distinguibili dal punto di vista operativo. È anche un dato di fatto, e abbastanza ovvio, calcolabile perché Haskell lo calcola. Tanto su Haskell. Stai chiedendo del fraseggio molto particolare della documentazione di Haskell. L'ho letto dicendo che dovrebbe soddisfare le due equazioni date, ma quelle due equazioni non sono sufficienti per la definizione di . Ecco perché: posso darti due modelli di (semplicemente digitati) $\bot$$\lambda x . \bot$seqseqseq$\lambda$ -calculus in cui seqè calcolabile e soddisfa le equazioni date, ma in uno dei modelli e λ x . $\bot$$\lambda x . \bot$ d'accordo, mentre nell'altro no.

In un semplice modello teorico-dominio in cui le espressioni sono interpretate nel dominio delle funzioni continue [ D → E ] abbiamo ⊥ = λ x . ⊥ , ovviamente. Prendi domini Scott efficaci o qualcosa del genere per rendere tutto calcolabile. È facile da definire in un tale modello.$\lambda$$[D \to E]$$\bot = \lambda x . \bot$seq

Possiamo anche avere un modello di -calculus in cui distingue ⊥ e λ x . ⊥ , e quindi ovviamente η -rule non può contenere. Ad esempio, possiamo farlo interpretando le funzioni nel dominio [ D → E ] ⊥ , vale a dire il dominio dello spazio delle funzioni con un ulteriore fondo collegato. Ora ⊥ è, beh, il fondo di [ D → E ] ⊥ , mentre λ x . ⊥ è l'elemento appena sopra di esso. Non possono essere distinti dall'applicazione perché entrambi valutano$\lambda$seq$\bot$$\lambda x . \bot$$\eta$$[D \to E]_\bot$$\bot$$[D \to E]_\bot$$\lambda x . \bot$ , indipendentemente da cosa li applichi (sonoestensivamente uguali). Ma abbiamouna mappa tra domini e sempre distingue il fondo da tutti gli altri elementi.$\bot$seq

Si noti che la specifica per seqcui si cita è non sua definizione. Per citare il rapporto di Haskell "La funzione seq è definita dalle equazioni : [e quindi dalle equazioni fornite]".

L'argomento suggerito sembra essere che seq sarebbe imputabile se seq (\ x -> ⊥) b = ⊥.

Tale comportamento violerebbe le specifiche di seq.

È importante sottolineare che, da allora seq è polimorfico, seqnon può essere definito in termini di decostruttori (proiezioni / corrispondenza dei modelli, ecc.) Su uno dei due parametri.

Esiste una prova che non esiste un seq calcolabile che identifichi (\ x -> ⊥) con ⊥ :: A -> B?

Se seq' (\x -> ⊥) b, uno potrebbe pensare che potremmo applicare il primo parametro (che è una funzione) ad un certo valore e quindi uscire ⊥. Tuttavia, seqnon può mai identificare il primo parametro con un valore di funzione (anche se sembra essere uno per un certo uso seq) a causa del suo tipo polimorfico parametrico. Parametricità significa che non sappiamo nulla dei parametri. Inoltre, seqnon potrà mai prendere un'espressione e decidere "è questo ⊥?" (cfr. il problema di Halting), seqpuò solo provare a valutarlo e divergere da solo a ⊥.

Che cosa seq fa è valutare il primo parametro (non completamente, ma in "forma normale testa debole" [1], cioè al costruttore più in alto), quindi restituire il secondo parametro. Se il primo parametro sembra essere ⊥(cioè un calcolo non terminante), la valutazione causa seqnon terminazione, e quindi seq ⊥ a = ⊥.

[1] Teoremi liberi in presenza di seq - Johann, Voigtlander http://www.iai.uni-bonn.de/~jv/p76-voigtlaender.pdf

$\lambda x.\, \bot$$\lambda x.\, \bot$

Samson Abramsky ha esaminato questo problema molto tempo fa e ha scritto un documento intitolato " The Lazy Lambda Calculus ". Quindi, se vuoi definizioni formali, è qui che potresti guardare.

Dimostrando che λ x. Ω ‌ ≠ Ω in è uno degli obiettivi che Abramsky stabilisce per la sua pigra teoria del calcolo lambda (pagina 2 di suo articolo , già citato da Uday Reddy), perché entrambi sono in forma normale testa debole. A partire dalla definizione 2.7, discute esplicitamente che la riduzione dell'et λ x. M x → M non è generalmente valido, ma è possibile se M termina in ogni ambiente. Ciò non significa che M debba essere una funzione totale, ma solo che la valutazione di M deve terminare (riducendo ad esempio una lambda).

La tua domanda sembra essere motivata da preoccupazioni pratiche (prestazioni). Tuttavia, anche se il Rapporto Haskell potrebbe essere meno del tutto chiaro, dubito che equiparare λ x. ‌ ‌con ⊥ produrrebbe un'utile attuazione di Haskell; se si implementi o meno Haskell '98 è discutibile, ma data l'osservazione, è chiaro che gli autori lo intendevano.

Infine, come fa seq a generare elementi per un tipo di input arbitrario? (So ​​che QuickCheck definisce la tabella dei tipi arbitraria per questo, ma non ti è permesso aggiungere tali vincoli qui). Questo viola la parametricità.

Aggiornato : non sono riuscito a codificare questo diritto (perché non ho una conoscenza fluente di Haskel) e la correzione sembra richiedere runSTaree nidificate . Ho provato a usare una singola cella di riferimento (nella monade ST) per salvare tali elementi arbitrari, leggerli in seguito e renderli universalmente disponibili. La parametricità dimostra che break_parametricitynon è possibile definire di seguito (tranne restituendo bottom, ad esempio un errore), mentre potrebbe recuperare gli elementi generati dal seq proposto.

import Control.Monad.ST
import Data.STRef
import Data.Maybe

produce_maybe_a :: Maybe a
produce_maybe_a = runST $ do { cell <- newSTRef Nothing; (\x -> writeSTRef cell (Just x) >> return x) `seq` (readSTRef cell) }

break_parametricity :: a
break_parametricity = fromJust produce_maybe_a

Devo ammettere che sono leggermente confuso nel formalizzare la prova di parametricità necessaria qui, ma questo uso informale della parametricità è standard in Haskell; ma ho imparato dagli scritti di Derek Dreyer che la teoria necessaria è stata rapidamente elaborata in questi ultimi anni.

modifiche:

• Non sono nemmeno sicuro che tu abbia bisogno di quelle estensioni, che sono studiate per linguaggi di tipo ML, imperativi e non tipizzati, o se le teorie classiche della parametricità coprono Haskell.
• Inoltre, ho citato Derek Dreyer semplicemente perché mi sono imbattuto solo in seguito nel lavoro di Uday Reddy - ne ho appreso solo recentemente da "L'essenza di Reynolds". (Ho iniziato a leggere davvero letteratura sulla parametricità solo nell'ultimo mese).