Perfect recall in non-deterministic broadcast environments

For completeness we reproduce the results ofvan der Meyden(1996b) about non-deterministic KBPs in broadcast environments. The situation is described by the locale in Figure3.6. Actions are now split into public and private components, where the private part influences the agents’ private states, and the public part is broadcast and recorded in the system state. Moreover the protocol of the environment is a function of the environment state only. Once again an agent’s view consists of the common observation and their private state. As the representations developed in the previous section are adequate for this case, we work more astractly here.

Our goal here is to instantiate theSimIncrEnvironmentlocale with respect to the assumptions made in theFiniteBroadcastEnvironmentlocale. This is similar to the previous section.

context FiniteBroadcastEnvironment

begin

As for the deterministic variant, we abstract traces using the common observation. Note that this now includes the public part of the agents’ actions.

definition tObsC :: "(’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState Trace ⇒ (’cobs _× ’ePubAct _× (’a _⇒ ’pPubAct)) Trace" where "tObsC ≡ tMap (λs. (envObsC (es s), pubActs s))"

Similarly we introduce common and agent-specific abstraction functions:

definition tObsC_abs :: "(’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState Trace ⇒ ((’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState

× (’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState) set" where "tObsC_abs t _≡ { (tFirst t’, tLast t’) |t’.

t’ ∈ SPR.jkbpC ∧ tObsC t’ = tObsC t }"

definition agent_abs :: "’a _⇒ (’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState Trace ⇒ ((’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState

record (’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState =

es :: "’es"

ps :: "’a ⇒ ’ps"

pubActs :: "’ePubAct × (’a ⇒ ’pPubAct)" locale FiniteBroadcastEnvironment =

Environment jkbp envInit envAction envTrans envVal envObs

for jkbp :: "(’a :: finite, ’p, (’pPubAct :: finite × ’ps :: finite)) JKBP" and envInit

:: "(’a, ’ePubAct :: finite, ’es :: finite, ’pPubAct, ’ps) BEState list" and envAction :: "(’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState

⇒ (’ePubAct _× ’ePrivAct) list" and envTrans :: "(’ePubAct _× ’ePrivAct)

⇒ (’a _⇒ (’pPubAct _× ’ps))

⇒ (’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState ⇒ (’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState"

and envVal :: "(’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState ⇒ ’p ⇒ bool" and envObs :: "’a ⇒ (’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState

⇒ (’cobs × ’ps × (’ePubAct × (’a ⇒ ’pPubAct)))" + fixes envObsC :: "’es ⇒ ’cobs"

and envActionES :: "’es ⇒ (’ePubAct × (’a ⇒ ’pPubAct))

⇒ (’ePubAct × ’ePrivAct) list"

and envTransES :: "(’ePubAct × ’ePrivAct) ⇒ (’a ⇒ ’pPubAct)

⇒ ’es _⇒ ’es"

defines envObs_def: "envObs a _≡ (λs. (envObsC (es s), ps s a, pubActs s))" and envAction_def: "envAction s _≡ envActionES (es s) (pubActs s)" and envTrans_def:

"envTrans eact aact s _≡ (_| es = envTransES eact (fst ◦ aact) (es s) , ps = snd _◦ aact

, pubActs = (fst eact, fst ◦ aact) |)" Figure 3.6: Finite broadcast environments with non-deterministic KBPs.

where "agent_abs a t ≡ { (tFirst t’, tLast t’) |t’.

t’ ∈ SPR.jkbpC ∧ spr_jview a t’ = spr_jview a t }" The simulation is identical to that in the previous section:

record (’a, ’ePubAct, ’es, ’pPubAct, ’ps) SPRstate =

sprFst :: "(’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState"

sprLst :: "(’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState" sprRel :: "((’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState

× (’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState) set" definition spr_sim :: "(’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState Trace

⇒ (’a, ’ePubAct, ’es, ’pPubAct, ’ps) SPRstate"

where "spr_sim ≡ λt. (_| sprFst = tFirst t, sprLst = tLast t, sprRel = tObsC_abs t _|)" The Kripke structure over simulated traces is also the same:

definition spr_simRels :: "’a _⇒ ((’a, ’ePubAct, ’es, ’pPubAct, ’ps) SPRstate

× (’a, ’ePubAct, ’es, ’pPubAct, ’ps) SPRstate) set" where "spr_simRels ≡ λa. { (s, s’) |s s’.

envObs a (sprFst s) = envObs a (sprFst s’)

∧ envObs a (sprLst s) = envObs a (sprLst s’)

∧ sprRel s = sprRel s’ }"

definition spr_simVal :: "(’a, ’ePubAct, ’es, ’pPubAct, ’ps) SPRstate ⇒ ’p ⇒ bool" where "spr_simVal ≡ envVal ◦ sprLst"

abbreviation "spr_simMC ≡ mkKripke (spr_sim ‘ SPR.jkbpC) spr_simRels spr_simVal" As usual, showing thatspr_simis in fact a simulation is routine for all properties except for reverse simulation. For the latter we adapt the techniques ofLomuscio, van der Meyden, and Ryan(2000) (see also §A.5.2): we can show that, givent ∈ jkbpC, we can construct a tracet’ ∈ jkbpCindistinguishable fromtby agenta, based on the public actions, the common observation anda’s private and initial states. We do this with a splicing operation:

definition sSplice :: "’a _⇒ (’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState ⇒ (’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState ⇒ (’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState" where "sSplice a s s’ _≡ s(_| ps := (ps s)(a := ps s’ a) _|)"

The effect ofsSplice a s s’is to updateswitha’s private state ins’. The key properties are that provided the common observation onsands’are the same, then agenta’s observation on

sSplice a s s’is the same as ats’, while everyone else’s is the same as ats.

We hoist this operation pointwise to traces:

abbreviation tSplice :: "(’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState Trace ⇒ ’a

⇒ (’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState Trace

⇒ (’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState Trace" ("_ ./_ _" [50, 1000, 51] 50)

where "t ./a t’ ≡ tZip (sSplice a) t t’"

The key properties are that after splicing, iftandt’have the same common observation, then so doest ./a t’, and for all agentsa’ 6= a, the viewa’has oft ./a t’is the same as it has of

t, while forait is the same ast’.

We can conclude that provided the two traces are initially indistinguishable toa, and not com- monly distinguishable, thent ./a t’is a canonical trace:

lemma tSplice_jkbpC:

assumes tt’: "{t, t’} _⊆ SPR.jkbpC"

assumes init: "envObs a (tFirst t) = envObs a (tFirst t’)" assumes tObsC: "tObsC t = tObsC t’"

shows "t ./_a t’ _∈ SPR.jkbpC"

The proof is by simultaneous induction overtandt’and depends crucially on the public actions being recorded in the state and commonly observed.

lemma spr_sim: "sim SPR.MC spr_simMC spr_sim" end

locale FiniteBroadcastEnvironmentIndependentInit =

FiniteBroadcastEnvironment jkbp envInit envAction envTrans envVal envObs envObsC envActionES envTransES

for jkbp :: "(’a::finite, ’p, (’pPubAct::{default,finite} _× ’ps::finite)) JKBP" and envInit :: "(’a, ’ePubAct :: {default, finite}, ’es :: finite,

’pPubAct, ’ps) BEState list"

and envAction :: "(’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState ⇒ (’ePubAct × ’ePrivAct) list"

and envTrans :: "(’ePubAct × ’ePrivAct) ⇒ (’a ⇒ (’pPubAct × ’ps))

⇒ (’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState ⇒ (’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState"

and envVal :: "(’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState ⇒ ’p ⇒ bool" and envObs :: "’a ⇒ (’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState

⇒ (’cobs × ’ps × (’ePubAct × (’a ⇒ ’pPubAct)))" and envObsC :: "’es ⇒ ’cobs"

and envActionES :: "’es _⇒ (’ePubAct _× (’a _⇒ ’pPubAct))

⇒ (’ePubAct _× ’ePrivAct) list"

and envTransES :: "(’ePubAct _× ’ePrivAct) _⇒ (’a _⇒ ’pPubAct) _⇒ ’es _⇒ ’es" + fixes agents :: "’a list"

fixes envInitES :: "’es list" fixes envInitPS :: "’a ⇒ ’ps list" defines envInit_def:

"envInit ≡ [ (| es = esf, ps = psf, pubActs = (default, λ_. default) |) . psf ← listToFuns envInitPS agents, esf ← envInitES ]" assumes agents: "set agents = UNIV" "distinct agents"

Figure 3.7: Finite broadcast environments with non-deterministic KBPs, wheretheinitial private and environment states are independent.

sublocale FiniteBroadcastEnvironment

< SPR!: SimIncrEnvironment jkbp envInit envAction envTrans envVal spr_jview

envObs spr_jviewInit spr_jviewIncr spr_sim spr_simRels spr_simVal

Perfect recall in independently-initialised non-deterministic broadcast environments If the private and environment parts of the initial states are independent we can reduce the state space of the construction of the previous section by working only with sets of states rather than relations. We capture this independence in theFiniteBroadcastEnvironmentIndependentInitlocale shown in Figure3.7by asking that the initial states be the Cartesian product of possible private and environment states. As there are initially no public actions from the previous round, we use thedefaultclass to indicate that there is a fixed but arbitrary choice to be made here.

context FiniteBroadcastEnvironmentIndependentInit

begin

definition tObsC_ii_abs :: "(’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState Trace ⇒ (’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState set" where "tObsC_ii_abs t ≡ { tLast t’ |t’. t’ ∈ SPR.jkbpC ∧ tObsC t’ = tObsC t }"

definition agent_ii_abs :: "’a ⇒ (’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState Trace ⇒ (’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState set" where "agent_ii_abs a t _≡

{ tLast t’ |t’. t’ ∈ SPR.jkbpC ∧ spr_jview a t’ = spr_jview a t }"

The simulation is similar to the single-agent case (§3.7.3); for a given canonical tracetit pairs the set of worlds that any agent considers possible with the final state oft:

type_synonym (in -) (’a, ’ePubAct, ’es, ’pPubAct, ’ps) SPRstate = "(’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState set

× (’a, ’ePubAct, ’es, ’pPubAct, ’ps) BEState" definition "spr_ii_sim ≡ λt. (tObsC_ii_abs t, tLast t)" definition "spr_ii_simRels ≡ λa.

{ (s, s’) |s s’. envObs a (snd s) = envObs a (snd s’) _∧ fst s = fst s’ }" definition "spr_ii_simVal _≡ envVal _◦ snd"

abbreviation

"spr_ii_simMC ≡ mkKripke (spr_ii_sim ‘ SPR.jkbpC) spr_ii_simRels spr_ii_simVal" That the simulation is adequate is shown in a similar way as earlier variants.

lemma spr_ii_sim: "sim SPR.MC spr_ii_simMC spr_ii_sim" end

sublocale FiniteBroadcastEnvironmentIndependentInit

< SPRii!: SimIncrEnvironment jkbp envInit envAction envTrans envVal spr_jview

envObs spr_jviewInit spr_jviewIncr spr_ii_sim spr_ii_simRels spr_ii_simVal