# Перетягування обмеженого неясного контексту: Що запам 'ятовується

<!-- category -- AI,Patterns,Architecture,LLM,DiSE -->
<datetime class="hidden">2026-01-06T16:00</datetime>

Однією з найпростіших способів пошкодити штучний інтелект - дозволити йому забагато запам 'ятати.

Більшість підходів "зрозумівання контекстуM SK1 зводяться до однієї з двох помилок

- **Помістити все в про prompt** і сподіваюсь, що модель зрозуміть, що має значення
- **Повторно переглянути підсумки** і сприймати дрейф як факт життя

Обидві підходи дорого коштують, непрозрачні , і нестабільні на довгому горизонтіM SK2

Існує кращий образец - МСК0, який відображає те, як біологічні системи насправді масштабують когніцію.

Я називаю це **Перетягування обмеженого неясного контексту** МSK0CFCD).

[TOC]

---


## Модель в одному реченні

> **Перетягування обмеженого неясного контексту** це модель, в якій можливими моделями запропонують, що є вагомим, але лише детерміністичними правилами можна передати цю вагомість вперед, щоб вплинути на майбутнє мислення або покоління.

Або ще ясніше:

> *Моделі можуть помітити*

Це те ж саме філософське розкол, що і [Стримана неясність](/blog/constrained-fuzziness-pattern) і [Обмежений фузій МСМ](/blog/constrained-mom-mixture-of-models) - щойно застосували вздовж **вісь часу** замість **вісь прийняття рішень**.

---


## Найважливіша помилка в тому, як сприймати контекст як текст

ЛЛМ не мають МСК0 пам 'ятайтеМSK1 Вони мають шаблон - співпадіння над символами МSK3

Коли ми розглядаємо контекст як "just more text", ми отримуємоM SK2

- тихий дрейф
- неоднозначна термінологія
- втрачена вартість
- підсумки, які суперечать попереднім підсумкам
- переклади, які перетворюють одне й те ж слово п 'ять разів
- контекст стає неверізованою залежністю ( ніхто не знає, що змінилося , але результати змінилися МSK2

Довгі контекстні вікна не розв 'язують цього. Вони просто затримають невдачі.

Справжнє питання - *скільки* контексту, щоб зберегти, алеM SK1

> **Що заслуговує на виживання?**

---


## Правило CFCD

CFCD стверджує жорстке відокремлення:

МSK0 Роль | Дозволено бути неяскравим МSK2 | Дозвволено стати майбутнім обмеженням
|------|---------------------|--------------------------------------|
| Вив 'язування слизистості МSK1 Так МSK2 Ні |
| Пропагування у контексті МSK1 Ні МSK2 Так |
МSK0 Покоління | Так MSК2 Ні МСК3
| Помешкання на прикріпленні МSK1Ледер МSK2 | Ні M| Так МСК5

Ймовірність може *запропонувати*. Детермінізм вирішує, що рухається вперед

Детерміністичне значення: **ті самі вхідні дані + ті самі правила МSK1 ті ж ланцюги**. Ви все ще можете використовувати ймовірністі бали ; ви просто прокручуєте їх через фіксоване підвищення МSK2 функції, що закінчуються

CFCD - це те, як ви отримуєте переваги контексту без платити за контекст

---


## До прикладу 1: Підсумування ( вертикальне перетягуванняM SK2

### Наївний підхід

- Дорожній документ
- Підсумувати кожен шматок
- Підсумувати підсумки
- Прийміть дрейф

Це не працює, тому що:

- поєднання ранніх помилок
- акцент змінюється навмисно
- протиріччя приховані

### Погляньмо на CFCD

Найголовніша думка: **виявлення salience не потребує LLM**. Ви можете використати детермінативний ML (вбудовані модулі МSK2 TF МSK3IDF \ , BM \ МSK5 для того, щоб знайти те, що має значення

[DocSummarizer](/blog/docsummarizer-advanced-concepts) implements this:

1. **Розглянемо документ у сегменти** ( реченняM SK1 заголовки , переліки МSK3 кодові блоки )
2. **Виgenerувати вбудова** використовуючи ONNX речення-трансформатори (MLM SK2 не LLM)
3. **Вирахуйте показники salience** за допомогою:
   - Схожість косину з документом центроїд
   - TF-IDF для значення терміну
   - Веси місця (introM SK1conclusion boost)
   - Содержание-регулювання типу M SK1наративний vs екзпозиторний)
4. **Виbierz верхню частину-K, використовуючи MMR** (Максимальна маргинальна важливістьM SK1
   - Досконалість балансу (подібність до центроїдів МSK1 з різноманіттю
   - Детерміністичне: ті самі вхідні дані M SK1 той самий вибір
5. **LLM синтезує лише з обраних сегментів**

LLM ніколи не бачить повного документу.

```csharp
// From DocSummarizer: SegmentExtractor.cs
public class SegmentExtractor
{
    private readonly OnnxEmbeddingService _embeddingService;  // ML, not LLM

    public async Task<ExtractionResult> ExtractAsync(string docId, string markdown)
    {
        // 1. Parse document into typed segments
        var segments = ParseToSegments(docId, markdown);

        // 2. For large docs: semantic pre-filtering with multi-anchor approach
        //    - Guaranteed coverage: first/last sentences per section, constraints
        //    - BM25 candidate generation with pseudo-query from TF-IDF terms
        //    - Topic anchors via k-means clustering on sample embeddings
        if (segments.Count > _config.MaxSegmentsToEmbed)
        {
            (segmentsToEmbed, centroid) = await SemanticPreFilterAsync(segments, targetCount);
        }
        else
        {
            await GenerateEmbeddingsAsync(segments);
            centroid = CalculateCentroid(segments);
        }

        // 3. Score by salience using MMR (deterministic)
        //    Salience = lambda * sim(segment, centroid) * position_weight * content_weight
        //             - (1 - lambda) * max_sim(segment, higher_ranked_segments)
        ComputeSalienceScores(segments, centroid, contentType);

        // 4. Return top-K as anchors for synthesis
        var topBySalience = segments
            .OrderByDescending(s => s.SalienceScore)
            .Take(Math.Max(_config.FallbackBucketSize, targetCount))
            .ToList();

        return new ExtractionResult
        {
            AllSegments = segments,
            TopBySalience = topBySalience,
            Centroid = centroid,
            ContentType = contentType
        };
    }

    /// <summary>
    /// Greedy MMR selection: balances relevance with diversity
    /// </summary>

    private void ComputeSalienceScores(List<Segment> segments, float[] centroid, ContentType contentType)
    {
        var candidates = new HashSet<Segment>(segments.Where(s => s.Embedding != null));
        var ranked = new List<Segment>();

        // Pre-compute centroid similarities with content-type adjustments
        foreach (var segment in candidates)
        {
            var baseSim = CosineSimilarity(segment.Embedding!, centroid);
            var contentWeight = ComputeContentTypeWeight(segment, contentType);
            segment.SalienceScore = baseSim * segment.PositionWeight * contentWeight;
        }

        // Greedy MMR: pick best, penalise similar, repeat
        while (candidates.Count > 0)
        {
            var best = candidates
                .Select(c => new {
                    Segment = c,
                    Score = _config.MmrLambda * c.SalienceScore
                          - (1 - _config.MmrLambda) * MaxSimToRanked(c, ranked)
                })
                .OrderByDescending(x => x.Score)
                .First();

            best.Segment.SalienceScore = 1.0 - ((double)ranked.Count / segments.Count);
            ranked.Add(best.Segment);
            candidates.Remove(best.Segment);
        }
    }
}
```

### Адаптивний вибір: Усвідомлення контексту

Тому що вихідний код **рейтингова колекція**, ви можете адаптувати число засадок до моделі синтезу під час запуску

```csharp
public class AdaptiveSynthesizer
{
    public int ComputeAnchorBudget(ModelProfile model, ExtractionResult extraction)
    {
        // Larger context windows → more anchors
        var baseTokenBudget = model.ContextWindow / 4;  // Reserve 25% for output

        // More powerful models → can handle more complex synthesis
        var complexityMultiplier = model.Tier switch
        {
            ModelTier.Small => 0.5,   // tinyllama: fewer, simpler anchors
            ModelTier.Medium => 1.0,  // llama3.2:3b: standard
            ModelTier.Large => 1.5,   // llama3.1:8b+: more context, nuanced synthesis
            _ => 1.0
        };

        var anchorBudget = (int)(baseTokenBudget * complexityMultiplier / _avgTokensPerSegment);

        // Never exceed what we have
        return Math.Min(anchorBudget, extraction.TopBySalience.Count);
    }

    public async Task<Summary> SynthesizeAsync(
        ExtractionResult extraction,
        ModelProfile model)
    {
        var budget = ComputeAnchorBudget(model, extraction);

        // Take top-K from already-ranked segments
        var anchors = extraction.TopBySalience.Take(budget).ToList();

        // Synthesis model only sees what survived selection + adaptation
        return await _llm.SynthesizeAsync(anchors, model);
    }
}
```

Це все ще детерміністичне: **ті самі вхідні дані + той самий модельний профиль МSK1 ті самі ланцюги**. Рейтинг відбувається один раз МSK1 адаптація - це лише шматок МSK2

Це означає, що

- Використовуйте швидку маленьку модель з анкерами 5 для швидких підсумків
- Використовуйте потужну модель з 50 засадками для комплексного аналізу
- Динамично врегулювати середню трубу -, якщо перший спроба не має по coverage

Найголовніша думка: **прикріплення - це структура, а не проза**. Вбудова та MMR є детерміністичними МSK1 LLM робить тільки остаточну синтезу МSK2 обмеженою тим, що вижили .

**Контракт на ancoraння:** генерація може відрізнятися формулюванням, але не повинна протистояти ланцюгам

Конкретне представлення锚а:

```json
{
  "policyVersion": "cfcd-v1",
  "segments": [
    {"id":"seg-12","text":"Reset requires holding button 10s","salience":0.92},
    {"id":"seg-45","text":"Factory reset clears all settings","salience":0.88}
  ],
  "coverage": "3.2% semantic sample",
  "hedging": "sampled 3% - avoid definitive conclusions"
}
```

---


## До прикладу 2: Перетворення

Перевод exposses this pattern even more clearly.

### Модій провалу

Перевести речення

- неоднозначна термінологія
- переименовані об 'єкти
- тонкий семантичний дрейф

Навіть з величезним контекстним вікном , моделі все ще " почуваються вільними МSK2 змінювати фрази

### Погляньмо на CFCD

1. Спочатку в уривок dokumentu, **кандидати в термінологію**:
   - відповідних іменників
   - технічні терміни
   - повторювані фрази
2. Збудувати **терміновий банкнот**:
   - джерело →
   - впевненість
   - перший-ви бачили місце розташування
3. Для кожного речення:
   - дозволити незрозумілий переклад
   - **стримати** вибір, використовуючи книгу
   - дозволити відхилення лише з сильним локальним доказом
4. Обновлюйте ledger детерміністично, якщо:
   - знов і знову з 'являється краще картування
   - або оголошується explicit override

**Що є сильним локальним доказом?**

- Термин з 'являється в словнику, таблиціM SK1 або блокі визначення ( структурні знакиMSC3
- В налаштуваннях explicit user override
- Повторюється впродовж останніх частин W (швидкішний вікноM SK1 з послідовним використанням

Це детерміністичне: структурні сигнали виявлені за допомогою класифікації шаблону або аналітикаM SK1 а не модельного судження.

Поліція за замовчанням МСК0 Δ МSK1 розрив у довірі , W=50 шматки M SK4 fortuna per domain ).

```csharp
public class TermLedger
{
    private readonly Dictionary<string, TermMapping> _mappings = new();

    public record TermMapping(
        string SourceTerm,
        string TargetTerm,
        float Confidence,
        string FirstSeenChunkId,
        int LastSeenChunkIndex,               // Track recency
        int VotesForCurrentTarget,
        int TotalVotes,                       // Preserve history
        string? ChallengerTarget = null,
        int ChallengerVotes = 0,
        float ChallengerConfidence = 0);

    public void ProposeMapping(string source, string target, float confidence, string chunkId, int chunkIndex)
    {
        source = source.ToLowerInvariant().Trim();

        if (_mappings.TryGetValue(source, out var existing))
        {
            if (existing.TargetTerm == target)
            {
                // Same as current: accumulate votes
                _mappings[source] = existing with
                {
                    Confidence = Math.Max(existing.Confidence, confidence),
                    VotesForCurrentTarget = existing.VotesForCurrentTarget + 1,
                    TotalVotes = existing.TotalVotes + 1,
                    LastSeenChunkIndex = chunkIndex
                };
            }
            else if (existing.ChallengerTarget == target)
            {
                // Same as challenger: accumulate challenger votes
                var newChallengerVotes = existing.ChallengerVotes + 1;
                var newChallengerConfidence = Math.Max(existing.ChallengerConfidence, confidence);

                // Switch if challenger has >= 2 votes AND higher confidence
                if (newChallengerVotes >= 2 && newChallengerConfidence > existing.Confidence)
                {
                    // Swap: old current becomes challenger, challenger becomes current
                    _mappings[source] = existing with
                    {
                        TargetTerm = target,
                        Confidence = newChallengerConfidence,
                        VotesForCurrentTarget = newChallengerVotes,
                        TotalVotes = existing.TotalVotes + 1,
                        LastSeenChunkIndex = chunkIndex,
                        ChallengerTarget = existing.TargetTerm,  // Preserve old mapping as challenger
                        ChallengerVotes = existing.VotesForCurrentTarget,
                        ChallengerConfidence = existing.Confidence
                    };
                }
                else
                {
                    _mappings[source] = existing with
                    {
                        ChallengerVotes = newChallengerVotes,
                        ChallengerConfidence = newChallengerConfidence,
                        TotalVotes = existing.TotalVotes + 1,
                        LastSeenChunkIndex = chunkIndex
                    };
                }
            }
            else if (confidence > existing.ChallengerConfidence)
            {
                // New challenger replaces old challenger
                _mappings[source] = existing with
                {
                    ChallengerTarget = target,
                    ChallengerVotes = 1,
                    ChallengerConfidence = confidence,
                    TotalVotes = existing.TotalVotes + 1,
                    LastSeenChunkIndex = chunkIndex
                };
            }
        }
        else
        {
            _mappings[source] = new TermMapping(
                source, target, confidence, chunkId, chunkIndex,
                VotesForCurrentTarget: 1, TotalVotes: 1);
        }
    }

    public string? GetCanonicalTranslation(string source)
    {
        source = source.ToLowerInvariant().Trim();
        return _mappings.TryGetValue(source, out var mapping)
            ? mapping.TargetTerm
            : null;
    }
}
```

У практиці ви також хочете, щоб голос застарів. ( або ліхтарне вікно. ) так, що ранні помилки не стають постійними. МSK3 Головне, що правило застарівання є детерміністичним.

**Чому це важливо для виправлення:** Якщо переклад перевертається: "factory reset " mid-documentM SK3 ви можете відокремити ledger і побачити точно, коли та чому

```
chunk-12: "factory reset" → "Werkseinstellungen" (votes: 3, conf: 0.82)
chunk-47: challenger "Zurücksetzen" reaches 2 votes, conf: 0.91
chunk-47: SWITCH - "factory reset" → "Zurücksetzen" (old mapping preserved as challenger)
```

Ніяких підозрювань МСК0 Ні МSK1модель тільки-но вирішила ". Невидимий, детерміністичнийМSK4 перевіряєтьсяM SK5

Це дає вам:

- локальна гнучкість (модель управляє формулюваннямиM SK1
- глобальна послідовність (лідер встановлює термінологіюM SK1
- обмежені витрати ( не обов 'язково перекладати
- перевірямі рішення ( залог піддається інспектації )

Ось чому **послідовність термінів** не можна розв 'язати за допомогою " тільки більше контекстуM SK1

---


## Це не пам 'ять - Це просування обмежень

CFCD робить **не** дати модель пам 'яті.

Він дає *система* пам 'ять.

Модель:

- не володіє державою
- не вирішує, що залишається
- не має власного контексту

Система:

- зберігає ланцюги
- нав 'язує обмеження
- закінчується
- чітко контролює тривалість життя

**Правила закінчування терміну** (детерміністичнийM SK1 немодельний -останавлений МSK3

- **Час-на основіM SK1** прикріплення закінчуються після `T` не звертаючись до
- **Використовуйте-на основі:** ланкери з нульовими відбитками `N` наступні шматочки руйнуються
- **Контрадіція-на основіM SK1** спірник має ≥2 голоси І перевершує теперішній рівень довіри ΔM SK1 в скрутному вікні частин W

Ця різниця - це все.

```mermaid
flowchart TB
    subgraph Model["Probabilistic Model"]
        M1[Detect Salience]
        M2[Generate Output]
    end

    subgraph System["Deterministic System"]
        S1[Promote Anchors]
        S2[Store in Ledger]
        S3[Enforce on Generation]
        S4[Expire Stale Context]
    end

    M1 --> S1 --> S2
    S2 --> S3 --> M2
    S2 --> S4

    style Model stroke:#f59e0b,stroke-width:2px
    style System stroke:#22c55e,stroke-width:3px
```

### Трубопровод CFCD

Ось модель з рахунком як першим об 'єктом klasy-

```mermaid
flowchart LR
    S[Stream: chunks/sentences] --> M[Model proposes salience]
    M --> P[Promotion rules]
    P --> L[Ledger / Anchors]
    L --> G[Generation constrained by anchors]
    G --> O[Output]
    L --> E[Expiry rules]
    E -.-> L

    style L stroke:#22c55e,stroke-width:3px
    style P stroke:#22c55e,stroke-width:2px
    style E stroke:#22c55e,stroke-width:2px
    style M stroke:#f59e0b,stroke-width:2px
    style G stroke:#f59e0b,stroke-width:2px
```

Зелені коробки - детерміністики. Оранжеві - ймовірностіM SK1 Переводник сидить між ними, тримаючи те, що вижилиMSC3

### Що змінилося в практиці?

Три зміни:

- Ви перестанете продовжувати прозу
- Ви наполегливо *надруковані ланкери*
- Ви сприймаєте рахунку як API,, а не прохання

Про prompt стає *перегляд* not the ledger itself.

Те, що - це момент - це не контекст

### Що зветься як Anchor?

Анкори не є "важливий текстM SK1 Вони є **надруковані, структуровані факти** що обмежують генерацію:

- **Термінологічні картографії**: `factory reset` → `restore factory settings`
- **Об 'єкти та ID**: `ProductName`, `ModelNumber`, `UserID`
- **Обмеження / інваріантів**: МSK1Reset потребує втримки кнопки
- **Настрої користувача / обмеження стилю**МSK0 "Використовуйте офіційний тонM SK2 ♫ ♫ МSK3 ♫ Британське правописання ♫ "
- **Метадані об 'єму**МSK0 "3.2% семантичний зразок МSK2
- **Версію**: `policyVersion: "cfcd-v1"`, `anchorSchemaVersion: 2`

Справа в тому, що ланкери не проза, вони структурні. Модель пише навколо них.

---


## Біологічне поєднання

*Це аналогія МСК0 не біологічна твердження МSK1 пунктом є вибіркова консолідація , не літеральний механізм.*

Мозок не відтворює весь сенсорний поток.

Вони:

- виявити привабливість
- сконsolidувати вибірково
- стримувати шум
- заморозити представлення, коли вони стали стабільними

Мова, МСК0, рухові здібності, МSK1 та сприйняття залежать від **стриманий ріст-вперед**, не сировий зворотній зв 'язокM SK1

CFCD - це той самий принцип

| Біологічна система
|------------------|-----------------|
| Зауважаність МSK1 Що помітити МSK2 | Вив 'язане слизистість мSK4 нерозбірливо M) мSK6
МSK0 Консолідація ( Що запам 'ятовувати МSK2 | Продвиження якорів
| Похибка МSK1 Що не слід ігнорувати МSK2 | Правила закінчування терміну служби M( детерміністична МСК5 МСК6
| Згадати МSK1 Що отримати МSK2 | Попит на Ledger

---


## Об 'єднати візерунки

CFMoM і CFCD - це одна і та сама ідея, яка розглядається з різних куточків:

| виміри МSK1 візерунок МSK2
|-----------|---------|
| Єдиний заявитель МSK1 [Стримана неясність](/blog/constrained-fuzziness-pattern) |
| Множество кандидатів МSK1 [Обмежений фузій МСМ](/blog/constrained-mom-mixture-of-models) |
| Довгий МSK1 горизонтальний контекст МSK2 Стримане схвильоване перетягування контексту |

Усі троє підтримують одне й те саме правило.

> **Ймовірність запропонує. Детермінізм залишаєтьсяM SK1**

Як тільки ви internalizуєте це правило,

```mermaid
flowchart LR
    subgraph CFP["Part 1: Constrained Fuzziness"]
        P1[Single Proposer] --> C1[Constrainer] --> O1[Output]
    end

    subgraph CFMoM["Part 2: Constrained Fuzzy MoM"]
        P2A[Proposer A] --> CS[Consensus Space]
        P2B[Proposer B] --> CS
        P2C[Proposer C] --> CS
        CS --> C2[Coordination Constrainer] --> O2[Output]
    end

    subgraph CFCD["Part 3: Context Dragging"]
        T1[Time T] --> A1[Anchors]
        T2[Time T+1] --> A1
        A1 --> C3[Constrained Generation] --> O3[Output]
    end

    style CFP stroke:#22c55e,stroke-width:2px
    style CFMoM stroke:#3b82f6,stroke-width:2px
    style CFCD stroke:#8b5cf6,stroke-width:2px
```

---


## Чому це не головне?

Тому що це

- знизує витрати на обчислення (не переM SK1розробка для консенсусу МSK2
- працює з маленькими моделями (anchors do heavyliftingM SK1
- здається нудним в демо. (не "репертуальна пам 'ять МSK2 заяви
- producs fewer dramatic failures (failures are explicitM SK1
- вимагає реального мислення систем. ( не тільки про prompt engineering )

Іншими словами, це оптимізує виробництво

---


## Анти-Patterns це замінює

| АнтиM SK1 Патерн МSK2 Проблема МSK3 Решение CFCD |
|--------------|---------|---------------|
| **Помістити все у контексті** | Нескінченна вартістьM SK1 розріджування уваги | Пропонувати тільки те, що виживає від селекції МSK3
| **Рекурсивне підсумування** | дрейф МSK1 протиріччя МSK2 Anchors are structure , not prose
| **Сподіваюсь, модель запам 'ятає** | Без жодних гарантій | Система має тривалість МSK2
| **Per-запрос повного переM SK1розробки** | Skalи витрат з історією | Переписник залишається на всіх запитах МSK2
| **Природний язык "memory"** | Семантичний дрейф МSK1 Надруковані ланкери МSK2 експлуатні мапи |
| **Один-масштаб-вписується в-всякий контекст** | Модель з пропускною спроможністю для відходів або голоду МSK1 Пристосовальне відрізання з сортованої колекції |

---


## Субстрат Implementation: Невичерпний

[Найяскравіший.Ефемеральний](https://github.com/scottgal/mostlylucid.atoms) є субстратом, який робить CFCD практичною.

- [Огонь і не забувай](/blog/fire-and-dont-quite-forget-ephemeral-execution) - філософія
- [Бібліотека швидкого виконання](/blog/ephemeral-execution-library) - Implementation
- [Ефемеральні сигнали](/blog/ephemeral-signals) - сигнал
- [Навчитися ЛРУ](/blog/learning-lrus-when-capacity-makes-systems-better) - чому значення має обмежена пам 'ять

| Ефемерний примітив МSK1 Роль CFCD МSK2
|--------------------|-----------|
| **Сигнал** | Candidate salience МSK1model proposesM SK2 |
| **Огранічені вікна** | Немає безмежних зв 'язків.
| **Правила виведення** | Забуття є явною
| **Вичерпнення Sliding** | Стальний контекст автоматично закінчується
| **Поширення сигналу** | Анкери рухаються вперед без мутації МSK1

Ефемеральний не " пам 'ятаєM SK1 Він **вирішує, що можна запам 'ятати, і на який час**.

Це саме те, що вимагає CFCD.

```csharp
public class CFCDCoordinator
{
    private readonly SignalSink _sink;
    private readonly TermLedger _ledger;
    private readonly TimeSpan _anchorLifetime = TimeSpan.FromHours(1);

    public void PromoteAnchor(string term, string translation, string chunkId, int chunkIndex)
    {
        _ledger.ProposeMapping(term, translation, 0.8f, chunkId, chunkIndex);

        // Emit signal for observability (key = chunkId for correlation)
        _sink.Raise($"anchor.promoted:{term}", key: chunkId);
    }

    public void ExpireStaleAnchors()
    {
        var cutoff = DateTimeOffset.UtcNow - _anchorLifetime;

        // Ledger entries older than cutoff without recent usage are removed
        // This is deterministic, not model-decided
        _ledger.ExpireOlderThan(cutoff);
        _sink.Raise("anchors.expired");
    }
}
```

---


## Втілення Скетч: Перевод Dokumentів

Об 'єднати їх для створення повної системи перекладу документів:

```csharp
public class CFCDTranslationPipeline
{
    private readonly ILlmService _llm;
    private readonly TermLedger _ledger;
    private readonly SignalSink _sink;
    private readonly int _seedChunks = 3;  // K: configurable seed window

    public async Task<TranslatedDocument> TranslateAsync(
        Document source,
        string targetLanguage)
    {
        var chunks = Chunker.Chunk(source, maxTokens: 500).ToList();
        var translated = new List<TranslatedChunk>();

        // Phase 1: Extract terminology candidates (first pass, fuzzy)
        // Seed from first K chunks: front-loads terminology, avoids churn later
        for (var i = 0; i < Math.Min(_seedChunks, chunks.Count); i++)
        {
            var chunk = chunks[i];
            var candidates = await _llm.ExtractTerminologyAsync(chunk);
            foreach (var term in candidates)
            {
                _ledger.ProposeMapping(
                    term.Source,
                    term.ProposedTranslation,
                    term.Confidence,
                    chunkId: chunk.Id,
                    chunkIndex: i);
            }
        }

        _sink.Raise("terminology.seeded");

        // Phase 2: Translate with ledger constraints
        for (var i = 0; i < chunks.Count; i++)
        {
            var chunk = chunks[i];

            // Get canonical translations for terms in this chunk
            var constraints = ExtractConstraints(chunk, _ledger);

            // Translate with constraints (model must respect ledger)
            var result = await _llm.TranslateWithConstraintsAsync(
                chunk,
                targetLanguage,
                constraints);

            // Update ledger with any new terms (deterministic rules)
            foreach (var newTerm in result.NewTerminology)
            {
                if (ShouldPromote(newTerm, _ledger))
                {
                    _ledger.ProposeMapping(
                        newTerm.Source,
                        newTerm.Target,
                        newTerm.Confidence,
                        chunkId: chunk.Id,
                        chunkIndex: i);

                    _sink.Raise($"anchor.promoted:{newTerm.Source}");
                }
            }

            translated.Add(result.Chunk);
        }

        return new TranslatedDocument(translated, _ledger.GetAllMappings());
    }

    private bool ShouldPromote(TermCandidate term, TermLedger ledger)
    {
        // Deterministic rules, not model judgment:
        // - Proper nouns always promoted
        // - Technical terms promoted if repeated
        // - Common words never promoted
        return term.Type == TermType.ProperNoun ||
               (term.Type == TermType.Technical && term.OccurrenceCount >= 2);
    }
}
```

---


## Закінчується думка

Більшість систем штучного інтелекту робить помилку, вважаючи, що розум покращується, запам 'ятовуючи *більше*.

Взагалі-то, інтелект МСК0 вирішує, що робити **ніколи більше не думати**.

CFCD - це те, як ви це робите, не брехаючи собі.

---


## Серіал

| частина МSK1 візерунок МSK2 вісь |
|------|---------|------|
| 1 | [Стримана неясність](/blog/constrained-fuzziness-pattern) | Едина компонента МSK1
| 2 | [Обмежений фузій МСМ](/blog/constrained-mom-mixture-of-models) | Багато компонентів МSK1
| МSK1 ♫ ♫ МSK2 ♫ Стримане схвильоване перетягування контексту ♫ ( ♫ цей artykuł ♫
| 4 | [Підсумовувач зображення](/blog/constrained-fuzzy-image-intelligence) | Практична Implementation МSK1

Усі три моделі мають однакову інваріантність: **ймовірнісні компоненти запропонують; детерміністичні системи тривають**.

І [Десять заповідей використання LLM](/blog/tencommandments) кодувати ці правила. [Архітектура DiSE](/blog/dise-architecture-overview) implements them for code evolution. [Розпізнавання Bot](/blog/botdetection-introduction) implements them for request classification. [DocSummarizer](/blog/docsummarizer-advanced-concepts) implements them for document retrieval. [ImageSummarizer](/blog/constrained-fuzzy-image-intelligence) implements them for image analysis.

Різні домени. Схожа модельM SK1 Спеціальне правило. [Доум-Суммарізер](/blog/doomsummarizer-deep-research) впроваджує відтягування контексту для паралельного довгого-форму генерації dokumentu M SK1 запуск сумісел , негативні про prompts M SK3 континуитет об 'єктів , і детекцію дрейфу підтримують послідовність над одночасними LLM wywołaннями MSC5

---


## Наступне: Практична Implementation

**Частина 4** тепер доступна: [Обкладач зображення : Конstrained Fuzzy Image RAG Engine](/blog/constrained-fuzzy-image-intelligence). Він реалізує всі три візерунки в хвилі - базується на аналізі зображення каналу МSK2 КолірWave обчислює факти M SK3 VisionLlmWave пропонує , ImageLedger накопичує важливі риси MSC5 і детерміністичне відбору обмежує вихідні дані MNK6 Клоні його з [github.comM SK1scottgal/lucidrag](https://github.com/scottgal/lucidrag).