[Python] Insiemi e multiprocessor.

[enrico franchi]

2016-05-26 17:09 GMT+01:00 alessandro medici <alexxandro.medici a gmail.com>:

> In effetti pensavo a qualcosa di assai più complesso ma, ovvio,
>

Io pero' sono un po' confuso. Ovvero, capisco la specifica "generica"
voglio qualcosa che si comporti come gli insiemi, ma... il punto e' che
nella pratica e' qualcosa che non vuoi (o ci sono gia' cose che fanno
quello che ti serve).

Ovvero... cosa e' un insieme? In matematica un insieme e' *semplicemente*
una collezione di "oggetti" (ovviamente non parliamo in questo caso di
programmazione ad oggetti... parliamo di oggetti matematici).
Questo e' un insieme. Niente di piu', niente di meno.

Quindi poi si apre la questione di "come specifico un insieme"? E veniamo
appunto alla descrizione intensionale o estensionale. Ma questo non e'
parte della *definizione* di insieme (ovvero del concetto di insieme), ma
della descrizione di uno specifico insieme. Sono solo modi di specificare
insiemi.

Ma la faccenda fondamentale e' che in matematica non c'e' reale differenza
fra manipolare enti finiti ed infiniti. Esattamente come in matematica non
ci sono grossi problemi ad avere teoremi "di esistenza". Poi certo, c'e'
tutta una polemica interna verso teoremi non costruzionisti... ma appunto,
la matematica va avanti. L'informatica, invece, ha grosse difficolta' con
cose non costruzioniste. Perche' vuole dire che non abbiamo l'algoritmo:
sappiamo che una certa cosa esiste, ma non sappiamo calcolarla. Tutto
questo e' anche legato (ci arriviamo dopo) al concetto di
turing-calcolabile.

Ora... per un po' mi sono occupato di programmazione logica. E tutto questo
discorso e' terribilmente relato a cose come assunzione di mondo
chiuso/mondo aperto (OWA/CWA) e alla negazione come fallimento (NAF) e alle
logiche non-monotone. E questi sono problemi di ricerca *molto* sentiti.
Perche' appunto... sappiamo fare linguaggi di programmazione logici che
fanno CWA... ma per avere NAF (che e' relativamente comoda) si esce dalla
logica del primo-ordine (tipo in Prolog). Nota anche che questa parte di
Prolog e' fuori dalla parte strettamente dichiarativa di Prolog e diventa
invece procedurale.

Ora perche' tutto sto pappardello? Per dire che dimenticati Python (per
semplicita'). Tutto questo discorso degli insiemi, fallo in Prolog. Fallo
in Prolog perche' Prolog *li ha*, di fatto -- anche se non nella forma che
ti aspetti --. Poi capisci quali sono le limitazioni che Prolog ti da su
sta roba (niente affatto banali). Tutto questo puoi farlo in modo
"relativamente semplice" anche in Python -- relativamente semplice vuole
dire che in pratica devi scrivere un motore grosso modo equivalente a
Prolog... il che vuole dire che si puo' fare e si sa come farlo, non che
sia effettivamente rapido da fare --.

Ecco... e scoprirai che il concetto di insieme in Prolog e' comunque
sostanzialmente diverso dal concetto "intuitivo" di insieme che hai (ed e'
diverso pure dal concetto di insieme della logica matematica -- ricordiamo
che prolog implementa "completamente" la first-order logic, ma di fatto ha
bisogno di features extra-logiche, che diventano anche procedurali -- per
fare il resto, fra cui naf, che appunto e' importante parte del discorso).

E qui si scopre che uno dei primi concetti da gestire e' quello di modello
stabile e poi di modello ben fondato (incidentalmente, la mia tesi
magistrale era su sta roba). E si scopre anche che non ci sono modi
efficienti per implementare la semantica di modello ben fondato in un
linguaggio di programmazione. Wikipedia sostiene che ci siano algoritmi
quadratici per calcolarlo (ma a suo tempo mi pare fosse ben piu'
complicato, io ricordo che eravamo molto contenti di averlo fatto in modo
cubico). E quindi si arriva ad answer set programming.


Ma insomma... TL;DR

MediciSet("is zero of Zeta Function") & MediciSet("is complex and has real
part == 1/2")

Se hai veramente implementato gli insiemi "come li vuoi tu", mi sai anche
calcolare quella roba lassu'. Se sai calcolare quella roba lassu', hai
appena dimostrato (o disprovato) l'ipotesi di Riemann e diventi il
matematico piu' importante della nostra generazione. Si... ho saltato un
botto di passaggi per arrivare dal pappardello a questa versione breve.

Ora... buona fortuna. Ma per un uso pratico degli insiemi, non ti serve
niente di cui sopra... e li hai gia'. Per esempio... vuoi sapere se un ente
matcha certe proprieta'? Banale. Ci sono anche librerie -- tipo hamcrest --
che ti rendono facile scrivere le regole. Se le regole sono relativamente
semplici computazionalmente e parti da un insieme finito, puoi anche
calcolarlo facilmente. Se l'insieme e' infinito, beh... amen. Puoi comunque
comporre regole e compagnia e testare ogni candidato.

Quindi non capisco cosa siano i tuoi insiemi. Non possono essere "i veri
insiemi" (scusa, ma sono scettico sul fatto che in un estate rifondi tutta
la logica computazionale risolvendo alcuni dei problemi piu' ardui della
materia). E quindi che resta... quello che gia' abbiamo. O mi sono perso
qualcosa?





-- 
.
..: -enrico-
-------------- parte successiva --------------
Un allegato HTML è stato rimosso...
URL: <http://lists.python.it/pipermail/python/attachments/20160527/d37f5dca/attachment.html>