mod* EXPLICIT-STATE-SCP {
  pr(SCP)
  [Observation < State]
  op __ : State State -> State {assoc comm}
  -- hidden state <--> explicit state
  op hs2es : Sys -> State {strat: (1 0)}
  op es2hs : State -> Sys
  -- observations
  op cell1:_ : PCell -> Observation
  op cell2:_ : BCell -> 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 drop2 : State -> State {strat: (1 0)}
  --
  var S : Sys
  var SS : State
  var PC : PCell
  var BC : BCell
  vars B1 B2 : Bool
  var N : Nat
  var L : List
  --
  eq hs2es(S) = (cell1: cell1(S)) (cell2: cell2(S))
                (bit1: bit1(S)) (bit2: bit2(S))
                (next: next(S)) (list: list(S)) .
  eq cell1(es2hs((cell1: PC) SS)) = PC .
  eq cell2(es2hs((cell2: BC) SS)) = BC .
  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 drop2(SS) = hs2es(drop2(es2hs(SS))) .
}

eof

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