LLM Layer-0 Functional Compliance Specification: Defining the Six Core Roles of Large Language Models

This article introduces the LLM Layer-0 Functional Compliance Specification project on GitHub, published by gatchimuchio on 2026-05-25. The project uses formal mathematical theorems to define the six core functional roles that contemporary large language models must instantiate, providing a unified foundation and common language for LLM auditing, regulation, and architectural discussions. Any system missing any of these roles cannot be called a contemporary LLM.

The technology of large language models has developed explosively, but the lack of a unified foundational definition leads to communication confusion and inconsistent judgment standards in regulatory audits, developer architectural discussions, and researcher model comparisons. This open-source project proposes a solution: defining the six core functional roles that an LLM must satisfy in the form of mathematical theorems, which is a formal "functional necessity theorem"—any system missing any role is not a contemporary LLM.

The Layer-0 specification includes six functional roles that must be instantiated:

1. TOKEN_OR_SYMBOL_SPACE: The boundary of basic unit representation for model input and output;
2. CONTEXT_CONDITIONING_STATE: The boundary of reasoning states that affect predictions (e.g., key-value cache in Transformers);
3. LEARNED_PARAMETERIZED_TRANSFORM: A parameterized transformation function obtained through training (distinguished from traditional rule-based systems);
4. CONDITIONAL_LINGUISTIC_OUTPUT_SURFACE: The boundary of the output space considering conditional probability distributions;
5. SEQUENCE_MODELING_OBJECTIVE_OR_EQUIVALENT_FITTING_CRITERION: The optimization objective driving model learning (e.g., next-token prediction);
6. DECODING_OR_EMISSION_INTERFACE: The mechanism to convert internal states into observable outputs (e.g., greedy decoding, sampling).

Proof Method: Uses finite exhaustive method to verify 64 (2^6) role subsets; only the complete set passes, all proper subsets fail. This can be reproduced via make audit and make verify. Architecture Independence: Applies to architectures like Transformer, Dense, MoE, SSM/Mamba, RWKV, etc. The six roles remain unchanged, only the implementation methods differ, providing a stable foundation for discussions.

1. Audit and Compliance: make audit returns deterministic results and executable certificates, avoiding ambiguous judgments;
2. Regulation and Standard Setting: Provides a formal boundary definition for "whether a system is an LLM", unaffected by architectural evolution;
3. Common Language for Architectural Discussions: Separates "what an LLM is" from "how to implement an LLM". Specific technologies (e.g., attention mechanism, RoPE) are under Layer-0;
4. Counterexample Protocol: Critics need to provide a more rigorous decomposition or valid LLM counterexample; "it depends on the definition" is not a valid refutation.

Industry Alignment: Cites official descriptions from OpenAI, Anthropic, xAI, Meta, Mistral, etc., to ensure consistency between theory and practice. Multi-Layer Verification System:

Layer	Content Established	Verification Support	Boundary
Layer0	Mathematical necessity of the six roles	Term boundary axioms + role separation argument	Formal theorem domain
LayerA	Finite obligation graph theorem	Exhaustive enumeration of 64 subsets	Formal executable certificate
LayerB	Public LLM family mapping	Official references and witnesses	Public witness mapping
Layer1+	Architectural branch positioning	Public architecture descriptions	Implementation branches under Layer0

Technical Implementation: Provides a fully reproducible environment. The main artifact is llm_minimal_architecture_groups_v3_0.py, and the LayerA certificate is located at appendices/layer_a_obligation_graph_enumeration_v0_5/layer_a_executable_certificate.json. Verification commands include make audit, make verify, make test-all. The expected results are: main audit passes, count of passing proper subsets is 0. Limitations: The six role labels are not the only possible English labels; merging five components hides responsibility boundaries, while seven+ components enter implementation refinement; the counterexample protocol has strict requirements (need to prove that the candidate system is an LLM and lacks a role or equivalent function).

The LLM Layer-0 Functional Compliance Specification establishes a mathematically rigorous definition foundation for LLMs through formal definitions and exhaustive proof, providing a common language for auditing, regulation, and architectural discussions. Its value lies in stabilizing the communication foundation without restricting innovation, and it provides a valuable theoretical basis for AI governance organizations, enterprises auditing third-party systems, and technical personnel to understand the essence of LLMs.