module Clock-Actors {
     ...

     datatype Name := Ticker | Clock
     datatype TLS := local1 | local2 | local3
     datatype CLS := (local N)
     datatype TCLS := (ticker TLS) | (clock CLS)
     ...

     declare config: [(TP Name TCLS)] -> (Cfg (Actor Name TCLS))
     declare next: [TCLS (Step Name)] -> TCLS
     declare ready-to: [TCLS (Step Name)] -> Boolean
     ...
}

module Ticker {
 assert ready-to-definition :=
  (fun
   [(ls ready-to (send Ticker Ticker 'continue)) <==>
      (ls = ticker local1)  
    (ls ready-to (send Ticker Clock 'tick)) <==>
      (ls = ticker local2)  
    (ls ready-to (send Ticker id c)) <==> 
      [false  when (~ (id = Ticker & c = 'continue) &
                    ~ (id = Clock & c = 'tick))]
    (ls ready-to (receive Ticker Ticker 'continue)) <==>
      (ls = ticker local3)  
    (ls ready-to (receive Ticker fr c)) <==>
      [false  when (~ (fr = Ticker & c = 'continue))]
    (ls ready-to (create Ticker id')) <==> false])
 ...

 }

module Ticker {
...
  assert next-definition :=
    (fun
     [(next (ticker local1) step) =
        [(ticker local2)  when (step = (send Ticker Ticker 'continue))
         (ticker local1)  when (step =/= (send Ticker Ticker 'continue))]
      (next (ticker local2) step) =
        [(ticker local3)  when (step = (send Ticker Clock 'tick))
         (ticker local2)  when (step =/= (send Ticker Clock 'tick))]
      (next (ticker local3) step) =
        [(ticker local1)  when (step = (receive Ticker Ticker 'continue))
         (ticker local3)  when (step =/= (receive Ticker Ticker 'continue))]])
...
}

module Clock {
  assert ready-to-definition :=
    (fun
     [(ls ready-to (receive Clock fr c))
         <==> (fr = Ticker & c = 'tick & exists t . ls = clock local t)
      (ls ready-to (send Clock to c)) <==> false
      (ls ready-to (create Clock id')) <==> (exists t . ls = clock local t)])
...
}

module Clock {
...
  assert next-definition :=
    (fun
     [(next (clock (local t)) (receive id fr c)) =
        [(clock (local (S t))) when (id = Clock & fr = Ticker & c = 'tick)
         (clock (local t))     when (~ (id = Clock & fr = Ticker & c = 'tick))]
      (next (clock (local t)) (send id to c)) = (clock (local t))
      (next (clock (local t)) (create id id')) = (clock (local t))])
}

module Progress {
 define Theory := 
  (theory-clone [Progress.Theory 'Clock CA] 
		 'Clock-Actors.Progress.Theory)
 define Theory1 := 
  (theory-clone [Theory 'Clone1 [sender Ticker  receiver Ticker]]
		 'Clock-Actors.Progress.Theory1)
 define Theory2 := 
  (theory-clone [Theory 'Clone2 [sender Ticker  receiver Clock]]
		 'Clock-Actors.Progress.Theory2)
}

define P :=
  ( Initial then (create Clock Ticker)
            then (send Ticker Ticker ’continue)
            then (send Ticker Clock ’tick)
            then (receive Clock Ticker ’tick)
            then (receive Ticker Ticker ’continue)
            then (send Ticker Ticker ’continue)
            then (send Ticker Clock ’tick)
            then (receive Ticker Ticker ’continue)
            then (send Ticker Ticker ’continue)
            then (send Ticker Clock ’tick)
            then (receive Clock Ticker ’tick))

define M :=
	(One (message’ Ticker ls0 Clock ’tick))
define CM :=
	(One (message’ Ticker ls0 Ticker ’continue))
    
define P-result :=
  (config Initial =
  	s0 ++ (actor Clock (clock local zero) &
  (unique-ids
  	(config Initial) ++
  	(actor Ticker
  		(new-ls (clock local zero)))) &
  (clock (local zero ))
	ready-to (create Clock Ticker)
  ==>
  config P =
	s0 ++ (actor Clock
		(clock local (S (S zero )))) ++
	(actor Ticker (ticker local3)) ++ M ++ CM)

module Clock-Actors {
     ...

     datatype Name := Ticker | Clock
     datatype TLS := local1 | local2 | local3
     datatype CLS := (local N)
     datatype TCLS := (ticker TLS) | (clock CLS)
     ...

     declare config: [(TP Name TCLS)] -> (Cfg (Actor Name TCLS))
     declare next: [TCLS (Step Name)] -> TCLS
     declare ready-to: [TCLS (Step Name)] -> Boolean
     ...
}