Information-Computational Core: Canonical Domain Analysis (Revised to 7 Primitives)

Status: Canonical reference. Full 12-step analysis of the info-comp core at 7 primitives. Revision history:

• v1: 6 primitives {Σ, P, C, K, μ, Γ} in v1_full_analysis/information-computational-landscape.md
• v2 (this document): 7 primitives {Σ, P, C, Ke, Kd, μ, Γ} — K split into Encoder (Ke) + Decoder (Kd) Revision trigger: Cognitive substrate analysis discovered evaluator determinism as the critical variable separating hard from soft information substrates. The key observation: formal systems can be fully encoded in language, but without deterministic evaluators, encoding alone doesn't produce reliable function. This raised the question: why didn't the info-comp core catch this? Because Shannon's framework assumes decoders are deterministic — Code (K) bundles encoding and decoding, hiding the evaluator as an independent variable. The fix: split K into Ke (encoder) and Kd (decoder), making decoder determinism independently assessable. This finding implies Shannon's framework is incomplete for systems with non-deterministic decoders — potentially publishable as an information theory extension.

Step 1 — Information Gathering

1.1 What we're analyzing

The information-computational core: the abstract structure of information processing. This domain captures what ALL information-processing systems have in common — biological (DNA→protein), computational (data→computation), cognitive (symbol→meaning), and communicative (signal→received message).

1.2 Sources

Primary mathematical foundations:

• Shannon (1948): "A Mathematical Theory of Communication" — source coding, channel coding, entropy, capacity
• Shannon & Weaver (1949): "The Mathematical Theory of Communication" — extended framework
• Kolmogorov (1965): Algorithmic information theory — complexity independent of distribution
• Cover & Thomas (2006): "Elements of Information Theory" — modern treatment

Coding theory:

• Hamming (1950): Error-correcting codes
• Reed & Solomon (1960): Polynomial codes
• Berrou et al. (1993): Turbo codes
• Gallager (1962), Richardson & Urbanke (2008): LDPC codes
• Arikan (2009): Polar codes — capacity-achieving

Rate-distortion and source coding:

• Shannon (1959): Rate-distortion theory
• Ziv & Lempel (1977, 1978): LZ77/LZ78 universal compression
• Huffman (1952): Optimal prefix codes
• Rissanen (1976): Arithmetic coding

Extensions and connections:

• Solomonoff (1964): Algorithmic probability and induction
• Chaitin (1966): Algorithmic randomness
• Jaynes (2003): Maximum entropy methods — information theory ↔ statistical mechanics
• MacKay (2003): "Information Theory, Inference, and Learning Algorithms"

The revision trigger (from biology analysis):

• bio_v2/exploration-situated-substrate-architecture.md — evaluator discovery
• abstract_conclusions/exploration-abstract-structure-and-info-comp-revision.md — K→Ke+Kd split rationale
• bio_v2/synthesis-information-substrate-architecture.md §10 — info-comp as validator of situated substrate architecture

1.3 Key observations from literature

Shannon's framework has a specific structural assumption: the encoder f(s)→x and decoder g(y)→ŝ are DETERMINISTIC functions. All noise lives in the channel P(Y|X). Shannon's theorems (source coding, channel coding, rate-distortion) are proven under this assumption.

This assumption is valid for:

• Digital communication (encoders and decoders are algorithms — deterministic by construction)
• DNA replication (ribosome is a molecular machine — deterministic by physical geometry)
• Formal mathematics (proof rules are deterministic — valid or invalid)

This assumption FAILS for:

• Human language comprehension (interpretation varies by person, context, culture)
• AI/LLM output interpretation (statistical generation, semantically variable)
• Cultural transmission (meaning drifts across generations)

The failure isn't a "noisy channel" problem — it's a NOISY DECODER problem. Shannon's framework can't model it because it assumes decoders are noise-free. Adding channel redundancy doesn't help when the decoder is the noise source.

Step 1b — Domain Type Declaration

Type: Substrate

The info-comp core describes the MACHINERY of information processing — how information is structured, transmitted, encoded, decoded, measured, and constrained. It's analogous to biology (machinery of life), entity system (machinery of typed data), and cognitive substrate (machinery of thought).

Predictions from substrate type:

• Filter tightness: ~12-20% (tight — sequential dependencies)
• Core triad function: information flow (how information is structured and transformed)
• Dependency chain depth: moderate to deep (sequential processing stages)
• Heavy pair count: approximately equals primitive count

These predictions will be checked against findings.

Step 2 — Landscape Analysis

2.1 The information theory landscape

Information theory is a mature mathematical field (~75 years). Its core structure has been stable since Shannon, with major extensions in coding theory, network information theory, and connections to other fields.

Key landscape features:

2.2 What recurs across the landscape

Every area of information theory involves the same structural elements:

1. An ALPHABET of symbols
2. A STATISTICAL STRUCTURE over those symbols
3. A PHYSICAL or LOGICAL MEDIUM for transmission/storage
4. An ENCODING PROCESS that maps source to medium
5. A DECODING PROCESS that recovers meaning from received signals
6. QUANTITATIVE MEASURES of information content
7. FUNDAMENTAL BOUNDS on what's achievable

These seven elements recur whether you're studying compression, error correction, cryptography, or machine learning. They're the candidate primitives.

Step 3 — Primitive Extraction

3.1 The original 6-primitive analysis (v1)

The v1 analysis identified 6 primitives:

3.2 Why Code (K) must split

The K primitive bundles two structurally independent operations:

Encoding (source → channel-compatible form):

• Maps source symbols to channel inputs
• Can be optimized for source statistics (compression)
• Can be optimized for channel characteristics (error protection)
• Can be deterministic or lossy
• Example: Huffman encoding, LDPC encoding, DNA→mRNA transcription, natural language production

Decoding (received signal → interpreted meaning):

• Maps channel outputs to estimated source symbols
• Can be deterministic (lookup table, ribosome) or stochastic (human interpretation)
• Its reliability determines system reliability
• Example: Viterbi decoding, ribosome translation, human reading comprehension, LLM output parsing

The primitive test — independent existence:

• Can encoding exist without decoding? YES — writing a message that nobody reads, DNA in a test tube, encrypted data with lost key. The encoding exists independently.
• Can decoding exist without encoding? MARGINALLY — a decoder can interpret raw channel output (pattern recognition on noise), but this is degenerate. More precisely: decoding presupposes SOMETHING was encoded, even if the specific encoding scheme is unknown.

The primitive test — independent failure modes:

• Encoder failure: information is mis-encoded. The message doesn't faithfully represent the source. Effect: wrong content. Example: imprecise language, lossy compression artifacts, transcription errors.
• Decoder failure: information is mis-decoded. The received message is misinterpreted. Effect: wrong interpretation. Example: misreading, cultural misunderstanding, hallucination, ribosome misincorporation.

These are INDEPENDENT. Perfect encoding + bad decoding = wrong understanding of correct content. Bad encoding + perfect decoding = correct execution of wrong instructions. The failure modes are structurally different.

The structural argument: The biology analysis revealed that evaluator determinism (Kd level) is the single most important variable separating information substrates. With K bundled, the info-comp core literally cannot express this distinction — all substrates have "Code" at some level. With Ke and Kd separated, the decoder's determinism becomes independently assessable.

3.3 The revised 7-primitive set

3.4 What was gained by splitting

With Kd as a separate primitive, the info-comp core can now:

1. Distinguish hard from soft substrates: Kd4 (deterministic decoder) vs Kd1-2 (stochastic decoder). Previously invisible when K bundled encoder and decoder.

2. Model evaluator noise independently of channel noise: Kd-noise is independent of C-noise. Shannon's original framework could only model C-noise. Now BOTH noise sources are expressible: which dominates? (For cognition-linguistic: Kd-noise > C-noise. For biology: C-noise > Kd-noise. For entity system: both ≈ 0.)

3. Predict system reliability: Total system noise ≈ C-noise + Kd-noise. Reliable system requires BOTH clean channel AND deterministic decoder.

4. Explain hallucination: AI has C-noise ≈ 0 (digital) but Kd-noise > 0 (statistical semantics). Failure is AT THE DECODER, not the channel. Shannon's original framework couldn't express this.

5. Map cleanly to the situated substrate architecture: Kd → Vr (evaluator) is now a direct one-to-one mapping, instead of K → {En+Vr} as a split.

Step 3b — Partial Levels

Symbol (Σ)

Phase transition: Σ2→Σ3 (Extensibility). Below: alphabet is fixed — the system works with a closed set of symbols. Above: alphabet can GROW — new symbols are added. The information system becomes open. DNA is Σ2 (fixed 4 bases for ~4 Gy). Entity types are Σ3-4 (extensible + hierarchical). Natural language is Σ3 (vocabulary grows continuously).

Distribution (P)

Phase transition: P2→P3 (Context dependence). Below: probability depends only on the immediately preceding symbol. Above: probability depends on EXTENDED CONTEXT — the meaning of a word depends on the whole sentence/paragraph. Simple Markov models fail; richer statistical models needed (neural language models, HMMs).

Channel (C)

Phase transition: C1→C2 (Noise introduction). Below: transmission is perfect — no information lost. Above: some information corrupted. Error correction becomes necessary. Shannon's channel coding theorem applies from C2 upward.

Encoder (Ke)

Phase transition: Ke2→Ke3 (Channel adaptation). Below: encoding optimized for SOURCE (compress well) but not CHANNEL (no error protection). Above: optimized for BOTH — compressed AND error-protected. Reliable communication over noisy channels becomes possible.

Second critical transition: Ke3→Ke4 (Semantic encoding). Below: encoding preserves SYMBOLS faithfully but doesn't constrain MEANING. Above: encoding constrains MEANING — type systems tell you what data IS, not just what bytes it contains. Encoding becomes FORMAL rather than merely symbolic.

Decoder (Kd)

Phase transition: Kd3→Kd4 (Determinism). THE critical transition for information substrates. Below: decoder is reliable but can still err — different decoder instances may produce slightly different outputs for the same input. Above: decoder is DETERMINISTIC — every instance produces exactly the same output for the same input.

This is the hard-substrate gate. Biology crosses it at the ribosome (molecular geometry enforces deterministic codon→amino acid mapping). The entity system crosses it at handler dispatch (type system enforces deterministic routing). Cognition crosses it only for formal content (proofs, mathematics). Cognition in linguistic mode stays below Kd4 — interpretation is inherently variable.

Measure (μ)

Phase transition: μ1→μ2 (Mutual information). Below: measure how much information a source CONTAINS. Above: measure how much one variable tells about ANOTHER. Information theory becomes a theory of COMMUNICATION, not just sources.

Constraint (Γ)

Phase transition: Γ1→Γ2 (Capacity). Below: resources are finite but the FUNDAMENTAL LIMIT is unknown. Above: the theoretical maximum is known — Shannon capacity tells the best possible performance regardless of code cleverness.

Step 3c — Evaluator Identification

The info-comp core IS the abstract domain of information processing. Its "evaluator" — the mechanism that translates encoding into function — is the Decoder (Kd) itself. The decoder IS the evaluator at the information-theoretic level.

This is why the K→Ke+Kd split was necessary: the evaluator was hidden inside the bundled Code primitive. Making Kd explicit makes the evaluator visible at the abstract level.

Evaluator determinism in the info-comp core:

• The decoder (Kd) ranges from Kd0 (no interpretation) to Full Kd (verified deterministic)
• Kd4 is the hard-substrate gate — deterministic decoding
• The info-comp core can now MODEL evaluator determinism as a structural variable, not just assume it

Mapping to the situated substrate architecture:

• Kd (info-comp decoder) → Vr (SSA evaluator) — DIRECT one-to-one mapping
• This is the cleanest mapping in the entire info-comp → SSA correspondence

Step 4 — Dependencies

Σ → (nothing; foundation)
P → Σ (distributions are OVER symbols)
C → Σ (channel transmits symbols)
Ke → Σ, P (encoder maps source distribution to channel-compatible symbols)
Kd → C, Ke (decoder interprets channel output, knowing encoding scheme)
μ → P (entropy computed from distribution)
Γ → μ, C, Ke, Kd (bounds relate all components)

DAG:

Σ (hub — no dependencies)
  ├── P ──── μ
  ├── C
  └── Ke ─── Kd
              │
Γ ← (μ + C + Ke + Kd)

Hub: Σ (Symbol). Everything operates on symbols. The alphabet is the foundation.

Terminal: Γ (Constraint). Depends on everything else. Bounds and rates relate ALL components — you need to know the source (Σ,P), the channel (C), the code (Ke,Kd), and the measure (μ) to state the fundamental limits.

Key dependency: Kd → C + Ke. The decoder needs BOTH the channel characteristics (what noise was introduced) AND the encoding scheme (what was encoded) to decode correctly. This captures a real structural constraint: you can't decode without knowing what was encoded and how the channel might have corrupted it.

Depth: Maximum chain length is 4: Σ → P → Ke → Kd → Γ (through the μ requirement on Γ needing P). This is moderate — comparable to biology's depth.

Step 5 — Pair Enumeration

C(7,2) = 21 pairs.

21 unique pairs (correcting: #21 is duplicate, actual count is 21 from C(7,2)).

Step 6 — Load Classification

Heavy pairs

11 heavy pairs of 21 (52%). High integration — consistent with the info-comp core being a tightly coupled abstract domain.

Light/moderate pairs

Check against substrate-type prediction

Predicted: heavy pair count ≈ primitive count. Actual: 11 heavy of 7 primitives. HIGHER than predicted — more like the entity system (11/15 = 73%) than typical substrates (6/15 = 40%). This reflects the tight integration of information-theoretic concepts — everything relates to everything else through Shannon's unified framework.

Step 7 — Coherent Sub-lattice

Dependency constraints

Σ must be present for anything else. Given Σ:

• P needs Σ only
• C needs Σ only
• Ke needs Σ + P
• Kd needs C + Ke (which needs Σ + P)
• μ needs P (which needs Σ)
• Γ needs μ + C + Ke + Kd (which needs everything)

Enumeration

Valid subsets of {P, C, μ, Ke, Kd, Γ} given Σ always present:

Invalid examples:

• {Kd} alone: needs C + Ke → INVALID
• {C, μ}: μ needs P → INVALID
• {P, Kd}: needs C + Ke → INVALID
• {Γ} alone: needs everything → INVALID
• {C, Ke}: Ke needs P → INVALID
• {P, C, Kd}: Kd needs Ke → INVALID
• {μ}: needs P → INVALID

Total: 13 valid subsets + {}: 13 subsets of the 6 non-Σ primitives, plus {} = already counted. Including {} and {Σ} alone: 15 coherent subsets of 128 (2^7).

Wait — let me recount. The total lattice is 2^7 = 128 (all subsets of 7 primitives). But Σ must be present for anything. So the valid subsets are: {}, {Σ}, and {Σ + valid subset of remaining 6}. The 13 valid subsets above all include Σ.

• {} (empty — no primitives): 1
• {Σ} (just symbols): 1
• {Σ} + 13 valid combinations of {P,C,μ,Ke,Kd,Γ}: 13

Total: 15 coherent subsets of 128.

Filter: 15/128 = 11.7%. TIGHT.

Check against substrate-type prediction

Predicted: ~12-20%. Actual: 11.7%. Confirmed — tight filter consistent with substrate type. The deep dependency chain (Γ requires everything, Kd requires C+Ke) creates strong filtering. Slightly tighter than biology (12.5%), reflecting the info-comp core's strict sequential logic.

Step 8 — Build-up Sequence

Primary path

Step 0: {} → {Σ}
  Symbols exist. Information can be represented discretely.
  At this level: alphabets, enumeration, basic encoding in the Claude Shannon sense
  of "symbols from a finite set."

Step 1: {Σ} → {Σ, P}
  Symbols have statistical structure. Not all messages equally likely.
  At this level: source models, frequency analysis, language statistics.

Step 2: {Σ, P} → {Σ, P, μ}
  Information content can be MEASURED. Entropy quantified.
  Source coding theorem: H(X) bounds lossless compression.
  At this level: entropy calculations, source characterization, redundancy detection.

Step 3: {Σ, P, μ} → {Σ, P, μ, Ke}
  Information can be ENCODED — mapped into efficient representation.
  Compression is possible. Huffman, arithmetic coding.
  At this level: encoding design, compression algorithms, representation optimization.

Step 4: {Σ, P, μ, Ke} → {Σ, P, μ, Ke, C}
  Encoded information can be TRANSMITTED through a (noisy) channel.
  Communication becomes possible. Channel models arise.
  At this level: transmission systems, noise models, physical channels.

Step 5: {Σ, P, μ, Ke, C} → {Σ, P, μ, Ke, C, Kd}
  Transmitted information can be DECODED — interpreted at the receiver.
  *** GENESIS TRANSITION ***
  Before: information exists, is measured, is encoded, is transmitted — but not INTERPRETED.
  After: information is decoded — it produces meaning/function at the receiver.
  This is where information becomes FUNCTIONAL, not just structural.
  At this level: decoding algorithms, error correction, signal recovery, interpretation.

Step 6: {Σ, P, μ, Ke, C, Kd} → {Σ, P, μ, Ke, C, Kd, Γ}
  Fundamental LIMITS are known. Shannon's theorems bound what's achievable.
  The system is fully characterized — you know what CAN and CANNOT be done.
  At this level: capacity theorems, rate-distortion theory, converse theorems, impossibility results.

The genesis transition: Step 4→5 (Kd appearing)

The decoder's appearance is the genesis transition at the info-comp level. This parallels:

• Biology: ribosome emergence (Vr appearing — encoding becomes functional)
• Entity system: handler dispatch activation (X appearing — data becomes computation)
• Cognition: symbolic language (Sy appearing — representation becomes communicable meaning)
• SSA: Vr appearing (Step 1→2 — encoding translates to function)

In ALL cases, the genesis transition is the EVALUATOR/DECODER emerging — the mechanism that translates encoding into function. The info-comp core confirms this at the most abstract level.

Alternative path

{Σ} → {Σ, C} → {Σ, P, C} → {Σ, P, C, Ke} → {Σ, P, C, Ke, Kd} → add μ → add Γ

This path starts with channel (transmission exists before encoding is optimized). Less common in theory but natural in practice — transmission systems existed before source coding theory. Both paths converge at step 5 (Kd appearing).

Step 9 — Load-bearing Compositions

Core triads

Primary: {Σ, Ke, Kd} — "What is a code?"

Symbol alphabet + encoder + decoder. The complete information code. All three pairs heavy:

• Σ-Ke: symbols define what can be encoded ✓
• Σ-Kd: symbols define what can be decoded ✓ (through Ke — but structurally Σ determines the alphabet of decoded outputs)
• Ke-Kd: encoder and decoder must be MATCHED ✓

This is the CODE triad — the structural unit of information translation.

Secondary: {Σ, P, μ} — "What is a source?"

Alphabet + distribution + entropy measure. All three pairs heavy:

• Σ-P: alphabet with distribution = source ✓
• P-μ: distribution's entropy ✓
• Σ-μ: alphabet size bounds entropy ✓

This is the SOURCE triad — the structural unit of information content.

Two core triads correspond to Shannon's two fundamental theorems:

• Source coding theorem: {Σ, P, μ} + Ke — entropy bounds compression
• Channel coding theorem: {Σ, Ke, Kd} + C + Γ — capacity bounds reliable rate

Multiple heavy triads are common across domains — any domain with sufficient integration will have several all-heavy triangles. Which gets elevated to "core triad" remains partly judgmental. Here the two candidates correspond to the two independently motivated halves of Shannon's framework, which gives structural reason for both.

Named compositions (triangles)

Quad compositions

{Σ, P, Ke, μ} — Source coding system. The complete source coding setup: alphabet, statistics, encoder, and measure. This is where compression theory lives. Requires Ke adapted to P, measured by μ, operating on Σ.

{C, Ke, Kd, Γ} — Channel coding system. The complete channel coding setup: channel, encoder, decoder, and bounds. This is where reliability theory lives. Requires Ke and Kd jointly optimized for C within Γ.

{Σ, P, Ke, Kd} — End-to-end code. Source to destination: alphabet, statistics, encoding, decoding. No bounds or measures — just the operational code.

Full composition

{Σ, P, C, Ke, Kd, μ, Γ} — Complete information system. Shannon's full framework. All components present, all theorems applicable. The emergent property: FUNDAMENTAL LIMITS ON RELIABLE INFORMATION PROCESSING are known and achievable.

Step 10 — Emergent Properties

The evaluator noise prediction

This is the key new emergent property enabled by the Ke/Kd split:

When Kd-noise > C-noise, adding channel redundancy doesn't improve system reliability.

Shannon's framework says: add redundancy to overcome channel noise. But if the DECODER is noisier than the channel, redundancy in the channel doesn't help — the decoder will still misinterpret the redundant message. The solution is different: make the encoding MORE FORMAL (raise Ke to Ke4) so the decoder has less room for interpretation, or replace the decoder with a deterministic one (raise Kd to Kd4).

This predicts:

• Saying the same thing louder or more often doesn't fix misunderstanding (human communication)
• Making AI outputs longer or more detailed doesn't fix hallucination (encoder noise)
• Only FORMAL ENCODING + DETERMINISTIC DECODING produces reliable systems (entity system, biology)

Step 11 — Cross-Domain Structural Patterns

11.1 Comparison to other substrate-type domains

Observations:

1. Filter tightness is in the substrate range (11.7% — tightest analyzed). Confirmed substrate type.
2. Core triad function is information flow — confirmed substrate type.
3. TWO core triads is unusual — only the info-comp core has this. Reflects the domain's dual structure (source theory + channel theory). The UI domain also found two core triads, but for different reasons.
4. Heavy pair percentage (52%) is between biology (40%) and entity system (73%). The info-comp core is more tightly integrated than biology but less than the entity system.

11.2 The 6→9 expansion pattern

If the info-comp core is a substrate, it should expand to a ~9-primitive surface through bridge mechanisms. Does it?

The info-comp core's "surface" is the Abstract Surface {St, Or, Rg, Pr, Ac, Pt, Ex, [Rs], [Gn]} — what all functional surfaces have in common. The expansion from info-comp (7) to abstract surface (7+2 = 9) follows the pattern:

• Core triad {Σ, Ke, Kd} becomes AMBIENT at surface: symbols, encoding, and decoding are assumed by every surface function
• Non-core {P, C, μ, Γ} expand into surface roles:
  • P (distribution) → patterns underlying Structure (St) and Organization (Or)
  • C (channel) → medium for Perception (Pr) and Exchange (Ex)
  • μ (measure) → basis for Regulation (Rg) — measure deviations to regulate them
  • Γ (constraint) → bounds that Protection (Pt) enforces and Action (Ac) operates within

This maps, though less tightly than the concrete substrate→surface mappings. The abstract level has looser correspondence than the concrete level — expected because abstraction loses domain-specific detail.

11.3 Phase transition alignment

The genesis transition aligns across all levels: it's always the DECODER/EVALUATOR appearing. The determinism transition also aligns: it's always the decoder/evaluator becoming deterministic. This cross-domain alignment supports the info-comp core as a valid abstraction of substrate structure.

Step 12 — Cross-Domain Mapping

12.1 Mapping to the situated substrate architecture (SSA)

Assessment: The mapping is NOT one-to-one overall. Σ and Ke both map to En. P maps to Cm at population scale. μ informs Se but isn't identical. The two frameworks are COMPLEMENTARY perspectives on the same systems:

• Info-comp core: INTERNAL structure of information processing (what happens inside)
• SSA: EXTERNAL architecture of situated information systems (how they're organized in context)

The Kd→Vr mapping is the cleanest — direct one-to-one. This validates the K→Ke+Kd split: before the split, K→{En+Vr} was a messy split. After, Kd→Vr is direct.

12.2 Mapping to concrete substrates

12.3 What the positioning reveals

The Ke-Kd diagonal is the reliability axis. Systems with both high Ke AND high Kd are reliable. Systems with either low are unreliable:

Key insight: Shannon's framework predicts that reliable communication requires the decoder to be MORE deterministic than the channel is noisy. When the DECODER is the main noise source (cognition-linguistic: Kd1-2), you can't code around it the way you can code around channel noise. This is WHY hard evaluators matter: they remove the evaluator as a noise source, leaving only channel noise, which CAN be coded around (error correction, hash verification).

Manifestation Landscape

Positioned systems

Attractor positions

Summary

Domain characterization

What the revision changes

Validation status