mod* EXPLICIT-STATE-ABP {
  pr(ABP)
  [Observation < State]
  op __ : State State -> State {assoc comm}
  -- hidden state <--> explicit state
  op hs2es : Sys -> State
  op es2hs : State -> Sys
  -- observations
  op fifo1:_ : PFifo -> Observation
  op fifo2:_ : BFifo -> Observation
  op bit1:_  : Bool -> Observation
  op bit2:_  : Bool -> Observation
  op next:_  : Nat -> Observation
  op list:_  : List -> Observation
  -- transitions
  op send1 : State -> State {strat: (1 0)}
  op send2 : State -> State {strat: (1 0)}
  op rec1  : State -> State {strat: (1 0)}
  op rec2  : State -> State {strat: (1 0)}
  op drop1 : State -> State {strat: (1 0)}
  op dup1  : State -> State {strat: (1 0)}
  op drop2 : State -> State {strat: (1 0)}
  op dup2  : State -> State {strat: (1 0)}
  --
  var S : Sys
  var SS : State
  var PF : PFifo
  var BF : BFifo
  vars B1 B2 : Bool
  var N : Nat
  var L : List
  --
  eq hs2es(S) = (fifo1: fifo1(S)) (fifo2: fifo2(S)) 
                (bit1: bit1(S)) (bit2: bit2(S)) 
                (next: next(S)) (list: list(S)) .
  eq fifo1(es2hs((fifo1: PF) SS)) = PF .
  eq fifo2(es2hs((fifo2: BF) SS)) = BF .
  eq bit1(es2hs((bit1: B1) SS)) = B1 .
  eq bit2(es2hs((bit2: B2) SS)) = B2 .
  eq next(es2hs((next: N) SS)) = N .
  eq list(es2hs((list: L) SS)) = L .
  -- 
  eq send1(SS) = hs2es(send1(es2hs(SS))) .
  eq send2(SS) = hs2es(send2(es2hs(SS))) .
  eq rec1(SS) = hs2es(rec1(es2hs(SS))) .
  eq rec2(SS) = hs2es(rec2(es2hs(SS))) .
  eq drop1(SS) = hs2es(drop1(es2hs(SS))) .
  eq dup1(SS) = hs2es(dup1(es2hs(SS))) .
  eq drop2(SS) = hs2es(drop2(es2hs(SS))) .
  eq dup2(SS) = hs2es(dup2(es2hs(SS))) .
}

eof

open EXPLICIT-STATE-ABP
  ops s0 s1 s2 s3 : -> State .
--> init
  eq s0 = hs2es(init) .
  red s0 .
-->  s1 = rec2(dup1(drop1(send1(send2(send1(s0))))))
  eq s1 = rec2(dup1(drop1(send1(send2(send1(s0)))))) .
  red s1 .
--> s2 = rec1(rec1(send2(s1)))
  eq s2 = rec1(rec1(send2(s1))) .
  red s2 .
--> s3 = rec2(rec2(rec2(dup1(send1(s2)))))
  eq s3 = rec2(rec2(rec2(dup1(send1(s2))))) .
  red s3 .
close