Convolutional code¶

A convolutional code maps a stream of input symbols to redundant output symbols through a finite-memory convolutional encoder, so each output depends on the current input and a bounded history and can be decoded from trellis structure.

Version: v1 · 2026-09-28 · History
Domain-specific #: 8710
Domain group: Formal Sciences
Origin domain: Information Theory
Subdomain: Coding Theory → Information Theory

Core Idea¶

A convolutional code is an error-correcting code in which a finite-state encoder continuously maps input symbols to redundant output symbols using the current input and a bounded memory of previous inputs. Generator polynomials specify the modulo-two combinations produced at each step. A rate k/n encoder consumes k input bits and emits n coded bits per step; its constraint length or memory determines how many preceding inputs influence the output and how many encoder states the decoder must distinguish.

Because the same transition rule repeats over time, possible state sequences form a time-invariant trellis. A received sequence is decoded by finding likely paths through that trellis. The Viterbi algorithm gives maximum-likelihood sequence decoding with complexity exponential in encoder memory but linear in message length; BCJR computes symbolwise posterior probabilities. Soft decisions retain reliability information and generally outperform hard-bit decisions. Tail bits, tail-biting, or known state conventions terminate finite messages, while puncturing deletes selected coded symbols to obtain higher rates from a lower-rate mother code. Recursive systematic convolutional components underpin turbo codes.

A convolutional code is not ordinary numerical convolution, encryption, or a block code with no memory, although terminated encoding maps finite blocks to finite blocks and can be represented algebraically. More memory can improve distance properties but raises trellis complexity and decoding delay. Catastrophic generator choices can allow a low-weight output from an unbounded-weight input and must be avoided. Performance also depends on channel, interleaving, termination, and decoder metric. The abstraction is sliding redundant encoding: local memory spreads each information symbol across several transmitted times, and the resulting state continuity lets a decoder use whole-sequence evidence to correct corrupted symbols.

How would you explain it like I'm…

Mixed-In Message Helper

When you send a message over a crackly walkie-talkie, some bits get lost. A convolutional code spreads each piece of your message across several sounds you send, mixing it with the pieces just before it. Then, even if a few sounds get garbled, the listener can figure out what you meant by looking at the whole pattern.

Memory-Mixing Error Fixer

When computers send information, noise can flip some bits (the 0s and 1s). A convolutional code protects the message by adding extra bits. The sender's encoder remembers the last few input bits, and at each step it mixes the new bit with those remembered bits to produce a few output bits. That way, each input bit affects several outputs spread across time. The receiver looks at the whole stream of bits and figures out the most likely original message, fixing mistakes along the way. Remembering more makes the code stronger but makes decoding slower and harder.

Sliding-Memory Error-Correcting Code

A convolutional code is an error-correcting code in which the encoder has a small memory: at each step, it combines the current input bits with a fixed number of previous input bits to produce extra, redundant output bits. The combinations are set by 'generator polynomials', which list which bits get added together modulo two. A rate k/n encoder takes in k bits and puts out n bits per step. Because the encoder behaves like a machine with a limited number of states, all possible state sequences can be drawn as a trellis, a grid of states over time. The receiver decodes by finding the most likely path through the trellis; the Viterbi algorithm does this efficiently. Unlike a block code, which encodes chunks separately with no memory, a convolutional code spreads each input bit across several outputs over time. It is not the same as numerical convolution or encryption. More memory improves error correction but makes decoding more complex and slower.

A convolutional code is an error-correcting code produced by a finite-state encoder that continuously maps input symbols to redundant output symbols using the current input and a bounded memory of previous inputs. Generator polynomials specify the modulo-two combinations formed at each step; a rate k/n encoder consumes k bits and emits n per step, and the constraint length (memory) determines how many past inputs influence each output and how many states the decoder must track. Because the transition rule is time-invariant, state sequences form a trellis, and decoding means finding likely trellis paths. The Viterbi algorithm gives maximum-likelihood sequence decoding with cost exponential in memory but linear in message length, while BCJR computes symbol-wise posterior probabilities; soft-decision inputs, which keep reliability information, generally outperform hard decisions. Finite messages are terminated with tail bits, tail-biting, or a known-state convention, and puncturing deletes selected coded symbols to reach higher rates from a lower-rate mother code. Recursive systematic convolutional encoders are the components of turbo codes. More memory can improve distance properties at the cost of trellis complexity and decoding delay, and catastrophic generators, where an infinite-weight input can yield a finite-weight output, must be avoided. It is not numerical convolution, encryption, or a memoryless block code.

Structural Signature¶

Sig role-phrases:

the streaming input symbols — successive k-bit units presented to the encoder
the bounded encoder memory — prior inputs retained as finite state and influencing current output
the generator polynomials — modulo-two tap patterns mapping state and current input to coded symbols
the redundant output stream — n coded bits per step yielding rate k/n protection
the repeated state-transition rule — time-invariant finite-state mechanism unfolding across the message
the trellis representation — possible state paths organized by time and labeled with input/output transitions
the sequence decoder — Viterbi, BCJR, or related inference using path-wide received evidence
the reliability metric — hard decisions or richer soft information scoring candidate transitions
the finite-message boundary rule — tail bits, tail-biting, or known states specifying termination
the performance tradeoff — increased memory and distance potential exchanged for exponential state complexity, delay, and catastrophic-code avoidance

What It Is Not¶

Not ordinary numerical convolution. The name refers to repeated finite-memory coding operations over an input stream.
Not encryption. Redundancy is added for error correction, not secrecy.
Not a memoryless block code, even when a finite message is terminated. Encoder state couples output symbols across successive input times.
Not decoded by judging each received bit independently. Trellis methods compare state-consistent paths or posterior sequences.
Not automatically stronger whenever memory grows. Distance properties can improve, but state complexity, delay, and implementation cost rise exponentially.
Not valid for every generator choice. Catastrophic encoders can map unbounded-weight inputs to low-weight outputs and must be excluded.
Not fully characterized by nominal rate. Termination, puncturing, channel, interleaving, and soft-versus-hard metrics materially affect performance.

Scope of Application¶

A convolutional code is an engineering instrument and applies when a symbol stream is protected by a finite-state encoder whose redundant output depends on current input and bounded input memory.

Communication links. Generator polynomials and trellis decoding protect noisy radio, modem, and wired channels.
Spacecraft telemetry. Long streams use well-characterized codes, puncturing, interleaving, and soft decisions.
Broadcasting. Rate-compatible families trade redundancy against throughput under standardized channel assumptions.
Storage systems. Sequence decoding exploits state continuity across locally corrupted symbols.
Punctured-code design. A lower-rate mother code yields higher rates by deleting a declared output pattern.
Turbo-code components. Recursive systematic convolutional encoders provide constituent codes for iterative decoding.
Coding-theory education. Trellises, free distance, Viterbi, BCJR, termination, and soft metrics illustrate finite-memory protection.
Applicability boundary. This is not numerical convolution, encryption, or a memoryless block code; generator convention, rate, memory, initial and terminal state, puncturing, channel, metric, decoder, and latency must be explicit, while catastrophic generators and larger memories can undermine implementation despite attractive nominal parameters.

Clarity¶

Convolutional code names a finite-state error-correcting scheme whose repeated generator rule maps each input block and bounded memory of prior inputs to redundant outputs. Rate, generator polynomials, constraint length, termination, puncturing, and channel model define the actual code. The term distinguishes streaming state dependence from block codes that map independent fixed messages. The sharper coding question is which trellis paths remain confusable after noise, what free distance and decoder metric separate them, and how memory improves protection while increasing Viterbi or BCJR complexity.

Manages Complexity¶

A convolutional code compresses a streaming redundancy rule into rate, generator polynomials, encoder memory, state, and termination. All possible messages become paths through a repeated trellis rather than separate codebooks. The decoder tracks path metrics and survivor states; free distance summarizes protection, while constraint length predicts complexity. Punctured, recursive, systematic, tail-biting, and terminated branches alter rate and boundary behavior. This finite-state representation makes maximum-likelihood or posterior decoding tractable over long streams and reveals the core tradeoff: greater memory can separate error paths better but grows the state space exponentially.

Abstract Reasoning¶

State move. Feed message symbols and encoder memory through generator polynomials to produce a redundant output stream. Trellis move. Represent encoder states and transitions so decoding becomes a path problem rather than independent symbol correction. Likelihood move. Use received evidence to select the most likely path with Viterbi, BCJR, or sequential methods under the channel model. Distance move. Relate free distance and constraint length to error performance and computational cost. Termination move. Account for tail bits, puncturing, and rate changes. Boundary move. A convolutional code is not convolution used for filtering, and redundancy does not guarantee correction beyond its code and decoder assumptions.

Knowledge Transfer¶

Within the home domain. Convolutional codes transfer across radio, satellite, deep-space, mobile, and storage communications when a finite-state encoder produces redundant output from current and prior input symbols and a trellis decoder estimates the path. Generator polynomials, constraint length, rate, distance, puncturing, and termination retain exact roles. Beyond the home domain (C — coding method). They apply literally to any channel system implementing the code, not to generic convolution in signal processing. Their boundary is conditional: redundancy does not ensure correction beyond distance and decoder assumptions, and correlated noise, synchronization, or poor termination can dominate performance.

Examples¶

Canonical¶

A rate-½ convolutional encoder accepts one input bit per step and emits two modulo-two combinations of the current bit and two stored prior bits according to generator polynomials. The memory creates four states and a trellis of possible transitions. Over a noisy channel, a Viterbi decoder scores complete paths using received symbols and chooses the most likely sequence rather than decoding each bit independently. Tail bits return the encoder to a known state; a tail-biting version instead constrains initial and final states to coincide.

Mapped back: Bits are the streaming input symbols, registers the bounded encoder memory, taps the generator polynomials, and paired symbols the redundant output stream. Evolution is the repeated state-transition rule, represented by the trellis representation and inferred by the sequence decoder.

Applied / In Practice¶

A communication system feeds soft reliability values rather than hard bits into the decoder, improving path discrimination. Engineers compare constraint lengths: additional memory can improve distance but doubles states exponentially, increasing latency and computation. They test termination and screen generator choices for catastrophic behavior, where low-weight outputs can correspond to problematic long inputs. Puncturing may change effective rate but leaves the mother code's state rule documented.

Mapped back: Soft values are the reliability metric, termination the finite-message boundary rule, and memory/complexity/catastrophe the performance tradeoff.

Structural Tensions¶

T1 — Identity versus admissible variation. Convolutional code must remain recognizable across legitimate variants. Admissible variation is bounded by this condition: Generator polynomials and trellis decoding protect noisy radio, modem, and wired channels. The stable element is expressed by this invariant: A convolutional code maps a stream of input symbols to redundant output symbols through a finite-memory convolutional encoder, so each output depends on the current input and a bounded history and can be decoded from trellis structure. Treating every surface change as a new abstraction fragments the identity, while allowing a change to the constitutive relation produces a false positive.

Diagnostic: After the proposed variation, can an analyst still establish this invariant: A convolutional code maps a stream of input symbols to redundant output symbols through a finite-memory convolutional encoder, so each output depends on the current input and a bounded history and can be decoded from trellis structure?

T2 — Recognition versus proxy. The domain needs observable or inferential evidence for Convolutional code, but the evidence is not automatically the identity. The working recognition rule is: the finite-message boundary rule — tail bits, tail-biting, or known states specifying termination. A familiar indicator can occur without the defining relation, and the relation can persist when a customary detector is unavailable.

Diagnostic: Does the evidence establish the defining claim—A convolutional code maps a stream of input symbols to redundant output symbols through a finite-memory convolutional encoder, so each output depends on the current input and a bounded history and can be decoded from trellis structure—or only a correlated sign?

T3 — Definition versus operational judgment. A compact definition aids reuse, whereas actual classification in coding theory can require expert decisions about boundary conditions, measurements, conventions, or exceptions. Because the same transition rule repeats over time, possible state sequences form a time-invariant trellis. The definition must constrain those judgments without pretending that every admissible case can be recognized from a label alone.

Diagnostic: Which observation would make a competent practitioner reject the classification under the stated definition?

T4 — Scope versus overextension. Convolutional code has a genuine habitat in which generator polynomials and trellis decoding protect noisy radio, modem, and wired channels. Yet This is not numerical convolution, encryption, or a memoryless block code; generator convention, rate, memory, initial and terminal state, puncturing, channel, metric, decoder, and latency must be explicit, while catastrophic generators and larger memories can undermine implementation despite attractive nominal parameters. A useful application map therefore has to be broad enough to cover recurring practice and narrow enough to exclude merely topical or metaphorical occurrences.

Diagnostic: Can the claimed application fill the same carrier and relation roles, or has only the name traveled?

T5 — Transfer versus domain accent. Knowledge about Convolutional code can travel within its home domain, and some structural lessons may travel farther. Convolutional codes transfer across radio, satellite, deep-space, mobile, and storage communications when a finite-state encoder produces redundant output from current and prior input symbols and a trellis decoder estimates the path. What transfers must be separated from the specialist vocabulary, warrant, and closure conditions that remain anchored in coding theory.

Diagnostic: Is the receiving case a literal instance of Convolutional code, a co-instance of Redundancy, or only an analogy?

T6 — Autonomy versus reduction. Convolutional code structurally presupposes Redundancy, but the edge does not erase the domain differentia. The broader node supplies only the necessary structural relation; coding theory supplies the carrier, warrant, boundary, and exception conditions expressed by this identity: A convolutional code maps a stream of input symbols to redundant output symbols through a finite-memory convolutional encoder, so each output depends on the current input and a bounded history and can be decoded from trellis structure. The entry is over-split if those conditions add no discriminating work and under-specified if the parent alone is used for cases that require them.

Diagnostic: Can a domain expert use the added conditions to distinguish Convolutional code from another case that equally instantiates Redundancy?

Structural–Framed Character¶

Convolutional code is mixed: structurally specifiable but materially dependent on its disciplinary frame. Its structural side consists of the carrier the streaming input symbols — successive k-bit units presented to the encoder and the constitutive relation A convolutional code maps a stream of input symbols to redundant output symbols through a finite-memory convolutional encoder, so each output depends on the current input and a bounded history and can be decoded from trellis structure. Its framed side comes from coding theory, which fixes what the terms denote, what counts as evidence, and when a qualification or exception defeats the classification.

Across the principal tests, the entry is not merely a free-floating pattern. Evaluative weight: the identity can be stated descriptively even when its use has practical or normative consequences. Practice dependence: the finite-message boundary rule — tail bits, tail-biting, or known states specifying termination. Institutional stabilization: disciplinary conventions may stabilize the name and test without necessarily creating every underlying event or relation. Vocabulary portability: the invariant is A convolutional code maps a stream of input symbols to redundant output symbols through a finite-memory convolutional encoder, so each output depends on the current input and a bounded history and can be decoded from trellis structure. Import versus recognition: an outside case qualifies literally only if the same typed roles and collapse condition are available; otherwise the comparison is analogical.

The reusable remainder is Redundancy under a reviewed Composition relation. That node preserves the necessary cross-domain organization after the coding theory-specific carrier, evidence, and exceptions are removed. Convolutional code remains autonomous because its recognition and collapse conditions distinguish cases that the parent alone leaves together.

Structural Core vs. Domain Accent¶

What is skeletal. The portable skeleton is a typed carrier organized by a constitutive relation, an invariant, a recognition test, and a collapse condition. Here the carrier is the streaming input symbols — successive k-bit units presented to the encoder. The decisive relation is A convolutional code maps a stream of input symbols to redundant output symbols through a finite-memory convolutional encoder, so each output depends on the current input and a bounded history and can be decoded from trellis structure, which also states the controlling invariant at this level. Stripped of specialist nouns, this organization is represented by Redundancy.

What is domain-bound. coding theory supplies the actual objects or agents, admissible transformations, units or conventions, standards of warrant, and named exceptions. In this case, recognition requires evidence for the finite-message boundary rule — tail bits, tail-biting, or known states specifying termination. Admissible variation is bounded by the condition that generator polynomials and trellis decoding protect noisy radio, modem, and wired channels, and the classification collapses when the name refers to repeated finite-memory coding operations over an input stream. These are constitutive differentia, not illustrative decoration.

Why it remains a domain-specific node. The reviewed DAG relation is Composition to Redundancy. Outside coding theory, the parent captures only the reusable structural remainder. The specialist name remains literal only where the finite-message boundary rule — tail bits, tail-biting, or known states specifying termination can be established under the domain's standards of warrant.

This entry presupposes Redundancy.

Immediate parent — Redundancy (composition/presupposes). Convolutional code structurally presupposes Redundancy rather than being a subtype of it. The candidate identity is: A convolutional code maps a stream of input symbols to redundant output symbols through a finite-memory convolutional encoder, so each output depends on the current input and a bounded history and can be decoded from trellis structure. Its operation cannot be stated without the parent relation—Duplicate critical components.—but it adds domain-specific carriers, constraints, and warrants. The defining source account begins: A convolutional code is an error-correcting code in which a finite-state encoder continuously maps input symbols to redundant output symbols using the current input and a bounded memory of previous inputs.
Nearest catalog surface declined — Convolution. Its rematch score was 0.197174. Retrieval proximity did not establish synonymy or parentage; the carrier, invariant, and collapse condition remain different.
Related reasoning operations. Evidence, comparison, boundary testing, and representation can support a case without becoming additional DAG parents.

Relationships to Other Abstractions¶

Current abstraction Convolutional code Domain-specific

Parents (1) — more general patterns this builds on

Convolutional code presupposes Redundancy Prime

Convolutional code structurally presupposes Redundancy rather than being a subtype of it.

Hierarchy paths (12) — routes to 8 parentless roots

Convolutional code → Redundancy → Reserve → Economy Of Force → Allocation → Scarcity → Constraint

Show alternative paths (11)

Neighborhood in Abstraction Space¶

Convolutional code sits in a sparse region of the domain-specific corpus (77^th percentile for distinctiveness): few abstractions share its structure, so a faithful description tends to retrieve it precisely.

Family — Unclustered & Miscellaneous (2551 abstractions)

Nearest neighbors

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

Not to Be Confused With¶

Redundancy. This is the reviewed immediate parent or structural prerequisite, not a synonym. Tell: retain Convolutional code only when the domain-specific relation A convolutional code maps a stream of input symbols to redundant output symbols through a finite-memory convolutional encoder, so each output depends on the current input and a bounded history and can be decoded from trellis structure. and its source-domain warrant are established; otherwise route the case to Redundancy.
Sequential Decoding. This is the closest catalog retrieval surface, not an accepted synonym or parent. Tell: Ask which entry's carrier, invariant, and collapse test the case actually satisfies; shared vocabulary or a score of 0.788568 is insufficient.
Not ordinary numerical convolution. The name refers to repeated finite-memory coding operations over an input stream. Tell: Require the positive recognition condition that the finite-message boundary rule — tail bits, tail-biting, or known states specifying termination.
Not encryption. Redundancy is added for error correction, not secrecy. Tell: Replace the familiar surface feature and test whether a convolutional code maps a stream of input symbols to redundant output symbols through a finite-memory convolutional encoder, so each output depends on the current input and a bounded history and can be decoded from trellis structure.
A detector, representation, or consequence. A method may reveal Convolutional code, a notation may describe it, and an outcome may follow from it without any of those being identical to the abstraction. Tell: Would the defining relation remain if the present detector, notation, or downstream effect changed?
A metaphorical transfer. A case outside the home domain may resemble the structure while lacking its native role types and standards of warrant. Tell: If only the general organization survives, route the comparison to Redundancy rather than treating it as another Convolutional code instance.

References¶

Frozen Wikipedia revision: https://en.wikipedia.org/wiki/Convolutional_code (revision 1366655790).
Supporting reference preserved in the packet: https://web.archive.org/web/20190406181758/https://ieeexplore.ieee.org/abstract/document/390945/
Supporting reference preserved in the packet: http://tda.jpl.nasa.gov/progress_report/42-63/63H.PDF
Supporting reference preserved in the packet: https://leseprobe.buch.de/images-adb/7b/4f/7b4f94db-7c55-4836-9b61-2ff98cb242d9.pdf
Supporting reference preserved in the packet: https://www.mathworks.com/help/comm/examples/llr-vs-hard-decision-demodulation.html
Supporting reference preserved in the packet: https://www.mathworks.com/help/comm/ug/estimate-ber-for-hard-and-soft-decision-viterbi-decoding.html
Supporting reference preserved in the packet: https://www.mathworks.com/help/comm/ug/digital-modulation.html#brc6yjx
Supporting reference preserved in the packet: https://www.mathworks.com/help/comm/ug/digital-modulation.html#brc6ymu
Supporting reference preserved in the packet: https://ipnpr.jpl.nasa.gov/progress_report/42-63/63H.PDF

The frozen Wikipedia revision is discovery provenance. The cited source set was reviewed for identity, formal or operational relation, and scope. The encyclopedia's structural synthesis is bounded to those claims; URL transport failure alone was not treated as substantive contradiction.