On the Subject of the Insomnious Automaton

If my mind was also a finite state machine, then, honestly, I think I’d also have constant insomnia...

Note down the three variables that should be submitted (from the module’s top display) in order left-to-right.

For variables fi and Fi, convert them to Ri/Si/Ji/Ki according to the table below (the “Clouds” and “No Clouds” rows refer to whether or not clouds are drawn on the module’s purple box):

	fi	Fi
Clouds	Ji	Ki
No Clouds	Ri	Si

Follow the instructions on the next pages to determine and submit the three desired variables.

How input works for the module:

• Initially, the module will be in the Awake state. Hover over the box’s lid for 3 seconds to transition the module into the Ready state.
• In the Ready state:
  • The Left and Right sides input 0 and 1, respectively.
  • The Bottom side completely resets input.
  • The Front side deletes the last inputted character (be careful - pressing this side at least twice within 0.2 seconds will cause a strike).
  • Pressing the lid will transition the module into the Submitting state, in which it’ll check for the input being correct, strike if it’s wrong, and solve (go into the Asleep state) if all three variables have been correctly inputted.

Mechanism Debugging+: Extended Instructions.

Generating the automaton

Convert the first character of the serial number from base-36 to decimal. If it is odd, then this module’s automaton has 5 states (q0, q1, q2, q3, q4). If it is even - 6 states (q0, q1, q2, q3, q4, q5).

Construct the table below. If the automaton has 5 states, discard the q5 column.

In this table, the intersection of an initial state (column, qi) and the input (row, xi) gives a ”transition”, which returns two values - the final state (qj), and the output (yi).

To determine the final state of each transition, first, determine the functions z0(i), z1(i), and z2(i) by following the instructions on the next page. After doing that, to determine the final state of a transition with the initial state qi and input xj:

1. Calculate zj(i), and keep the result in range [-5; 5] by adding/subtracting 3.
2. Add i to the result.
3. If in step 1 you used the z2 function, take the absolute value of the current result.
4. Prepend ‘q’ to the result to get the final state of the transition.
5. If the final state of the transition doesn’t have a column corresponding to it, it is impossible - make sure to mark this in the table.

Determine the output of all transitions with initial state qi and final state qj:

• If the final state has been marked as impossible, the transition doesn’t have an output.
• If i<j, then the output is y0,
• If i>j, then the output is y1,
• If i=j, then the output is y2,

Determining the z functions

Represent the fourth and fifth characters of the serial number as their alphabetical positions and convert them to base-3. Pad them with leading zeros to three trits, if needed. To determine z0(i), use the most significant trits, for z1(i) - the second, and for z2(i) - the least significant.

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

z0(i)	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(i)	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(i)	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.

Assigning binaries

Order all final states (q0 through q4 for 5 states, and q0 through q5 for 6 states), inputs (x0, x1, x2), and outputs (y0, y1, y2) in descending order of frequencies within the automaton’s table.

• An input’s frequency is equal to how many transitions with a possible final state it is a part of.
• When ordering, ties are broken in ascending order of indexes (e.g. q2 comes before q3)

In the sorted order:

• Assign the inputs and the outputs binaries 00, 01, and 10.
• Assign the final states binaries 000, 001, 010, 100, 011, and 101.
  • If the automaton has 5 states, 101 will be left unassigned.

Replace all final states, inputs, and outputs within the automaton’s table with their assigned binarires. Additionally, replace all initial states with their corresponding final states’ binaries, and also replace the input rows’ labels with their corresponding inputs’ binaries.

Filling in the truth table

Construct the truth table on the next page. Set the output columns to the module’s desired variables. For every variable Ri/Si/Ji/Ki, if wi is not yet an output column, set it to be one.

Fill in all of your wi and vi output columns. For every row:

1. Take the input columns’ u’s and w’s binaries in this row.
2. Use u’s binary as the row (input) and w’s binary as the column (initial state) for your automaton’s table.
3. If the intersection’s final state is impossible or if the row/column that needs to be used doesn’t exist in automaton’s table, set all of the outputs in the current row to ‘*’.
4. Otherwise:
   • Look at the intersection’s final state - the truth table’s wi output in the current row will be equal to the (i + 1)th bit of the final state’s binary.
   • Look at the intersection’s output - the truth table’s vi output in the current row will be equal to the (i + 1)th bit of the output’s binary.

Fill in all of your Ri/Si/Ji/Ki output columns. For every row where the output columns haven’t been set to ‘*’, for every output column Ri/Si/Ji/Ki:

1. Take the (i + 1)th bit of the input column w’s binary in this row, and take the output column wi’s bit in this row.
2. Use both of the obtained bits in the table below to obtain the value of the Ri/Si/Ji/Ki output column in the current row.

w (input)	wi (output)	Ri	Si	Ji	Ki
0	0	*	0	0	*
0	1	0	1	1	*
1	0	1	0	*	1
1	1	0	*	*	0

Input		Output
u	w
00	000
01	000
10	000
11	000
00	001
01	001
10	001
11	001
00	010
01	010
10	010
11	010
00	011
01	011
10	011
11	011
00	100
01	100
10	100
11	100
00	101
01	101
10	101
11	101
00	110
01	110
10	110
11	110
00	111
01	111
10	111
11	111

Submitting the variables

For each variable that needs to be submitted (in left-to-right order on the module’s display):

• Prepare the table below.
  • A bar on top of a variable is the variable with a NOT operator applied to it.

Clear		w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2
		000	001	011	010	110	111	101	100
u0u1	00
u0u1	01
u0u1	11
u0u1	10

• Fill the table in using the previously made truth table.
  • For every cell in the table, use its row’s binary for the u input column in the truth table, its column’s binary for the w input column, and the variable you are currently submitting for the output column.
• Write a logical expression for the Karnaugh map formed by the filled-in table.
  • Remember - the logical expression should cover all of the map’s ‘1’s, none of its ‘0’s, and each groups of the expression should cover at least one ‘1’.
  • The manual for the module Karnaugh Map has more instructions on how to work with Karnaugh maps (although, on a smaller scale).
• If the entire map can be covered with the logical expression FALSE or TRUE, submit ”0” or ”1” (press the box’s Left/Right side then immediately press its Lid) for the current variable, respectively. Otherwise, keep following these instructions.
• Convert all variables in the expression to digits according to the table below.

w0	w1	w2	u0	u1
0	1	2	3	4

• Transform every group in the expression into inputtable characters for the module:
  • For every variable with a NOT operator applied to it (x), note it down as ”x-”.
  • Note down the first variable of the group, then, for every other variable in the group (a), append ”-a-!” to it.
    • E.g., if you have the group xyzw, you would note it down as ”x-y--!-z-!-w-!”.
• Write all of the transformed groups as one string of characters.
• Remove all occurrences of double-‘-’s (”--”) in the string.
• Append ”!-” to the string the number of times equal to the number of groups in the expression minus 1.

• Input all of the characters of the resulting string into the module according to the table below.
  • Remember, Left side = 0, Right side = 1, Lid = submit input.

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

Mechanism Debugging+: Full Example.

Bomb Edgework

• 2 Batteries in 1 Holder (2 AA-Batteries, 0 D-Batteries),
• A Lit FRK indicator, a Lit SND indicator, and an Unlit TRN indicator,
• A plate with a Serial port,
• Serial Number (S#): AE5PH8.

Module Read

• Top display: w1, v1, f2.
• The purple box has clouds drawn on it.
• ”Clouds” + fi = Ji in the table, so f2 = J2.
• The variables that should be submitted are w1, v1, and J2.

Determining the z functions

• Fourth S# character - P, alphabetical position = 16 → 121 (in ternary).
• Fifth S# character - H, alphabetical position = 8 → 022 (in ternary).
• z0(i) (column 1, row 0) = AA - D.
• z1(i) (column 2, row 2) = (SN6 % 4) + BH + floor(PP / 2) - 2 * i.
• z2(i) (column 1, row 2) = 4 - i * (1 + floor((1 + P) / (1 + (SN2 % 3)))).
• For convenience, simplifying the functions by substituting values of edgework variables:
  • z0(i) = AA - D
    = 2 - 0
    = 2.
  • z1(i) = (SN6 % 4) + BH + floor(PP / 2) - 2 * i
    = (8 % 4) + 1 + floor(1 / 2) - 2 * i
    = 0 + 1 + 0 - 2 * i
    = 1 - 2 * i.
  • z2(i) = 4 - i * (1 + floor((1 + P) / (1 + (SN2 % 3))))
    = 4 - i * (1 + floor((1 + 1) / (1 + (14 % 3))))
    = 4 - i * (1 + floor(2 / (1 + 2)))
    = 4 - i * (1 + floor(2 / 3))
    = 4 - i * (1 + 0)
    = 4 - i.
• After simplifying:
  • z0(i) = 2
  • z1(i) = 1 - 2 * i
  • z2(i) = 4 - i

Generating the automaton

• First character of S# - A → 10 (from base-36 to decimal), even, so the automaton has 6 states:

	q0		q1		q2		q3		q4		q5
x0	qj	yi	qj	yi	qj	yi	qj	yi	qj	yi	qj	yi
x1	qj	yi	qj	yi	qj	yi	qj	yi	qj	yi	qj	yi
x2	qj	yi	qj	yi	qj	yi	qj	yi	qj	yi	qj	yi

• Calculating final states:
  • x0, q0: z0(0) = 2 + 0 = 2 → final state - q2.
  • x0, q1: z0(1) = 2 + 1 = 3 → final state - q3.
  • x0, q2: z0(2) = 2 + 2 = 4 → final state - q4.
  • x0, q3: z0(3) = 2 + 3 = 5 → final state - q5.
  • x0, q4: z0(4) = 2 + 4 = 6 → final state - q6, which doesn’t have a column - impossible.
  • x0, q5: z0(5) = 2 + 5 = 7 → final state - q7, which doesn’t have a column - impossible.
  • x1, q0: z1(0) = 1 + 0 = 1 → final state - q1
  • x1, q1: z1(1) = -1 + 1 = 0 → final state - q0
  • x1, q2: z1(2) = -3 + 2 = -1 → final state - q-1, which doesn’t have a column - impossible.
  • x1, q3: z1(3) = -5 + 3 = -2 → final state - q-2, which doesn’t have a column - impossible.
  • x1, q4: z1(4) = -7, keeping in range [-5; 5] → -4 + 4 = 0 → final state - q0.
  • x1, q5: z1(5) = -9, keeping in range [-5; 5] → -3 + 5 = 2 → final state - q2.
  • x2, q0: z2(0) = 4 + 0 = 4 → final state - q4.
  • x2, q1: z2(1) = 3 + 1 = 4 → final state - q4.
  • x2, q2: z2(2) = 2 + 2 = 4 → final state - q4.
  • x2, q3: z2(3) = 1 + 3 = 4 → final state - q4.
  • x2, q4: z2(4) = 0 + 4 = 4 → final state - q4.
  • x2, q5: z2(5) = -1 + 5 = 4 → final state - q4.
• Filling in the final states in the table (impossible final states are marked with a ‘-’):

	q0		q1		q2		q3		q4		q5
x0	q2	yi	q3	yi	q4	yi	q5	yi	-	yi	-	yi
x1	q1	yi	q0	yi	-	yi	-	yi	q0	yi	q2	yi
x2	q4	yi	q4	yi	q4	yi	q4	yi	q4	yi	q4	yi

• Determining outputs:
  • x0, q0: q0 → q2, 0 < 2 - output is y0.
  • x0, q1: q1 → q3, 1 < 3 - output is y0.
  • x0, q2: q2 → q4, 2 < 4 - output is y0.
  • x0, q3: q3 → q5, 3 < 5 - output is y0.
  • x0, q4: impossible final state, no output.
  • x0, q5: impossible final state, no output.
  • x1, q0: q0 → q1, 0 < 1 - output is y0.
  • x1, q1: q1 → q0, 1 > 0 - output is y1.
  • x1, q2: impossible final state, no output.
  • x1, q3: impossible final state, no output.
  • x1, q4: q4 → q0, 4 > 0 - output is y1.
  • x1, q5: q5 → q2, 5 > 2 - output is y1.
  • x2, q0: q0 → q4, 0 < 4 - output is y0.
  • x2, q1: q1 → q4, 1 < 4 - output is y0.
  • x2, q2: q2 → q4, 2 < 4 - output is y0.
  • x2, q3: q3 → q4, 3 < 4 - output is y0.
  • x2, q4: q4 → q4, 4 = 4 - output is y2.
  • x2, q5: q5 → q4, 5 > 4 - output is y1.
• Filling in the outputs in the table (absent outputs are marked with a ‘-’):

	q0		q1		q2		q3		q4		q5
x0	q2	y0	q3	y0	q4	y0	q5	y0	-	-	-	-
x1	q1	y0	q0	y1	-	-	-	-	q0	y1	q2	y1
x2	q4	y0	q4	y0	q4	y0	q4	y0	q4	y2	q4	y1

Assigning binaries

• Frequencies of final states, inputs, and outputs within the automaton’s table:

• Ordering everything in descending order of frequencies (and in ascending order of indexes in case of ties):

• Assigning binaries in the sorted order:

• Replacing everything in automaton’s table with the corresponding binaries:

	001		100		010		011		000		101
01	010	00	011	00	000	00	101	00	-	-	-	-
10	100	00	001	01	-	-	-	-	001	01	010	01
00	000	00	000	00	000	00	000	00	000	10	000	01

Filling in the truth table

• Setting the output columns to the module’s desired variables - w1, v1, and J2. Because we have an J2 output column, and w2 is not yet one, we set it to be an output column too:

Input		Output
u	w	w1	w2	v1	J2
...

• Filling in the w1, w2, and v1 output columns (w1 = 2nd bit of each final state’s binary,
  w2 = 3rd bit of each final state’s binary, v1 = 2nd bit of every output’s binary):
  • u = 00, w = 000: final state - 000 → w1 = 0, w2 = 0; output - 10 → v1 = 0.
  • u = 01, w = 000: impossible final state → w1 = w2 = v1 = J2 = *.
  • u = 10, w = 000: final state - 001 → w1 = 0, w2 = 1; output - 01 → v1 = 1.
  • u = 11, w = 000: row ”11” doesn’t exist → w1 = w2 = v1 = J2 = *.
  • u = 00, w = 001: final state - 000 → w1 = 0, w2 = 0; output - 00 → v1 = 0.
  • u = 01, w = 001: final state - 010 → w1 = 1, w2 = 0; output - 00 → v1 = 0.
  • u = 10, w = 001: final state - 100 → w1 = 0, w2 = 0; output - 00 → v1 = 0.
  • u = 11, w = 001: row ”11” doesn’t exist → w1 = w2 = v1 = J2 = *.
  • u = 00, w = 010: final state - 000 → w1 = 0, w2 = 0; output - 00 → v1 = 0.
  • u = 01, w = 010: final state - 000 → w1 = 0, w2 = 0; output - 00 → v1 = 0.
  • u = 10, w = 010: impossible final state → w1 = w2 = v1 = J2 = *.
  • u = 11, w = 010: row ”11” doesn’t exist → w1 = w2 = v1 = J2 = *.
  • u = 00, w = 011: final state - 000 → w1 = 0, w2 = 0; output - 00 → v1 = 0.
  • u = 01, w = 011: final state - 101 → w1 = 0, w2 = 1; output - 00 → v1 = 0.
  • u = 10, w = 011: impossible final state → w1 = w2 = v1 = J2 = *.
  • u = 11, w = 011: row ”11” doesn’t exist → w1 = w2 = v1 = J2 = *.
  • u = 00, w = 100: final state - 000 → w1 = 0, w2 = 0; output - 00 → v1 = 0.
  • u = 01, w = 100: final state - 011 → w1 = 1, w2 = 1; output - 00 → v1 = 0.
  • u = 10, w = 100: final state - 001 → w1 = 0, w2 = 1; output - 01 → v1 = 1.
  • u = 11, w = 100: row ”11” doesn’t exist → w1 = w2 = v1 = J2 = *.
  • u = 00, w = 101: final state - 000 → w1 = 0, w2 = 0; output - 01 → v1 = 1.
  • u = 01, w = 101: impossible final state → w1 = w2 = v1 = J2 = *.
  • u = 10, w = 101: final state - 010 → w1 = 1, w2 = 0; output - 01 → v1 = 1.
  • u = 11, w = 101: row ”11” doesn’t exist → w1 = w2 = v1 = J2 = *.
  • u = 00, w = 110: column ”110” doesn’t exist → w1 = w2 = v1 = J2 = *.
  • u = 01, w = 110: column ”110” doesn’t exist → w1 = w2 = v1 = J2 = *.
  • u = 10, w = 110: column ”110” doesn’t exist → w1 = w2 = v1 = J2 = *.
  • u = 11, w = 110: column ”110” doesn’t exist → w1 = w2 = v1 = J2 = *.
  • u = 00, w = 111: column ”111” doesn’t exist → w1 = w2 = v1 = J2 = *.
  • u = 01, w = 111: column ”111” doesn’t exist → w1 = w2 = v1 = J2 = *.
  • u = 10, w = 111: column ”111” doesn’t exist → w1 = w2 = v1 = J2 = *.
  • u = 11, w = 111: column ”111” doesn’t exist → w1 = w2 = v1 = J2 = *.

Input		Output
u	w	w1	w2	v1	J2
00	000	0	0	0
01	000	*	*	*	*
10	000	0	1	1
11	000	*	*	*	*
00	001	0	0	0
01	001	1	0	0
10	001	0	0	0
11	001	*	*	*	*
00	010	0	0	0
01	010	0	0	0
10	010	*	*	*	*
11	010	*	*	*	*
00	011	0	0	0
01	011	0	1	0
10	011	*	*	*	*
11	011	*	*	*	*
00	100	0	0	0
01	100	1	1	0
10	100	0	1	1
11	100	*	*	*	*
00	101	0	0	1
01	101	*	*	*	*
10	101	1	0	1
11	101	*	*	*	*
00	110	*	*	*	*
01	110	*	*	*	*
10	110	*	*	*	*
11	110	*	*	*	*
00	111	*	*	*	*
01	111	*	*	*	*
10	111	*	*	*	*
11	111	*	*	*	*

• Filling in the J2 output column for rows where it isn’t an ‘*’ already:
  • u = 00, w = 000: 3rd bit of the input w - 0, w2 = 0 → 0,0 in the table → J2 = 0.
  • u = 10, w = 000: 3rd bit of the input w - 0, w2 = 1 → 0,1 in the table → J2 = 1.
  • u = 00, w = 001: 3rd bit of the input w - 1, w2 = 0 → 1,0 in the table → J2 = *.
  • u = 01, w = 001: 3rd bit of the input w - 1, w2 = 0 → 1,0 in the table → J2 = *.
  • u = 10, w = 001: 3rd bit of the input w - 1, w2 = 0 → 1,0 in the table → J2 = *.
  • u = 00, w = 010: 3rd bit of the input w - 0, w2 = 0 → 0,0 in the table → J2 = 0.
  • u = 01, w = 010: 3rd bit of the input w - 0, w2 = 0 → 0,0 in the table → J2 = 0.
  • u = 00, w = 011: 3rd bit of the input w - 1, w2 = 0 → 1,0 in the table → J2 = *.
  • u = 01, w = 011: 3rd bit of the input w - 1, w2 = 1 → 1,1 in the table → J2 = *.
  • u = 00, w = 100: 3rd bit of the input w - 0, w2 = 0 → 0,0 in the table → J2 = 0.
  • u = 01, w = 100: 3rd bit of the input w - 0, w2 = 1 → 0,1 in the table → J2 = 1.
  • u = 10, w = 100: 3rd bit of the input w - 0, w2 = 1 → 0,1 in the table → J2 = 1.
  • u = 00, w = 101: 3rd bit of the input w - 1, w2 = 0 → 1,0 in the table → J2 = *.
  • u = 10, w = 101: 3rd bit of the input w - 1, w2 = 0 → 1,0 in the table → J2 = *.

Snippet of the relevant table

w (input)	wi (output)	Ji
0	0	0
0	1	1
1	0	*
1	1	*

Final Truth Table

Input		Output
u	w	w1	w2	v1	J2
00	000	0	0	0	0
01	000	*	*	*	*
10	000	0	1	1	1
11	000	*	*	*	*
00	001	0	0	0	*
01	001	1	0	0	*
10	001	0	0	0	*
11	001	*	*	*	*
00	010	0	0	0	0
01	010	0	0	0	0
10	010	*	*	*	*
11	010	*	*	*	*
00	011	0	0	0	*
01	011	0	1	0	*
10	011	*	*	*	*
11	011	*	*	*	*
00	100	0	0	0	0
01	100	1	1	0	1
10	100	0	1	1	1
11	100	*	*	*	*
00	101	0	0	1	*
01	101	*	*	*	*
10	101	1	0	1	*
11	101	*	*	*	*
00	110	*	*	*	*
01	110	*	*	*	*
10	110	*	*	*	*
11	110	*	*	*	*
00	111	*	*	*	*
01	111	*	*	*	*
10	111	*	*	*	*
11	111	*	*	*	*

Submitting the variables

• First variable for submission - w1. Filling in the Karnaugh map for it:

		w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2
		000	001	011	010	110	111	101	100
u0u1	00	0	0	0	0	*	*	0	0
u0u1	01	*	1	0	0	*	*	*	1
u0u1	11	*	*	*	*	*	*	*	*
u0u1	10	0	0	*	*	*	*	1	0

• A logical expression for this map - w0u1 + w0w2u0u1 + w0w1u1*:

		w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2
		000	001	011	010	110	111	101	100
u0u1	00	0	0	0	0	*	*	0	0
u0u1	01	*	1	0	0	*	*	*	1
u0u1	11	*	*	*	*	*	*	*	*
u0u1	10	0	0	*	*	*	*	1	0

• Converting variables in the expressions to digits: 04 + 0234 + 014.
• Transforming all groups into inputtable characters:
  • 04 → 0-4-!.
  • 0234 → 0234- → 0-2-!-3-!-4--!.
  • 014 → 0-1-4 → 0--1--!-4-!.
• Writing the groups as one string: 0-4-!0-2-!-3-!-4--!0--1--!-4-!.
• Removing double-‘-’s: 0-4-!0-2-!-3-!-4!01!-4-!.
• Appending 2 ”!-”s (3 groups, 3 - 1 = 2): 0-4-!0-2-!-3-!-4!01!-4-!!-!-.
• Inputting all the characters into the module: 100 011 001 011 111 100 011 110 011 111 011 000 011 111 011 001 111 100 101 111 011 001 011 111 111 011 111 011.
• Submitting input - correct.

* An alternative and more optimized logical expression for this variable’s map (utilizing just 2 groups instead of 3) was w1u1 + w0w2u0u1.

• Second variable for submission - v1. Filling in the Karnaugh map for it:

		w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2
		000	001	011	010	110	111	101	100
u0u1	00	0	0	0	0	*	*	1	0
u0u1	01	*	0	0	0	*	*	*	0
u0u1	11	*	*	*	*	*	*	*	*
u0u1	10	1	0	*	*	*	*	1	1

• A logical expression for this map - w2u0 + w0w1w2:

		w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2
		000	001	011	010	110	111	101	100
u0u1	00	0	0	0	0	*	*	1	0
u0u1	01	*	0	0	0	*	*	*	0
u0u1	11	*	*	*	*	*	*	*	*
u0u1	10	1	0	*	*	*	*	1	1

• Converting variables in the expressions to digits: 23 + 012.
• Transforming all groups into inputtable characters:
  • 23 → 2-3 → 2--3-!.
  • 012 → 01-2 → 0-1--!-2-!.
• Writing the groups as one string of characters: 2--3-!0-1--!-2-!.
• Removing double-‘-’s: 23-!0-1!-2-!.
• Appending 1 ”!-” (2 groups, 2 - 1 = 1): 23-!0-1!-2-!!-.
• Inputting all the characters into the module: 110 000 011 111 100 011 101 111 011 110 011 111 111 011.
• Submitting input - correct.

• Third and last variable for submission - J2. Filling in the Karnaugh map for it:

		w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2
		000	001	011	010	110	111	101	100
u0u1	00	0	*	*	0	*	*	*	0
u0u1	01	*	*	*	0	*	*	*	1
u0u1	11	*	*	*	*	*	*	*	*
u0u1	10	1	*	*	*	*	*	*	1

• A logical expression for this map - u0u1 + w1u1:

		w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2	w0w1w2
		000	001	011	010	110	111	101	100
u0u1	00	0	*	*	0	*	*	*	0
u0u1	01	*	*	*	0	*	*	*	1
u0u1	11	*	*	*	*	*	*	*	*
u0u1	10	1	*	*	*	*	*	*	1

• Converting variables in the expressions to digits: 34 + 14.
• Transforming all groups into inputtable characters:
  • 34 → 34- → 3-4--!.
  • 14 → 1-4 → 1--4-!.
• Writing the groups as one string of characters: 3-4--!1--4-!.
• Removing double-‘-’s: 3-4!14-!.
• Appending 1 ”!-” (2 groups, 2 - 1 = 1): 3-4!14-!!-.
• Inputting all the characters into the module: 000 011 001 111 101 001 011 111 111 011.
• Submitting input - correct. Module solved!