# How the C = A(c₁, c₂, ..., cₙ) Context Formalization Works in Practice

> Understand the C = A(c₁, c₂, ..., cₙ) context formalization. Learn how this assembly function mathematically combines canonical components into LLM context for practical application. Explore its real-world function and impact.

- Repository: [davidkimai/context-engineering](https://github.com/davidkimai/context-engineering)
- Tags: deep-dive
- Published: 2026-02-28

---

**The C = A(c₁, c₂, ..., cₙ) formalization treats context assembly as a mathematical function where an assembly function A combines six canonical components—instructions, knowledge, tools, memory, state, and query—into the final context C that is fed to the LLM.**

The `davidkimai/context-engineering` repository implements this rigorous mathematical approach to prompt engineering, transforming ad-hoc prompt construction into a structured, programmable pipeline. By treating context assembly as an objective function, the framework enables systematic optimization of relevance, completeness, and token efficiency.

## Understanding the Mathematical Foundation

### Breaking Down the Equation

The core formalization appears in [`00_COURSE/00_mathematical_foundations/01_context_formalization.md`](https://github.com/davidkimai/context-engineering/blob/main/00_COURSE/00_mathematical_foundations/01_context_formalization.md) and defines the relationship:

- **C**: The final assembled context string that interacts directly with the LLM's input window
- **A**: The assembly function—a deterministic or adaptive algorithm that combines components according to specific strategies
- **c₁ … cₙ**: Individual context components that carry distinct semantic roles in the prompt

### The Six Canonical Components

The framework defines six canonical variables in the foundational documentation (lines 42-50 of [`01_context_formalization.md`](https://github.com/davidkimai/context-engineering/blob/main/01_context_formalization.md)):

- **c₁ – Instructions**: System prompts, role definitions, and behavioral constraints that establish the LLM's persona and operational boundaries
- **c₂ – Knowledge**: External facts, documents, and retrieved passages providing factual grounding for the response
- **c₃ – Tools**: Function-calling specifications, API descriptions, and tool schemas that enable external capabilities
- **c₄ – Memory**: Recent conversation history and long-term user profiles that maintain dialogue continuity
- **c₅ – State**: Current situational variables such as user location, time-of-day, or session metadata
- **c₆ – Query**: The immediate user request that the LLM must process and answer

## Implementing the Assembly Function A

The assembly function **A** is implemented in the `ContextAssembler` class as a family of strategies rather than a single algorithm. Each strategy optimizes for different latency, relevance, or complexity requirements while respecting the `max_tokens` constraint.

### Linear Assembly Strategy

The **linear strategy** orders components by fixed priority (`instructions → knowledge → tools → memory → state → query`) and concatenates them until the token budget is reached. This method appears in lines 93-125 of [`01_context_formalization.md`](https://github.com/davidkimai/context-engineering/blob/main/01_context_formalization.md):

```python
def assemble_linear(self, components: List[ContextComponent]) -> str:
    # Order by priority, respect token budget, truncate if needed

    ordered = sorted(components, key=lambda c: c.priority)
    result = []
    current_tokens = 0
    
    for comp in ordered:
        if current_tokens + comp.token_count <= self.max_tokens:
            result.append(comp.content)
            current_tokens += comp.token_count
        else:
            break
            
    return "\n\n".join(result)

```

### Weighted and Hierarchical Strategies

For knowledge-heavy scenarios, the **weighted strategy** scores each component by `relevance × weight` and selects the highest-scoring subset that fits within the token budget. Weights are configurable per use-case, allowing dynamic prioritization of critical components like **c₂** (knowledge) over **c₅** (state).

The **hierarchical strategy** groups components into semantic layers (foundation, integration, capabilities, request) and builds a nested structure that mirrors the logical flow of multi-step reasoning tasks.

### Adaptive Protocol Selection

The **adaptive strategy** implemented in `UnifiedContextEngineeringSystem` (lines 860-940) selects the optimal assembly method based on historical performance data. The `AdaptiveOptimizer` evaluates recent quality metrics—relevance, completeness, consistency, and efficiency—stored by `PerformanceMonitor`, then dynamically chooses between linear, weighted, or hybrid approaches.

## End-to-End Workflow in Practice

The complete implementation of C = A(c₁, c₂, ..., cₙ) follows a five-stage pipeline orchestrated by the `UnifiedContextEngineeringSystem`:

1. **Template selection** – The `TemplateLibrary` chooses prompt templates for each component based on query type and domain requirements.

2. **Component analysis** – The `ComponentAnalyzer` wraps raw inputs into `ContextComponent` data classes, scoring each for relevance, clarity, completeness, and token count (lines 53-85).

3. **Strategy optimization** – The `AdaptiveOptimizer` determines whether to use linear, weighted, or hierarchical assembly based on performance history.

4. **Context assembly** – The `ContextAssembler` executes the chosen strategy, producing the final string **C** while respecting token budgets.

5. **Quality assessment** – The `ContextQualityAssessor` evaluates the assembled context against relevance, completeness, consistency, and efficiency metrics, feeding any deficits back to the optimizer for iterative refinement.

The system returns a structured JSON object containing the formalized context, quality scores, assembly metadata, and learning insights for subsequent optimizations.

## Code Examples

### Simple Linear Assembly

The following example demonstrates basic linear assembly using the core classes defined in [`00_COURSE/00_mathematical_foundations/01_context_formalization.md`](https://github.com/davidkimai/context-engineering/blob/main/00_COURSE/00_mathematical_foundations/01_context_formalization.md):

```python
from context_engineering import ComponentAnalyzer, ContextAssembler

# Raw components (normally gathered from templates, retrieval, etc.)

raw = {
    "instructions": "# You are a helpful assistant\nYou must answer concisely.",

    "knowledge": "The Eiffel Tower is 324 m tall.",
    "tools": "function call: get_weather(location)",
    "memory": "User asked about Paris last turn.",
    "state": "Current time: 2026-02-28 14:00 UTC",
    "query": "What is the height of the Eiffel Tower?"
}

# Analyze each component (adds relevance scores, token counts)

analyzer = ComponentAnalyzer()
components = [
    analyzer.analyze_instructions(raw["instructions"], raw["query"]),
    analyzer.analyze_knowledge([raw["knowledge"]], raw["query"]),
    analyzer.analyze_knowledge([raw["tools"]], raw["query"]),
    analyzer.analyze_knowledge([raw["memory"]], raw["query"]),
    analyzer.analyze_knowledge([raw["state"]], raw["query"]),
    analyzer.analyze_knowledge([raw["query"]], raw["query"])
]

# Assemble with linear strategy (A = linear)

assembler = ContextAssembler(max_tokens=8000)
final_context = assembler.assemble_linear(components)

print(final_context)  # This is the concrete C

```

### Weighted Assembly with Custom Weights

For scenarios requiring component prioritization, use the weighted strategy with configurable weights:

```python
weights = {
    "instructions": 1.5,
    "knowledge": 2.0,
    "tools": 1.0,
    "memory": 0.8,
    "state": 0.5,
    "query": 1.0
}

assembler = ContextAssembler(max_tokens=8000)
final_context = assembler.assemble_weighted(components, weights)

print(final_context)

```

The weights reflect **relative importance** for specific tasks—for example, knowledge-intensive research assigns higher values to `c₂` while state-heavy applications prioritize `c₅`.

### Adaptive Protocol Usage

The high-level API demonstrates the complete adaptive pipeline implemented in `UnifiedContextEngineeringSystem` (lines 860-940):

```python
from unified_system import UnifiedContextEngineeringSystem

system = UnifiedContextEngineeringSystem()

user_query = "Give me a quick summary of the latest AI safety research."
resources = {
    "knowledge_sources": ["https://arxiv.org/abs/2305.12345", "OpenAI safety blog post ..."],
    "available_tools": ["search_api", "summarize_tool"],
    "conversation_history": [],
    "current_context": {}
}

result = system.formalize_context(user_query, resources)

print(result["formalized_context"])          # C

print(result["quality_assessment"]["overall"])  # quality score

```

## Summary

- The **C = A(c₁, c₂, ..., cₙ)** formalization provides a mathematical framework for context assembly, treating the process as a function where assembly function **A** combines six canonical components into final context **C**.
- The six components—instructions (**c₁**), knowledge (**c₂**), tools (**c₃**), memory (**c₄**), state (**c₅**), and query (**c₆**)—are defined in [`00_COURSE/00_mathematical_foundations/01_context_formalization.md`](https://github.com/davidkimai/context-engineering/blob/main/00_COURSE/00_mathematical_foundations/01_context_formalization.md).
- The assembly function **A** supports multiple strategies—**linear**, **weighted**, **hierarchical**, and **adaptive**—implemented in the `ContextAssembler` class to optimize for token budgets, relevance, and task complexity.
- The end-to-end pipeline involves `ComponentAnalyzer`, `AdaptiveOptimizer`, and `ContextQualityAssessor` classes, orchestrated by `UnifiedContextEngineeringSystem` (lines 860-940), enabling dynamic, learning-driven context construction.

## Frequently Asked Questions

### What does C represent in the C = A(c₁, c₂, ..., cₙ) formalization?

**C** represents the **final assembled context**—the concrete string or structured data that is actually fed to the LLM's input window at inference time. According to the source code in [`00_COURSE/00_mathematical_foundations/01_context_formalization.md`](https://github.com/davidkimai/context-engineering/blob/main/00_COURSE/00_mathematical_foundations/01_context_formalization.md), this is the only variable in the equation that directly interacts with the language model, representing the complete synthesis of all individual components after processing by the assembly function **A**.

### How does the assembly function A handle token budget constraints?

The assembly function **A** implements **token-budget-aware strategies** within the `ContextAssembler` class to ensure **C** never exceeds the model's context window. The **linear strategy** concatenates components by fixed priority until `max_tokens` is reached, explicitly checking `current_tokens + comp.token_count <= self.max_tokens` before inclusion. The **weighted strategy** selects the highest-scoring subset of components that fits within the budget, while the **adaptive strategy** dynamically adjusts selection based on historical token efficiency metrics.

### Can I add custom components beyond the six canonical ones?

Yes, the formalization supports **extending the component schema** beyond the six canonical variables (c₁ through c₆). The repository provides a JSON schema in [`context-schemas/context_v6.0.json`](https://github.com/davidkimai/context-engineering/blob/main/context-schemas/context_v6.0.json) that formalizes component structures, while [`40_reference/schema_cookbook.md`](https://github.com/davidkimai/context-engineering/blob/main/40_reference/schema_cookbook.md) demonstrates how to add custom components such as **c₇ for privacy constraints** or domain-specific metadata. The `ComponentAnalyzer` and `ContextAssembler` classes operate on generic `ContextComponent` objects, making the system agnostic to the specific number or semantic type of components processed by the assembly function **A**.

### Where is the UnifiedContextEngineeringSystem implemented?

The `UnifiedContextEngineeringSystem` class is implemented in [`00_COURSE/00_mathematical_foundations/01_context_formalization.md`](https://github.com/davidkimai/context-engineering/blob/main/00_COURSE/00_mathematical_foundations/01_context_formalization.md) at **lines 860-940**. This high-level orchestration class integrates the complete pipeline: it coordinates the `TemplateLibrary` for component selection, the `ComponentAnalyzer` for scoring, the `AdaptiveOptimizer` for strategy selection, and the `ContextQualityAssessor` for iterative refinement. The class exposes the `formalize_context()` method, which returns a structured JSON object containing the assembled context **C**, quality metrics, and learning insights for subsequent optimizations.