On the Subject of the Insomnious Automaton

Astro, what kind of books are you reading in your "book club"?!

This module has two screens and a music box. You must put the music box to sleep.

• The top screen shows three variables that need to be submitted.
• The bottom screen shows the state of the box or the current input, consisting of a stack string and a bit string.
• The box has 4 states:
  1. Awake: The box is awake. Input is unavailable.
  2. Ready: The box is trying to fall asleep. Input is available.
  3. Submitting: Submitting and checking a variable.
  4. Asleep: The box is asleep. The module is solved.
• The sides of the box can be pressed and correspond to different actions:
  • The left and right sides input 0 and 1 respectively.
  • The bottom side completely resets the input.
  • The front side deletes the last character of the top (stack) string. Pressing it too frequently (at least twice within 0.2 seconds) will cause a strike.
  • Pressing the lid will submit the input. Holding the cursor over the lid for 3 seconds will transition the box from the Awake state to the Ready state.
• Any error transitions the box to the Awake state.
• Holding the module's status light will provide additional visual indication of the box's state. Holding it again will disable this indicator.

Mechanism Debugging: Instructions.

The mechanism is a finite state machine. If the value (in base-36) of the first character of the serial number is odd, the automaton has 5 states, otherwise - 6. Label the states q0, q1, ...

State transitions consist of:

• Initial state q(t),
• Input x,
• Final state q(t+1),
• Output y.

This automaton is generated by the following rule:

• On input x0: qi transitions to q(i+z0(i)).
• On input x1: qi transitions to q(i+z1(i)).
• On input x2: qi transitions to q(|i+z2(i)|).

The functions zi are defined on the last page of the instructions.

If a state with that number does not exist, then such a transition does not exist either.

The output of the transition qi → qj is determined as follows:

• If i<j, output is y0,
• If i>j, output is y1,
• If i=j, output is y2.

Count the number of uses for the elements of the set of final states, the set of inputs, and the set of outputs. Assign them binary representations such that:

• Elements that are not used must be completely ignored.
• Representations within a set cannot repeat.
• Representations must have the minimum possible length. Furthermore, within a set, all representations must be of the same length.
• The more frequently an element is used, the fewer ones should be in its representation.
• In case of equal usage counts, elements with a smaller index get the smallest possible numbers (when converting the binary representation to decimal).

Strict adherence to these rules will yield the one and only correct representation of the set elements.

The bits of the q representation are called w0, w1, ...; the bits of the x representation are called u0, ...; the bits of the y representation are called v0, ...

Construct a truth table for wi(t+1), vi, and also Ri and Si (or Ji and Ki, if clouds are drawn on the box). The module requests Ri or Ji as fi, and Si or Ki as Fi. The table is constructed from all possible values of ui and wi(t). Use the table below to get the values for R, S, J, and K:

w(t)	w(t+1)	R	S	J	K
0	0	*	0	0	*
0	1	0	1	1	*
1	0	1	0	*	1
1	1	0	*	*	0

Find (and, if desired, optimize (e.g., using a Karnaugh map)) the expression for the required variables. Since you can only use 2 operators (NOT and NOR), use De Morgan's laws (!x + !y = !(xy); !x!y = !(x+y)). Create a stack from the elements below:

0	Pushes w0 onto the stack.
1	Pushes w1 onto the stack.
2	Pushes w2 onto the stack.
3	Pushes u0 onto the stack.
4	Pushes u1 onto the stack.
-	Inverts the top element of the stack.
!	Applies NOR to the top two elements of the stack.

Submit the stack, replacing its symbols with the given 3-bit sequences:

000	3	100	0
001	4	101	1
010		110	2
011	-	111	!

If the result of the expression is TRUE/FALSE, then submit 1/0 as the bit string with the stack string being empty.

Represent the fourth and fifth characters of the serial number as their alphabetical positions and convert them to base-3. The numbers should have three trits; if not, pad them with leading zeros to three trits. For z0 use the most significant trit, for z1 the second, and for z2 the least significant.

Use the fourth character of the serial number for columns and the fifth for rows.

If any function returns a value with an absolute value greater than 5, then add/subtract 3 until the obtained value is in the range [-5; 5].

z0	0	1	2
0	SN6 - 5	AA - D	LI - UI
1	EMP - NOEMP	3 - B	2 * PP - 3
2	BH - I	PT - 3	2 * P - SN3 - 2

z1	0	1	2
0	SN3 - 2 * i	3 * B - D - 2 * i	4 + FRK + TRN - BOB - SND - 2 * i
1	2 + PAR + SER - 2 * i	floor(SN2 / 4) - 2 * i	NOEMP + I - 2 * i
2	4 + P - LI - UI - 2 * i	PT + AA - EMP - 2 * i	(SN6 % 4) + BH + floor(PP / 2) - 2 * i

z2	0	1	2
0	round((SN2 - SN3 - SN6) / 3 - (1 + EMP) * i / (1 + BH))	2 + B - floor((D + 7) * i / (3 + UI))	6 - I - 2 * i * (BOB + SIG + MSA + IND)
1	2 + PP - ceil(i * PT / 2)	1 + AA - i * (I - CLR - CAR - FRQ - NSA)	LI - i * (1 + RJ + PS + RCA - DVI)
2	3 + UI - i * (round(2 * (5 - SN3) / 3) + BOB)	4 - i * (1 + floor((1 + P) / (1 + (SN2 % 3))))	3 + ceil(round(SN6 / 2) / 2) - i * (2 + ceil(NOEMP / 2))

Variables in this table:

• SN2, SN3, SN6 - the second, third, and sixth characters of the serial number respectively. For SN2, convert from base-36 to decimal.
• B, BH, AA, D - total number of batteries, number of battery holders, number of AA batteries and D batteries respectively.
• P, PT, PP, EMP, NOEMP, DVI, PS, RCA, RJ, PAR, SER - number of ports, number of distinct port types, number of port plates, number of empty and non-empty plates, number of DVI-D, PS/2, Stereo RCA, RJ-45, Parallel, and Serial ports respectively.
• I, LI, UI - number of indicators, number of lit and unlit indicators respectively.
• <indicator name> - presence of an indicator with that name. If such an indicator is present, this variable equals 1, otherwise 0.