Foundations — State diagram and state table design

This page assumes you know nothing. Before you can read a state diagram or a state table, you must earn every mark on it. We build them one symbol at a time, each resting on the one before.

0. The rawest idea: a "signal that arrives over time"

Before any state, there is a stream of inputs. In these circuits the input is a single wire that, at each tick of a clock, carries either a low voltage (call it $0$) or a high voltage (call it $1$).

• Plain words: one yes/no per moment.
• The picture: a conveyor belt delivering one card (0 or 1) to the machine at each tick — see the figure below.
• Why the topic needs it: the whole purpose of a sequential circuit is to react to a stream of these, not a single one. "History" means "the bits that already went by on the belt."

1. The clock — WHAT makes "next" mean something

• Plain words: the heartbeat that says "now — take a step."
• The picture: a metronome. Between ticks, nothing changes; on each tick, one belt-card is read and the machine takes exactly one step.
• Why the topic needs it: words like "next state" and "one cycle" are meaningless without a notion of discrete steps. The tick is what turns continuous voltages into a clean sequence of moves. This is why we can draw a finite diagram of arrows instead of describing continuous physics.

2. Memory vs no-memory — WHY we need states

• Plain words: combinational = "no memory, answers only about now"; sequential = "remembers, answers about now-in-context."
• The picture: a light switch (combinational — position tells you everything) versus a combination lock (sequential — same button press means different things depending on what you pressed before). See Combinational Circuits for the memoryless contrast.
• Why the topic needs it: the entire chapter exists because we cannot store all past bits (that needs infinite memory). We must compress history — and that compressed summary is the state.

3. The state — the central symbol

• Plain words: a sticky note that says "how far along am I?"
• The picture: a lock chasing the secret code 1011 keeps one note: "nothing yet" / "got the 1" / "got 1-0" / "got 1-0-1." Four notes = four states. It never keeps the full button history.
• Why the topic needs it: replacing an infinite history with a finite label is the whole trick. Every other symbol on the page (bubbles, arrows, tables) is just bookkeeping for states.

4. The state bubble and the transition arrow — the diagram's alphabet

Now we can read the pictures.

• Plain words: circles are the sticky notes; arrows are the rules for updating them.
• The picture: a subway map — stations (states) linked by lines (transitions). The figure below shows one bubble, one arrow, and how a label rides on the arrow.
• Why the topic needs it: this is the visual grammar of the entire topic. Everything you design ends up as bubbles + arrows.

The subscript notation $S_0,S_1,\dots$

• Why: we need distinct, orderable names so tables have clean row headings. The order matters only when we later assign binary codes.

5. Inputs and outputs as symbols: $X$ and $Z$

• Plain words: $X$ = "what the belt just handed me"; $Z$ = "what I shout back."
• The picture: $X$ is the incoming card, $Z$ is a lamp that lights ($Z=1$) or stays dark ($Z=0$).
• Why the topic needs it: we need short single letters so table columns and arrow labels stay readable. Writing "the input bit at this tick" on every arrow would be unbearable.

The label X/Z and the slash /

• Plain words: "input X gives output Z on this move."
• The picture: a signpost on the arrow reading 1/1 = "on a 1, light the lamp as we pass."
• Why the topic needs it: this is exactly how a Mealy machine records outputs — on the arrow, because a Mealy output depends on state and input at the same instant.

6. Moore vs Mealy — WHERE the output symbol lives

We now know outputs are single bits $Z$. The two machine styles differ only in where $Z$ is written.

• The picture: Moore = a lamp bolted onto each station (lights whenever you sit there); Mealy = a lamp on each track segment (flashes as you travel it). See the figure.
• Why the topic needs it: the placement is the entire practical difference between the two designs. Same behaviour, two notations.

7. The state table — the diagram written as a grid

• Plain words: the arrows re-typed as a lookup table.
• The picture: a train timetable — "from station $S_2$, if input 1, go to $S_3$."
• Why the topic needs it: a table is complete and mechanical — you can check every (state, input) pair is filled. Diagrams are easy to draw but easy to leave incomplete.

8. State assignment — turning names into binary codes

• Plain words: give each sticky note a barcode of bits.
• The picture: relabelling four stations as 00, 01, 10, 11 so a machine that only understands wires can store "which state" using two wires.
• Why the topic needs it: real memory (flip-flops — see Flip-Flops and Latches) stores bits, not the letter "$S_2$." With $n$ states you need enough bits to give each a distinct code; two bits give $2^2=4$ codes, enough for four states. This is the bridge to State Assignment and Reduction and later to Excitation Tables and Next-State Equations.

How the foundations feed the topic

Equipment checklist

Test yourself — cover the right side and answer each before revealing.

Connections

• Parent topic (Hinglish) — the full design recipe these foundations unlock
• Finite State Machines — the abstract model where "finite states" comes from
• Combinational Circuits — the memoryless contrast in §2
• Flip-Flops and Latches — the physical memory that stores the assigned bits
• State Assignment and Reduction — next step after §8
• Excitation Tables and Next-State Equations — where binary codes turn into logic
• Sequence Detectors — the canonical machine these symbols describe