Skip to content

Moore machine

A finite-state transducer whose output is determined solely by its current state, while input affects output only indirectly by selecting later states.

Version
v1 · 2026-09-28 · History
Domain-specific #
10810
Domain group
Applied Sciences & Engineering
Origin domain
Computer Science & Software Engineering
Subdomain
Automata Theory → Computer Science & Software Engineering
Aliases
Moore automaton

Core Idea

A Moore machine is a finite-state transducer that separates transition from emission. Its transition function consumes current state and input to choose a next state, while its output function reads only the active state. A diagram therefore places output labels on nodes, not on arcs.

This separation gives outputs stable for the duration of a state and makes state the machine's complete output-relevant memory. It also creates a timing convention: an input influences output by causing a transition, and Moore–Mealy conversions may introduce an initial output or one-step shift even when the machines are otherwise expressively equivalent.

Structural Signature

Sig role-phrases:

  • finite state set — stores the machine's entire abstract memory It is essential. Counterfactual: An unbounded-memory transducer is not a finite Moore machine.
  • initial state — fixes output and behavior before input processing begins It is essential. Counterfactual: Without initialization the realized transduction is underdetermined.
  • input alphabet — provides symbols that select transitions It is essential. Counterfactual: An autonomous output generator is a degenerate different setting.
  • transition function — maps each current state and input to the next state It is essential. Counterfactual: If one state-input pair branches, the deterministic Moore definition fails.
  • output alphabet — declares the possible emitted values It is essential. Counterfactual: States without outputs define an acceptor or transition system instead.
  • state-output function — assigns one output to each state independently of current input It is essential. Counterfactual: Allowing current input in the output function produces a Mealy machine.

What It Is Not

  • It is not a Mealy machine whose immediate output also depends on input.
  • It is not a state diagram without an output function.
  • It is not necessarily a physical clocked circuit, though such circuits commonly implement it.
  • It is not equivalent to another transducer until initialization and output timing are aligned.
  • Closest near-miss. A Mealy machine is the closest near miss because its output depends jointly on current state and input.

Scope of Application

  • Digital logic. Sequential controllers decode outputs from state registers.
  • Protocol control. Finite states organize stable responses to event symbols.
  • Automata theory. State-output transducers support equivalence and minimization reasoning.
  • Reactive modeling. Observable output traces describe stateful behavior.

Clarity

Declare the six-tuple, total or partial transition convention, timing of state observation, initialization output, state and transition labels, and equivalence criterion for traces. Do not infer Moore semantics merely because a diagram happens to show output text inside nodes.

Manages Complexity

The model compresses an indefinitely long input history into finitely many equivalence classes represented by states. Assigning outputs to those states makes behavior transparent, but state minimization, timing, unreachable states, and implementation hazards remain separate questions.

Abstract Reasoning

  1. Fix finite state, input, and output alphabets.
  2. Choose an initial state and state-output mapping.
  3. Define one next state for each admissible state-input pair.
  4. Simulate by emitting the current state's output under the declared timing convention.
  5. Advance state from the input symbol.
  6. Compare machines by aligned input/output traces and initialization.
  7. Reject Mealy-style direct input-output dependence or translate it with explicit timing effects.

Knowledge Transfer

State-output decomposition transfers to software controllers and circuits when finite abstract state and discrete observation timing are defensible. It stops at systems requiring unbounded memory, continuous dynamics, or direct combinational input-output response unless those are abstracted separately. The cargo is output as a function of state alone.

Examples

Applied / In Practice

States remember the previous bit and state labels emit whether the remembered/current relation satisfies the detector design.

Mapped back: memory → Finite states retain prior context; output → Each active state has one label.

Applied / In Practice

Flip-flops encode state, next-state logic consumes input, and decode logic maps state to stable actuator outputs.

Mapped back: transition → Input changes the next register value; output → Decode uses the current register state.

Applied / In Practice

An output label is chosen directly from the present input on each arc.

Mapped back: boundary → That is Mealy-style output..

Structural Tensions

T1 — State-Only Output Stability versus Response Latency. State decoding isolates output from immediate input but can require an extra state or tick to reflect an event.

Diagnostic: State the sampling convention and align input/output pairs before comparing machines.

T2 — Equivalent Behavior versus Different Realization. A Mealy transducer may implement the same stream relation with fewer states or a timing offset.

Diagnostic: Compare trace convention and initialization, not diagrams alone.

Structural–Framed Character

The six-tuple and output dependency are formal structural commitments; clock and trace conventions frame observable equivalence. Physical glitches or delays belong to implementation unless included in the machine model.

Structural Core vs. Domain Accent

The skeleton is finite memory controlling observable output. Automata theory supplies alphabets, transition and output functions, initial state, traces, and Moore–Mealy conversion. Those commitments distinguish this transducer class.

  • Approved root in the frozen placement. Deterministic automaton is a plausible future superclass, but the frozen node is unparented and this repair does not authorize a new edge.

  • Related — Mealy machine and finite-state transducer. They provide the nearest contrast and broader machine family.

Neighborhood in Abstraction Space

Moore machine sits in a crowded region of the domain-specific corpus (35th percentile for distinctiveness): several abstractions share nearly its structure, so a description that fits it tends to fit its neighbors too.

Family — Digital Logic & Finite-State Machines (10 abstractions)

Nearest neighbors

Computed from structural-signature embeddings · 2026-10-08

Not to Be Confused With

  • Mealy machine. Tell: Its output function depends on current state and current input.
  • Deterministic finite acceptor. Tell: Recognizes language membership and need not emit an output at every state.
  • State-transition system. Tell: May omit finite alphabets, determinism, or an output mapping.
  • Clocked sequential circuit. Tell: Is a hardware realization family rather than the abstract definition.

References

  • Frozen Wikipedia discovery revision: https://en.wikipedia.org/wiki/Moore_machine (revision 1365891913).
  • Preserved source candidate: http://leeseshia.org/
  • Preserved source candidate: http://www.mi.ras.ru/~karatsuba/list_e.html
  • Preserved source candidate: https://web.archive.org/web/20200923004331/https://www.thecompletecodes.com/2019/09/Moore-and-Mealy-Machine.html

The frozen Wikipedia revision is discovery provenance. The retained source set was reviewed for identity, formal or operational relation, and scope. The encyclopedia's structural synthesis is bounded to those claims; a thin authority surface is recorded as a nonblocking source-strengthening repair rather than concealed.