Linguaggi logici per modellare ed implementare agenti ... · S. Kripke. Semantical analysis of...

transcript

Linguaggi logiciper modellare ed

implementare agentiintelligenti

Viviana Mascardi

Anno accademico 2005/2006

Materiale di riferimento

Logic-Based Specification Languages for Intelligent Software Agentsdi V. Mascardi, M. Martelli e L. SterlingAccettato per pubblicazione su Theory and Practice of Logic ProgrammingJournal

L’articolo completo e scaricabile da ftp://ftp.disi.unige.it/pub/

person/MascardiV/Papers/TPLP03.ps.gz

Estensioni della logica delprim’ordine ed agenti intelligenti

• Abbiamo gia visto che nella logica del prim’ordine (FOL) non si ri-escono a rappresentare tutte le caratteristiche proprie di un agenteintelligente.

• La rappresentazione di “nozioni intenzionali”, infatti, comporta una se-rie di problemi risolvibili utilizzando estensioni della FOL.

• Anche la rappresentazione dello scorrere del tempo e dell’evoluzioneda uno stato all’altro richiedono l’utilizzo di operatori logici non presentinella FOL.

Estensioni della logica delprim’ordine ed agenti intelligenti

• Vedremo alcune logiche che estendono FOL e che sono particolar-mente adatte a rappresentare caratteristiche proprie degli agenti intel-ligenti.

Logiche analizzate

• Situation calculus [J. McCarthy. Situations, actions and causal laws. Technicalreport, Stanford University, 1963. Reprinted in Semantic Information Processing,M. Minsky ed., The MIT Press, 1968, 110–117]

• Logica modale [S. Kripke. Semantical analysis of modal logic I. Normal proposi-tional calculi. Zeitschrift fur math. Logik und Grundlagen der Mathematik, 9:67–96,1963]

• Logica temporale FML [M. Fisher. A normal form for first-order temporal for-mulae. In D. Kapur, editor, Proceedings of the 11th International Conference onAutomated Deduction (CADE’92), pages 370–384. Springer-Verlag, 1992. LNCS607]

Logiche analizzate (cont.)

• Logica deontica [G. H. von Wright. Deontic logic. Mind, 60:1–15, 1951. Reprinted

in G. H. von Wright, Logical Studies, pp. 58–74. Routledge and Kegan Paul, 1957]

• Logica dinamica [D. Kozen and J. Tiuryn. Logics of programs. In J. van Leeuwen,

editor, Handbook of Theoretical Computer Science. Volume B, pages 789–840,

• Logica lineare [J. Y. Girard. Linear logic. Theoretical Computer Science, 50(1):1–

102, 1987]

Situation calculus

J. McCarthy. Situations, actions and causal laws. Technical report, Stan-ford University, 1963. Reprinted in Semantic Information Processing, M. Min-sky ed., The MIT Press, 1968, 110–117.

• Caratterizzato da situazioni e azioni.

• S0 e la costante che denota la situazione iniziale; do : azione ×situazione→ situazione e la funzione che consente di creare nuovesituazioni a partire da situazioni esistenti ed azioni effettuate.

Situation calculus (cont.)

• Predicato @: situazione × situazione. s @ s′ significa che s′ puoessere raggiunta a partire da s tramite un numero finito di azioni.

• Predicato Poss : action × situation. L’interpretazione di Poss(a, s)e che e possibile eseguire l’azione a nella situazione s.

• Simboli di predicati e simboli di funzione che denotano proprieta efunzioni indipendenti dalla situazione.

• Simboli che denotano azioni.

Situation calculus (cont.)

• Simboli di predicati e simboli di funzione che denotano proprieta efunzioni dipendenti dalla situazione (si chiamano fluenti).

Logica modale

S. Kripke. Semantical analysis of modal logic I. Normal propositional cal-culi. Zeitschrift fur math. Logik und Grundlagen der Mathematik, 9:67–96,1963.S. Kripke. Semantical considerations on modal logic. Acta PhilosophicaFennica, 16:83–94, 1963.S. Kripke. Semantical analysis of modal logic II. Non-normal modal propo-sitional calculi. In Addison, Henkin, and Tarski, editors, The theory of mod-els, pages 206–220, Amsterdam, North-Holland, 1965.

• E una estensione della logica classica con un connettivo 2 e la suacontroparte ♦, noti come necessita e possibilita rispettivamente.

Logica modale (cont.)

• Se una formula 2p e vera, allora p e necessariamente vera, cioe, evera in ogni possibile scenario.

• Se una formula ♦p e vera, allora p e possibilmente vera, cioe, e verain almeno un possibile scenario.

• E possibile definire ♦ in funzione di 2:

♦p⇔ ¬2¬p

Logica modale (cont.)

• Per dare un significato agli operatori 2 e ♦, i modelli della logicamodale sono solitamente basati sui mondi possibili, che sono unacollezione di modelli della logica classica collegati da relazioni di ac-cessibilita.

Logica temporale

Vediamo un esempio di logica temporale chiamata FML [M. Fisher. A nor-mal form for first-order temporal formulae. In D. Kapur, editor, Proceedingsof the 11th International Conference on Automated Deduction (CADE’92),pages 370–384. Springer-Verlag, 1992. LNCS 607].

• FML e una logica temporale del prim’ordine basata su una nozione ditempo discreto e lineare, con passato finito e futuro infinito.

• FML introduce due nuovi connettivi alla logica classica, until (U ) esince (S), e diversi operatori che si possono definire in termini di Ue S.

Logica temporale (cont.)

• Il significato intuitivo di una formula logica temporale ϕ Uψ e che ψdiventera vera in qualche istante di tempo futuro t e che in tutti gliistanti tra l’istante corrente e t (differenti dall’istante corrente e t) ϕsara vera. S e l’analogo di U nel passato.

• La semantica di FML si basa sull’idea “sulla base del passato, eseguile azioni future”.

Logica temporale (cont.)

• Operatori derivati da S e U :

©ϕ ϕ sara‘ vera nel prossimo istante [false Uϕ] ϕ l’istante corrente non e‘ l’istante iniziale e ϕ era vera

nell’istante precedente [false Sϕ]©• ϕ se l’istante corrente non e‘ l’istante iniziale allora ϕ era vera

nell’istante precedente [¬ ¬ϕ]♦ϕ ϕ sara‘ vera in qualche istante futuro [true Uϕ]♦• ϕ ϕ era vera in qualche istante passato [true Sϕ]2ϕ ϕ sara‘ vera in tutti gli istanti futuri [¬ ♦¬ϕ]ϕ ϕ era vera in tutti gli istanti passati [¬♦• ¬ϕ]

Logica deontica

G. H. von Wright. Deontic logic. Mind, 60:1–15, 1951. Reprinted inG. H. von Wright, Logical Studies, pp. 58–74. Routledge and Kegan Paul,1957.C. E. Alchourron and E. Bulygin. Normative Systems. Springer-Verlag,1971.H-N. Castaneda. Thinking and Doing. The Philosophical Foundations ofInstitutions. Reidel Publishing Company, Dordrecht, 1975.

• La logica deontica e la logica per ragionare sul comportamente idealee reale.

Logica deontica (cont.)

• Include operatori per rappresentare permessi, obblighi, e proibizioni,doveri, diritti, potere.

• Tradizionalmente, la logica deontica e stata usata per analizzare lastruttura della legge normativa e per effettura ragionamento in quelcontesto.

• Recentemente si e invece realizzato che le logica deontica puo essereusata al di fuori della analisi in campo legale: infatti, puo essere usataanche per ragionare sul comportamento ideale e reale.

• Esempio: Il sistema OS di von Wright (Old system)

– Il sistema OS e basato su due operatori deontici: O, che significaobbligo, e P che significa permesso. Sia p una proposizione nelcalcolo proposizionale, allora Op e Pp sono formule nel linguaggiodeontico OS.

– Il sistema OS consiste dei seguenti assiomi e regole di inferenza

(OS0) tutte le tautologie del calcolo proposizionale

(OS1) Op ≡ ¬P¬p

(OS2) Pp ∨P¬p

(OS3) P(p ∨ q) ≡ Pp ∨Pq

(OS4) p≡qPp≡Pq

– Si e realizzato che is sistema OS e molto simile alla logica modaleusando O come 2 (operatore di necessita). La logica deontica ela logica modale possono essere viste come la stessa logica se siaggiunge alla logica deontica l’assioma

(O>) O(p ∨ ¬p)

Logica dinamica

D. Kozen and J. Tiuryn. Logics of programs. In J. van Leeuwen, editor,Handbook of Theoretical Computer Science. Volume B, pages 789–840,1990.

• A differenza della logica modale tradizionale, nella logica dinamica glioperatori di necessita e possibilita dipendono dalle azioni disponibili.

• La logica dinamica e stata usata in molte aree della intelligenza artifi-ciale distribuita.

• Consideriamo programmi regolari e formule del linguaggio della logicadinamica definiti per mutua induzione come segue.

Logica dinamica (cont.)

Sia PA un insieme di simboli di azioni atomiche. I programmi regolarisono definiti nel modo seguente:

– tutti i simboli di azione atomica in PA sono programmi regolari;

– se p e q sono programmi regolari, allora p ; q e un programmaregolare che indica l’esecuzione di p e q in successione;

– se p e q sono programmi regolari, allora (p+ q) e un programmaregolare che indica l’esecuzione di p oppure di q;

– se p e un programma regolare, allora p∗ e un programma regolareche indica l’esecuzione di un numero finito di iterazioni di p;

– se ϕ e una formula del linguaggio della logica dinamica, allora ϕ?e un programma regolare che rappresenta l’azione di verificare ilvalore di verita di ϕ;

Le formule del linguaggio della logica dinamica sono definite nel seguentemodo:

– tutte le formule proposizionali sono formule del linguaggio della log-ica dinamica;

– se p e un programma regolare e ϕ e una formula della logica di-namica allora [p]ϕ e una formula della logica dinamica che indicache se p termina, allora deve terminare in uno stato che soddisfaϕ;

– se p e un programma regolare e ϕ e una formula della logica di-namica, allora 〈p〉ϕ e una formula della logica dinamica che indicache e possibile eseguire p e terminare in uno stato che soddisfa ϕ;

– se ϕ e ψ sono formule della logica dinamica allora ϕ ∨ ψ, ϕ ∧ ψ,ϕ =⇒ ψ and ¬ϕ sono formule della logica dinamica.

Logica lineare

J. Y. Girard. Linear logic. Theoretical Computer Science, 50(1):1–102,1987.

La logica lineare e un raffinamento “resource-oriented” della logica clas-sica. L’idea alla base della logica dinamica e che le assunzioni (risorse)possono essere usate solo un numero finito di volte.

• Esponenziali: “!” (of course) and “?” (why not?) esprimono la capacitadi iterare una certa azione. !A indica disponibilita infinita di A.

• Implicazione lineare: − (lollo) e usata per la implicazione lineare. Larelazione tra implicazione lineare e implicazione intuizionista e A ⇒B ≡ (!A) −B.

Logica lineare (cont.)

• Congiunzioni: ⊗ (times) e & (with) corrispondono a usi differenti dellaparola “e”. Entrambe le congiunzioni esprimono la disponibilita di dueazioni. In caso di ⊗, entrambe le azioni verranno eseguite, mentre incaso di & solo una di esse verra eseguita (possiamo decidere quale).Date A − B e A − C, non c’e modo di derivare A − B ⊗ C, ma epossibile derivare A −B&C.

• Disgiunzioni: ⊕ (plus), duale di &, e ............................................................................................... (par),duale di ⊗. ⊕ esprime lascelta di una azione tra due possibili. ............................................................................................... esprime la dipendenza tra duetipi di azioni e puo essere usata per modellare la concorrenza.

Logica lineare (cont.)

• Negazione lineare: (·)⊥ (nil) esprime la negazione lineare. L’implicazionelineare si riscrive in A⊥ ............................................................................................... B ed esprime la dualita

azione di tipo A = reazione di tipo A⊥

• Elementi neutri: 1 (rispetto a ⊗), ⊥ (rispetto a ...............................................................................................), > (rispetto a &) and0 (rispetto a ⊕).

Programmazione logica ed agenti intelligenti

Esistono diversi vantaggi nell’adottare un linguaggio di programmazionelogica per specificare un sistema ad agenti:

• Prototipazione rapida: un programma logico e una specifica eseguibile,ovvero un prototipo. Puo essere realizzato rapidamente e a bassocosto.

• Esecuzione del MAS: l’evoluzione di un MAS consiste in una succes-sione nondeterministica di eventi. Da un punto di vista astratto, unlinguaggio di programmazione basato sulla logica e un linguaggio non-deterministico nel quale la computazione avviene tramite un processodi ricerca.

Programmazione logica ed agenti intelligenti (cont.)

• Capacita di ragionamento al meta-livello: gli agenti possono averebisogno di ragionare sul proprio comportamento e modificare dinami-camente le regole che lo guidano. La possibilita offerta dalla program-mazione logica di vedere programmi come dati risulta quindi utile aquesto scopo.

Programmazione logica ed agenti intelligenti (cont.)

• Razionalita e reattivita degli agenti: la interpretazione dichiarativa equella operazionale dei programmi logici hanno relazioni strette con larazionalita e la reattivita degli agenti. Possiamo pensare ad un pro-gramma logico puro come alla specifica della componente razionaledegli agenti. Il comportamento reattivo degli agenti puo invece esseremodellato dalla interpretazione operazionale dei programmi logici (uti-lizzo di predicati di sistema, esecuzione dei goal da sinistra a destra).Vedere [R. Kowalski and F. Sadri. Towards a unified agent architecture that com-

bines rationality with reactivity. In D. Pedreschi and C. Zaniolo, editors, In Proc. of

the LID International Workshop, pages 137–149. Springer Verlag, 1996].

Linguaggi analizzati

Analizzeremo i seguenti linguaggi per la programmazione di agenti basatisulla logica. Per ciascuno di essi esiste un interprete, spesso implementatoin Prolog.

• ConGolog [G. De Giacomo, Y. Lesperance and H. J. Levesque, ConGolog, a con-current programming language based on the situation calculus, Artificial Intelligence,121, pp 109–169, 2000];

• AGENT-0 [Y. Shoham, Agent-oriented programming, Artificial Intelligence, 60, pp51–92, 1993];

• il linguaggio IMPACT [K. Arisha, T. Eiter, S. Kraus, F. Ozcan, R. Ross, andV. S. Subrahmanian. IMPACT: A platform for collaborating agents. IEEE IntelligentSystems, 14(2):64–72, 1999.];

Linguaggi analizzati (cont.)

• Dylog [M. Baldoni, L. Giordano, A. Martelli and V. Patti, Modeling Agents in a Logic

Action Language in Proc. of Workshop on Practical Reasoning Agents, FAPR2000,

London, UK, 2000];

• Concurrent METATEM [M. Fisher and H. Barringer, Concurrent METATEM Pro-

cesses – A Language for Distributed AI in Proc. of the European Simulation Multi-

conference, Copenhagen, Denmark, 1991];

• Ehhf [G. Delzanno and M. Martelli, Proofs as Computations in Linear Logic, Theo-

retical Computer Science, 258(1–2), pp 269–297, 2001].

Esempio: la proposta di un contratto

buyerRole sellerRole

contractProposal

refuse

accept

contractProposal

refuse

accept

contractProposal

acknowledge

Esempio: la proposta di un contratto (cont.)

Quando l’agente venditore (seller) riceve un messaggio “contractProposal(stuff,amount, price)”,

– se c’e abbastanza merce nel magazzino e il prezzo proposto e ≥ max,il seller invia un messaggio “accept” all’agente compratore (buyer) e, con-correntemente, spedisce la merce richiesta∗;– se non c’e abbastanza merce in magazzino oppure il prezzo propostoe ≤ min, il seller invia un messaggio “refuse” al buyer;– se c’e abbastanza merce in magazzino e min≤ prezzo proposto≤max,il seller invia un messaggio “contractProposal” al buyer per negoziare sulprezzo.

∗Se non e possibile definire azioni concorrenti nel linguaggio, l’invio del messaggio e laspedizione della merce verranno eseguite sequenzialmente.

ConGolog

G. De Giacomo, Y. Lesperance and H. J. Levesque, ConGolog, a con-current programming language based on the situation calculus, ArtificialIntelligence, 121, pp 109–169, 2000

ConGolog si basa sul situation calculus.

ConGolog: sintassi

a Azione primitiva.Φ? Attesa di una condizione.(δ1; δ2) Sequenza.(δ1 | δ2) Scelta nondeterministica di azioni.πv.δ Scelta nondeterministica di argomenti.δ∗ Iterazione nondeterministica.proc P1(

→v1)δ1 end; . . . proc Pn(

→vn)δn end; δ

Procedure.if Φ then δ1 else δ2 Condizionale sincronizzato.while Φ? do δ Ciclo sincronizzato.(δ1 ‖ δ2) Esecuzione concorrente.(δ1〉〉δ2) Concorrenza con prorita‘.

ConGolog: sintassi (cont.)

δ‖ Iterazione concorrente.< Φ→ δ > Interrupt.

ConGolog: come definire un agente

Occorre specificare:

• le azioni primitive;

• le funzioni ed i predicati indipendenti dalla situazione;

• le funzioni ed i predicati fluenti;

• lo stato iniziale;

ConGolog: come definire un agente

• gli assiomi che determinano le precondizioni delle azioni ed i loro ef-fetti;

• il programma vero e proprio, usando la sintassi descritta.

ConGolog: esempio – l’agente seller

Azioni primitive:

ship(Buyer, Product, Required-amount)send(Sender, Receiver, Message)

Funzioni indipendenti dalla situazione:

min-price(Product) = Minmax-price(Product) = Max

Fluenti primitivi:

receiving(Sender, Receiver, Message, S)storing(Product, Amount, S)

ConGolog: esempio (cont.)

Stato iniziale:

min-price(orange) = 1max-price(orange) = 2∀ S, R, M, ¬ receiving(S, R, M, s0)storing(orange, 1000, s0)

Assiomi sulle precondizioni:

poss(ship(Buyer, Prod, Req-amnt), S) ≡storing(Prod, Amnt, S) ∧ Amnt ≥ Req-amnt

poss(send(Sender, Receiver, Message), s) ≡ true

Assiomi sugli stati successivi:

poss(A, S) =⇒(receiving(Send, Rec, Msg, do(A, S)) ≡(A = send(Send, Rec, Msg) ∨ (A 6= send(Send, Rec, Msg) ∧ Msg = empty-msg))

poss(A, S) =⇒(storing(Prod, Amnt, do(A, S)) ≡(A = ship(Buy, Prod, Req-amnt) ∧ storing(Prod, Req-amnt + Amnt, S)) ∨(A 6= ship(Buy, Prod, Req-amnt) ∧ storing(Prod, Amnt, S)))

L’agente seller esegue la procedura seller-life-cycle:

proc seller-life-cyclewhile true do

if receiving(Buy, sell,contractProposal(Prod, Req-amnt, Price), now)

thenif storing(Prod, Amnt, now)∧ Amnt ≥ Req-amnt∧ Price ≥ max-price(Prod)

thenship(Buy, Prod, Req-amnt) ‖send(sell, Buy, accept(Prod, Req-amnt, Price))

else .........

else nil

ConGolog: semantica

• La semantica di ConGolog e data come una sematica di transizionemediante due predicati, Final(δ, s) e Trans(δ, s, δ′, s′).

• Il primo predicato definisce quando un programma δ puo legalmenteterminare in una situazione s.

• Il secondo predicato definisce quando un programma δ nella situ-azione s puo legalmente eseguire un passo, arrivando alla situaziones′ e con il programma δ′ ancora da eseguire.

ConGolog: implementazione

• Una implementazione di ConGolog e stata realizzata in Prolog.

• La definizione dell’interprete per ConGolog e basata sui predicati Final,Trans e Do.

• L’interprete e scaricabile dalla Home page del Cognitive Robotics Group,http://www.cs.toronto.edu/cogrobo/.

ConGolog: estensioni

• Legolog (LEGO MINDSTORM in (Con)Golog) usa un pianificatore re-alizzato estendendo ConGolog per controllare un robot LEGO MIND-STORM. Il linguaggio usato estende ConGolog con capacita di gestireazioni primitive, azioni esterne e percezione dell’ambiente. Vedere laHome page di Legolog, http://www.cs.toronto.edu/cogrobo/Legolog/index.html.

• IndiGolog (Incremental Deterministic (Con)Golog) e un linguaggio diprogrammazione ad alto livello in cui i programmi sono eseguiti in-crementalmente e consentono l’interleaving di azioni, pianificazione,percezione e gestione di eventi esterni.

ConGolog: estensioni (cont.)

• CASL (Cognitive Agent Specification Language e un ambiente per laspecifica e verifica di MASs basato su ConGolog.

AGENT-0

Y. Shoham, Agent-oriented programming, Artificial Intelligence, 60, pp 51–92, 1993

AGENT-0 integra aspetti della logica modale, temporale e deontica.

AGENT-0: sintassi

<program> ::= <timegrain> <fact>* <capability>* <commitrule>*<timegrain> ::= m | h | d | y<capability> ::= (<action> <mntlcond>)<commitrule> ::= (COMMIT <msgcond> <mntlcond>

(<agent> <action>)*)<msgcond> ::= <msgconj> | (<msgcond> OR <msgcond>)<msgconj> ::= <msgpattern> | (<msconj> AND <msconj>)<msgpattern> ::= (<agent> INFORM <fact>) |

(<agent> REQUEST <action>) |(NOT <msgpattern>)

<mntlcond> ::= <mntlconj> | (<mntlcond> OR <mntlcond>)<mntlconj> ::= <mntlpattern> | (<mntlconj> AND <mntlconj>)<mntlpattern>::= (B <fact>) | ((CMT <agent>) <action>) |

(NOT <mntlpattern>)

AGENT-0: sintassi (cont.)

Fatti. I fatti sono atomi collocati temporalmente del tipo(t atom)

e(NOT (t atom))

Per esempio, (0 (stored orange 1000)) e un fatto in AGENT-0 che sta-bilisce che al tempo 0 c’erano 1000 arance nel magazzino.

Azioni private. La sintassi per le azioni private e(DO t p-action)

dove t e un istante di tempo e p-action e il nome di una azione privata.Gli effetti delle azioni private possono essere visibili oppure no agli altriagenti.

Azioni comunicative. La sintassi e:(INFORM t a fact)

dove t e l’istante di tempo in cui avviene l’azione di informare, a e ilnome del destinatario e fact e un fatto.

(REQUEST t a action)dove t e un istante di tempo, a e il nome del destinatario e action e unaazione.

(UNREQUEST t a action)dove t e un istante di tempo, a e il nome del destinatario e action e unaazione.

Non-azione. Una non-azione evita che un agente debba vincolarsi allaesecuzione di una azione.

(REFRAIN action)

Condizioni mentali. Una condizione mentale e una combinazione logicadi pattern mentali che possono assumere due forme:

(B fact)che significa che l’agente crede che fact sia vero, oppure

((CMT a) action)dove CMT indica “commitment”.

Capacita. La sintassi e(action mentalcondition)

l’agente e capace di effettuare action se la condizione mentale men-talcondition e vera.

Azioni condizionali. La sintassi e(IF mentalcondition action)

l’azione action puo essere eseguita solo se la condizione mentalementalcondition vale.

Condizioni sui messaggi. Una “message condition” (condizione sui mes-saggi) e una combinazione logica di message patterns, che sono triple

(From Type Content)dove From e il nome del sender, Type e INFORM, REQUEST o UN-REQUEST e Content e un fatto o una azione.

“Commitment rule”. Una “commitment rule” (regola di impegno) ha laforma:

(COMMIT messagecondition mentalcondition (agent action)*)dove messagecondition e mentalcondition sono condizioni sui mes-saggi e condizioni mentali, agent e un nome di agente, action e unaazione e * denota la ripetizione di zero o piu volte.

AGENT-0: come definire un agente

Il programma che definisce un agente e caratterizzato dal “timegrain”, se-guito dalle capacita, dalle credenze iniziali dell’agente e dalle sue commit-ment rules.

AGENT-0: esempio – l’agente seller

Le variabili sono precedute da “?”. Le variabili quantificate universalmente sono prece-dute da “?!”.

timegrain := m

CAPABILITIES :=((DO ?time (ship ?!buyer ?stuff ?required-amount?!price))(AND (B (?time (stored ?stuff ?stored-amount)))

(>= ?stored-amount ?required-amount))

INITIAL BELIEFS :=(0 (stored orange 1000))(?!time (min-price orange 1))(?!time (max-price orange 2))

AGENT-0: esempio – l’agente seller (cont.)

COMMITMENT RULES :=

(COMMIT(?buyer REQUEST

(DO now+1 (ship ?buyer ?stuff ?req-amnt ?price)))

(AND (B (now (stored ?stuff ?stored-amount))) (>= ?stored-amount ?req-amnt)(B (?!time (max-price ?stuff ?max))) (>= ?price ?max))

(?buyer (DO now+1(ship ?buyer ?stuff ?req-amnt ?price)))

(myself (INFORM now+1 ?buyer(accepted ?stuff ?req-amnt ?price)))

(myself (DO now+1 (update-stuff ?stuff ?req-amnt))))

(COMMIT

(?buyer REQUEST

(OR (AND (B (now (stored ?stuff ?stored-amount)))

(< ?stored-amount ?req-amnt))

(AND (B (?!time (min-price ?stuff ?min)))

(<= ?price ?min)))

(myself (INFORM now+1 ?buyer

(refused ?stuff ?req-amnt ?price)))

(COMMIT

(?buyer REQUEST

(AND (B (now (stored ?stuff ?stored-amount))) (>= ?stored-amount ?req-amnt)

(B (?!time (max-price ?stuff ?max))) (< ?price ?max)

(B (?!time (min-price ?stuff ?min))) (> ?price ?min))

(myself (DO now+1 (eval-mean ?max ?price

?mean-price)))

(myself (REQUEST now+1 ?buyer

(eval-counter-proposal ?stuff ?req-amnt

?mean-price)))

AGENT-0: semantica

Non definita

AGENT-0: implementazione

Un prototipo dell’interprete di AGENT-0 e stato implementato in CommonLisp ed e stato installato su computer Sun/Unix, DecStation/Ultrix e Mac-intosh.

Una seconda implementazione e stata sviluppata dalla Hewlett Packard.

L’interprete AGENT-0 e caratterizzato dal seguente ciclo:

1. Leggi i messaggi correnti ed aggiorna le credenze ed i “commitment”;

2. Esegui i commitment previsti per l’istante di tempo corrente, eventual-mente modificando nuovamente le credenze.

AGENT-0: estensioni

• PLACA arricchisce AGENT-0 con un meccanismo per la gestione flessibiledi piani. Aggiunge due strutture dati allo stato dell’agente: una listadi intenzioni ed una lista di piani. Sono inoltre disponibili all’agentealtri costrutti quali (ADOPT (INTEND x)), che significa che l’agenteaggiunge l’intenzione di eseguire x alla sua intention list.

AGENT-0: estensioni (cont.)

• Agent-K rappresenta un tentativo di standardizzare lo scambio di mes-saggi, adottando la sintassi di KQML. Agent-K introduce due modifichealla struttura di AGENT-0:

1. rimpiazza i messaggi di tipo INFORM, REQUEST, and UNRE-QUEST in uscita con un comando, KQML, che prende il messag-gio, il tempo e la performative KQML come parametri;

2. Consente di generare piu di un commitment che soddisfa un sin-golo messaggio.

IMPACT

K. Arisha, T. Eiter, S. Kraus, F. Ozcan, R. Ross, and V. S. Subrahmanian.IMPACT: A platform for collaborating agents. IEEE Intelligent Systems,14(2):64–72, 1999.V.S. Subrahmanian, P. Bonatti, J. Dix, T. Eiter, S. Kraus, F. Ozcan, andR. Ross. Heterogenous Active Agents. The MIT Press, 2000. 580 pages.

Include operatori propri della logica deontica.

IMPACT: sintassi

• code calls: S : f(t1, . . . , tn).

• code call atom: in(t, cc) or notin(t, cc)

• code call condition: congiunzione di code call atoms.

• action: α(X1, . . . , Xn) + liste che definiscono le precondizioni, gli ef-fetti e i fatti da cancellare + script di esecuzione.

• integrity constraints: ψ ⇒ χa, dove ψ e una code call condition e χae un code call atom o un constraint atom.

IMPACT: sintassi (cont.)

• programma di un agente: insieme di regole della forma:Modα← χ&L1 & · · · &Ln

dove Mod puo essere O (obliged), F (forbidden), P (permitted), W

(waived) oppure Do (esecuzione di una azione); χ e una code callcondition, L1, . . . , Ln sono espressioni della forma Oα(~t), Pα(~t),Fα(~t), Doα(~t), and Wα(~t) (o loro negazioni).

IMPACT: come definire un agente

• Stabilire quali pacchetti verranno acceduti dall’agente, e mediante qualeAPI.

• Definire lo stato iniziale dell’agente.

• Definire le azioni a disposizione dell’agente.

• Definire gli integrity constraints.

• Definire il programma.

IMPACT: esempio – l’agente seller

Assumiamo che l’agente acceda:

• un database oracle che mantiene l’informazione sulla quantita di mercedisponibile ed il suo prezzo minimo e massimo. Le informazioni sonomantenute in una relazione stored stuff;

• un pacchetto msgbox che consente all’agente di scambiare messaggi;

• un pacchetto math che esporta funzioni matematiche.

La relazione stored stuff inizialmente contiene la tupla <orange, 1000, 1,2>.

IMPACT: esempio – l’agente seller (cont.)

Le azioni che l’agente puo effettuare sono sendMessage(Sender, Receiver,Message) (vedi [T. Eiter, V. S. Subrahmanian, and G. Pick. Heterogeneous active

agents, I: Semantics. Artificial Intelligence, 108(1-2):179–255, 1999] per descrizionecompleta) e ship(Buyer, Stuff, Req amount).

ship(Buyer, Stuff, Req amount)

Pre(ship(Buyer, Stuff, Req amnt)) =in(Old amnt, oracle:select(stored stuff.amount, name, =, Stuff)) ∧in(Diff, math:subtract(Old amnt, Req amnt)) ∧ Diff ≥ 0

Add(ship(Buyer, Stuff, Req amnt)) =in(Diff, oracle:select(stored stuff.amount, name, =, Stuff))

Del(ship(Buyer, Stuff, Req amnt)) =in(Old amnt, oracle:select(stored stuff.amount, name, =, Stuff))

Integrity constraints:

in(Min, oracle:select(stored stuff.min, name, =, Stuff)) ∧in(Max, oracle:select(stored stuff.max, name, =, Stuff)) =⇒

0 < Min < Max

in(Amount, oracle:select(stored stuff.amount, name, =, Stuff)) =⇒Amount > 0

Programma dell’agente:

Do sendMessage(Seller, Buyer,accept(Stuff, Req amount, Price))←

in(〈 i, Buyer, Seller, contractProposal(Stuff, Req amount, Price), T〉,msgbox:getMessage(Sender)),in(Max, oracle:select(stored stuff.max, name,=, Stuff)),in(Amount, oracle:select(stored stuff.amount,name, =, Stuff)),Price >= Max, Amount >= Req amount

O ship(Buyer, Stuff, Req amount)←Do sendMessage(Seller, Buyer,accept(Stuff, Req amount, Price))

Do sendMessage(Seller, Buyer,refuse(Stuff, Req amount, Price))←

in(〈 i, Buyer, Seller, contractProposal(Stuff, Req amount, Price), T〉,msgbox:getMessage(Sender)),in(Min, oracle:select(stored stuff.max, name,=, Stuff)),Price <= Min

Do sendMessage(Seller, Buyer,refuse(Stuff, Req amount, Price))←

in(〈 i, Buyer, Seller, contractProposal(Stuff, Req amount, Price), T〉,msgbox:getMessage(Sender)),in(Amount, oracle:select(stored stuff.amount,name, =, Stuff)),Amount < Req amount

Do sendMessage(Seller, Buyer,contractProposal(Stuff, Req amount, Means))←

in(〈 i, Buyer, Seller, contractProposal(Stuff, Req amount, Price), T〉,msgbox:getMessage(Sender)),in(Max, oracle:select(stored stuff.max,name, =, Stuff)),in(Min, oracle:select(stored stuff.min,name, =, Stuff)),in(Amount, oracle:select(stored stuff.amount,

name, =, Stuff)),Price > Min, Price < Max,Amount >= Req amountin(Means, math:evalMeans(Max, Price))

IMPACT: sematica

Se il comportamento di un agente e definito da un programma P, la do-manda che l’agente si pone continuamente e:

Qual e l’insieme di tutti gli action status atoms della forma Doα(~t)

che sono veri rispetto ad P, lo stato corrente O e l’insieme ICdegli integrity constraint?

L’insieme in questione definisce le azioni che un agente deve eseguire;esistono diverse semantiche di IMPACT che descrivono come individuarequesto insieme seguendo modalita sempre piu raffinate.

IMPACT: implementazione

L’implementazione dell’ambiente IMPACT consiste in due parti, entrambeimplementate in Java:

1. L’ “IMPACT Agent Development Environment” (IADE) che e usato dallosviluppatore per costruire e compilare gli agenti, e

2. la parte che gestisce l’esecuzione a run-time, che consente agli agentidi identificare l’insieme di azioni da eseguire e le conseguenti modi-fiche allo stato.

IMPACT: estensioni

• Estensioni “meta” per ragionare sugli altri agenti a partire dalle cre-denze che essi hanno.

• Estensioni temporali per specificare aspetti temporali dell’esecuzione.

• Estensioni probabilistiche per gestire l’incertezza.

• Estensioni per la tolleranza agli errori per consentire agli agenti di con-tinuare la loro esecuzione anche in caso di errori/guasti.

IMPACT: estensioni (cont.)

• Estensioni per la sicurezza per fornire agli agenti meccanismi di si-curezza.

M. Baldoni, L. Giordano, A. Martelli and V. Patti, Modeling Agents in a LogicAction Language in Proc. of Workshop on Practical Reasoning Agents,FAPR2000, London, UK, 2000

Gli approcci su cui si basa sono quelli della logica dinamica e della log-ica modale.

Dylog: sintassi

• [a]α: α vale dopo ogni esecuzione di a.

• 〈a〉α: c’e una possibile esecuzione di a dopo la quale α vale.

• 2 α: α vale in tutti gli stati.

• Leggi delle azioni: a causes F if Fs.

• Leggi delle precondizioni: a possible if Fs.

• Leggi causali: F if Fs.

• Procedure: definite come una collezione di procedure clauses della formap0 is p1, . . . , pn (n ≥ 0).

• Pianificazione: plan(p, Fs, as).

• Percezione: s senses f.

Dylog: come definire un agente

• Si definiscono i fluenti.

• Si definiscono i fatti che non sono fluenti.

• Si definiscono le osservazioni iniziali.

• Si definiscono le azioni primitive, in termini delle leggi di precondizione,azione e causali.

• Si definiscono le procedure.

Dylog: esempio – l’agente seller

Fluenti:

functionalFluent(storing/2).

functionalFluent(new message/2).

Fatti non fluenti:

min-price(orange, 1).

max-price(orange, 2).

Osservazioni iniziali:

obs(storing(orange, 1000)).

Dylog: esempio – l’agente seller (cont.)

Azioni primitive:

receive

Leggi di precondizione:receive possible if true.

Percezione:receive sensesnew message(Sender, Message).

Routine che implementa la percezione:senses routine( , new message,Sender, Message) :- ....

send(Sender, Receiver, Message)

Dylog: example (cont.)

ship(Buyer,Stuff, Req Amnt, Price)

Leggi di azione:ship(Buyer, Stuff, Req Amnt, Price)

causes storing(Stuff, Amount)if ?storing(Stuff, Old Amount) &

(Amount is Old Amount - Req Amnt).

Leggi di precondizione:ship(Buyer, Stuff, Req Amnt)

possible if ?storing(Stuff, Old Amount) &(Old Amount >= Req Amnt).

ship(Buyer, Stuff, Req Amnt)possible if max-price(Stuff, Max) &

(Price >= Max).

Procedure:

seller agent cycle ispreceive &manage message &seller agent cycle.

manage message isp?new message(Buyer,

contractProposal(Stuff, Req Amnt, Price)) &?storing(Stuff, Old Amount) &(Old Amount >= Req Amnt) &max-price(Stuff, Max) & (Price >= Max) &ship(Buyer, Stuff, Req Amnt, Price) &send(seller, Buyer,accept(Stuff, Req Amnt, Price))

manage message isp?new message(Buyer,contractProposal(Stuff, Req Amnt, Price)) &?storing(Stuff, Old Amount) &(Old Amount < Req Amnt) &send(seller, Buyer,

refuse(Stuff, Req Amnt, Price))

manage message isp?new message(Buyer,contractProposal(Stuff, Req Amnt, Price)) &min-price(Stuff, Min) & (Price <= Min)send(seller, Buyer,refuse(Stuff, Req Amnt, Price))

manage message isp?new message(Buyer,contractProposal(Stuff, Req Amnt, Price)) &?storing(Stuff, Old Amount) &(Old Amount >= Req Amnt) &max-price(Stuff, Max) & (Price < Max) &min-price(Stuff, Min) & (Price > Min) &(New Price is (Price + Max) / 2) &send(seller, Buyer,contractProposal(Stuff, Req Amnt, New Price))

Dylog: sematica

La caratterizzazione logica di Dylog puo essere fornita in due passi:

• Prima viene introdotta l’interpretazione logica multimodale della de-scrizione dinamica del dominio che descrive la parte monotona dellinguaggio.

• Poi, viene fornita una semantica adduttiva che spiega il comporta-mento della parte non monotona del linguaggio.

Dylog: implementazione

• Dylog e definito da una procedura di prova che costruisce un piano lin-eare facendo assunzioni sui possibili risultati delle azioni di percezione.

• Un interprete basato su questa procedura di prova e stato implemen-tato in SICStus Prolog.

• Questa implementazione consente di usare Dylog come un linguaggiodi programmazione per eseguire procedure, ma anche per ragionaresulle procedure, estraendo dalle procedure piani condizionali o pianilineari.

Dylog: implementazione (cont.)

• Dettagli ulteriori presso la ALICE Home Page, http://www.di.unito.it/˜alice/

Dylog: estensioni

• Gli agenti Dylog sono stati estesi per rappresentare correttamente cre-denze di altri agenti. Lo scopo era quello di ragionare sulle conver-sazioni.

• Gli agenti sono anche stati arricchiti con un “communication kit” cheinclude un insieme di speech acts, azioni per la gestione di messaggie protocolli di comunicazione.

Concurrent METATEM

M. Fisher and H. Barringer, Concurrent METATEM Processes – A Lan-guage for Distributed AI in Proc. of the European Simulation Multiconfer-ence, Copenhagen, Denmark, 1991

Coincide con il linguaggio logico temporale FML: ha la stessa sintassi esemantica.

Concurrent METATEM: come definire un agente

• Definire l’interfaccia dell’agente (che messaggi esporta ed importa).

• Definire i predicati dell’agente (indipendenti dal tempo – rigid– e fluenti– flexible).

• Definire le regole del programma.

Concurrent METATEM: esempio – l’agente seller

Interfaccia dell’agente seller:

seller(contractProposal)[accept, refuse, contractProposal, ship]

Rigid predicates:

min-price(orange, 1).

max-price(orange, 2).

Flexible predicates:

storing(orange, 1000).

Concurrent METATEM: esempio – l’agente seller (cont.)

Regole del programma:

∀ Buyer. ∀ Stuff. ∀ Req Amnt. ∀ Price.[contractProposal(Buyer, seller, Stuff,Req Amnt, Price) ∧storing(Stuff, Old Amount) ∧Old Amount >= Req Amnt ∧max-price(Stuff, Max) ∧ Price >= Max] =⇒

[ship(Buyer, Stuff, Req Amnt, Price) ∧accept(seller, Buyer, Stuff, Req Amnt, Price)]

∀ Buyer. ∀ Stuff. ∀ Req Amnt. ∀ Price.[contractProposal(Buyer, seller,Stuff, Req Amnt, Price) ∧storing(Stuff, Old Amount) ∧min-price(Stuff, Min) ∧Old Amount < Req Amnt ∨ Price <= Min] =⇒

[refuse(seller, Buyer, Stuff, Req Amnt, Price)]

Concurrent METATEM: esempio – l’agente seller (cont.)

∀ Buyer. ∀ Stuff. ∀ Req Amnt. ∀ Price.[contractProposal(Buyer, seller,Stuff, Req Amnt, Price) ∧storing(Stuff, Old Amount) ∧min-price(Stuff, Min) ∧max-price(Stuff, Max) ∧Old Amount >= Req Amnt ∧Price > Min ∧ Price < Max ∧New Price = (Max + Price) / 2] =⇒

[contractProposal(seller, Buyer,Stuff, Req Amnt, New Price)]

Concurrent METATEM: sematica

La semantica di FML e data tramite una relazione |= cha stabilisce il valoredi verita di una formula in un modelloM in un particolare istante di tempoi e rispetto ad una assegnazione di valori alle variabili.

e per ogni j, se i < j < k allora 〈M, j, hv〉 |= ϕ〈M, i, hv〉 |= ϕ Sψ iff per qualche k tale che 0 ≤ k < i, 〈M, k, hv〉 |= ψ

Concurrent METATEM: implementazione

• Sono state prodotto due implementazioni del paradigma descritto inquesta sezione.

• La prima e un interprete prototipale per METATEM implementato inScheme.

• Un secondo interprete per una versione ristretta di METATEM (casoFOL) e stato implementato in Prolog ed e stato usato come un lin-guaggio per programmare transazioni in basi di dati temporali.

Concurrent METATEM: estensioni

• Gli agenti Concurrent METATEM sono stati estesi con capacita delib-erative e credenze e con ragionamento in presenza di risorse limitate.

• Sono state proposte estensioni nella direzione “multi-agente”: Concur-rent METATEM e stato proposto come un linguaggio di coordinazione.Sono stati proposti meccanismi per definire gruppi di agenti.

• La nozione di “confidenza” e stata aggiunta sia a singoli agenti Con-current METATEM sia a MAS. Lo sviluppo di teams di agenti e statorecentemente affrontato.

G. Delzanno and M. Martelli, Proofs as Computations in Linear Logic, The-oretical Computer Science, 258(1–2), pp 269–297, 2001

L’approccio formale su cui si basa e quello della logica lineare.

Ehhf : sintassi

Un programma Ehhf e una collezione di clausole multi-conclusione dellaforma

A1............................................................................................... . . . ............................................................................................... An −Goal,

dove Ai sono formule atomiche e la disgiunzione lineare A1............................................................................................... . . . ............................................................................................... An

corrisponde alla testa della clausola, mentre Goal e il body.

A − B e una implicazione lineare. Clausole di questo tipo consumano lerisorse (formule) di cui hanno bisogno per essere applicate in un passo dirisoluzione.

Ehhf : sintassi (cont.)

Ehhf fornisce gli strumenti per limitare la applicazione di una clausola data.Le clausole di tipo esteso hanno la forma

G1 & . . .& Gm ⇒ (A1............................................................................................... . . . ............................................................................................... An −Goal),

dove le formule Gi sono condizioni che devono essere verificate per poterutilizzare la clausola.

Ehhf : come definire un agente

In maniera analoga al Prolog, e necessario definire i fatti e le regole (ovvi-amente utilizzando la sintassi Ehhf ).

Ehhf : esempio – l’agente sellerFatti iniziali:

min-price(orange, 1).max-price(orange, 2).storing(orange, 1000).seller-mail-box([]).

Regola che governa il ciclo di vita dell’agente:

∀ Message. ∀ OtherMessages.seller-mail-box([Message|OtherMessages]) ...............................................................................................

seller-cycle −manage(Message) ...............................................................................................

seller-mail-box(OtherMessages) ...............................................................................................

seller-cycle.

Ehhf : esempio – l’agente seller (cont.)

Regole per gestire i messaggi:

∀ Buyer. ∀ Stuff. ∀ Req Amnt. ∀ Price.Old Amount >= Req Amnt &difference(Old Amount, Req Amnt,Remaining Amnt) &max-price(Stuff, Max) & Price >= Max =⇒

manage(contractProposal(Buyer, Stuff,Req Amnt, Price)) ...............................................................................................

storing(Stuff, Old Amount) −storing(Stuff, Remaining Amount) ...............................................................................................

ship(Buyer, Stuff, Req Amnt, Price) ...............................................................................................

send(Buyer, accept(seller, Stuff,Req Amnt, Price).

∀ Buyer. ∀ Stuff. ∀ Req Amnt. ∀ Price.min-price(Stuff, Min) & Price <= Min =⇒

manage(contractProposal(Buyer, Stuff,Req Amnt, Price)) −

send(Buyer, refuse(seller, Stuff,Req Amnt, Price).

∀ Buyer. ∀ Stuff. ∀ Req Amnt. ∀ Price.storing(Stuff, Old Amount) &Old Amount < Req Amnt =⇒

send(Buyer, refuse(seller, Stuff,Req Amnt, Price).

∀ Buyer. ∀ Stuff. ∀ Req Amnt. ∀ Price.Old Amount >= Req Amnt &min-price(Stuff, Min) & Price > Min &max-price(Stuff, Max) & Price < Max &eval-means(Max, Price, Means) =⇒

send(Buyer, contractProposal(seller, Stuff,Req Amnt, Means).

Ehhf : sematica

Si puo fornire una semantica operazionale che determina come riscriverele formule presenti nello stato dell’agente

• Dato un multinsieme di formule atomiche Ω0, che rappresentano lostato della computazione, si puo effettuare un passo di risoluzioneΩ0 → Ω1 applicando un’istanza A1

............................................................................................... . . . ............................................................................................... An − G di una clausolanel programma P , se il multinsieme Θ composto da A1, . . . , An econtenuto in Ω0.

• Ω1 si ottiene rimuovendo Θ da Ω0 ed aggiungendo G al multinsiemerisultante.

Ehhf : sematica (cont.)

• Nel caso un cui le clausole abbiano una “guardia”, bisogna verificareche la guardia sia soddisfatta nello stato corrente prima di poter appli-care un passo di risoluzione. La verifica della guardia non consumane aggiunge risorse allo stato dell’agente.

Ehhf : implementazione

• Esiste un interprete sviluppato da M. Bozzano in Lambda Prolog, unlinguaggio che supporta sintassi astratta higher-order.

• Il codice puo essere scaricato dalla Ehhf FTP Area, ftp://ftp.disi.unige.it/person/BozzanoM/Terzo/

Ehhf : estensioni

• Nel contesto dei MAS, Ehhf e stato usato per specificare una architet-tura basata sulla BDI e per verificare la correttezza di un MAS dove gliagenti sono specificati tramite regole event–condition–action.

• Ehhf e anche stato usato per modellare basi di dati orientate aglioggetti e deduttive.

Confronto finale

T Sns Cm Cc N M SmConGolog × AGENT-0 IMPACT × Dylog × Conc. METATEM Ehhf

T: Tempo.Sns: Sensing (percezione).Cm: Comunicazione.Cc: Concorrenza.

N: Nondeterminismo.M: Modularita‘.

Sm: Semantica formale.: Supportato appieno.×: Parzialmente supportato.: Non supportato.

Linguaggi logici per modellare ed implementare agenti ... · S. Kripke. Semantical analysis of...

Documents