Prima di tutto forniamo un pò di informazioni sulla macchina cavia, in modo da fornire un termine di paragone per I risoltati; la macchina in questione è un pò vecchiotta in quanto viene utilizzata essenzialmente per smanettarci:

Il sistema in questione è stato installato tramite net-install e selezionando I seguenti gruppi di pacchetti:

Procediamo fornendo una panoramica sulla modalità di boot del PC ed in particolare dei sistemi GNU/Linux.
Il primo elemento che entra in esecuzione è il BIOS (Basic Input/Output System) ovverro un programma che risiede in un chip della scheda madre che si occupa di riconoscere una parte dell’hardware (generalmente il processore, I lettori ottici e I dischi fissi). Una volta finita la ricognizione dell’hardware il BIOS legge l’MBR (Master Boot Record) del disco di avvio pemettendo così il caricamento del boot loader ovvero quel software che vi permette di scegliere il sistema operativo da avviare.
La maggior parte delle distribuzioni di Linux permette di scegliere tra LILO (LInux LOader)  e GRUB
(GRand Unified Bootloader); Debian di default utilizza GRUB.
Il boot loader si occupa di caricare il kernel scelto nella memoria ram.
A questo punto il kernel Linux acquisisce il controllo e, in un sistema Debian, avvia init (pacchetto sysvinit). Init è semplicemente un sofwtare che seguendo un elenco più o meno ordinato avvia un insieme di demoni tra I quali (nel caso in cui si utilizzi un greeting grafico) GDM, KDM o altri.
Riassumendo, graficamente la procedura di boot può essere rappresentata dalla seguente linea temporale:

A tal proposito ho ritenuto utile suddividere la guida in 4 parti, ognuna delle quali è dedicata ad una specifica fase della procedura di boot.

Sebbene la maggior parte delle moderne schede madre sono equipaggiate da BIOS che permettono personalizzazioni davvero minime, è consigliabile effettuare tutto il possibile per fare in modo che il tempo che va tra l’accenzione del computer ed il caricamento del boot loader sia ridotto all’osso.
Sebbene sia consigliabile utilizzare la versione più recente per il proprio BIOS, questa è un’operazione ad alto rischio in quanto, come sicuramente saprete, può compromettere il funzionamento della scheda madre; mi sento quindi di consigliarla esclusimanete ad utenti di PC quali HP e TOSHIBA (ce ne saranno altri ma io conosco questi) che forniscono sul proprio sito un utility per flashare il BIOS all’ultima versione disponibile. Premetto che però tali utility vengono sviluppate per essere eseguite sotto Windows (presumo solo per scopi commerciali) quindi è un’operazione che vi consiglio di fare prima di installare Linux; nel caso in cui Linux già sia presente sul vostro PC, se disponete di un ampia partizione di swap, potreste provare ad installare temporaneamente Windows su tale partizione (che diventerebbe NTFS o FAT32), lasciando così illese sia la partizione di root che le home.

Per quanto riguarda I parametri se utilizzare un BIOS Award come quello della macchina in questione avete ampi margini di smanettamento (vi rimando a google per le guide a proposito) altrimenti una cosa che sicuramente potete fare è selezionare l’unità dove risiede GRUB come la prima da avviare; in caso contrario il BIOS controllerà prima la presenza di eventuali CD/DVD nel lettore ottico o se è possibile (nei modelli che lo prevedono) effettuare il boot da LAN.

Lo scopo di questa sezione è ridurre il tempo necessario a GRUB per avviare il caricamento del kernel. Purtroppo anche qui non abbiamo la possibilità di fare tanto se non tentare di diminuire al minimo l’interazione di GRUB con l’utente.
Se infatti avviamo la nostra macchina sempre e solo con lo stesso kernel e se non abbiamo altri sistemi operativi installati, possiamo dire a GRUB di non mostrare la schermata con la lista dei sistemi operativi disponibili e di diminuire a zero l’attesa che di solito viene impiegata per dare all’utente l’opportunità di scegliere cosa avviare.
A tal proposito bisogna procedere con la modifica del file /boot/grub/menu.lst settando a 0 (zero) la voce timeout e decommentando la linea.

Inutile dire che l’ideale sarebbe compilare il kernel a mano ed eliminare tutto quello che non ci occorre (compresa l’ Initial RamDisk Image), ma sono dell’opinione che è una cosa alquanto tediosa da fare esclusivamente per sistemi embendeed; resta comunque il fatto che almeno una volta nella vita è un’esperienza che un utente Linux DEVE fare perchè consente di conoscere infiniti concetti che altrimenti resterebbero ignoti.
Utilizzeremo quindi il parco kernel fornito da mamma Debian: quello che dobbiamo fare è scegliere il kernel specifico per la nostra architettura, nel mio caso essendo un Pentium III ho scelto il kernel ottimizzato per processori i686.
Per avere una lista dei kernel disponibili (naturalmente mi aspetto che I repository siano configurati) occorre digitare da terminale

per verificare il kernel utilizzato

La scelta del kernel dedicato alla nostra architettura è un’operazione che ci consentirà anche durante il nostro lavoro di ottenere prestazioni migliori in quanto il kernel dovrebbe utilizzare le istruzioni macchina specifiche per la nostra CPU.

Nel tempo che va tra il caricamento da parte di GRUB e l’avvio di init, il kernel compie delle azioni di default quali riconoscimento hardware ed altro. Configurando propriamente il boot loader facendo in modo che quest’ultimo passi degli utili parametri d’avvio al kernel, possiamo cercare di bypassare le azioni che risultano inutili per l’utilizzo che facciamo del nostro PC.
La lista dei parametri che è possibile passare al kernel linux è smisurata a tal proposito mi limito ad elencare e spiegare quelli che io ho ritenuto utili e vi rimando alla lettura di questa guida.
Torniamo ad editare il file /boot/grub/menu.lst e modifichiamo le seguenti righe SENZA ELIMINARE IL CANCELLETTO:

a questo punto:

Naturalmente questi sono I valori relativi alla macchina in questione quindi non vanno presi come paramentri generali.

Prima di iniziare ad addentrarci in questa sezione, consiglierei di studiare a fondo il funzionamento di sysv-init al fine di comprendere le azioni che compieremo e la procedura di boot in generale.
Consiglio inoltre di installare bootchart, uno strumento che ci permetterà di avere informazioni più dettagliate e soprattutto di monitorare I miglioramenti di quest’ultima fase della procedura di boot.

Poi modificare il file /boot/grub/menu.lst ed aggiungere la seguente il seguente comando init=/sbin/bootchartd” ai parametri di boot del nostro kernel.
Bootchart verrà avviato come primo processo dal kernel e si occuperà poi di avviare init e di monitorare il suo comportamento.
A questo punto riavviare il sistema e poi digitare

Questo comando ci permetterà di ottendere un immagine png che conterra il grafico rappresentante la nostra procedura di boot:

La figura rappresenta I demoni avviati ed il tempo occorso per ciascun avvio; in alto possiamo leggere il tempo totale impiegato: 57secondi.

Installiamo il pacchetto sysv-rc-conf ed avviamo sysv-rc-conf come root; questa utility ci permette di gestire I demoni avviati da init durante la fase di boot del sistema. Ogni demone rappresenta un servizio che il nosto computer ci fornirà; analiziamo quelli del calcolatore in questione.

Eliminando le “X” possiamo disabilitare I servizi che non utiliziamo; personalmente io ho eliminato

Solitamente in un sistema GNU/Linux è possibile usufruire di più console accessibili tramite la combinazione di tasti CTRL + ALT + Fx.
Di base Debian ne attiva 6 testuali ed una dove eseguirà il server grafico ma difficilmente un utente desktop avrà bisogno di 6 console grafiche. A tal proposito può essere utile lasciare abilitate esclusivamente la console con il server grafico ed un unica console testuale utile per eventuali assistenze tecniche.
Editiamo il file /etc/inittab e commentiamo le seguenti righe:

Sysvinit avvia un demone solo quando quello precedente segnala che il suo startup è avvenuto con successo. Modificando opportunamente I file di configurazione possiamo istruire init affinche avvii I demoni direttamente senza aspettare risposta dal demone precedente.

Alcuni demoni durante la fase di avvio necessitano di essere eseguiti in una shell; di default la shell utilizzata sia per l’avvio che per gli utenti è BASH (Bourne Again SHell), la più diffusa e completa del mondo Linux. Utilizzare uno strumento tanto potente solo per fornire un ambiente di esecuzione ai demoni risulta però controproducente; può essere quindi più indicato installare e settare come shell di default DASH, uno strumento più modesto ma che fa comunque il suo lavoro.

A questo punto il link /bin/sh punterà a /bin/dash di conseguenza quest’ultima verrà usata in fase d’avvio. Questa operazione non dovrebbe comunque intaccare le potenzialità della shell usata dall’utente in quanto quest’ultima è indicata nel file /etc/passwd
[pagebreak]

All’avvio il sistema controlla il file /etc/network/interfaces per sapere come gestire le interfacce di rete, se non settato corretamente il sistema all’avvio potrebbe cercare di richiedere I parametri di rete per un’ipotetica interfaccia ethernet scollegata. A tal proposito il mio consiglio è quello di istruire il sistema affinche all’avvio configuri automaticamente solo l’interfaccia di loopback.
Editare il file /etc/network/interfaces nel seguente modo:

Analizzando gli script dei demoni presenti in /etc/init.d ci accorgiamo che sulla testa di ognuno di essi sono specificate, attraverso alcuni commenti, le dipendenze di ogni demone rispetto ad altri. Tali commenti non sono interpretati da init che avvia I demoni basandosi sui numeri interi specificati nel nome dello script (vd. /etc/rc2.d/).
Accade quindi che init avvia un demone che spreca cicli CPU attendendo l’avvio del demone dal quale dipende.
Esistono sistemi alternativi a sysv-init che si basano sulle dipendenze dei demoni (initNG) o sugli eventi da essi generati (Upstart di Ubuntu) ma il nostro intento è quello di configurare in modo ottimale sysv-init che è lo standard de facto.
Sarebbe quindi utile analizzare le dipendenze dei demoni e cambiare I numeri interi in modo da ordinare la fase di boot; fortunatamente l’utility InsServ lo fa al posto nostro:

Eccoci alla fine.
Riavviamo il PC e rianalizziamo l’output di bootchart -f png

Implementazione, nel linguaggio prolog, del metodo dei Tableaux Analitici studiato nel corso di Logica.

Nel sistema sono stati definiti i seguenti operatori:

:- op(650, xfy, sse).
:- op(640, xfy, implies).
:- op(630, yfx, or).
:- op(620, yfx, and).
:- op(610, fy, not).

Il primo parametro del predicato op/3 rappresenta la priorità dell’operatore definito; nel nostro caso l’operatore con maggior priorità è il not, seguito in ordine da and, or, implies, sse.
Questi operatori rappresentano i connettivi logici come rappresentato in tabella:

Per i quantificatori utilizziamo invece due predicati (forall(x,fbf) e exists(x,fbf)), entrambi hanno bisogno di due parametri: il primo è la variabile da quantificare ed il secondo è la formula ben formata quantificata. I simboli di variabile presenti nelle formule
ben formate passate in input sono in minuscolo in modo da distinguerli dalle variabili Prolog. Il sistema presentato elabora fbf (formule ben formate) della logica del primo ordine chiuse e pure.
Prima di iniziare a sviluppare il tableau per la formula data in input, è interrogato il predicato fbf_chiusa/1:

fbf_chiusa(
X and Y ) :- !, fbf_chiusa(X),fbf_chiusa(Y).

fbf_chiusa(
X or Y ) :- !, fbf_chiusa(X), fbf_chiusa(Y).

fbf_chiusa(
X implies Y ) :- !, fbf_chiusa(X), fbf_chiusa(Y).

fbf_chiusa(
X sse Y ) :- !, fbf_chiusa(X), fbf_chiusa(Y).

fbf_chiusa(
forall(X,Y) ) :- atomic(X),instantiate(Y,X,-1,Y1),!, fbf_chiusa(Y1).

fbf_chiusa(
exists(X,Y) ) :- atomic(X), instantiate(Y,X,-1,Y1),!,fbf_chiusa(Y1).

fbf_chiusa(
not X ) :- ! ,fbf_chiusa(X).

fbf_chiusa(
X ) :- atomo_ground(X).

%instantiate(Y,X,N,Y1)
:- Y1 è la formula Y dove ogni occorrenza di X è sostituita con N

%atomo_ground(X)
:- X è un atomo ground.

Questo predicato è vero se il suo argomento è una formula ben formata chiusa. In particolare il controllo atomo_ground(X) è fatto verificando che X sia un atomo, e che tutti i suoi termini siano degli interi (istanziamo le variabili sul dominio dei numeri interi).

Descrizione implementazione

Cominciamo la descrizione dell’implementazione presentando i predicati ausiliari. Innanzitutto abbiamo i predicati che ci permettono di identificare il tipo di formula:

is_alpha(_
and _).

is_alpha(_
sse _).

is_alpha(not
(_ or _)).

is_alpha(not
(_ implies _)).

is_beta(_ or
_).

is_beta(_
implies _).

is_beta(not
(_ and _)).

is_beta(not
(_ sse _)).

is_delta(exists(
_ , _ )).

is_delta(not
forall( _ , _ )).

is_fresh_gamma(forall(
X , Y ), forall( X , Y , 0)).

is_fresh_gamma(not
exists( X , Y ), not exists( X , Y , 0)).

is_gamma(forall(
_ , _ , _ )).

is_gamma(not
exists( _ , _ , _ )).

Altri predicati sono atomo/1 e atomo_ground/1 :

atomo_ground(X)
:- compound( X ), X =.. [_|Terms], lista_interi(Terms).

lista_interi([]).

lista_interi([Termine
| Terms]) :- integer(Termine), lista_interi(Terms).

atomo(X) :-
compound( X ), X =.. Parametri, parametri_validi(Parametri).

parametri_validi([]).

parametri_validi([Parametro
| Tail]) :- atomic(Parametro),

Parametro \== not,

Parametro \== and,

Parametro \== or,

Parametro \== implies,

Parametro \== sse,

Parametro \== forall,

Parametro
\== exists,

!,

parametri_validi(Tail).

Questi predicati sono utilizzati da fbf_chiusa/1 (già presentata nel precedente paragrafo) e da istantiate/4 riportato di seguito:

instantiate(
X and Y , Var , Par , X1 and Y1) :- !,

instantiate(X,Var,Par,X1),

instantiate(Y,Var,Par,Y1).

instantiate(
X or Y , Var , Par , X1 or Y1) :- !,

instantiate(X,Var,Par,X1),

instantiate(Y,Var,Par,Y1).

instantiate(
X implies Y , Var , Par , X1 implies Y1) :- !,

instantiate(X,Var,Par,X1),

instantiate(Y,Var,Par,Y1).

instantiate(
X sse Y , Var , Par , X1 sse Y1) :- !,

instantiate(X,Var,Par,X1),

instantiate(Y,Var,Par,Y1).

instantiate(
forall(X,Y),Var,Par,forall(X,Y1)) :- X \== Var,

!,

instantiate(Y,Var,Par,Y1).

instantiate(
forall(X,Y),Var,_,forall(X,Y)) :- X == Var, !.

instantiate(
exists(X,Y),Var,Par,exists(X,Y1)) :- X \== Var,

!,

instantiate(Y,Var,Par,Y1).

instantiate(
exists(X,Y),Var,_,exists(X,Y)) :- X == Var,!.

instantiate(
not X,Var,Par, not X1 ) :-!, instantiate(X,Var,Par,X1).

instantiate(
X,Var,Par,X1 ) :- atomo(X), !, substitute_occurrences(X,Var,Par,X1).

substitute_occurrences(X,Var,Par,X1):-
X =.. [Pred|Terms], substitute(Terms,Var,Par,Terms1),X1=.. [Pred|Terms1].

substitute([],_,_,[]).

substitute([Term
| Tail],Var,Par,[Term1 | Tail1]) :- Term == Var,Term1 = Par,!,
substitute(Tail,Var,Par,Tail1).

substitute([Term
| Tail],Var,Par,[Term1 | Tail1]) :- Term \== Var,Term1 = Term,!,
substitute(Tail,Var,Par,Tail1).

Il predicato istantiate(X, V, P,
X1) è vero quando X1 è la formula ottenuta sostituendo nella formula X tutte le
occorrenze della variabile V con il parametro P.

Passiamo ora allo sviluppo dell’albero di fbf costituente il tableau.

Il cuore del calcolo è nel predicato tclose(Fbf, Limite) che è vero se il tableau sviluppato per la formula Fbf chiude istanziando massimo “Limite” parametri. Fbf deve essere una formula ben formata chiusa:

tclose(Fbf,Limite)
:- fbf_chiusa(Fbf), closed_branch([Fbf],[],[],[],[],[],Limite,0,[]).

Ogni ramo del tableau è descritto dai termini di closed_branch/9:

closed_branch(Fbfs,As,Ds,Bs,Gs,Ls,Limite,Params,Elaborate)

in particolare:

• Fbfs: lista delle formule in attesa di essere
  inserite in uno stack sul ramo
• As: stack delle formule di tipo alfa sul ramo
• Ds: stack delle formule di tipo delta sul ramo
• Bs: stack delle formule di tipo beta sul ramo
• Gs: stack delle formule di tipo gamma sul ramo
• Ls: stack di letterali sul ramo
• Limite: massimo numero di parametri da utilizzare
• Params: parametri introdotti (rappresentati dagli
  interi da 1 a Params)
• Elaborate: lista delle formule già elaborate (utile
  per stampare il ramo)

Il tableau è sviluppato elaborando le formule in base alla priorità: prima le formule alfa, poi le delta, le beta, ed infine le gamma. Per memorizzare le formule del ramo ancora da elaborare sono utilizzati quattro stack (As, Ds, Bs,Gs).

Elaborazione formule alfa

La formula da elaborare è presa in testa allo stack “As” delle formule alfa. Successivamente vengono introdotte due nuove formule Alpha1 ed Alpha2 tali che il predicato regola_alpha(Formula,Alpha1,Alpha2) risulta vero. Tali formule sono poi inserite nello stack delle formule da elaborare. Di seguito è riportato il codice necessario:

%alpha

closed_branch([Formula|As],Ds,Bs,Gs,Ls,Limite,Params,Elaborate)
:-

regola_alpha(Formula,Alpha1,Alpha2),

!,

closed_branch([Alpha1,Alpha2],As,Ds,Bs,Gs,Ls,Limite,Params,[Formula|Elaborate]).

regola_alpha(
A and B, A, B ).

regola_alpha(
not ( A implies B ), A, not B ).

regola_alpha(
not ( A or B ), not A, not B ).

regola_alpha(
A sse B, A implies B, B implies A).

La formula elaborata viene inserita nella lista Elaborate.

Elaborazione formule delta

La formula da elaborare è presa in testa allo stack “Ds”delle formule delta ed a partire da essa viene introdotta una nuova formula Delta1 che soddisfa il predicato regola_delta(Formula,Delta1,Limite,Params). Questa formula è poi inserita nello stack delle formule da elaborare. Di seguito è riportato il codice necessario:

%delta

closed_branch([],[Formula|Ds],Bs,Gs,Ls,Limite,Params,Elaborate)
:-

Params < Limite,

regola_delta(Formula,Delta1,Limite,Params),

Params1 is Params + 1,

!,

closed_branch([Delta1],[],Ds,Bs,Gs,Ls,
Limite,Params1,[Formula|Elaborate]).

%delta

closed_branch([],[Formula|Ds],Bs,Gs,Ls,Limite,Params,Elaborate)
:-

Params >= Limite,

!,

closed_branch([],[],Ds,Bs,Gs,Ls, Limite,Params,[Formula|Elaborate]).

regola_delta(exists(X,Fbf),Fbf1,_,N):-
N1 is N+1, instantiate( Fbf , X , N1 , Fbf1).

regola_delta(not
forall(X,Fbf),not Fbf1,_,N):- N1 is N+1, instantiate( Fbf , X , N1 , Fbf1).

La formula elaborata viene inserita nella lista Elaborate.

Elaborazione formule beta

La formula da elaborare è presa in testa allo stack “Bs” delle formule beta e sono introdotte due nuove formule Beta1 e Beta2 che soddisfano il predicato regola_beta(Formula,Beta1,Beta2). Queste formule prodotte sono inserite nello stack delle formule da elaborare, ma in questo caso vi sono due chiamate ricorsive al predicato poichè una formula di tipo beta prevede una biforcazione del ramo.

Di seguito è riportato il codice necessario:

%beta

closed_branch([],[],[Formula|Bs],Gs,Ls,Limite,Params,Elaborate)
:-

regola_beta(Formula,Beta1,Beta2),

!,

closed_branch([Beta1],[],[],Bs,Gs,Ls,
Limite,Params,[Formula|Elaborate]),

closed_branch([Beta2],[],[],Bs,Gs,Ls,
Limite,Params,[Formula|Elaborate]).

regola_beta(
A or B, A, B ).

regola_beta(
A implies B, not A, B ).

regola_beta(
not ( A and B ), not A, not B ).

regola_beta(
not ( A sse B ), not ( A implies B ), not ( B implies A ) ).

La formula elaborata viene inserita nella lista Elaborate.

Elaborazione formule gamma

Le formule di tipo gamma sono date in input nella forma:

forall(x,fbf) oppure
not exists(x,fbf)

Per semplificare la gestione di queste formule sono introdotte nuove formule ad esse equivalenti attraverso il predicato is_fresh_gamma/2:

is_fresh_gamma(forall(
X , Y ), forall( X , Y , 0)).

is_fresh_gamma(not
exists( X , Y ), not exists( X , Y , 0)).

Queste nuove formule hanno la forma:

forall(x,fbf,n) oppure
not exists(x,fbf,n)

dove n è un intero che porta traccia dei parametri per i quali già è stata istanziata la formula fbf. Ogni volta si istanzia la formula, cambiamo il valore di n in questo modo:

incrementa(forall(X,
Fbf, _), forall(X, Fbf, Params), Params).

incrementa(not
exists(X, Fbf, _), not exists(X, Fbf, Params), Params).

La formula gamma da elaborare è presa in testa allo stack “Gs”delle formule gamma. A partire da questa formula vengono introdotte una lista Gammas di nuove formule. Tali formule, introdotte attraverso il predicato regola_gamma(Formula,Gammas,Limite,Params,Params1), rappresentano tutte le instanziazioni della formula quantificata con i parametri da n fino a Params1.

Queste formule prodotte sono inserite nello stack delle formule da elaborare.

Di seguito è riportato il codice necessario:

%gamma

closed_branch([],[],[],[Formula|Gs],Ls,Limite,Params,Elaborate)
:-

is_gamma(Formula),

Params < Limite,

regola_gamma(Formula,Gammas,Limite,Params,Params1),

incrementa(Formula, Formula1,
Params1),

append(Gs, [Formula1], Gs2),

!,

closed_branch(Gammas,
[],[],[],Gs2,Ls, Limite,Params1,[Formula|Elaborate]).

%gamma

closed_branch([],[],[],[Formula|Gs],Ls,Limite,Params,Elaborate)
:-

is_gamma(Formula),

Params >= Limite,

regola_gamma(Formula,Gammas,Limite,Params,Params1),

!,

closed_branch(Gammas,
[],[],[],Gs,Ls, Limite,Params1,[Formula|Elaborate]).

regola_gamma(forall(X,
Fbf, N), Gammas, Limite, Params, Params1) :-

regola_gamma(Gammas, X, Fbf, N, N, Limite, Params, Params1).

regola_gamma(not
exists(X, Fbf, N), Gammas, Limite, Params, Params1) :-

regola_gamma(Gammas, X, not Fbf, N, N, Limite, Params, Params1).

%
la regola gamma introduce parametri nuovi

regola_gamma([],
_, _, N, _, Limite, Params, _) :- N == Params, N >= Limite,!.

regola_gamma([Fbf1],
X, Fbf, N, _, Limite, Params, Params1) :- N == Params,

Params <
Limite,

!,

Params1 is Params
+ 1,

instantiate( Fbf
, X , Params1 , Fbf1).

%
la regola gamma non introduce parametri nuovi

regola_gamma([Fbf1
| Gammas], X, Fbf, N, Next, _, Params, Params1) :- N < Params,

Next < Params,

Next1 is Next+1,

instantiate( Fbf
, X , Next1 , Fbf1),

!,

regola_gamma(Gammas,
X, Fbf, N, Next1, _, Params, Params1).

regola_gamma([],
_, _, N, Next, _, Params, Params) :- N < Params , Next == Params.

Notiamo che se la formula è stata già istanziata sul ramo su tutti i parametri permessi dal limite, essa non sarà ulteriormente istanziata.

Inserimento delle formule negli stack

Quando il predicato closed_branch ha arietà 9, allora il primo termine è la lista delle fbf in attesa di essere inserite nello stack adatto (push/11).

closed_branch([Fbf|_],As,Ds,Bs,Gs,Ls,_,_,Elaborate)
:-

chiude(Fbf,As,Ds,Bs,Gs,Ls),

!,

stampa_ramo([Fbf],As,Ds,Bs,Gs,Ls,Elaborate,’CHIUSO’).

closed_branch([Fbf|Fbfs],As,Ds,Bs,Gs,Ls,Limite,Params,Elaborate):-

\+ chiude(Fbf,As,Ds,Bs,Gs,Ls),

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As1,Ds1,Bs1,Gs1,Ls1),

!,

closed_branch(Fbfs,As1,Ds1,Bs1,Gs1,Ls1,Limite,Params,Elaborate).

push_formula(not
not Fbf,As,Ds,Bs,Gs,Ls,As1,Ds1,Bs1,Gs1,Ls1) :-

!,

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As1,Ds1,Bs1,Gs1,Ls1).

push_formula(Fbf,As,Ds,Bs,Gs,Ls,[Fbf
| As],Ds,Bs,Gs,Ls) :- is_alpha(Fbf), !.

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As,[Fbf
| Ds],Bs,Gs,Ls) :- is_delta(Fbf), !.

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As,Ds,[Fbf
| Bs],Gs,Ls) :- is_beta(Fbf), !.

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As,Ds,Bs,[Fbf1
| Gs],Ls) :- is_fresh_gamma(Fbf, Fbf1), !.

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As,Ds,Bs,[Fbf
| Gs],Ls) :- is_gamma(Fbf), !.

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As,Ds,Bs,Gs,[Fbf
| Ls]) :- atomo(Fbf), !.

push_formula(not
Fbf,As,Ds,Bs,Gs,Ls,As,Ds,Bs,Gs,[not Fbf | Ls]) :- atomo(Fbf), !.

In questo punto è fatto il controllo di chiusura del ramo: un ramo è chiuso se contiene una coppia di fbf complementari(chiude/6). Resta invece aperto quando non ci sono più formule da sviluppare.

closed_branch([],[],[],[],[],Ls,_,_,Elaborate)
:- !,

stampa_ramo([],[],[],[],[],Ls,Elaborate,’APERTO’).

closed_branch([Fbf|_],As,Ds,Bs,Gs,Ls,_,_,Elaborate)
:- chiude(Fbf,As,Ds,Bs,Gs,Ls),

!,

stampa_ramo([Fbf],As,Ds,Bs,Gs,Ls,Elaborate,’CHIUSO’).

chiude(not
Fbf,_,_,Bs,_,_) :- is_alpha(Fbf), member(Fbf, Bs), !.

chiude(not
Fbf,_,_,_,Gs,_) :- is_delta(Fbf), member(Fbf, Gs), !.

chiude(not
Fbf,As,_,_,_,_) :- is_beta(Fbf), member(Fbf, As), !.

chiude(not
Fbf,_,Ds,_,_,_) :- is_gamma(Fbf), member(Fbf, Ds), !.

chiude(not
Fbf,_,_,_,_,Ls) :- atomo_ground(Fbf), member(Fbf, Ls), !.

chiude(Fbf,_,_,Bs,_,_)
:- is_alpha(Fbf), member(not Fbf, Bs), !.

chiude(Fbf,_,_,_,Gs,_)
:- is_delta(Fbf), member(not Fbf, Gs), !.

chiude(Fbf,As,_,_,_,_)
:- is_beta(Fbf), member(not Fbf, As), !.

chiude(Fbf,_,Ds,_,_,_)
:- is_gamma(Fbf), member(not Fbf, Ds), !.

chiude(Fbf,_,_,_,_,Ls)
:- atomo_ground(Fbf), member(not Fbf, Ls), !.

Quando è terminata l’elaborazione di un ramo lo si stampa a video con stampa_ramo/8.

Output

Per ogni ramo del tableau sviluppato, è stampata a video la lista delle formule contenute in quel ramo. Il predicato è stampa_ramo/8:

• il primo termine Fbf contiene la lista contenente
  la fbf con la quale viene chiuso quel ramo (se il ramo è aperto questo
  parametro è una lista vuota)
• l’ultimo termine Tipo è una stringa che può essere:
  • APERTO: se il ramo è aperto
  • CHIUSO: se il ramo è chiuso

stampa_ramo(Fbf,As,Ds,Bs,Gs,Ls,Elaborate,Tipo)
:-

write(’===========[RAMO '),
write(Tipo), write(']===========’), nl,

stampa_formule(Elaborate),

stampa_formule(As),

stampa_formule(Ds),

stampa_formule(Bs),

stampa_formule(Gs),

stampa_formule(Ls),

stampa_ultima_formula(Fbf),

nl,

write(’===================================’), nl, nl.

stampa_formule(
[] ).

stampa_formule(
[Formula | Formulas] ) :-

stampa_formule(Formulas),

write(Formula),
nl.

stampa_ultima_formula([]).

stampa_ultima_formula([Fbf])
:- write(Fbf), write(’ XXX’).

Esempi di output a video sono riportati negli esempi d’uso.

Esempi d’uso

In questa sezione sono riportati degli esempi d’uso: il primo con una formula valida (tableau con un unico ramo), il secondo con una formula soddisfacibile ma non valida e infine un esempio con una formula valida
con un tableau con più rami.

Tutte le prove sono state fatte con un limite sul numero di parametri introducibili pari a 10, quindi quando si parlerà di soddisfacibilità  in relazione alla presenza di rami aperti del tableau si intenderà sempre relativamente a un dominio con cardinalità uguale al numero di parametri introducibili.

Esempio formula valida

Per prima cosa bisogna caricare il codice nell’interprete prolog (swi-prolog), e poi chiedere all’interprete:

?- prova(not
exists(y,forall(x,(f(y) implies f(x))))).

===========[RAMO
CHIUSO]===========

not exists(y,
forall(x, f(y)implies f(x)), 0)

not forall(x,
f(1)implies f(x))

not
(f(1)implies f(2))

not exists(y,
forall(x, f(y)implies f(x)), 1)

not forall(x,
f(2)implies f(x))

not
(f(2)implies f(3))

not exists(y,
forall(x, f(y)implies f(x)), 2)

f(1)

not f(2)

f(2) XXX

===================================

true.

?-

E’ stampato a video un unico ramo
chiuso: questo vuol dire che la formula di partenza Ø$y“x(F(y)®F(x))
è insoddisfacibile, e quindi la sua negata $y“x(F(y)®F(x))
è valida.

Esempio formula soddisfacibile

Verifichiamo la non validità di una formula . Con un’analisi semantica si può facilmente vedere che {f(0,1), f(1,0)} è un contro-modello nel dominio {0, 1}. Neghiamo la formula e proviamo a dimostrarla con il metodo dei Tableaux:

?- prova(not
(forall(y,exists(x,f(x,y))) implies exists(x,forall(y, f(x,y))))).

===========[RAMO
APERTO]===========

not
(forall(y, exists(x, f(x, y)))implies exists(x, forall(y, f(x, y))))

not exists(x,
forall(y, f(x, y)), 0)

not forall(y,
f(1, y))

forall(y,
exists(x, f(x, y)), 0)

exists(x,
f(x, 2))

exists(x,
f(x, 1))

not exists(x,
forall(y, f(x, y)), 1)

not forall(y,
f(4, y))

not forall(y,
f(3, y))

not forall(y,
f(2, y))

forall(y,
exists(x, f(x, y)), 2)

exists(x,
f(x, 7))

exists(x,
f(x, 6))

exists(x,
f(x, 5))

exists(x,
f(x, 3))

exists(x,
f(x, 4))

forall(y,
exists(x, f(x, y)), 7)

not exists(x,
forall(y, f(x, y)), 4)

not f(1, 2)

f(3, 2)

f(4, 1)

not f(4, 5)

not f(3, 6)

not f(2, 7)

f(8, 7)

f(9, 6)

f(10, 5)

===================================

true.

?-

Siccome il tableau sviluppato per la formula negata non chiude, allora la formula originale non è valida. Per sapere se essa è soddisfacibile o insoddisfacibile
sviluppiamo un altro tableau non negando la formula:

?-
prova((forall(y,exists(x,f(x,y))) implies exists(x,forall(y, f(x,y))))).

===========[RAMO
APERTO]===========

forall(y,
exists(x, f(x, y)))implies exists(x, forall(y, f(x, y)))

not
forall(y, exists(x, f(x, y)))

not
exists(x, f(x, 1), 0)

not
exists(x, f(x, 1), 1)

not
exists(x, f(x, 1), 2)

not
exists(x, f(x, 1), 3)

not
exists(x, f(x, 1), 4)

not
exists(x, f(x, 1), 5)

not
exists(x, f(x, 1), 6)

not
exists(x, f(x, 1), 7)

not
exists(x, f(x, 1),

not
exists(x, f(x, 1), 9)

not
exists(x, f(x, 1), 10)

not
f(1, 1)

not
f(2, 1)

not
f(3, 1)

not
f(4, 1)

not
f(5, 1)

not
f(6, 1)

not
f(7, 1)

not
f(8, 1)

not
f(9, 1)

not
f(10, 1)

===================================

===========[RAMO
APERTO]===========

forall(y,
exists(x, f(x, y)))implies exists(x, forall(y, f(x, y)))

exists(x,
forall(y, f(x, y)))

forall(y,
f(1, y), 0)

forall(y,
f(1, y), 1)

forall(y,
f(1, y), 2)

forall(y,
f(1, y), 3)

forall(y,
f(1, y), 4)

forall(y,
f(1, y), 5)

forall(y,
f(1, y), 6)

forall(y,
f(1, y), 7)

forall(y,
f(1, y),

forall(y,
f(1, y), 9)

forall(y,
f(1, y), 10)

f(1,
1)

f(1,
2)

f(1,
3)

f(1,
4)

f(1,
5)

f(1,
6)

f(1,
7)

f(1,

f(1,
9)

f(1,
10)

===================================

true.

?-

Abbiamo due rami aperti, quindi la formula è soddisfacibile.

Ultimo esempio d’uso

Vogliamo provare la validità della formula.

?- prova(not
(exists(x, exists(y,r(x,y) or r(y,x)) ) implies exists(x,exists(y,r(x,y))) )).

===========[RAMO
CHIUSO]===========

not
(exists(x, exists(y, r(x, y)or r(y, x)))implies exists(x, exists(y, r(x, y))))

exists(x,
exists(y, r(x, y)or r(y, x)))

exists(y,
r(1, y)or r(y, 1))

r(1, 2)or
r(2, 1)

not exists(x,
exists(y, r(x, y)), 0)

not exists(y,
r(2, y), 0)

not exists(y,
r(1, y), 0)

not exists(y,
r(1, y), 2)

not exists(y,
r(2, y), 2)

not exists(x,
exists(y, r(x, y)), 2)

r(1, 2)

not r(2, 1)

not r(2, 2)

not r(1, 1)

not r(1, 2)
XXX

===================================

===========[RAMO
CHIUSO]===========

not
(exists(x, exists(y, r(x, y)or r(y, x)))implies exists(x, exists(y, r(x, y))))

exists(x,
exists(y, r(x, y)or r(y, x)))

exists(y,
r(1, y)or r(y, 1))

r(1, 2)or
r(2, 1)

not exists(x,
exists(y, r(x, y)), 0)

not exists(y,
r(2, y), 0)

not exists(y,
r(2, y), 2)

not exists(x,
exists(y, r(x, y)), 2)

not exists(y,
r(1, y), 0)

r(2, 1)

not r(2, 1)
XXX

===================================

true.

?-

Dall’output dell’elaborazione si vede che il tableau
sviluppato ha due rami chiusi, quindi la formula è valida.

Codice sorgente completo

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Definizione degli operatori logici

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

:-
op(650, xfy, sse).

:-
op(640, xfy, implies).

:-
op(630, yfx, or).

:-
op(620, yfx, and).

:-
op(610, fy, not).

% Per i
quantificatori usiamo forall(x,fbf) e exists(x,fbf).

% Le
costanti devono essere dei numeri, e le lettere in minuscolo sono le variabili

:-
op(600, xfy, \).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Predicato per verificare il tipo

% delle formule ben formate

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

is_alpha(_
and _).

is_alpha(_
sse _).

is_alpha(not
(_ or _)).

is_alpha(not
(_ implies _)).

is_beta(_
or _).

is_beta(_
implies _).

is_beta(not
(_ and _)).

is_beta(not
(_ sse _)).

is_delta(exists(
_ , _ )).

is_delta(not
forall( _ , _ )).

is_fresh_gamma(forall(
X , Y ), forall( X , Y , 0)).

is_fresh_gamma(not
exists( X , Y ), not exists( X , Y , 0)).

is_gamma(forall(
_ , _ , _ )).

is_gamma(not
exists( _ , _ , _ )).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Controllo formula atomica ground

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

atomo_ground(X)
:- compound( X ), X =.. [_|Terms], lista_interi(Terms).

lista_interi([]).

lista_interi([Termine
| Terms]) :- integer(Termine), lista_interi(Terms).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Controllo formula atomica

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

atomo(X)
:- compound( X ), X =.. Parametri, parametri_validi(Parametri).

parametri_validi([]).

parametri_validi([Parametro
| Tail]) :- atomic(Parametro),

Parametro \== not,

Parametro \== and,

Parametro \== or,

Parametro \== implies,

Parametro \== sse,

Parametro \== forall,

Parametro \== exists,

!,

parametri_validi(Tail).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Controllo formula ben formata

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

fbf_chiusa(
X and Y ) :- !, fbf_chiusa(X),fbf_chiusa(Y).

fbf_chiusa(
X or Y ) :- !, fbf_chiusa(X), fbf_chiusa(Y).

fbf_chiusa(
X implies Y ) :- !, fbf_chiusa(X), fbf_chiusa(Y).

fbf_chiusa(
X sse Y ) :- !, fbf_chiusa(X), fbf_chiusa(Y).

fbf_chiusa(
forall(X,Y) ) :- atomic(X),instantiate(Y,X,-1,Y1),!, fbf_chiusa(Y1).

fbf_chiusa(
exists(X,Y) ) :- atomic(X), instantiate(Y,X,-1,Y1),!,fbf_chiusa(Y1).

fbf_chiusa(
not X ) :- ! ,fbf_chiusa(X).

fbf_chiusa(
X ) :- atomo_ground(X).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Instanziazione di fbf quantificate

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

instantiate(
X and Y , Var , Par , X1 and Y1) :- !,

instantiate(X,Var,Par,X1),

instantiate(Y,Var,Par,Y1).

instantiate(
X or Y , Var , Par , X1 or Y1) :- !,

instantiate(X,Var,Par,X1),

instantiate(Y,Var,Par,Y1).

instantiate(
X implies Y , Var , Par , X1 implies Y1) :- !,

instantiate(X,Var,Par,X1),

instantiate(Y,Var,Par,Y1).

instantiate(
X sse Y , Var , Par , X1 sse Y1) :- !,

instantiate(X,Var,Par,X1),

instantiate(Y,Var,Par,Y1).

instantiate(
forall(X,Y),Var,Par,forall(X,Y1)) :- X \== Var,

!,

instantiate(Y,Var,Par,Y1).

%le
occorrenze interne della variabile sono bounded nel quantificatore

instantiate(
forall(X,Y),Var,_,forall(X,Y)) :- X == Var, !.

instantiate(
exists(X,Y),Var,Par,exists(X,Y1)) :- X \== Var,

!,

instantiate(Y,Var,Par,Y1).

%le
occorrenze interne della variabile sono bounded nel quantificatore

instantiate(
exists(X,Y),Var,_,exists(X,Y)) :- X == Var,!.

instantiate(
not X,Var,Par, not X1 ) :-!, instantiate(X,Var,Par,X1).

instantiate(
X,Var,Par,X1 ) :- atomo(X), !, substitute_occurrences(X,Var,Par,X1).

substitute_occurrences(X,Var,Par,X1):-
X =.. [Pred|Terms], substitute(Terms,Var,Par,Terms1),X1=..

[Pred|Terms1].

substitute([],_,_,[]).

substitute([Term
| Tail],Var,Par,[Term1 | Tail1]) :- Term == Var,Term1 = Par,!,

substitute(Tail,Var,Par,Tail1).

substitute([Term
| Tail],Var,Par,[Term1 | Tail1]) :- Term \== Var,Term1 = Term,!,

substitute(Tail,Var,Par,Tail1).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% calcolo del Tableau

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

prova(Fbf)
:- tclose(Fbf, 10). % il numero 10 e’ un valore indicativo

tclose(Fbf,
Limite) :- fbf_chiusa(Fbf), closed_branch([Fbf],[],[],[],[],[], Limite, 0, []).

closed_branch([],[],[],[],[],Ls,_,_,Elaborate)
:- !, stampa_ramo([],[],[],[],[],Ls,Elaborate,’APERTO’).

closed_branch([Fbf|_],As,Ds,Bs,Gs,Ls,_,_,Elaborate)
:- chiude(Fbf,As,Ds,Bs,Gs,Ls),

!,

stampa_ramo([Fbf],As,Ds,Bs,Gs,Ls,Elaborate,’CHIUSO’).

closed_branch([Fbf|Fbfs],As,Ds,Bs,Gs,Ls,Limite,Params,Elaborate):-

\+
chiude(Fbf,As,Ds,Bs,Gs,Ls),

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As1,Ds1,Bs1,Gs1,Ls1),

!,

closed_branch(Fbfs,As1,Ds1,Bs1,Gs1,Ls1,Limite,Params,Elaborate).

closed_branch([],As,Ds,Bs,Gs,Ls,Limite,Params,Elaborate)
:- closed_branch(As,Ds,Bs,Gs,Ls,Limite,Params,Elaborate).

%alpha

closed_branch([Formula|As],Ds,Bs,Gs,Ls,Limite,Params,Elaborate)
:-

regola_alpha(Formula,Alpha1,Alpha2),

!,

closed_branch([Alpha1,Alpha2],As,Ds,Bs,Gs,Ls,Limite,Params,[Formula|Elaborate]).

%delta

closed_branch([],[Formula|Ds],Bs,Gs,Ls,Limite,Params,Elaborate)
:-

Params < Limite,

regola_delta(Formula,Delta1,Limite,Params),

Params1 is Params + 1,

!,

closed_branch([Delta1],[],Ds,Bs,Gs,Ls, Limite,Params1,[Formula|Elaborate]).

%delta

closed_branch([],[Formula|Ds],Bs,Gs,Ls,Limite,Params,Elaborate)
:-

Params >= Limite,

!,

closed_branch([],[],Ds,Bs,Gs,Ls, Limite,Params,[Formula|Elaborate]).

%beta

closed_branch([],[],[Formula|Bs],Gs,Ls,Limite,Params,Elaborate)
:-

regola_beta(Formula,Beta1,Beta2),

!,

closed_branch([Beta1],[],[],Bs,Gs,Ls,
Limite,Params,[Formula|Elaborate]),

closed_branch([Beta2],[],[],Bs,Gs,Ls,
Limite,Params,[Formula|Elaborate]).

%gamma

closed_branch([],[],[],[Formula|Gs],Ls,Limite,Params,Elaborate)
:-

is_gamma(Formula),

Params < Limite,

regola_gamma(Formula,Gammas,Limite,Params,Params1),

incrementa(Formula, Formula1,
Params1),

append(Gs, [Formula1], Gs2),

!,

closed_branch(Gammas,
[],[],[],Gs2,Ls, Limite,Params1,[Formula|Elaborate]).

%gamma

closed_branch([],[],[],[Formula|Gs],Ls,Limite,Params,Elaborate)
:-

is_gamma(Formula),

Params >= Limite,

regola_gamma(Formula,Gammas,Limite,Params,Params1),

!,

closed_branch(Gammas,
[],[],[],Gs,Ls, Limite,Params1,[Formula|Elaborate]).

regola_alpha(
A and B, A, B ).

regola_alpha(
not ( A implies B ), A, not B ).

regola_alpha(
not ( A or B ), not A, not B ).

regola_alpha(
A sse B, A implies B, B implies A).

regola_beta(
A or B, A, B ).

regola_beta(
A implies B, not A, B ).

regola_beta(
not ( A and B ), not A, not B ).

regola_beta(
not ( A sse B ), not ( A implies B ), not ( B implies A ) ).

regola_delta(exists(X,Fbf),Fbf1,_,N):-
N1 is N+1, instantiate( Fbf , X , N1 , Fbf1).

regola_delta(not
forall(X,Fbf),not Fbf1,_,N):- N1 is N+1, instantiate( Fbf , X , N1 , Fbf1).

regola_gamma(forall(X,
Fbf, N), Gammas, Limite, Params, Params1) :-

regola_gamma(Gammas, X, Fbf, N, N, Limite, Params, Params1).

regola_gamma(not
exists(X, Fbf, N), Gammas, Limite, Params, Params1) :-

regola_gamma(Gammas, X, not Fbf,
N, N, Limite, Params, Params1).

% la
regola gamma introduce parametri nuovi

regola_gamma([],
_, _, N, _, Limite, Params, _) :- N == Params, N >= Limite,!.

regola_gamma([Fbf1],
X, Fbf, N, _, Limite, Params, Params1) :- N == Params, Params < Limite,

!,

Params1 is Params
+ 1,

instantiate( Fbf
, X , Params1 , Fbf1).

% la
regola gamma non introduce parametri nuovi

regola_gamma([Fbf1
| Gammas], X, Fbf, N, Next, _, Params, Params1) :- N < Params,

Next < Params,

Next1 is Next+1,

instantiate( Fbf
, X , Next1 , Fbf1),

!,

regola_gamma(Gammas, X, Fbf, N, Next1, _, Params, Params1).

regola_gamma([],
_, _, N, Next, _, Params, Params) :- N < Params , Next == Params.

push_formula(not not
Fbf,As,Ds,Bs,Gs,Ls,As1,Ds1,Bs1,Gs1,Ls1) :- !,

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As1,Ds1,Bs1,Gs1,Ls1).

push_formula(Fbf,As,Ds,Bs,Gs,Ls,[Fbf
| As],Ds,Bs,Gs,Ls) :- is_alpha(Fbf), !.

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As,[Fbf
| Ds],Bs,Gs,Ls) :- is_delta(Fbf), !.

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As,Ds,[Fbf
| Bs],Gs,Ls) :- is_beta(Fbf), !.

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As,Ds,Bs,[Fbf1
| Gs],Ls) :- is_fresh_gamma(Fbf, Fbf1), !.

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As,Ds,Bs,[Fbf
| Gs],Ls) :- is_gamma(Fbf), !.

push_formula(Fbf,As,Ds,Bs,Gs,Ls,As,Ds,Bs,Gs,[Fbf
| Ls]) :- atomo(Fbf), !.

push_formula(not
Fbf,As,Ds,Bs,Gs,Ls,As,Ds,Bs,Gs,[not Fbf | Ls]) :- atomo(Fbf), !.

chiude(not
Fbf,_,_,Bs,_,_) :- is_alpha(Fbf), member(Fbf, Bs), !.

chiude(not
Fbf,_,_,_,Gs,_) :- is_delta(Fbf), member(Fbf, Gs), !.

chiude(not
Fbf,As,_,_,_,_) :- is_beta(Fbf), member(Fbf, As), !.

chiude(not
Fbf,_,Ds,_,_,_) :- is_gamma(Fbf), member(Fbf, Ds), !.

chiude(not
Fbf,_,_,_,_,Ls) :- atomo_ground(Fbf), member(Fbf, Ls), !.

chiude(Fbf,_,_,Bs,_,_)
:- is_alpha(Fbf), member(not Fbf, Bs), !.

chiude(Fbf,_,_,_,Gs,_)
:- is_delta(Fbf), member(not Fbf, Gs), !.

chiude(Fbf,As,_,_,_,_)
:- is_beta(Fbf), member(not Fbf, As), !.

chiude(Fbf,_,Ds,_,_,_)
:- is_gamma(Fbf), member(not Fbf, Ds), !.

chiude(Fbf,_,_,_,_,Ls)
:- atomo_ground(Fbf), member(not Fbf, Ls), !.

%
incrementa(Fbf, Fbf1) :- Fbf1 e’ la formula di tipo gamma Fbf con il campo
contatore N incrementato

incrementa(forall(X,
Fbf, _), forall(X, Fbf, Params), Params).

incrementa(not
exists(X, Fbf, _), not exists(X, Fbf, Params), Params).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Utilita’

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%
maximum(X, Y, Z) :- Z e’ il massimo tra X e Y

maximum(X,Y,X)
:- X >= Y.

maximum(X,Y,Y)
:- X < Y.

%
delete(X, Lista, Lista1) :- Lista1 e’ la lista risultante dalla cancellazione
di X da Lista

delete(X,
[X|Rest], Rest).

delete(X,
[Y | Rest], [Y|Deleted]) :- !, delete(X, Rest, Deleted).

nonmember(_,
[]).

nonmember(X,
[Y|Ys]):- X \== Y, !, nonmember(X, Ys).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Utilita’ per la stampa

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

stampa_ramo(Fbf,As,Ds,Bs,Gs,Ls,Elaborate,Tipo)
:-

write(’===========[RAMO '), write(Tipo),
write(']===========’), nl,

stampa_formule(Elaborate),

stampa_formule(As),

stampa_formule(Ds),

stampa_formule(Bs),

stampa_formule(Gs),

stampa_formule(Ls),

stampa_ultima_formula(Fbf),

nl,

write(’===================================’), nl, nl.

stampa_formule(
[] ).

stampa_formule(
[Formula | Formulas] ) :- stampa_formule(Formulas), write(Formula), nl.

stampa_ultima_formula([]).

stampa_ultima_formula([Fbf])
:- write(Fbf), write(’ XXX’).

Seppur con idee diverse, i pionieri dell’IA (McCarthy, Minsky, Rochesterm, e Shannon) videro nel calcolatore digitale uno strumento con capacità di elaborazione ineguagliate, quindi uno strumento adatto al confronto con alcuni aspetti della mente umana.
Si cominciarono a sviluppare i primi programmi relativi ad ambiti ben delimitati in cui c’erano  solo regole esplicite per l’elaborazione simbolica e poca conoscenza specializzata. Motivo di questo inizio era la scarsa capacità di memoria e di calcolo dei calcolatori di quei tempi.
Successivamente si parte con lo sviluppo di sistemi esperti, dove la conoscenza specializzata nel campo ci porta ad avere buone prestazioni.

La diffusione di queste tecniche di IA ci conferma il successo dal punto di vista ingegneristico, ma cosa possiamo dire dal punto di vista psicologico?
Cosa implica la costruzione di macchine che riproducono caratteristiche essenziali dell’attività umana? Dove si colloca l’IA nell’ambito delle ricerche sul sistema cervello-mente che coinvolgono le neuroscienze e la psicologia?

Turing e la Macchina di Turing Universale

Abbinando le MdT (Macchine di Turing) alle codifiche di Godel, nasce un modo di codificare le MdT. Si ha inoltre un procedimento effettivo per la codifica e la decodifica.
Dalle MdT codificate, Turing arriva alla macchina universale, che è una particolare MdT che, accettando in input la descrizione di una qualsiasi MdT, riesce a comportarsi come essa.

Dalla MdT Universale nasce la nozione di Macchina Programmabile.
Da questa considerzione ci si chiese se le macchine possano essere intelligenti. Su questo Turing scrive l’articolo “Macchine calcolatrici e intelligenza”.

Macchine calcolatrici e intelligenza

Turing considera la domanda: “Possono pensare le macchine?“. In questa domanda i termini macchina e pensare non sono di facile definizione.

Possiamo definire la parola macchina possiamo imporre che la macchina sia composta da tre parti: memoria, unità operativa, e governo; dove la memoria è un deposito di informazioni, l’unità operativa è la parte atta ad eseguire operazioni, ed il governo coordina l’unità operativa e la memoria.
Quindi scendendo più in dettaglio riusciamo a definire cos’è una macchina.

Cosa possiamo invece definire la parola pensare? Turing non riesce a farlo.
Per questo pensa di riformulare la domanda “Possono pensare le macchine?” con un’altra. Riformula il problema in termini di un gioco dove si trovano tre persona A (un uomo), B (una donna), e C (un’interrogante). C è isolato in una stanza, e può comunicare con A e B mediante messaggi di tipo linguistico.
Lo scopo di C, che parla con due individui, è di capire chi è la donna e chi è l’uomo. B (che è la donna) ha il compito di aiutare l’interrogante C, mentre lo scopo di A (l’uomo) è quello di ingannarlo.
La domanda riformulata è: “Che cosa accadrà se una macchina prende il posto di A nel gioco? La frequenza delle risposte errate da parte di C sarà la stessa di quando il gioco si svolge tra uomini?“.

Chiamiamo questo Test di Turing.

Test di Turing e Intelligenza

Superare il test di Turing, non è una condizione né necessaria, né sufficiente per stabilire se un individuo o una macchina è intelligente.

• Condizione Necessaria: se un essere è intelligente deve necessariamente superare il Test di Turing. Ma ci sono situazioni, come quelle delle persone nello stato locked-in (ad esempio il famoso caso di Piergiorgio Welby), in cui l’individuo non è in grado di superare il test, ma comunque non possiamo dire che tale individuo non è intelligente.
• Condizione Sufficiente: supponiamo una macchina con un programma complicatissimo, che è fatta apposta per superare il Test di Turing. Questa macchina sa solo superare questo test e basta: possiamo definirela intelligente?

Quindi il superamento del Test di Turing da parte di una macchina non è né condizione necessaria, né condizione sufficiente per affermare che la macchina stressa sia intelligente.

Osservazioni all’articolo

Prima Osservazione: Funzionalismo

Notiamo che in questo gioco la macchina da risposte di tipo linguistico; infatti Turing divide nettamente le capacità fisiche di un essere umano, dalle capacità intellettuali (o mentali). Questo non è vero nell’eccezione Darwiniana in cui le capacità mentali di un essere vivente sono di fondamentale importanza per coordinare le capacità motorie, e permettono così di sopravvivere.
Essendo la mente umana composta da materiali diversi da quelli con i quali è costruita una macchina, Turing adotta il funzionalismo, ossia paragona il funzionamento degli oggetti anche se costruiti in modo diverso.

Seconda Osservazione: La mente funziona a stati discreti

I calcolatori digitali sono indubbiamente delle macchine a stati discreti. Ovvero si muovono a scatti improvvisi ben distinguibili l’uno dall’altro.
Anche se in realtà in natura niente è discreto; se indaghiamo un calcolatore digitale funziona anch’esso in modo continuo. Ma consideriamolo una macchina a stati discreti.
Ci conviene discretizzare la mente paragonandola ad un calcolatore digitale?

Terza Osservazione: I calcolatori digitali non sono caotici

Dato un input in ingresso ad una macchina riusciamo a predire tutti i suoi stati, ed il suo output, in modo esatto. Nel mondo invece vige la teoria del caos, nella quale piccole variazioni nelle condizioni iniziali producono grandi variazioni nel comportamento a lungo termine di un sistema. Ad esempio il battito d’ali di una farfalla può essere la causa di un uragano dall’altra parte del mondo.

Obiezioni Contrarie all’argomento principale dell’articolo

Obiezione Teologica: “Solo Dio ha il potere di creare esseri pensanti”.
Questa obiezione pone serie restrizioni alla provvidenza divina: chi ci dice che Dio non ci abbia dato il potere di creare macchine pensanti?

Obiezione della Testa nella Sabbia: Questa è l’obiezione di chi ha paura delle macchine pensanti. A queste persone piace sentirsi superiori di ogni altra cosa, e si sentono minacciati da questo tentativo di creare macchine pensanti.

Obiezione Matematica: I teoremi di incompletezza di Godel, ed altri risultati ad esso annessi, dimostrano che le macchine non possono conoscere tutte le verità. Quindi esistono dei limiti, e si sostiene che la mente umana non abbia questi limiti.
Ma non è giusto condannare così i calcolatori; diamo risposte errate anche noi. Inoltre ci possono essere uomini più abili di una macchina, ma possono essere costruite altre macchine più abili di questi uomini. Quindi non ci possono essere uomini più abili di tutte le macchine.

Obiezione dell’Autocoscienza: Possiamo dividere la coscienza in “essere consapevole del proprio stato”, ed “essere consapevoli di provare”. Possiamo costruire macchine con medoti di Machine Learning che sono consapevoli del proprio stato, ma non ancora riusciamo ad immaginare macchine che sappiano provare dei sentimenti.

Obiezioni basate su incapacità varie: ad esempio una macchina è capace di gustare le fragole con la panna.
Queste obiezioni nascono dal fatto che vogliamo far assomigliare le macchine agli essere umani. Ma, non essendo le macchine degli essere umani, è difficile avere un rapporto di amicizia tra un uomo ed una macchina.

Obiezione di Lady Lovelace: “La macchina può eseguire solo quello che gli diciamo di fare!”. Questa obiezione è vecchia e risale ai tempi della macchina universale di Babbage.
Con i moderni metodi di Machine Learning possiamo avere delle macchine che riescono ad apprendere, anche se sono formate da un nucleo di base non modificabile. Quindi anche essendo una macchina deterministica, possiamo avere macchine che modificano il proprio comportamento man mano che apprendono nuove regole.

Obiezione fondata sulla continuità del sistema nervoso: Ancora una volta ci rifacciamo al concetto di funzionalismo, secondo il quale cerchiamo di ottenere solo un comportamento intelligente, e non pretendiamo che internamente le cose funzionino allo stesso modo.

Possono le macchine pensare?

Dopo l’articolo di Turing partono gli studi per costruire macchine in grado di competere con l’uomo in ambiti intellettuali. Ma quel’è la strada migliore per iniziare a costruire queste macchine?

L’IA comincia a sviluppare programmi per calcolatori digitali capaci di svolgere attività molto astratte, come giocare a scacchi.
La robotica invece inizia mettendo in risalto il comportamento intelligente degli esseri viventi, e comincia a costruire dispositivi meccanici che si comportano in modo intelligente.

Parallelamente a queste due nasce anche la branca della Machine Learning, un’intuizione geniale da parte di Turing.

La cibernetica prima dei calcolatori digitali

La cibernetica nasce con i sistemi a retroazione. La differenza con il punto di vista di Turing, è che questa volta il comportamento intelligente è visto come un comportamento flessibile-adattativo all’ambiente: c’è un tentativo di collegare questi sistemi a retroazione ai sistemi biologici, con un conseguente collegamento alla scienza molto più forte.
Da un altro punto di vista notiamo che i cibernetici partono dal basso, costruendo prima sistemi molto semplici, mentre Turing punta a riprodurre l’attività mentale umana con un macchina… un compito arduo.

Un primo esempio di sistema a retroazione è la valvola di sfiato della caldaia di una locomotiva a vapore; il suo compito era quello di tenere la pressione costante all’interno della caldaia, in modo da mantenere costante la velocità del treno. Quindi quando la pressione era troppo alta, la valvola faceva uscire del vapore per farla diminuire.
Questo primo meccanismo di sistema a retroazione puntava a correggere l’errore, in un ciclo di questo tipo:

1. Osservare l’output del sistema
2. Misurare l’errore
3. Apportare le modifiche atte a correggere l’errore

Questi meccanismi hanno delle caratteristiche in comune con i sistemi biologici: ad esempio il corpo umano ha un meccanismo simile per controllare la temperatura corporea (la sudorazione).
Rosenblueth, Wiener, e Bigelow, nel loro articolo “Coportamento, Scopo, e Teleologia” affermano che i metodi di studio sia per gli organismi viventi, sia per le macchine, sono simili in quanto non sono state trovare delle caratteristiche qualitativamente diverse che caratterizzano un gruppo e non l’altro.

Possiamo dividere le cause dei mutamenti della natura in quelli provocati da:
- cause efficienti: è l’agente che determina operativamente il mutamento
- cause finali: è l’intenzione di qualche essere vivente a raggiungere un certo scopo

I cibernetici puntano a descrivere il comportamento intelligente usando solo le cause efficienti, in quanto le cause finali sono caratteristiche dei sistemi biologici.
Come esempio possiamo considerare il comportamento della falena che è stato descritto da uno studioso americano con sole cause efficienti.

Comportamento, Scopo, e Teleologia

Il comportamento intelligente può essere diviso in due grosse classi: il comportamento rivolto ad uno scopo (finalizzato), e il comportamento non rivolto ad uno scopo (causale).

Noi ci interessiamo al comportamento rivolto ad uno scopo. Ma cos’è uno scopo? Abbiamo un tentativo riduzionista, che riduce lo scopo ad un oggetto, e il suo raggiungimento è uno spostamento spazio/temporale dell’oggetto stesso.
Su questa visione di vedere uno scopo si inseriscono i critici obiettando il fatto che non sempre lo scopo è un oggetto.

Il comportamento rivolto ad uno scopo può essere diviso a sua volta in comportamento rivolto ad uno scopo con retroazione (o teleologico) o senza retroazione (non teleologico).
Il comportamento rivolto ad uno scopo senza retroazione raggruppa tutti quei casi in cui il movimento è talmente veloce in cui è impensabile che ci sia del tempo utile a modificare il movimento mentre lo si sta facendo. Ad esempio, il comportamento di una rana mentre colpisce una mosca per mangiarsela, è senza retroazione.

Ci interesseremo al comportamento rivolto ad uno scopo con retroazione, nel quale l’azione che si sta svolgendo è modificabile mentre la si sta facendo. Questo tipo di comportamento è più efficace del comportamento senza retroazione, specialmente quando lo scopo è un oggetto fermo.

Il comportamento rivolto ad uno scopo con retroazione può essere ulteriormente diviso in comportamento rivolto ad uno scopo con retroazione non predittivo o non estrapolativo (la falena che cammina verso la luce) e predittivo o estrapolativo (il gatto che balza per catturare un topo nella posizione in cui il topo dovrebbe stare dopo il balzo, quindi il gatto è capace di estrapolare la posizione del topo in un istante di tempo futuro).

Intelligenza e Comportamento rivolto ad uno scopo

Nell’articolo “Coportamento, Scopo, e Teleologia” non sono state individuate le condizioni necessarie e sufficienti per affermare che un agente ha il comportamento intelligente per raggiungere uno scopo. Questo perché il tentativo riduzionista per la descrizione di cosa si intende per scopo ci vincola troppo.

• Condizione Necessaria: Supponiamo ci sia un cavaliere alla ricerca del Santo Graal. Se il Santo Graal non esiste, come descriviamo lo scopo di questo cavaliere se imponiamo che lo scopo sia un oggetto?
• Condizione Sufficiente: Supponiamo una persona si sveglia all’improvviso durante la notte, e spara un colpo di pistola allo specchio. Come descriviamo lo scopo di questo signore? Il suo intento non era sparare nello specchio, ma l’ha fatto per motivi che non conosciamo.

Quindi la definizione di Scopo come una relazione spazio/temporale relativa ad un oggetto è troppo restrittiva per descrivere il comportamento intelligente rivolto ad uno scopo.

Il ruolo dei Modelli nella Scienza

La cibernetica lavora con i modelli. Obiettivo della scienza è ottenere la comprensione ed il controllo di una qualche parte dell’universo. Ad esempio la lancetta del barometro che si abbassa ha come causa  (comprensione) l’abbassamento della pressione; ed anche, la cura per una malattia (controllo) mediante antibiotici.

Ma nessuna parte dell’universo si lascia afferrare senza un minimo di astrazione. I modelli ci aiutano proprio a questo: un modello formale (o intellettuale) rappresenta con astrazione un sistema studiato (cioè la parte dell’universo che stiamo studiando).

Possiamo dividere i modelli in:

• Modello materiale: rappresentazione del sistema studiato ottenuto mediante un altro sistema, di solito più semplice, ma con proprietà simili al sistema studiato.
• Modello Formale: rappresenta in termini logici il sistema studiato in maniera semplice, con proprietà simili.

I modelli materiali sono utili quando:
- Vogliamo studiare un sistema di un campo inconsueto (sistema studiato), in un campo più familiare (modello meccanico)
- Il modello materiale permette di svolgere esperimenti in condizioni più favorevoli rispetto a quelle date dal sistema studiato. Ad esempio ci conviene sperimentare nuovi farmaci prima sui topi, e poi sugli umani. Ma su quale base diciamo che un topo è un modello materiale dell’umano? Lo diciamo secondo alcuni criteri di “somiglianza” rispetto al modello originale.

I modelli non sono utili quando:
- Se il modello formale non rispecchia bene il sistema studiato, anche il modello materiale sarà poco significativo.
- Se il modello materiale suggerisce esperimenti predittibili dal modello formale, allora esso è superfluo.

Possiamo dividere i problemi in quelli a scatola chiusa e quelli a scatola aperta.
Nei problemi a scatola chiusa conosciamo solo alcuni input e possiamo verificare gli output, ma non sappiamo cosa avviene dentro la scatola. La legge di trasformazione è quella legge che mette in relazione l’input con l’output. Per scoprire cosa c’è nella scatola possiamo provare ad aprirla ed individuare altri input e/o altri output in modo da svolgere studi più approfonditi. Man mano che apriamo tutte le scatole trovate durante lo studio, abbiamo un problema a scatola aperta.
Nell’aprire le scatole, e quindi nell’aggiungere dettagli alla nostra descrizione, facciamo un’ipotesi di modularità, ipotizzando che gli input individuati siano debolmente accoppiati con gli altri elementi della scatola. Bisogna stare attenti quando si studiano questi problemi a scendere nel dettaglio fino ad un livello per noi soddisfacente, in modo da avere una buona descrizione del problema senza complicarlo in modo eccessivo.

“Computer Simulation of Human Thinking” – Newell & Simon

Abbiamo discusso gli sviluppi della prima Cibernetica. Adesso ci spostiamo sul ramo della prima IA, ed esaminiamo il lavoro di Newell & Simon.

Newell & Simon, due neuroscienziati che studiavano la mente, avevano lo scopo di cercare dei modelli del mentale, ossia dei modelli che rappresentassero l’attività cognitiva umana.
Quindi volevano costruire dei programmi che simulassero i compiti cognitivi umani in modo psicologicamente realistico.

Per fare ciò si costruirono delle Microteorie. Ogni microteoria era relativa ad un particolare categoria di compiti cognitivi, ad esempio giocare a dama: essi chiedevano alla persona sotto esame di giocare a dama e pensare a voce alta, quindi riferire tutti i suoi ragionamenti selettivi ed euristici (introspezione).
Il programma risultante di questo studio, non solo doveva dare gli stessi risultati del ragionamento cognitivo (e quindi supera il test di Turing), ma nel calcolarli doveva elaborare le informazioni nello stesso modo di un essere umano. Quest’ultima condizione serve ad avere una simulazione psicologicamente realistica del ragionamento umano.
Una volta costruito un modello per un compito cognitivo, abbiamo una microteoria. Newell & Simon volevano trarre un modello della mente combinando tra loro tutte le microteorie ottenute.

La differenza con Turing, è che Newell & Simon consideravano il test di Turing “debole” in quando non riguarda i processi del pensiero, ma prende in considerazione solo la prestazione finale.

Critiche al lavoro di Newell & Simon

Critica sull’uso del protocollo verbale

Il protocollo verbale, con il quale i soggetti studiati illustravano il proprio processo di pensiero sono incompleti perché non tutti i processi della mente sono accessibili all’introspezione.
Inoltre questo metodo di studio del mentale è scorretto perché pensare e descrivere cosa si sta pensando sono due compiti concorrenti che possono interferire tra loro.
Si sta studiando il modo di pensare, o il modo in cui un essere umano descrive il proprio pensiero?

Critica sul dominio di applicazione

Le microteorie sono strettamente collegate al particolare problema. Quindi applicando il modello suggerito da una microteoria ad un problema simile a quello di partenza non si hanno buoni risultati.

Critica sul campione di persone

Il campione scelto per eseguire i test è ristretto, e non rispecchia il modo di pensare di tutta la popolazione. Inoltre ogni persona ha un modo particolare di pensare.

Critica sulla modularità

Newell & Simon non fanno ipotesi di modularità sulla mente e la considerano interamente in un’unica architettura unificata. Successivi studi (Chomsky, Marr, Fodor, ed altri) tentano di dividere la mente in moduli, in modo da poterli studiare indipendentemente.

Conclusioni

Il lavoro di Newell & Simon è stato fallimentare, ma il loro contributo all’IA è stato enorme. Tutt’oggi le euristiche da loro definite sono molto utilizzate.

Chomsky ed il Linguaggio Universale

Un esempio di ipotesi di modularità è il Linguaggio Universale di Chomsky. Lui osserva come i bambini nei loro primi anni di vita riescono ad imparare la lingua, e nota che gli stimoli che essi ricevono sono di scarsa qualità per ottenere i risultati che si hanno.
Quindi l’ipotesi di modularità di Chomsky è che nella nostra mente esiste un modulo di Grammatica Universale (UG) che ci aiuta ad imparare il linguaggio parlato.

Quello che ha fatto Chomsky è isolare questo modulo UG dalle restanti parti della mente, e studiarlo a se stante.
Questo è proprio quello che manca nel lavoro fatto da Newell & Simon, in quanto non avendo fatto ipotesi di modularità, non riescono a trovare delle variabili in comune a tutti gli essere umani con le quali è possibile creare un modello di tutta la mente umana.

David Marr

Marr, essendo allievo di Chomsky, prende da lui spunto, e nel suo articolo “Artificial Intelligence – A Personal View” espone la sua critica al lavoro di Newell & Simon.

Secondo Marr, un risultato nel campo dell’IA doveva seguire questi passaggi:

1. Definizione di cosa è calcolato, e perché è calcolato
2. Definire come calcolarlo, quindi definizione di un algoritmo
3. Dimostrazione di funzionamento

Il “perché” non è interessante da definire in quanto è legato alla natura del problema: il mondo è fatto così. Il “cosa” invece è molto interessante, in quanto questo passaggio non è stato considerato da Newell & Simon. Infatti è difficile definire “cosa” calcolare in modo preciso quando si sta tentando di costruire un modello per l’intera mente umana.

Marri chiama teorie di tipo 1 quelle in cui si riesce a trovare una buona descrizione di cosa è calcolato, e chiama teorie di tipo 2 quelle in cui non si è ancora riusciti a dare una descrizione formale.

Antonio Damasio

Molti hanno criticato Newell & Simon per mancanza di ipotesi di modularità. In realtà un’ipotesi di modularità è stata fatta: l’attività di problem solving della mente umana è considerata indipendente dalle emozioni provate.

Damasio, neurologo e neuroscienziato degli anni 80, nello studiare un caso clinico si accorge che il paziente non è in grado di provare emozioni.
Questo paziente è perfettamente in grado di effettuare ragionamenti razionali, e risponde correttamente a domande a lui poste. Però quando è coinvolto in prima persona non riesce a prendere le decisioni giuste con i suoi ragionamenti.

L’ipotesi di Damasio è che le emozioni hanno un ruolo importante nel ragionamento pratico.

Test effettuati con questo paziente mostrano che non è in grado di provare emozioni. Ad esempio in una partita a poker non prova tristezza se perde una mano di gioco, oppure riesce a parlare in modo freddo della sua malattia (o di eventi brutti) con freddezza.

Damasio va oltre questa ipotesi e ne formula un’altra, in cui afferma che, come le emozioni, le immagini mentali hanno un ruolo nel ragionamento pratico.

Supponiamo di essere stati morsi da un cane mentre passeggiavamo nel parco. Dopo qualche giorno se ripensiamo a quel cane, riusciamo ad immaginarlo e a ricostruirci nel nostro buffer visivo la sua immagine. Assieme alla scena ricostruita associamo un’emozione che può essere bella o brutta a seconda se il morso del cane ci è piaciuto oppure no (ovviamente in questo caso non ci è piaciuto). Quindi in futuro cercheremo di non passare vicino a quel cane perché rischiamo di essere morsi nuovamente: così facendo nel nostro ragionamento pratico elimineremo tutti gli scenari possibili che ci portano nelle vicinanze di quel cane.
Damasio dice con questa ipotesi che il paziente da lui studiato è incapace associare le immagini mentali alle emozioni, e quindi nel suo ragionamento pratico può scegliere un’azione che lo riporta a commettere un errore già fatto in passato.

Con queste ipotesi Damasio ha cercato di spiegare l’assenza di pianificazione e di prudenza che ha il suo paziente durante i ragionamenti pratici che lo coinvolgono i prima persona.
Inoltre mostra come le emozioni hanno un ruolo centrale nel ragionamento, e quindi è sbagliato considerarle indipendenti dal problem solving. Quindi sarà possibile progettare macchine con prestazioni pari a quelle degli essere umani anche se non provano emozioni?

Gottfried Wilhelm von Leibniz

Leibniz (Lipsia, 21 giugno 1646 – Hannover, 14 novembre 1716), è stato un filosofo, matematico, e logico tedesco. Ai suoi tempi la logica era quella Aristotelica, quindi del tipo soggetto-predicato.

Leibniz fu il primo ad intuire l’elaborazione simbolica con il suo progetto della Characteristica Universalis. L’idea alla base della Cu (Characteristica Universalis) era quella di creare un linguaggio universale per migliorare le comunicazioni politiche, religiose, e commerciali; quindi la Cu doveva essere un linguaggio in grado di guidare ogni sorta di ragionamento.

Il progetto della Cu prevedeva:

1. Una Lista dei concetti primitivi e simboli corrispondenti
2. Un’Arte Combinatoria utile a combinare i concetti primitivi:
   1. Ars Iudicandi: procedura di decisione della verità
   2. Ars Invenendi: procedura di decisione generativa

Notiamo che l’Ars Iudicandi e l’Ars Invenendi prevedevano l’introduzione nel sistema della Cu di due procedure effettive, ovvero ci doveva essere un procedimento preciso (algoritmo) sia per decidere la verità di una sentenza del linguaggio (Ars Iudicandi), sia per ottenere altre verità dalle verità che già conosciamo (Ars Invenendi).

I concetti di Procedura Effettiva e Calcolo Simbolico sono dunque nati da quest’idea di Leibniz.

Purtroppo il programma di sviluppare questo linguaggio è solo un progetto di Leibniz che non è mai stato sviluppato. Abbiamo solo dei documenti e schizzi a riguardo, che saranno poi usati da Frege.

Qui notiamo che l’Ars Iudicandi prevede una sorta di predicato dim(x,y), vero quando x è (il numero di) una dimostrazione della formula (di numero) y. Quindi è quasi un esempio compiuto di Sistema Formale.

Immanuel Kant

Kant (Königsberg, 22 aprile 1724 – Königsberg, 12 febbraio 1804) è stato un filosofo tedesco. Egli scrive un’opera alla fine del ‘700 nella quale diceva: “La matematica è una cosa certa, e noi dobbiamo studiare solo come arrivare a questa certezza. Inoltre ci si può chiedere: perché la matematica è certa? Qual è il suo fondamento?”.

Frege proverà a rispondere a questa domanda.

Friedrich Ludwig Gottlob Frege

Frege (Wismar, 8 novembre 1848 – Bad Kleinen, 26 luglio 1925) è stato un matematico, logico e filosofo tedesco, padre della logica matematica moderna.

Frege voleva rispondere alla domanda posta da Kant (“Perché la matematica è certa?”), usando l’intuizione che aveva avuto Leibniz nella sua Characteristica Universalis.

Qui è introdotta la Tesi Logicista (o Programma Logicista):

“La Matematica è riconducibile alla Logica”

Si afferma che la matematica è logica! Per portare avanti il Programma Logicista, Frege introduce la logica del primo e del secondo ordine come la conosciamo attualmente. Lui la chiamava Ideografia.
Nel 1879 Frege propose l’Ideografia un “linguaggio in formule del pensiero puro, a imitazione di quello aritmetico” in cui dice: il modo più sicuro di condurre una dimostrazione è quello puramente logico, il quale astrae dalla natura particolare delle cose e si basa soltanto sulle leggi sulle quali si fonda ogni conoscenza.

A supporto della Tesi Logicista, fu introdotto il primo esempio compiuto di Sistema Formale, ovvero un sistema che vincola il processo dimostrativo in modo tale che è sempre possibile riconoscere mediante un procedimento algoritmico se una qualsiasi configurazione di simboli è una dimostrazione oppure no.

Questo sistema formale prevedeva:

1. Insieme Finito di Assiomi Logici.
2. Insieme Finito di Regole di Inferenza che, senza introdurre conoscenza implicita, ci permettano di dedurre gli assiomi della Matematica dall’insieme di Assiomi Logici.

Inoltre ci sono due importanti Condizioni di Effettività che specificano un Sistema Formale:

• L’insieme degli Assiomi Logici è Effettivamente Decidibile
• L’insieme delle Dimostrazioni Logiche è Effettivamente Decidibile

In quest’ultima richiesta si intravede qualcosa del teorema di Gödel; si chiede che il predicato dim(x,y) sia effettivamente decidibile!

Come in Leibniz, anche questa volta ci deve essere un procedimento formale (Algoritmo) che ci assicuri le condizioni di effettività. Ma questa volta le condizioni di effettività sono espressamente richieste.

Inoltre Leibniz e Frege hanno obiettivi diversi, il primo vuole un linguaggio universale, mentre il secondo vuole verificare la certezza della matematica (un problema più piccolo rispetto alla definizione di una lingua universale); entrambi usano la logica come strumento per raggiungere il proprio fine epistemologico.

Bertrand Arthur William Russell

Frege prosegue con il suo programma logicista puntando a dimostrare gli assiomi della matematica (gli assiomi di Peano) partendo solo dagli assiomi logici. Nel sistema formale definito da Frege si possono individuare:

• Il principio di Coestensione: “data una proprietà P, esiste l’insieme y di tutti gli x che godono della proprietà P”
• Il principio del Terzo Escluso: almeno uno tra x e not x deve essere vero.

Russell (Trellech, 18 maggio 1872 – Penrhyndeudraeth, 2 febbraio 1970), è stato un filosofo, logico e matematico gallese. Si interessò al lavoro di Frege, e formulò il famoso Paradosso di Russell, causa della caduta del Programma Logicista.

Paradosso di Russell: Supponiamo la proprietà: not(x appartiene ad x)
Un elemento che gode di questa proprietà non appartiene a se stesso. Per il principio della coestensione c’è l’insieme di tutti gli elementi che godono di questa proprietà. Quindi diciamo y l’insieme di tutti gli elementi che non appartengono a se stessi. Adesso ci chiediamo: y appartiene a se stesso?

• Se y appartiene a se stesso allora gode della proprietà di non appartenere a se stesso.
• Se y non appartiene a se stesso allora per come è definito deve appartenere a se stesso

In entrambi i casi, grazie al principio del terzo escluso, giungiamo ad una contraddizione (questa è un’antinomia).

Russell nel 1901 formulò il paradosso e si rese conto delle conseguenze che avrebbe avuto per il programma logicista. Non esitò a mettersi in contatto con Frege con una lettera nell’estate del 1902 in cui illustra il paradosso.

Frege prese atto delle conseguenze distruttive per il sistema che aveva costruito in quegli anni e decise di scrivere un’appendice ai suoi Principî in cui confessava il fallimento della sua opera.

Siamo davanti ad una scelta:

- rinunciare al principio del terzo escluso: e quindi rinunciare alla logica classica

oppure

- rinunciare al principio di coestensione: ma in questo caso non si riescono più a derivare gli assiomi della matematica

Qui il Programma Logicista, e sorge il problema della certezza della matematica.

A seguire ci saranno due programmi che puntano a risolvere il problema della certezza della matematica: Il Programma Intuizionista, ed il Programma di Hilbert.

Luitzen Egbertus Jan Brouwer

Brouwer (Overschie, 27 febbraio 1881 – Blaricum, 2 dicembre 1966) è stato un matematico olandese. Fondò la Scuola Intuizionista (o costruttivista), nella quale dubitò
del principio del terzo escluso.

I requisiti del Programma Intuizionista erano:

1. Eliminazione del Principio del Terzo Escluso su totalità infinite.
2. Interpretazione delle dimostrazioni in modo Costruttivista: cioè una dimostrazione di “esiste x tale che P(x)” deve effettivamente esibire un elemento y per il quale è vero P(y).

Quindi gli intuizionisti puntano a limitare la matematica, eliminando l’uso di proposizioni ideali, come l’infinito in atto (o infinito attuale), che hanno permesso alla matematica di raggiungere ottimi risultati.

David Hilbert

Hilbert (Königsberg, 23 gennaio 1862 – Gottinga, 14 febbraio 1943) è stato un matematico tedesco. Rispose agli intuizionisti con il cosiddetto Programma di Hilbert.

Al contrario di Frege che voleva dimostrare gli assiomi matematici patendo dagli assiomi logici, Hilbert voleva formalizzare la matematica con degli assiomi e poi verificare la coerenza delle teorie matematiche formalizzate.

Quindi:

1. Formalizzare tutte le teorie matematiche “T” con sistemi formali T
2. Dimostrare la coerenza di tali sistemi T con metodi matematici finitisti.

Si comincio con la più semplice delle teorie, ossia con l’Aritmetica Elementare. I metodi matematici finitisti non sono mai stati definiti da Hilbert con precisione. Di sicuro sono metodi matematici in cui vengono chiesti i requisiti intuizionisti: quindi no al terzo escluso su totalità infinite e interpretazione costruttivista delle dimostrazioni. Molti concordano che i metodi finitisti sono inclusi nell’aritmetica Primitiva Ricorsiva dove valgono gli assiomi di Peano che descrivono l’aritmetica elementare.

Nasce la meta-matematica, ossia la parte della matematica che consente di studiare la matematica da punti di vista generali. Stiamo cioè usando la matematica stessa per risolvere il problema della certezza della matematica.
Nella metamatematica possiamo studiare varie proprietà dei sistemi formali, ad esempio:

• Coerenza: se T dimostra A allora non può dimostrare not A
• Correttezza: se T dimostra A allora A è vero nella teoria “T”
• Completezza: se A è vero nella teoria “T” allora T dimostra A

Notiamo che la correttezza di un sistema formale T implica la sua coerenza.

Ricapitolando Hilbert con il suo Programma della Coerenza (che è solo una parte del Programma di Hilbert) vuole dimostrare la coerenza della matematica utilizzando la matematica stessa.

Principia Mathematica (PM)

I Principia Mathematica, scritti da Russell e Whitehead tra il 1910 e il 1913, rappresentano un’importante tentativo di formalizzare la matematica con la logica. Traggono origine dal lavoro di Frege.

Chiameremo PM il sistema formale formalizzato in questo lavoro.

Kurt Gödel

Gödel (Brno, 28 aprile 1906 – Princeton, 14 gennaio 1978) è stato un matematico, logico e filosofo statunitense di origine austro-ungarica, noto soprattutto per i suoi lavori sull’incompletezza delle teorie matematiche. Gödel è ritenuto uno dei più grandi logici di tutti i tempi insieme a Frege e Aristotele.

Gödel si interessa al Programma di Hilbert, e formula il suo primo teorema di incompletezza:

Se PM è coerente, allora esiste una formula G nel linguaggio L(PM) tale che G è vera e non è dimostrabile in PM ne G ne not G

Ne segue come corollario il secondo teorema di incompletezza:

Se PM è coerente, e dato che la coerenza di PM è esprimibile all’interno di PM stesso (consis(PM) appartiene a L(PM)) allora in PM non è dimostrabile consis(PM)

Il secondo teorema di incompletezza è quello che fa cadere il Programma di Hilbert poiché afferma che non possiamo dimostrare la coerenza di PM all’interno di PM stesso,
cioè non possiamo dimostrare la coerenza della matematica all’interno della matematica stessa.

Però i teoremi di incompletezza si riferiscono al Sistema Formale PM. Per far cadere definitivamente il Programma di Hilbert bisognava generalizzare i teoremi di incompletezza a qualsiasi Sistema Formale che contiene l’aritmetica elementare.

Generalizzazione dei Teoremi di Incompletezza

Vogliamo generalizzare i teoremi di incompletezza in questo modo:

Per ogni sistema formale S tale che:

1. S contiene P (Aritmetica di Peano)
2. S soddisfa la condizioni di effettività di Frege
   • a) L’insieme degli assiomi è effettivamente decidibile
   • b) L’insieme delle dimostrazioni è effettivamente decidibile
3. S è coerente

Allora per S valgono i teoremi di incompletezza

Le ipotesi 1 e 3 sono ben precise. L’ipotesi 2.a e 2.b invece no! Infatti esse chiedono di avere due funzioni effettivamente calcolabili f(x) e g(Y) le quali ci decidano rispettivamente le formule ben formate di S e le dimostrazioni di S.

Questo è il punto di snodo tra i fondamenti della matematica e la nascita dell’informatica. Infatti una funzione è effettivamente calcolabile se esiste un algoritmo per essa.

Ma quale’è il concetto di algoritmo? Quali sono le funzioni calcolabili mediante un procedimento di calcolo (algoritmo)?

Tutt’ora non esiste un concetto di algoritmo preciso. La classe di tutti gli algoritmi è delineata con la tesi di Church-Turing, la quale essendo una tesi non può essere dimostrata.

Alan Mathison Turing

Turing (Londra, 23 giugno 1912 – Wilmslow, 7 giugno 1954) è stato un matematico, logico e crittanalista britannico, considerato uno dei padri dell’informatica.

Lavorò alla generalizzazione del teorema di Gödel, tentando di rispondere alla domanda: “che cos’è una funzione parzialmente calcolabile mediante un procedimento di calcolo (algoritmo)?”.

Church a quei tempi lavorava alla stessa domanda definendo la classe delle funzioni matematiche PRF, per poi arrivare ad un procedimento di calcolo (λ-calcolo).

Turing invece cominciò questo lavoro cominciando a definire il procedimento di calcolo (definito dalla Macchina di Turing), per poi arrivare alla classe di tutte le funzioni calcolabili da una Macchina di Turing.

Per definire la sua Macchia di Turing (d’ora in poi MdT), Turing osservo il comportamento di un essere umano che calcola. Quindi individua una serie di restrizioni:

1. L’umano effettua dei calcoli aiutandosi con un foglio. Nel caso di una macchina possiamo pensare ad un nastro potenzialmente infinito fatto di caselle contigue. In ogni casella possiamo
   scrivere un simbolo appartenente ad un alfabeto.
2. Limiti all’uso del nastro
   • a. Limite Percettivo: c’è un limite superiore B al numero di caselle contigue osservabili in un istante (questo implica che ci si può spostare sul nastro per vedere le prossime B caselle).
   • b. Limite di Memoria: l’alfabeto dei simboli scrivibili sul nastro è finito poiché l’essere umano non riesce a distinguere e ricordare infiniti simboli.
3. Il comportamento dipende dallo stato mentale (stato di memoria) dell’essere umano. Questo stato mentale dipende dalle azioni fatte precedentemente. Senza indagare molto sul cervello umano, imponiamo che questi stati siano in numero finito (deciso a priori).
4. Limitiamo il comportamento dell’essere umano che calcola, senza perdita di generalità, al compimento di un’azione per volta:
   • a. Si può cambiare il contenuto solo delle caselle osservate
   • b. Ci si può spostare di un numero L di caselle per volta
   • c. Si può cambiare lo stato mentale
5. Il calcolo è fatto in maniera Deterministica, dato lo stesso input otteniamo sempre lo stesso output

Ma come imponiamo la condizione di determinismo?

Consideriamo tutte le possibili azioni che può fare l’essere umano durante il calcolo. Diciamo C l’insieme di tutte le possibili coppie <stato mentale, configurazione dei simboli osservati>. Per ogni elemento di C si può scegliere di fare un’azione a scelta contenuta nell’insieme possibili di azioni A (scrittura di un simbolo, spostamento a destra, spostamento a sinistra, cambiamento di stato mentale). Definiamo l’insieme di tutte le possibili istruzioni I=CxA. L’insieme delle istruzioni come definito contiene delle istruzioni che definiscono un algoritmo non deterministico, poiché a parità di stato mentale e configurazioni di simboli osservati, possiamo trovare istruzioni che effettuano azioni diverse. Poniamo qui una condizione di determinismo, chiedendo di avere come insieme di istruzioni solo un sottoinsieme di I nel quale non compaiano istruzioni che possono essere applicate nello stesso stato del calcolo.

Questa è l’analisi dell’essere umano che calcola.

Adesso definiamo una macchina che simulerà il comportamento di calcolo dell’essere umano. Questa macchina avrà delle configurazioni interne q, che corrispondono agli stati mentali dell’umano. Lavora su un nastro osservando ad ogni nastro un numero B di caselle contigue, e può spostarsi di un numero L di caselle a destra o a sinistra. Può usare i simboli dell’alfabeto per scrivere sulla porzione di nastro osservata, e può cambiare la sua configurazione interna. Questa macchina riproduce il comportamento di calcolo di un essere umano.

Ponendo i vincoli B=1 e L=1 abbiamo proprio la definizione di Macchina di Turing (MdT). Chiamiamo classe delle funzioni Turing calcolabili (o T-calcolabili), la classe delle funzioni calcolabili con una MdT.

Turing arriva a formulare la seguente tesi:

“Ogni funzione calcolabile da un essere umano mediante algoritmo è una funzione T-calcolabile”

Notiamo che questa tesi è però ristretta alle funzioni calcolate da un essere umano, e non da un qualsiasi agente di calcolo (come un calcolatore). Proviamo ad estendere questa tesi in questo modo:

“Ogni funzione calcolabile da un calcolatore mediante algoritmo è una funzione T-calcolabile”

Per arrivare alla tesi di Church-Turing, osserviamo che i limiti B ed L sono soggetti ai limiti della fisica: la teoria delle relatività ci vieta di oltrepassare la velocità della luce. Inoltre in una singola cella di nastro possiamo registrarci un simbolo preso da un alfabeto finito, perché assumiamo che la materia (del nastro) abbia un vincolo di atomicità, ma su questo non è ancora stata formulata alcuna teoria scientifica.

Considerando i limiti della fisica possiamo riscrivere la tesi ed ottenere finalmente la Tesi di Church-Turing:

“Ogni funzione calcolabile da un algoritmo è una funzione T-calcolabile”

Con questa tesi sono stati generalizzati i teoremi di incompletezza di Gödel, chiedendo che le funzioni f(x) e g(Y) siano T-calcolabili. Cade definitivamente il Programma di Hilbert,
e il suo tentativo di verificare la certezza della matematica.

Sviluppi futuri

Quindi dal problema della matematica è nata la MdT, e Turing stesso definì la Macchina di Turing Universale, la quale è programmabile proprio come un moderno calcolatore digitale.

Da questo nasce il ramo dell’Intelligenza Artificiale (IA), e più in generale dell’Informatica.

Integrated Services Digital Network – ISDN

ISDN è un servizio di telefonia digitale basato sul protocollo ISDN. Quindi con il termine ISDN ci riferiamo sia al protocollo, sia al servizio implementato dal protocollo stesso.

ISDN: protocollo che descrive come si svolgono le chiamate
Una rete ISDN è quindi una rete digitale anche integrata nei servizi, in cui le diverse parti, il terminale, la rete di accesso, la rete di trasporto, sono realizzate per offrire gli stessi servizi. Elementi fondamentali per il supporto di tali servizi sono il protocollo di segnalazione della rete di trasporto ISUP (ITU-T Q.767) e della rete di accesso DSS1 (ITU-T Q.931), che fanno parte della pila di protocolli del sistema di segnalazione a canale comune n°7 insieme ad altri descritti nelle Racc. ITU-T serie Q. Attraverso tali protocolli vengono trasportate le informazioni che consentono l’espletamento dei diversi servizi; un esempio per tutti l’identità del chiamante, che viene trasportata dai protocolli di segnalazione dalla rete del chiamante verso la rete e il terminale del chiamato.

In Europa è usata la variante ISDN-DSS1 sviluppata da ETSI (European Telecomunications Standards Institute).
Sull’accesso BRA ISDN sono disponibili una serie di nuovi servizi come la segnalazione del numero telefonico di chi chiama (Caller ID) e il multinumero, cioè la possibilità di avere fino ad otto numeri telefonici sullo stesso abbonamento, ciascuno assegnato ad un apparecchio diverso (es. uno per il telefono, uno per il fax, uno per il modem in ingresso…). La tecnologia digitale utilizzata da ISDN garantisce una qualità audio molto elevata, eliminando completamente la diafonia e buona parte dei disturbi presenti nella tradizionale telefonia . In Italia ISDN BRA viene fornito in modalità mononumero o multinumero: è possibile cioè richiedere fino a 7 numeri telefonici diversi oltre al numero principale. Sempre sull’accesso base (BRA), che comprende 2 canali B a 64 Kbit/sec, è possibile collegarsi ad Internet sia ad una velocità di 64 Kbit/s, pagando una semplice telefonata, sia, se il Provider utilizzato lo permette, ad una velocità di 128 Kbit/s, sostenendo però il costo di due chiamate contemporanee. Inoltre sono disponibili i servizi di avviso di chiamata, conferenza a tre, presentazione dell’identità del chiamante (Caller ID), trasferimento di chiamata e per alcuni Operatori anche il servizio di richiamata su occupato.

Molto diffusa in Italia un tipo particolare di NT, chiamata NT1+, che ha al suo interno anche un Terminal Adapter (TA) a/b, capace di gestire due porte analogiche, permettendo cosi’ di connettere direttamente all’NT1+ apparati analogici come telefoni tradizionali o fax di gruppo 3. L’installazione della borchia ISDN deve essere richiesta al proprietario della rete.

Una ulteriore configurazione degli accessi è il “punto-punto” e “punto-multipunto” che in buona sostanza esprime il modo di dialogare della rete con uno o più terminali lato utente. La configurazione “punto-punto” è adottata in presenza, lato utente, di centralini (PABX)collegati sia su accesso primario che in pool di accessi base. La configurazione punto-multipunto è adottata ad esempio negli accessi base in cui sul bus isdn sono collegati dispositivi con numeri diversi (MSN) quali telefoni isdn, modem isdn, fax G4. La differenza tecnica che contraddistingue anche le due tipologie è il cosiddetto TEI, che viene utilizzato nel protocollo ISDN, per il quale una punto-punto è fisso a zero, mentre sulla punto-multipunto è variabile e deciso dalla centrale pubblica. Per capire se la tipologia e punto-punto o punto-multipunto, soprattutto nel caso di accesso base mononumero, bisogna contattare l’operatore che fornisce il servizio, non esistono veri e propri standard.

CALLER-ID: è la funzione che ci permette di vedere il numero di chi ci chiama.

MULTINUMERO: Possibilità di avere fino a 8 numeri su una singola linea ISDN. Ovviamente bisognerà assegnare un numero per ogni apparecchio.

Il collegamento ISDN più diffuso è quello base, a due canali (detto BRI):

La banda totale e’ 144 kbit/s!!! Di questa banda, solo i canali da 64 kbit/s sono sfruttati per trasferire informazioni utili all’utente finale, quindi in effetti l’utente beneficia di 128 kbit/s (sempre teorici)

Architettura ISDN

Alcuni termini

• NT (Network Terminator): Traduce il segnale proveniente dalla centrale telefonica, mediante U-BUS, in segnale utilizzabile dai nostri dispositivi ISDN, su S-BUS. Inoltre il Network Terminator permette di attaccarci
• TA (Terminal Adapter) : Permette di allacciare vecchi dispositivi analogigi al Network Terminator, in moda da poterli riutilizzare. E’ indicato per i vecchi FAX .

Esempio NT (Network Terminator)

Un Network Terminator, che prende in ingresso un U-Bus dalla linea ISDN, e caccia in output due S-Bus per allacciarci due dispositivi ISDN (ad esempio due telefono ISDN).

Notiamo che in S-Bus non è che un cavo ethernet, usato per ISDN… e (forse) per U-Bus si usa il doppino telefonico, o anche in questo caso un cavo ethernet.

Configurazione di ISDN

Una linea ISDN può avere varie configurazioni, in modo da adattarsi all’hardware con il quale deve funzionare (esempio PBX – centralino telefonico).

Canali

ISDN supporta due tipi di canali:

-> Canale B (Bearer): sono canali utilizzati per i dati ed hanno una banda prefissata di 64 kbit/s.

-> Canale D (Delta): sono canali usati per segnalazioni e controllo; in particolari configurazioni possono essere usati anche per i dati. La banda passante assegnata ad un canale D varia al variare del tipo di Accesso ISDN.

Accesso ISDN

Esistono due tipi di accesso ISDN:

• Accesso BRI [Basic Rate Interface - Accesso Base]:– 2 canali B– 1 canale D a 16 kbit/s==> Totale 2B+D = 144 kbit/s
• Accesso PRI T1 [Basic Rate Interface - Accesso Base]: (America, Giappone)– 23 canali B– 1 canale D a 64 kbit/s==> Totale 23B+D = 1536 kbit/s
• Accesso BRI E1 [Basic Rate Interface - Accesso Base]: (Europa, Asia, Australia)– 30 canali B– 2 canale D a 64 kbit/s==> Totale 30B+2D = 2048 kbit/s

Funzionamento Chiamate

I canali D sono usati per iniziare le chiamate. Una volta che la chiamata è iniziata, ad essa è allocato un canale B… quindi per ogni chiamata deve essere disponibile un canale B (sempre di 64 kbit/s).

Notiamo come i canali B sono allocati sempre in modo dinamico!

Considerazioni Tecniche

L’evoluzione di ISDN l’ha portato ad essere adottato in anbito aziendale. Queste ultime scelgono spesso tra due opzioni di installazione: il multinumero e la selezione passante.

Multinumero

E’ un servizio opzionale. Permette di avere un massimo di 8 terminali, sullo steso S-BUS, ognuno raggiungibile direttamente dall’esterno con un suo proprio numero telefonico.

• Possibile solo su ISDN accesso base (BRI)
• Solo due terminali possono essere attivi contemporaneamente
• Non chiede l’installazione di un PBX
• Le chiamate interne sono a pagamento
• NT (Network Terminator) deve essere configurato punto-multipunto

Selezione Passante

E’ un servizio opzionale. Permette di raggiungere direttamente i terminali interni appoggiandoci su un PBX (centralino telefonico). Non si ha il limite di 8 terminali su ogni linea ISDN.

• Possibile sia su linee BRI, sia su linee PRI
• Non c’è limite al numero di terminali interni attivi contemporaneamente
• Chiede l’instllazione di un PBX
• Le chiamate interne NON sono a pagamento
• NT (Network Terminator) deve essere configurato punto-punto

Considerazioni

Il multinumero si adatta solo in pochi casi… spesso perche’ sono richieste telefonate interne gratuite!

Ad esempio possiamo avere cinque ingressi ISDN: ipotizziamo i numeri telefonici da 0216029101 a 0216029105 (Le ultime due cifre individuano la linea fisica, e sono 5 BRI – quindi max 10 telefonate esterne contemporaneamente).
Grazie alla selezione passante riusciamo ad avere i numeri da 0216029100 a 0216029199… un range di ben 100 numero!

Essa è un esempio di funzione ricorsiva che non è primitiva ricorsiva poiché cresce più velocemente di qualsiasi funzione ricorsiva primitiva.

Qui il codice java che implementa questa funzione:

Ackermann.java

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

public class Ackermann {
 
 static long count = 0;
 
 private static long h(long m, long n) {
  
  count++;
  
  if (m == 0) {
   return n + 1;
  }
  if (n == 0) {
   return h(m-1, 1);
  }
  
  return h(m-1, h(m,n-1) );
 }
 
 private static long ack(long n) {
  return h(n, n);
 }
 
 public static void main(String[] args) {
  
  if (args.length != 1) {
   System.out.println("usage: Ackermann <number>\n\twhere number is a positive integer");
   System.exit(1);
  }
  
  long n = Long.valueOf(args[0]);
  
  count = 0;
  long retValue = ack(n);  
  System.out.println("ack(" + n + ") = " + retValue + " [recursive calls = "+ count +"]");
 
  
  System.exit(0);
 }
 
}

Il meccanismo di calcolo della funzione è estremamente semplice quanto pesante dal punto di vista computazionale. Questi sono i risultati ottenuti:

• ack(0) = 1  [recursive calls = 1]
• ack(1) = 3  [recursive calls = 4]
• ack(2) = 7  [recursive calls = 27]
• ack(3) = 61 [recursive calls = 2432]

Non riesco a calcolare ack(4) causa stack overflow (Exception in thread “main” java.lang.StackOverflowError).

La manutenzione di un blog attraverso internet è una caratteristica comune di tutti i blog. Questa è fatta attraverso una interfaccia web-based, cioè la famosa parte di amministrazione.
Molti blog supportano l’uso di software esterno (client per la gestione del blog), detto Weblog Client, per la gestione dei contenuti attraverso l’uso di API come le MetaWeblog API e le Atom Publishing Protocol.

Per Wordpress abbiamo una lunga lista di Weblog Client, ma prima di sceglierne uno bisogna abilitare il protocollo Atom Publishing oppure XML-RPC. Questo di fa spuntando la relativa opzione nelle impostazioni di scrittura di Wordpress.
Fatto questo dobbiamo scegliere un software tra wuelli disponibili per il nostro sistema operativo. Questi sono i software che ho individuato:

Linux

* BloGTK
* Drivel
* Flock
* Gnome Blog
* JBlogEditor
* QTM
* ScribeFire
* WriteToMyBlog – web based

Windows

* BlogDesk
* BlogJet
* Blog Writer
* Chrysanth WebStory
* Deepest Sender
* Ecto
* Elicit
* Flock
* JBlogEditor
* LIPIDr Blog Client
* Post2Blog
* Post2Blog Express
* Qumana
* ScribeFire
* Semagic
* Zoundry Raven
* w.bloggar
* WB Editor
* Windows Live Writer
* WriteToMyBlog – web based

Mac OS X:

* Ecto
* Flock
* JBlogEditor
* Journler (however blogging is being dropped soon from Journler)
* MacJournal
* MarsEdit
* QTM
* Qumana
* ScribeFire (formerly Performancing)
* TextMate
* WriteToMyBlog – web based

Per gestire questa grossa quantità di dati multimediali, sia da parte degli utenti, sia da parte dei sistemi automatici, ci aiuta Mpeg-7: uno standard nato per codificare i contenuti multimediali attraverso la definizione di metadati sui dati multimediali.

I precedenti standard Mpeg-1 (1992), Mpeg-2 (1994), e Mpeg-4 (1999) riguardano la codifica del video. Nel 2001 è stato definito Mpeg-7 che non definisce il modo di codificare un video, ma riguarda la sua metataggatura attraverso un linguaggio XML.
Perché 7? Mpeg-7 permette di definire metadati sui video codificati con Mpeg 1, 2, e 4. Siccome 4+2+1=7, nasce il nome Mpeg-7.

Notiamo come non è stato nominato Mpeg-3, lo standard per i famosissimi mp3 . In realtà questo standard non esiste, ma il nome Mpeg-3 è usato per riferirsi alla parte audio di Mpeg-2.

Metadati

I metadati associati ad un video permettono di descrivere cosa c’è nel video. Mpeg-7 permette descrizioni sia a basso livello (caratteristiche del segnale, come il colore di un oggetto), sia ad alto livello (informazioni semantiche, come la scena di un goal in una partita di calcio).
Un esempio di file XML in formato Mpeg-7 contenente la descrizione di un video di una notizia è:

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <!--Metadati generati automaticamente dall'applicazione-->
<Mpeg7 xmlns="urn:mpeg:mpeg7:schema:2001" xmlns:mpeg7="urn:mpeg:mpeg7:schema:2001"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="urn:mpeg:mpeg7:schema:2001 Mpeg7-2001.xsd">
 <Description xsi:type="ContentEntityType">
 <MultimediaContent xsi:type="VideoType">
 <Video>
 <MediaInformation>
 <MediaProfile>
 <MediaFormat>
 <Content href="MPEG7ContentCS" />
 <FileFormat href="urn:mpeg:mpeg7:cs:FileFormatCS:2001:3">
 <Name>mpeg</Name>
 </FileFormat>
 <FileSize>17333073</FileSize>
 <VisualCoding>
 <Format colorDomain="color"
 href="urn:mpeg:mpeg7:cs:VisualCodingFormatCS:2001:1" />
 <Frame height="576" rate="8000" width="720" />
 </VisualCoding>
 </MediaFormat>
 <MediaInstance id="v20090201_video_15213221">
 <InstanceIdentifier />
 <MediaLocator>
 <MediaUri>20090201_video_15213221.mov</MediaUri>
 </MediaLocator>
 </MediaInstance>
 </MediaProfile>
 </MediaInformation>
 <CreationInformation>
 <Creation>
 <Title>Obama: presto un piano per famiglie Usa per tagliare costi
 mutui</Title>
 <Abstract>
 <FreeTextAnnotation>
 Presidente cerca arginare effetti devastante crisi economica
 </FreeTextAnnotation>
 <StructuredAnnotation>
 <When>
 <Name>1 Feb 2009</Name>
 </When>
 </StructuredAnnotation>
 </Abstract>
 <Creator>
 <Role href="urn:mpeg:mpeg7:cs:RoleCS:2001:producer">
 <Name>Red</Name>
 </Role>
 <Agent xsi:type="OrganizationType">
 <Name>Apcom</Name>
 </Agent>
 </Creator>
 <CreationCoordinates>
 <Location>
 <Name>milano</Name>
 </Location>
 <Date>
 <TimePoint>2009-02-01T15:21:32</TimePoint>
 </Date>
 </CreationCoordinates>
 <CopyrightString>TMNews</CopyrightString>
 </Creation>
 <Classification>
 <Genre href="urn:mpeg:TVAnytime_v0.1ContentCS:3.14">
 <Name>est</Name>
 </Genre>
 <MediaReview>
 <Rating>
 <RatingValue>0.0</RatingValue>
 <RatingScheme best="5" style="higherBetter" worst="0">
 <Name>Overall</Name>
 </RatingScheme>
 </Rating>
 </MediaReview>
 </Classification>
 <RelatedMaterial>
 <MediaLocator>
 <MediaUri>20090201_video_17483840.mov</MediaUri>
 </MediaLocator>
 </RelatedMaterial>
 <RelatedMaterial>
 <MediaLocator>
 <MediaUri>20090201_video_18024720.mov</MediaUri>
 </MediaLocator>
 </RelatedMaterial>
 <RelatedMaterial>
 <MediaLocator>
 <MediaUri>20090201_video_18094945.mov</MediaUri>
 </MediaLocator>
 </RelatedMaterial>
 <RelatedMaterial>
 <MediaLocator>
 <MediaUri>20090201_video_18153193.mov</MediaUri>
 </MediaLocator>
 </RelatedMaterial>
 <RelatedMaterial>
 <MediaLocator>
 <MediaUri>20090202_video_13033231.mov</MediaUri>
 </MediaLocator>
 </RelatedMaterial>
 <RelatedMaterial>
 <MediaLocator>
 <MediaUri>20090202_video_13094131.mov</MediaUri>
 </MediaLocator>
 </RelatedMaterial>
 <RelatedMaterial>
 <MediaLocator>
 <MediaUri>20090202_video_16491593.mov</MediaUri>
 </MediaLocator>
 </RelatedMaterial>
 <RelatedMaterial>
 <MediaLocator>
 <MediaUri>20090202_video_17042673.mov</MediaUri>
 </MediaLocator>
 </RelatedMaterial>
 </CreationInformation>
 <UsageInformation>
 <Availability id="onDemand">
 <InstanceRef href="MPEG7PublicationTypeCS:4" />
 <Dissemination>
 <Format href="MPEG7PublicationTypeCS:4">
 <Name>Internet</Name>
 </Format>
 <Location>
 <Region>it</Region>
 </Location>
 </Dissemination>
 </Availability>
 <UsageRecord>
 <AvailabilityRef idref="onDemand" />
 <Audience>0</Audience>
 </UsageRecord>
 </UsageInformation>
 <MediaTime>
 <MediaTimePoint>T00:00:00</MediaTimePoint>
 <MediaDuration>PT0H0M29S</MediaDuration>
 </MediaTime>
 </Video>
 </MultimediaContent>
 <MultimediaContent xsi:type="ImageType">
 <Image>
 <MediaInformation>
 <MediaProfile>
 <MediaFormat>
 <Content href="urn:mpeg:mpeg7:cs:ContentCS:2001:2">
 <Name>visual</Name>
 </Content>
 <FileFormat href="urn:mpeg:mpeg7:cs:FileFormatCS:2001:3">
 <Name>JPEG2000</Name>
 </FileFormat>
 <FileSize>12014</FileSize>
 <VisualCoding>
 <Format colorDomain="binary"
 href="urn:mpeg:mpeg7:cs:VisualCodingFormatCS:2001:1">
 <Name>JPEG2000</Name>
 </Format>
 <Frame height="288" rate="0" width="360" />
 </VisualCoding>
 </MediaFormat>
 <MediaInstance id="i20090201_video_15213221">
 <InstanceIdentifier />
 <MediaLocator>
 <MediaUri>20090201_video_15213221.jpg</MediaUri>
 </MediaLocator>
 </MediaInstance>
 </MediaProfile>
 </MediaInformation>
 <CreationInformation>
 <Creation>
 <Title>
 Foto
</Title>
 <Creator>
 <Role href="urn:mpeg:mpeg7:cs:RoleCS:AUTHOR">
 <Name>Red</Name>
 </Role>
 <Agent xsi:type="OrganizationType">
 <Name>MPEG</Name>
 </Agent>
 </Creator>
 </Creation>
 </CreationInformation>
 </Image>
 </MultimediaContent>
 </Description>
</Mpeg7>

Mpeg-7 è un linguaggio XML, ossia usa XML per definire i metadati. In realtà un file Mpeg-7 non è altro che un file ‘.xml’ associato ad uno o più oggetti multimediali. Quindi è possibile memorizzare i metadati indipendentemente dai video… ad esempio un possibile uso di Mpeg-7, è la costruzione di un database multimediale!

Componenti di Mpeg-7

Lo standard Mpeg-7 è composta da quattro elementi fondamentali:

• Description Tools

• Descriptor

• Description Scheme

• DDL – Description Definition
  Language

• System Tool

I metadati di un oggetto multimediale saranno descritti usando i ‘Description Tools’.
I ‘Description Tools’ a loro volta fanno uso del ‘Description Definition Language’ (DDL) che è una estensione di XML Schema proprio per Mpeg-7.
I ‘System Tool’ non riguardano la definizione di metadati, ma la loro rappresentazione e trasmissione. Quindi il file XML è prodotto utilizzando solo ‘Description Tools’ e ‘DDL’, e poi questo file XML può essere diffuso utilizzando le tecniche dei ‘System Tools’.

Description Definition Language (DDL)

Il DDL è basato su XML Schema Language e ne rappresenta una sorta di estensione orientata al multimedia. In particolare XML Schema non è stato progettato per le descrizioni di contenuti audio/video e necessita quindi di tipi di dato per array e matrici, e tipo di dato per gestire il tempo (BasicTimePoint e BasicDuration).

Ad esempio la definizione di TimeType è:

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

<!-- Definition of Time datatype -->
<complexType name="TimeType">
 <sequence>
 <choice>
 <element name="TimePoint" type="mpeg7:TimePointType" />
 <element name="RelTimePoint" type="mpeg7:RelTimePointType" />
 <element name="RelIncrTimePoint" type="mpeg7:RelIncrTimePointType" />
 </choice>
 <choice minOccurs="0">
 <element name="Duration" type="mpeg7:durationType" />
 <element name="IncrDuration" type="mpeg7:IncrDurationType" />
 </choice>
 </sequence>
</complexType>
 
<!-- Definition of TimePoint datatype -->
<simpleType name="TimePointType">
 <restriction base="mpeg7:basicTimePointType">
 <pattern
 value="(\-?\d+(\-\d{2}(\-\d{2})?)?)?(T\d{2}(:\d{2}(:\d{2} (:\d+)?)?)?)?(F\d+)?(\-|\+\d{2}:\d{2})?" />
 </restriction>
</simpleType>
 
<!-- Definition of duration datatype -->
<simpleType name="durationType">
 <restriction base="mpeg7:basicDurationType">
 <pattern
 value="\-?P(\d+D)?(T(\d+H)?(\d+M)
 ?(\d+S)?(\d+N)?)?( \d+F)?((\-|\+)\d{2}:\d{2}Z)?" />
 </restriction>
</simpleType>

Usando queste definizioni di tipo contenute nella DDL, siamo in grado di descrivere il fatto che un certo filmato rappresenta un evento iniziato il 16 ottobre 2002 alle ore 17:00 in un paese con GTM+1, e dura 10 giorni, con questo codice:

0
1
2
3

<Time>
  <TimePoint>2002-10-16T17:00+01:00</TimePoint>
  <Duration>P10D</Duration>
</Time>

Ovviamente il DDL, oltre ai tipi qui introdotti (TimeType, TimePointType, e durationType), contiene molte altre definizioni che per brevità non tratteremo.

Description Tools

I Description Tools comprendono ‘Descriptor’ e ‘Descriptor Schemes’ che preferisco non distinguere e trattarli insieme, raggruppandoli in base alle loro funzionalità:

• Schema and Basic Elements:
  forniscono tutti i tipi di dato utilizzati nelle descrizioni, e la
  loro corrispondenza con i tag utilizzati in Mpeg-7;

• Content Description:
  rappresentazione dell’informazione audio/video sia a livello
  strutturale (basso livello), sia a livello semantico (alto livello);

• Content Management:
  permette di descrivere caratteristiche come creazione, formato, ed
  uso del materiale multimediale;

• Content Organization:
  Permette di gestire collezioni di materiale multimediale: si possono
  usare questi tool per implementare una base di dati XML di
  informazioni su materiale multimediale;

• Navigation and Access:
  aiutano l’accessibilità al file multimediale;

• User Interaction:
  permettono di memorizzare le preferenze dell’utente.

Con i Description Tools siamo in grado di produrre due tipi di descrizioni Mpeg-7 valide: le “Complete Descriptions” che descrivono interamente un materiale multimediale come un video (l’esempio di file xml Mpeg-7 di questo articolo corrisponde ad una Complete Description perchè descrive completamente il video), e le “Descriptions Units” che non sono descrizioni intere ma dei componenti che possono far parte di una Complete Description.

Conclusioni

Non si è trattata la parte dei System Tools, inoltre della parte dei Description Tool si è data una semplice descrizione generale. I Description Tool sono la parte più corposa dello standard Mpeg-7, e studiarli tutti può richiedere tempo. Si suggerisce a tal proposito di utilizzare i documenti ufficiali dello standard o l’utilissima guida di Chiariglione all’indirizzo http://www.chiariglione.org/mpeg/ .

Relazione tra XQuery ed XPath

Il linguaggio XML è diventato uno degli elementi fondamentali per la realizzazione di sistemi informativi, indipendentemente dalla tecnologia usata.

Storia

Il World Wide Web Consortium (W3C), in seguito alla guerra dei browser fu costretto a seguire le individuali estensioni al linguaggio HTML. Dovette scegliere quali caratteristiche standardizzare e quali lasciare fuori dalle specifiche ufficiali dell’HTML. Fu in questo contesto che iniziò a delinearsi la necessità di un linguaggio di markup che desse maggiore libertà nella definizione dei tag, pur rimanendo in uno standard.

Il “progetto XML”, che ebbe inizio alla fine degli anni ‘80 nell’ambito della SGML Activity del W3C, suscitò un così forte interesse a tal punto che la W3C creò un gruppo di lavoro, chiamato XML Working Group, composto da esperti mondiali delle tecnologie SGML, ed una commissione, XML Editorial Review Board, deputata alla redazione delle specifiche del progetto.

Nel febbraio del 1998 le specifiche divennero una raccomandazione ufficiale con il nome di Extensible Mark-up Language, versione 1.0. Ben presto ci si accorse che XML non era solo limitato al contesto web, ma era qualcosa di più: uno strumento che permetteva di essere utilizzato nei più diversi contesti, dalla definizione della struttura di documenti, allo scambio delle informazioni tra sistemi diversi, dalla rappresentazione di immagini alla definizione di formati di dati.

Il Linguaggio

• Definizione XML: (acronimo di eXtensible Markup Language) è un metalinguaggio di markup, ovvero un linguaggio marcatore che definisce un meccanismo sintattico che consente di estendere o controllare il significato di altri linguaggi marcatori. Costituisce il tentativo di produrre una versione semplificata di SGML che consenta di definire in modo semplice nuovi linguaggi di markup

Quindi quello che si fa con XML è definire/progettare dei propri “Linguaggi XML” (cioè un linguaggio basato su XML); ad esempio possiamo scegliere di codificare in XML i risultati di una giornata del campionato di calcio:

0
1
2
3
4
5
6
7
8
9
10
11

<partite giornata=”3°”>
 <partita numero=”1”>
  <squadra>Napoli</squadra>
  <squadra>Juventus</squadra>
  <risultato>3-0</risultato>
 </partita>
  <partita numero=”2”>
  <squadra>Roma</squadra>
  <squadra>Lazio</squadra>
  <risultato>2-2</risultato>
 </partita>
</partite>

Il processo di sviluppo di un linguaggio XML è detto “XMLificazione”: ossia la scelta dei tag (partite, partita, squadra, risultato), degli attributi (giornata, numero), e della loro struttura.

Ci possono essere però altri linguaggi XML che usano i nostri stessi tag, e mischiare più linguaggi XML con nomi dei tag uguali può portare a confusione, per questo possiamo introdurre un namespace per i nostri nomi.

• Namespace XML: Un namespace è una collezione di nomi di entità, definite dal programmatore, omogeneamente usate in uno o più file sorgente. Lo scopo dei namespace è quello di evitare confusione ed equivoci nel caso siano necessarie molte entità con nomi simili, fornendo il modo di raggruppare i nomi per categorie.Nel linguaggio XML i namespaces sono definiti esplicitamente.

Nel nostro caso la prima riga diventerà:

<partite giornata=”3°” xmlns=”http://www.fireteam.it”>

In questo modo indichiamo che il tag ‘partite’ e tutto il suo contenuto appartengono al namespace ‘http://www.fireteam.it’ di default.

Fin qui XML sembra la più banale delle tecnologie, eppure ha avuto così tanto successo… allora perché è così importante?

La Tecnologia XML

Il primo motivo è che tutti i file XML sono codificati in UNICODE (i famosi UTF-8 UTF-16, ed UTF-32), e sono stati eliminati in questo modo molto dei fastidi che affligevano i formati testuali.

Il secondo motivo è che con XML si può rappresentare l’informazione in modo semplice, mantenendo un minimo di struttura; non a caso l’informazione codificata in XML è detta semistrutturata, che è il compromesso dalla completa strutturazione (come ad esempio la struttura rigida di uno schema di un database relazionale) e l’assenza di struttura (schema-less, ossia il testo puro).

Il terzo motivo, che ritengo più importante, è che attorno a questo semplice linguaggio di markup sono state definite parecchie tecnologie utili a risparmiare lavoro durante il trattamento dei dati. Queste sono:

• Xpath: è un linguaggio parte della famiglia XML che permette di individuare i nodi all’interno di un documento XML.

• Linguaggi Schema: un linguaggio di schema è un linguaggio formale per esprimere “schemi”. Uno schema è la definizione formale della sintassi di un linguaggio XML, ovvero una famiglia di documenti XML.
  • DTD: Il linguaggio DTD è utile a definire schemi DTD per un particolare linguaggio XML. DTD è semplice, con un potere espressivo limitato, non è autoesplicativo poiché non usa una notazione XML (è descritto da una grammatica BNF), e tra i tanti difetti non supporta i namespace in quanto il linguaggio DTD stato definito è stato definito prima dei namespace.
  • Schema: è un linguaggio di schema nato per sostituire DTD. E’ più espressivo, è quasi autoesplicativo (è scritto in XML e la sua sintassi è definibile con XML schema stesso, ma non si riescono a catturare tutti gli aspetti sintattici del linguaggio). Inoltre introduce i tipi di dato e permette di crearne nuovi, in modo da riuscire a fare buoni controlli sui contenuti dei file XML.

• XSL: acronimo di eXtensible Stylesheet Language, è il linguaggio di descrizione dei fogli di stile per i documenti in formato XML. Com’è noto, lo standard XML prevede che i contenuti di un documento siano separati dalla formattazione della pagina in cui verranno pubblicati.
  • XSLT: XSL Transformations – il linguaggio di trasformazione dell’XML. Fa uso di XPath per accedere alle parti di un documento XML. La trasformazione è fatta da un modulo detto Processore XSLT, come ad esempio quello incluso nei browser.
  • XSL-FO: XSL Formatting Objects – usato per l’applicazione degli stili e del modo di apparizione a un documento XML.

• XQuery: abbrevazione per XML Query Language, è un linguaggio di programmazione specificato dal W3C e destinato ad interrogare documenti e basi di dati XML.

Qui è d’obbligo soffermarsi per discutere sull’utilità di un linguaggio di interrogazione XML. Un’ambiziosa applicazione di XML ha come scopo la generalizzazione del tradizionale modello delle basi di dati relazionali. Da tempo si sta cercando un’alternativa ai vecchissimi database relazionali, e si è provato in svariate direzioni… database gerarchici, database multidimensionali, database ad oggetti, ecc.

XML è un alternativa allettane! Oggi si scrive molto in XML, specialmente sul web dove vi sono pagine XHTML (che sono XML), e l’idea di avere un database XML perfettamente integrabile con tutti gli altri nostri dati non è affatto male… il World Wide Web può così diventare una gigantesca base di dati.

XQuery è un linguaggio per interrogare file XML, allo stesso modo in cui SQL interroga base di dati relazionali… ed è qui che una collezione di file XML è spesso chiamata Database XML.

E come tutti i linguaggi di interrogazione che si rispettano anche per XQuery c’è un algebra… XML Query Algebra definita dal W3C. In realtà i lavori sono ancora in progresso e ci sono varie proposte di algebra:

• Algebra per linguaggi di interrogazione XML: sono stati proposti svariati linguaggi di interrogazione XML, come XQuery, XML-QL, ed altri; quindi c’è un interesse crescente verso l’interrogazione di file XML. Non ancora però è stata definita un’algebra comune per questi linguaggi. Un algebra formale è un passo obbligato per avere una buona ottimizzazione delle query.
  • TAX: E’ una proposta di algebra non standard, utilizzata da un motore di database XML chiamato “Timber XML”. TAX sta per “Tree Algebra for XML”, ed è una proposta interessante perché usa un modello di dati dove i documenti XML sono effettivamente visti come alberi, quindi le varie operazioni (Selezione, Proiezione, Prodotto, Set, Raggruppamento, Aggregazione, Renaming, Reordering, Copy-and-Paste, Cancellazione, Inserimento) risultano definite in modo naturale.
  • XML Query Algebra: anche chiamata “The Algebra” è la proposta di standardizzazione da parte del W3C. Questa algebra, che sembra assomigliare ad un linguaggio di programmazione dichiarativo, non definisce le operazioni con operatori ad HOC, ma riesce a ricavare le consuete operazioni mediante l’uso di cicli for, assegnazioni di variabili, costrutti condizionali, ed altro. Inoltre i tipi di dato sono molto importanti, e sono definiti per ogni espressione. Una volta tradotta una query, la sua ottimizzazione sfrutta delle regole di inferenza logica; un metodo del tutto innovativo.

E quando queste tecnologie non riescono a soddisfare le nostre richieste, entra in gioco la solita programmazione:

• Programmazione XML: Benchè gli strumenti XML (Schema, XSLT, XQuery, XPath, ecc…) ci permettono di fare molti tipi di elaborazione, spesso c’è la necessita di manipolare file XML da linguaggi di programmazione di uso generale come ad esempio Java.
  • DOM: Il Document Object Model (DOM) è una forma di rappresentazione dei documenti strutturati come modello orientato agli oggetti. DOM definisce un API per accedere e manipolare file XML comune a diversi linguaggi.
  • SAX: (Simple API for XML) è un’API per numerosi linguaggi di programmazione che permette di leggere ed elaborare dei documenti XML. Contrariarmente al DOM, il SAX processa i documenti linea per linea. Il flusso di dati XML è unidirezionale, così che dati a cui si è acceduto in precedenza non possono essere riletti senza la rielaborazione dell’intero documento.
  • JDOM: JDom è un API per accedere ed elaborare documenti XMl specifica per il linguaggio di programmaziopne Java, che (rispettando il principio del 80/20) permette di sviluppare con semplicità l’80% delle applicazione, mentre richiede una soluzione ad HOC per il restante 20%… cioè JDom sacrifica parte della generalità per dar miglior supporto alle applicazioni più comuni.

• XML Retrieval: L’information retrieval (IR) è la disciplina che studia le tecniche utilizzate per il recupero mirato dell’informazione in formato elettronico.

Le Applicazioni XML

XML è oggi una tecnologia matura ed utilizzata negli ambiti più disparati… basta provare a salvare un documento di testo scritto con il famosissimo word processor OpenOffice, rinominare questo file .zip, e provare ad estrarre il contenuto: dentro troveremo il nostro documento descritto in XML!!!

Un altro esempio è SVG, lo standard aperto per la grafica vettoriale che punta a sostituire la tecnologia ‘flash’ sul web. Un file .svg è interamente scritto in XML, tant’è vero che si può aprire senza problemi con un qualsiasi editor di testo.

Alcuni linguaggi XML hanno avuto particolare successo come XHTML, CML (Chemical Markup Language), WML (usato nella tecnologia WAP dei cellulari), RSS ed altri… in particolare Mpeg7:

• Mpeg-7: MPEG-7 è uno standard nato per codificare i contenuti multimediali; non è uno standard nato per codificare flussi audio o video come, ad esempio, MPEG-1 MPEG-2 o MPEG-4 ma per definire metadati sui dati multimediali.La codifica utilizza l’XML per memorizzare dei metadati che utilizzano a loro volta il timecode del filmato permettendo di sincronizzare i flussi multimediali con particolari eventi. Per esempio, permette di sincronizzare un filmato con i suoi sottotitoli o un video con il testo della canzone.

Il concetto di espressione regolare è un formalismo importante utilizzato, in varie forme, in svariate applicazioni… ad esempio nei linguaggi di schema (come DTD di XML) per descrivere sequenze di elementi o caratteri. I linguaggi regolari sono utilizzati in molte altre aree dell’informatica oltre a XML, dall’elaborazione del testo e del linguaggio naturale alla verifica formale dei componenti hardware.

Potrebbe essere necessario, ad esempio, vincolare un valore ‘data’ in modo tale da rispettare il formato dd-mm-yyyy, ovvero sia composto da due cifre per il giorno, seguite da due per il mese e quattro per l’anno, tutto separato da un segno meno “-”. Alternativamente possiamo specificare che un certo valore deve essere un numero intero.

Chiamiamo Σ un alfabeto consistente in un insieme di atomi, che tipicamente sono caratteri Unicode o nomi di elementi. Un’espressione regolare su Σ è costruita in base alle seguenti regole:

• ogni atomo in Σ, preso da solo, è un espressione regolare;
• se a e b sono espressioni regolari, allora lo sono anche le seguenti:

  • a?

  • a*

  • a+

  • a b

  • a|b

  • (a)

Gli operatori ?, , e + hanno una precedenza superiore alla concatenazione (l’operatore vuoto o “giustapposizione”), che a sua volta ha una precedenza superiore a |. E’ sempre possibile usare le parentesi per raggruppare sotto-espressioni, superando così le precedenze di default. L’espressione ab*|c, in cui l’alfabeto Σ contiene a, b, e c, è interpretata come (a(b*))|c e non a(b*|c).

Una stringa finita di atomi di Σ può corrispondere o meno a una data espressione regolare a:

• un atomo r appartenente a Σ corrisponde unicamente al singolo atomo r;
• a? corrisponde ad a opzionalmente, ovvero a qualsiasi stringa corrisponda ad a più la stringa vuota;
• a* corrisponde a zero o più ripetizioni delle stringhe che corrispondono ad a;
• a+ corrisponde ad una o più ripetizioni delle stringhe che corrispondono ad a;
• a b corrisponde a ciò a cui corrisponde ‘a’ seguito da ciò a cui corrisponde b;
• a|b corrisponde all’unione delle corrispondenze di a e b;
• (a) ha le stesse corrispondente di a.

L’espressione regolare (a(b*))|c corrisponde così a tutte le stringhe composte da una a seguite da zero o più b, oppure una singola c da sola.

Un linguaggio regolare è un insieme di stringhe che corrispondono a una qualche espressione regolare.

E’ possibile definire un’espressione regolare d (che sta per digit, cifra) scrivendo:

0|1|2|3|4|5|6|7|8|9

laddove l’alfabeto è composto ad esempio da tutti caratteri Unicode. Possiamo partire da questa definizione per definire un’altra espressione regolare ‘data’ scrivendo dd-dd-dddd. Naturalmente quest’espressione corrisponde anche a stringhe come 88-26-9995, che non denotano date reali, ma con un po’ più di sforzo è possibile catturare precisamente l’insieme di stringhe desiderato: in effetti su può usare un linguaggio regolare per gestire correttamente anche gli anni bisestili, ma allora le cose si fanno parecchie complicate!

La seguente espressione regolare descrive gli interi con un alfabeto composto dalle dieci cifre e dal segno meno:

0|-?(|1|2|3|4|5|6|7|8|9)(0|1|2|3|4|5|6|7|8|9)*

Secondo questa definizione, -42, 0, 117 sono accettabili, mentre 000, -0 e 3.14 non lo sono.

Adesso facciamo l’ultimo esempio, più complicato! In XHTML il contenuto di un elemento table dev’essere una sequenza che consiste in un elemento opzionale ‘caption’ seguito da un certo numero di elementi ‘col’ o alternativamente ‘colgroup’, i quali a loro volta sono opzionalmente seguiti da un elemento ‘thead’ e uno ‘tfoot’, per concludere almeno un elemento ‘tbody’ (o alternativamente ‘tr’). Possiamo scrivere con un’espressione regolare:

caption? ( col* | colgroup* ) thead? tfoot? ( tbody+ | tr+ )

Esistono molte varianti delle espressioni regolari… ad esempio le regular expression del linguaggio perl: tuttavia la maggior parte di queste varianti si limita ad aggiungere zucchero sintattico alla notazione base che abbiamo appena presentato.

Un’estensione tipica sono gli intervalli di caratteri: [0-9], ad esempio, è una comoda abbreviazione per indicare le cifre al posto di 0|1|2|3|4|5|6|7|8|9. In modo analogo a{n,m} con n e m numeri interi non negativi, denota da n ad m ripetizioni di a. Un altro esempio sono le espressioni regolari usate nella suit di ufficio OpenOffice.

Espressioni Regolari in OpenOffice

Questa è l’introduzione alle espressioni regolari; per lavorare efficientemente con un vero implementazione di queste espressioni richiede ulteriore studio.