Transcript

Transcript

-----------------------------------------------------------------------80 cols--

module Lib where

someFunc :: IO ()
someFunc = putStrLn "someFunc"

data Agent = Agent
data Plan  = Plan
data World = World
data Prover = Prover

-- Assunzione 1: Essenzialmente tutto il planning che dobbiamo fare passa da una
-- risoluzione logica.

data Facts = Facts
data Statement = Statement
data Action = Action

prove :: Facts -> Statement -> Bool
prove = undefined

step :: Facts -> Facts
step = undefined

act :: World -> Agent -> (Action, World)
act = undefined

-- act' :: Agent -> State World Action
-- act' = undefined

-- minuta --
??? :: World -> [Rule] -> ??? -- [World]

qqq :: SimpleWorld -> [Agent] -> World --???

{-
Dunque, diciamo che un agente1 possa prendere un oggetto oppure saltare xD

Allora, abbiamo delle regole come

stato(qualcosa) -o salta(x) /\ stato(nuovostato)
stato(qualcosa) /\ oggetto(y) -o prende(x,y) /\ stato(nuovostato)

Quindi, quello che voglio dire e' che il `tick` dell'orologio del mondo e'
simulato dall'uso di una regola di inferenza. Quindi, diciamo, partiamo da una
regola, e possiamo avere tante possibili continuazioni. Per esempio, siamo nello
stato A e possiamo andare nello stato B,C o D Alcune di queste transizioni sono
regole che il mondo ha di per se, altre, se ammettiamo che gli agenti facciano
parte del mondo, sono possibili scelte che gli agenti fanno.
problema dell'npc della stanza.

I) Regole del mondo
aperta(porta)
dentro(Agente) /\ aperta(Porta) => fuori(Agente)
dentro(agente1)
dentro(agente2)

II) Goal della ggente
goal(agente1,  fuori(agente1))
goal(agente2, ~fuori(agente1))

-- Fromthe POV of the Agent, he is *just* proving things.
-- This works

-- Epistemic logic

-}

prove :: Judgement -> Maybe ProofTree
prove = undefined

act :: Agent -> Action
act = "head" . prove . goal

goal :: Agent -> Judgement
goal = undefined



-- purtroppo l'agente pensa di poter uscire senza aprire la porta.
-- Che succede quando prende la porta in faccia?


I) Regole del mondo
aperta(porta) True
dentro(Agente) /\ aperta(Porta) => fuori(Agente) True
dentro(agente1) True
dentro(agente2) True

agente1 Knows dentro(agente1)
agente1 Knows dentro(Agente) => fuori(Agente)

II) Goal della ggente
goal(agente1,  fuori(agente1))


realta2percezione :: Wo-----------------------------------------------------------------------80 cols--

module Lib where

someFunc :: IO ()
someFunc = putStrLn "someFunc"

data Agent = Agent
data Plan  = Plan
data World = World
data Prover = Prover

-- Assunzione 1: Essenzialmente tutto il planning che dobbiamo fare passa da una
-- risoluzione logica.

data Facts = Facts
data Statement = Statement
data Action = Action

prove :: Facts -> Statement -> Bool
prove = undefined

step :: Facts -> Facts
step = undefined

act :: World -> Agent -> (Action, World)
act = undefined

-- act' :: Agent -> State World Action
-- act' = undefined

-- minuta --
??? :: World -> [Rule] -> ??? -- [World]

qqq :: SimpleWorld -> [Agent] -> World --???

{-
Dunque, diciamo che un agente1 possa prendere un oggetto oppure saltare xD

Allora, abbiamo delle regole come

stato(qualcosa) -o salta(x) /\ stato(nuovostato)
stato(qualcosa) /\ oggetto(y) -o prende(x,y) /\ stato(nuovostato)

Quindi, quello che voglio dire e' che il `tick` dell'orologio del mondo e'
simulato dall'uso di una regola di inferenza. Quindi, diciamo, partiamo da una
regola, e possiamo avere tante possibili continuazioni. Per esempio, siamo nello
stato A e possiamo andare nello stato B,C o D Alcune di queste transizioni sono
regole che il mondo ha di per se, altre, se ammettiamo che gli agenti facciano
parte del mondo, sono possibili scelte che gli agenti fanno.

Problema dell'npc della stanza.

I) Regole del mondo
aperta(porta)
dentro(Agente) /\ aperta(Porta) => fuori(Agente)
dentro(agente1)
dentro(agente2)

II) Goal della ggente
goal(agente1,  fuori(agente1))
goal(agente2, ~fuori(agente1))

-- From the POV of the Agent, he is *just* proving things.
-- This works

-- Epistemic logic

-}

prove :: Judgement -> Maybe ProofTree
prove = undefined

act :: Agent -> Action
act = "head" . prove . goal

-- purtroppo l'agente pensa di poter uscire senza aprire la porta.
-- Che succede quando prende la porta in faccia?


I) Regole del mondo
~aperta(porta) True
dentro(Agente) /\ aperta(Porta) => fuori(Agente) True
dentro(agente1) True
dentro(agente2) True

agente1 Knows dentro(agente1)
agente1 Knows dentro(Agente) => fuori(Agente)

II) Goal della agente
fuori(agente1) True

lui riesce a dimostrare pero'
agente1 Knows fuori(agente1)

realta2percezione :: -> World -> AgentKnows -> MyWorld


-- 1. we need: linear logic, epistemic something
-- todo: rules of this logic