Algoritmi di ordine superiore

La maggior parte degli algoritmi noti sono di primo ordine, nel senso che i loro input e output sono dati "semplici". Alcuni sono di secondo ordine in modo banale, ad esempio ordinamento, hashtable o funzioni map e fold: sono parametrizzati da una funzione, ma in realtà non fanno nulla di interessante se non invocarlo su pezzi di altri dati di input.

Alcuni sono anche di secondo ordine ma un po 'più interessanti:

• Fingertree parametrizzati da monoidi
• Dividere una fingertree su un predicato monotono
• Algoritmi di somma dei prefissi, sempre di solito parametrizzati da un monoide o un predicato ecc.

Infine, alcuni sono "veramente" di ordine superiore nel senso che è più interessante per me:

• Il combinatore Y.
• Elenchi delle differenze

Esistono altri algoritmi non banali di ordine superiore?

Nel tentativo di chiarire la mia domanda, sotto "ordine non banale di ordine superiore" intendo "usare strutture di ordine superiore del formalismo computazionale in modo critico nell'interfaccia e / o implementazione dell'algoritmo"

Ci sono molte funzioni di ordine superiore su http://math.andrej.com/ , ad esempio nel post sui doppi esponenziali , appare il seguente tipo di Haskell (con i sinonimi del tipo espansi):

shift :: Bool -> ((Int -> Bool) -> Bool) -> ((Int -> Bool) -> Bool)

Puoi anche divertirti molto con il post A Haskell Monad for Infinite Search in Finite Time - ad esempio:

newtype S a = S ((a -> Bool) -> a)
bigUnion :: S (S a) -> S a

Immagino che il tipo di bigUnion sia del 4 ° o 5 ° ordine!

ci sono un sacco di algoritmi che sono "veramente di secondo ordine" anche se di solito non sono esplicitamente descritti in questi termini. Ogni volta che disponiamo di algoritmi temporali sub-lineari, è implicito un tipo di accesso all'oracolo all'ingresso, ovvero trattando realmente l'ingresso come una funzione.

Esempi:

(1) Gli algoritmi Ellipsoid quando si lavora con un "oracolo di separazione" (ad es. Http://math.mit.edu/~vempala/18.433/L18.pdf )

(2) Minimizzazione della funzione sottomodulare (ad es. Http://people.commerce.ubc.ca/faculty/mccormick/sfmchap8a.pdf )

(3) L'intero campo della verifica della proprietà è davvero di questa forma ( http://www.wisdom.weizmann.ac.il/~oded/test.html )

(4) Aste combinatorie nel modello di query (ad esempio http://pluto.huji.ac.il/~blumrosen/papers/iter.pdf )

C'è un'altra risposta a questa domanda: non ce ne sono. Più specificamente, qualsiasi algoritmo di questo ordine superiore (implementabile!) È meccanicamente equivalente a un algoritmo di primo ordine, usando la defunzionalizzazione .

Consentitemi di essere più preciso: sebbene esistano effettivamente algoritmi di ordine superiore, in pratica è sempre possibile riscrivere ogni istanza come un programma puramente di primo ordine. In altre parole, non esistono programmi saturi di ordine superiore, essenzialmente perché l'input / output dei programmi sono stringhe di bit. [Sì, quelle stringhe di bit possono rappresentare funzioni, ma questo è il punto: essi rappresentano le funzioni, sono non funzioni].

Le risposte già fornite sono eccellenti e la mia risposta non deve essere considerata come contraddittoria. Dovrebbe essere considerato come rispondere alla domanda in un contesto leggermente più ampio (programmi completi anziché algoritmi autonomi). E questo cambiamento di contesto cambia radicalmente la risposta. Il punto della mia risposta è ricordare alla gente questo, che è fin troppo facile da dimenticare.

Nelle librerie del combinatore parser l'ordine della funzione è generalmente piuttosto elevato. Scopri anche le funzioni di ordine superiore per l'analisi o perché qualcuno vorrebbe mai usare una funzione del sesto ordine? di Chris Okasaki. Journal of Functional Programming , 8 (2): 195-199, marzo 1998.

L'analisi calcolabile caratterizza i numeri reali a livello di codice, poiché i numeri reali contengono una quantità illimitata di informazioni e quindi le operazioni sui numeri reali sono di ordine superiore nel senso delle domande. Tipicamente, i numeri reali sono presentati usando una vista topologica sul flusso infinito di bit, lo spazio Cantor, prestando interesse al più ampio campo della topologia calcolabile.

Klaus Weihrach ne ha parlato come la Gerarchia di efficacia di tipo due della topologia calcolabile. Per ulteriori informazioni, guarda Weihrach & Grubba, 2009, Elementary Computable Topology , e la pagina di ricerca di John Tucker, Calcolo con dati topologici . Cito la pagina di Tucker nella mia domanda, Applicazioni di Cantor Space .

Un modulo di continuità funzionale è una mappa mche accetta un (continuo) funzionale F : (nat -> nat) -> nate genera un numero ktale che F f = F gogni volta che lo è f i = g iper tutti i < k. Esistono algoritmi per calcolare il modulo di continuità (non molto efficienti), in modo da renderlo un'istanza di un algoritmo di terzo ordine.

A complemento della risposta di Noam , ci sono anche diverse situazioni in cui è importante che l' output sia (una rappresentazione esplicita di) una funzione.

$C: \\{0,1\\}^n \rightarrow \\{0,1\\}^m$$A$ $(\alpha,L,\epsilon)$$C$$n$$A$$M_1,\dots,M_L$

$\begin{align}\forall w \in \\{0,1\\}^m, Pr_A [&\forall m,~(Ag(C(m),w) \geq \alpha \Rightarrow \\\ &\exists i \in [L],~\forall j \in [n],~Pr_{M_i}[M_i(j) = m_j] \geq 1-\epsilon)] \geq 2/3\end{align}$

$Ag$$A$$2/3$$\epsilon$$m$$m$$\alpha$

Negli algoritmi grafici, i vertici e gli spigoli sono generalmente considerati dati semplici ma possono effettivamente essere generalizzati in modo produttivo in modo da essere generati programmaticamente su richiesta.

Durante il mio dottorato di ricerca (in chimica computazionale) ho implementato molti algoritmi grafici in forma di ordine superiore per applicarli all'analisi dei grafici impliciti, principalmente perché i miei grafici reali erano infiniti, quindi non potevo permettermi di memorizzarli esplicitamente! In particolare, stavo studiando la topologia dei materiali amorfi rappresentata come piastrellature 3D di celle unitarie (supercellule).

Ad esempio, è possibile scrivere una funzione per calcolare l'ennesima shell vicina di un vertice di origine in iquesto modo:

nth i 0 = {i}
nth i 1 = neighbors i
nth i n = diff (diff (fold union empty (map neighbors (nth i (n-1)))) (nth i (n-1))) (nth i (n-2))

dove neighborsè una funzione che restituisce l'insieme di vertici vicini al vertice dato.

Ad esempio, il reticolo quadrato 2D:

neighbors (x, y) = {(x-1, y), (x+1, y), (x, y-1), (x, y+1)}

Altri algoritmi interessanti in questo contesto includono le statistiche dell'anello di percorso più breve di Franzblau.