Problem $2.[50$ points$]$

$($a$)[25$ points$]$ Design a timed process with the following behavior:

$1.$ Within any $10$ second interval, the process must receive $2$ events of type

A$.$ Receiving a second A exactly $10$ seconds after the first A is okay, but

receiving it after $10$ seconds is bad. If it does not receive two As within

$10$ seconds, it goes to an error state and stays there forever.

$2.$ Within any $20$ second interval, it must receive $3$ events of type B$,$ otherwise it goes to an error state. If any two B events are more than $10$ seconds apart, it goes to an error state. If it goes to an error state, it stays there forever.

$3.$ Let n be a positive integer. At each $20$n seconds, the machine remembers

the number of As and Bs received in the interval $[20($n $1),20$n$].$

$4.$ For all n$,$ at some time in $[20$n$+1,20$n$+2]$ the process outputs the number of As and Bs received in the interval $[20($n $1),20$n$]$ on the output OUT.

$($b$)[5$ points$]$ Consider an execution where the process never goes to an error state and the process receives an A exactly when it starts. Let t denote the time when it receives the second A$,$ u$1$ denote the time when it receives the first B and u$3$ the time when it receives the third B$.$ What are the minimum and maximum values for u$1$ t and u$3$ t$?$

$($c$)[5$ points$]$ Suppose the user promises that at most one A event is input in

any $5$ second window and that any two B events will be separated by at least $1$ second. What is the largest number of A and B events that may be reported on OUT?

$($d$)[5$ points$]$ Design a timed process that ensures the user$$s promise in $($c$).$ In other words, this process must produce at most one A event is output in any $5$ second window, and it must ensure that two B events are separated by at least $1$ second.

$($e$)[10$ points$]$ How would you change the timed process in $($d$)$ so that the

composition of the two timed process guarantees that the timed process in $($a$)$ never reaches an error state?

$($f$)[$Extra Credit: $20$ points$]$ Can you build the process in $($e$)$ such that the

composition of the two timed process has the largest number of executions that do not hit the error state?

The first image is my state machine for option $($a$)$ and my second image is my state machine for option $($d$).$ What other changes can I make for options $($e$)$ and $($f$)?$

I have copied the whole question. The images are my answers for option $($a$)$ and $($d$)$