# Dragging Constraint Fuzzy Context: Cosa viene ricordato Uno dei modi più facili per far fallire un sistema AI è lasciarlo ricordare troppo. La maggior parte degli approcci "context handlingM SK1 si riduce a uno dei due errori: - **Mettete tutto nel prompt.** E speriamo che il modello capisca cosa sia importante. - **Ripetitamente ri-summare i riassunti** e accettare la deriva come un fatto della vita. Entrambi gli approcci sono costosi, opaco, e instabili a lungo termineM SK2 C'è un modello migliore - che riflette il modo in cui i sistemi biologici scalano la cognizione . Io lo chiamo. **Dragging Contexto Fuzzy Constrained** (CFCD [TOC] --- ## Il modello in una sola frase > **Dragging Contexto Fuzzy Constrained** è un modello in cui i modelli probabilistici propongono ciò che è saliente, ma solo le regole deterministiche sono autorizzate a portare avanti quella salienza per influenzare il ragionamento futuro o la generazione. O più chiaramente: > *I modelli possono notare. L'ingegneria decide cosa rimane.* Questa è la stessa divisione filosofica. [Fuzzinesse limitata](/blog/constrained-fuzziness-pattern) e [MoM Fuzzy Constretto](/blog/constrained-mom-mixture-of-models) - è stato applicato lungo il **L'asse del tempo** Invece di **L'asse decisionale.**. --- ## L'errore principale: Trattare il contesto come un testo I LLM non "ricordate". Hanno uno schemaM SK2combaciano con i tokensMSC3 Quando trattiamo il contesto come " solo più testoM SK1 otteniamo: - Il movimento silenzioso - terminologia inconsistente - Il costo di fuga. - sommità che contraddichino i sommi precedenti. - traduzione che rinomina la stessa cosa cinque volte. - il contesto diventa una dipendenza non modificata ( nessuno sa cosa è cambiatoM SK1 ma i risultati sono cambiati) Le finestre del contesto più lunghe non lo risolvono. Rimangono solo in ritardo il fallimento. La vera domanda non è *Quanto?* Il contesto per mantenere, ma: > **Cosa merita di sopravvivere?** --- ## La regola del CFCD CFCD impone una separazione dura: | Role | Permessa di essere flessibileM SK2 | Permetteta di diventare un limite futuro? |------|---------------------|--------------------------------------| | Detezione della salinità | Sì | No S| | Promozione del contesto | No | Sì M| | Generazione | Sì | No S| | Conservazione dell'ancora (ledger) | No | Sì S| La probabilità può *suggerire*. Il determinismo decide cosa viene spinto avanti. Significa determinista: **Gli stessi input + la stessa politica ⇒ gli stessi ancor**. Potete ancora usare i punteggi probabilistici; li fate semplicemente passare attraverso una promozione fissaM SK2funzioni di decommissione (MMRMST4 RRFMSV5 regole di votoMSS6 La CFCD è il modo in cui si ottengono i benefici del contesto senza pagare il prezzo del contesto. --- ## Esempio 1: Summarisation (Vertical Dragging) ### L'approccio ingenuo - Documento in gran quantità - Somigliare ogni frammento - Raccogliere i riassunti - Accettare la deriva Questo fallisce perché: - combinazione di errori precoci - L'accento si sposta arbitrariamente. - Le contraddizioni sono nascoste. ### Approche del CFCD Il punto di vista chiave: **La rilevazione della salienza non richiede un LLM.**. Si può usare il ML deterministico (embeddings, TFM SK3IDFMSC4 BMMska5 per trovare ciò che contaMske6 e poi restringere l'LLM per vedere solo quello che è la selezione sopravvissuta. [DocSummarizer](/blog/docsummarizer-advanced-concepts) Implementa questo: 1. **Parlare il documento in segmenti.** (sentenziM SK1headings,listsMSC3code blocks ) 2. **Generare inserzioni** usando la frase ONNX-transformatori (MLM SK2 non LLMMSC3 3. **Computare i punteggi di salienza.** usando: - La somiglianza di cosine al centroide del document. - TF-IDF per l'importanza a termine - Pesi di posizione (introM SK1innalzamento della conclusione) - Contenuto-aggiustamenti di tipo M SK1narrative vs expository) 4. **Selezionate in alto-K usando MMR** (Relevance Marginale MaximaleM SK1 - Balance la rilevanza (similarità al centroideM SK1 con la diversità - Deterministici: gli stessi input → la stessa selezione 5. **LLM sintetizza solo da segmenti selezionati.** Il LLM non vede mai il documento completo. Genera intorno agli ancori, non attraverso loroM SK2 ```csharp // From DocSummarizer: SegmentExtractor.cs public class SegmentExtractor { private readonly OnnxEmbeddingService _embeddingService; // ML, not LLM public async Task 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 }; } /// /// Greedy MMR selection: balances relevance with diversity /// private void ComputeSalienceScores(List segments, float[] centroid, ContentType contentType) { var candidates = new HashSet(segments.Where(s => s.Embedding != null)); var ranked = new List(); // 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); } } } ``` ### Selezione adattativa: Sensibiltà alla finestra del contesto Perché il risultato è un **Raccolta in classifica**, si può adattare il numero di ancori al modello di sintesi durante l'attivazione. ```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 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); } } ``` Questo è ancora deterministico: **Gli stessi input + lo stesso profilo del modello → gli stessi ancri**. Il ranking avviene una voltaM SK1 l'adattamento è solo un pezzo. Questo significa che si può: - Utilizzate un piccolo modello veloce con ancor 5 per i rapidi esami. - Usate un modello potente con ancor 50 per un'analisi approfondita. - Adjustare dinamicamente il mid-pipeline se la prima prova non ha copertura. Il punto di vista chiave: **I cavi sono strutturali, non prosa.**. Gli inserimenti e il MMR sono deterministiciM SK1 Il LLM fa solo la sintesi finale, delimitato da ciò che è sopravvissuto **Contratto diancora:** La generazione può variare la formulazione, ma non deve contraddizionare le ancorheM SK1 Se le ancore sono insufficienti, deve essere protetta e / o chiedere più proveMSC4 Una rappresentazione di un ancraggio di cemento: ```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" } ``` --- ## Esempio 2: Traduzione (Dragaggio posteriore) La traduzione mostra ancora più chiaramente questo schema. ### Il modo di fallimento Traslate la frase-da-sentenza e otteneteM SK2 - terminologia inconsistente - Entità rinominate - delicata deriva semantica Anche con un'enorme finestra di contesto, i modelli ancora " sembrano liberiM SK2 per variare le frasi . ### Approche del CFCD 1. All'inizio del documento, estratto **Candidati terminologici.**: - Nomeni appropriati - i termini tecnici - frasi ripetute 2. Costruire una **Indicatore di termine**: - Source → mappatura del bersaglio - Confidenza. - primo-localizzazione vista 3. Per ogni frase: - permettere una traduzione confusa - **condurre.** Le scelte che si fanno usando il ledger. - consentire una deviazione solo con forti prove locali. 4. aggiornare il ledger in maniera determinista se: - Una migliore mappatura appare ripetutamente. - O è stato dichiarato un sovrarido esplicito. **Quello che conta come forte prova locale?** - Il termine appare in un vocabolario, tabulca, o blocco di definizione (cue strutturaleM SK3 - Override implicito dell'utente nella configurazione - Ripetito all'interno degli ultimi frammenti W (sliding window) con uso consistente Questo è deterministico: i segnali strutturali vengono rilevati tramite la classificazione dei modelli o del parsatoreM SK1 non lo studio dei modelli. La politica di default: ΔM SK1 L'incertezza di fiducia, W =50 blocchi MST4 fortuna per dominioMSC5 ```csharp public class TermLedger { private readonly Dictionary _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; } } ``` In pratica volete anche la decasione del voto (o una finestra scorrere ) così che gli errori precoci non diventino permanentiM SK3 La chiave è che la regola della decazione sia determinista, non modelloMSC5deciziataMST6 **Perché questo è importante per la debugging:** Se la traduzione ruota "factory reset" midM SK2document , si può differenziare il ledger e vedere esattamente quando e perché. ``` 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) ``` Niente indovinare. No "il modello è appena decisoM SK2 Inspicchabile , deterministicoM Sk4 verificabileM sk5 Questo ti dà: - La flessibilità locale (il modello gestisce il phrasing) - coerenza globale (l'agente delegato impone la terminologia) - Costo limitato (non c'è bisogno di ripensareM SK1traduzione per la coerenza) - Decisioni verificabili (l'accompagnatore è controllabileM SK1 Ecco perché. **coerenza terminologica** non può essere risolto con " solo più contesto". --- ## Non è memoria - E' propagazione di restrizioni La CFCD lo fa. **Non.** dare la memoria del modello. E' una cosa che dà *Il sistema* memoria. Il modello: - Non ha lo stato. - Non decide cosa persista. - non possiede il contesto Il sistema: - Raccolgono le ancorne. - Fornisce confini. - Termina la salienza stagnante. - controlla esplicitamente la durata della vita. **Regole di scadenza** (deterministaM SK1 non modello-decittoMSC3 - **Tempo-based:** Le cavie expirano dopo. `T` senza essere riferita. - **Usare-based:** Ancor con zero colpi sopra. `N` i frammenti successivi decadono. - **Contradizione-based:** Il contestatore ha ≥2 voti E supera la fiducia attuale di ΔM SK1 in una finestra di blocchi W. Questa distinzione è tutto. ```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 ``` ### Il Pipeline CFCD Ecco il modello con il ledger come primo oggetto della classe -: ```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 ``` Le scatole verdi sono deterministe. Le squadre arancione sono probabilistice. Il ledger si siede tra di loro , tenendo ciò che è sopravvissutoM SK3 ### Quali sono i cambiamenti nella pratica? Tre quarti: - smettete di fare prose persistente. - Si insiste. *Ancor stampate* - Trattiamo il ledger come un API, non come un prompt. Il prompt diventa un *Vedere* del ledger, non il ledger stesso. Quello ' è il momento "grok"M SK3 Il ledger non è il contesto . È un contratto. ### Cosa conta come anchoro? Gli ancor non sono "testo importante". Sono **i fatti strutturati,** che limitano la generazione: - **Mappe terminologiche**: `factory reset` → `restore factory settings` - **Entità e ID**: `ProductName`, `ModelNumber`, `UserID` - **Constrizioni invarianti /**: "La resettazione richiede un pulsante di comando. - **Preferenze degli utenti Constrizioni di stile /**: "Use formal tone", ≥"Spellazione ingleseM SK4 - **Metadati di copertura**: "3.2% campione semanticoM SK2 \5 ancori" - **La versione**: `policyVersion: "cfcd-v1"`, `anchorSchemaVersion: 2` Il punto è che le ancorhe non sono prosa, sono strutture, il modello scrive intorno a loro. --- ## Alignamento biologico *Questa è un'analogia, non una affermazione biologica: il punto è la consolidazione selettivaM SK2 non il meccanismo letterale .* I cervelli non riproducono l'intero flusso sensoriale. They: - rilevare la salienza. - Consolidare selettivamente. - inibire il rumore. - congelare le rappresentazioni una volta stabile. La lingua, le capacità motori, e la percezione si basano tutti su **Carriere limitata-forward**, non richiamo grezzo. Il CFCD è lo stesso principio, implementato meccanicamente. | Systemo biologico | Equivalente CFCD | |------------------|-----------------| | Attenzione (Cosa notare) | Detezione della salinità | Consolidazione (ciò che ricordare) |Promozione dell'ancora SSK4deterministaM SK5 | Inhibizione (Cosa ignorare) |Regole di deterrimento SSK4deterministicheM SK5 | Ricominciare (che cosa cercare) | Chiedere il foglio SSK4deterministaM SK5 | | --- ## Unificare i modelli CFMoM e CFCD sono la stessa idea vista da diversi angoli: | Dimensioni | Pattern | |-----------|---------| | Progettore singolo | [Fuzzinesse limitata](/blog/constrained-fuzziness-pattern) | | Molti proponenti | [MoM Fuzzy Constretto](/blog/constrained-mom-mixture-of-models) | | LongM SK1Contexto horizontale | Dragging Constraint Fuzzy Contexto Tutti tre rispettano la stessa regola: > **Probabilità propone. Il determinismo persiste.** Una volta che si interiorizza quella regola, la maggior parte "il design del sistema AIM SK2 smette di essere misterioso. ```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 ``` --- ## Perché questo non è mainstream Perché è così. - Riduce l'affluenza di calcolo (no reM SK1processo per la coerenza) - Funziona con piccoli modelli (ancor fanno il sollevamento pesante) - Sembra noioso in una demo. - produce meno fallimenti drammatici (failure sono esplicite) - Richiede pensare a sistemi reali (non solo ingegneria rapida) In altre parole: è ottimizzato per la produzione, non è insinuanteM SK2 --- ## Anti-Patterns lo sostituisce | Anti--Pattern | Problemo | Soluzione CFCD M| |--------------|---------|---------------| | **Mettete tutto nel contesto.** | Costo senza limitiM SK1 diluzione dell'attenzione | promuovere solo quello che sopravvive alla selezione | **Ricursiva sommificazione** | DriftM SK1 contraddizioni | Gli ancor sono strutturati, non prosa | | **Spero che il modello si ricordi.** | Nessuna garanzia | Il sistema possiede la persistenza | | **Per-request full re-processing** | Scale dei costi con storia | Il ledger persiste per tutte le richieste PSK2 | **linguaggio naturale "memory"** | Distorsione semantica | Ancore digitate, mappamenti espliciti MSC3 | **Uno-grandezza-combacia con l'-intero contesto** | Modello per la capacità di scarico o per l'infiammazione | Pieghe adattative dalla raccolta classificata | --- ## Substrate di Implementazione: Efemerale [Mostlylucid.Ephemeral](https://github.com/scottgal/mostlylucid.atoms) è il substrato che rende pratica la CFCD. Se non avete letto gli articoli di fondo' - [Fire and Don't Quite Forget](/blog/fire-and-dont-quite-forget-ephemeral-execution) - la filosofia - [Biblioteca di Esezione Efemerale](/blog/ephemeral-execution-library) - Implementazione - [Signali efemerali](/blog/ephemeral-signals) - segnale-coordinazione guidata - [Imparare LRU](/blog/learning-lrus-when-capacity-makes-systems-better) - perché la memoria limitata è importante | Primitivi ephemeri | Role del CFCD | |--------------------|-----------| | **I segnali** | Candidata salienza (modello propone) | | **finestre limitate** | No unbounded "memory | **Regole di Evizione** | Il dimenticare è esplicito | | **L'expizione a cascata** | Il contesto dello stop si spegne automaticamente | | **La propagazione del segnale** | Gli ancrasi portano avanti senza mutazione | Ephemerio non "ricordate". È **Decide cosa può essere ricordato, e per quanto tempo.**. Questo è esattamente quello che richiede la 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"); } } ``` --- ## Sketch di Implementazione: Traduzione del Documento Metterli insieme per un'intera catena di traduzione del documento: ```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 TranslateAsync( Document source, string targetLanguage) { var chunks = Chunker.Chunk(source, maxTokens: 500).ToList(); var translated = new List(); // 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); } } ``` --- ## Conclusione della mente L'errore che fanno la maggior parte dei sistemi AI è supporre che l'intelligenza migliora ricordando. *più*. In pratica, l'intelligenza si basa sul fatto di decidere cosa fare. **Non dovremo più pensarci.**. CFCD è il modo in cui lo fai senza mentire a te stesso. --- ## La serie | Parte | Tipo | Asse S| |------|---------|------| | 1 | [Fuzzinesse limitata](/blog/constrained-fuzziness-pattern) | Componente unica | | 2 | [MoM Fuzzy Constretto](/blog/constrained-mom-mixture-of-models) | Numerosi componenti | | 3 ≥| Dragging Constraint Fuzzy Contexto (Questo articolo) ♫| Tempo ♫ / memoria ♫ | 4 | [Summarizatore dell'immagine](/blog/constrained-fuzzy-image-intelligence) | Implementazione pratica | Tutti i tre modelli hanno la stessa invariante: **Componenti probabilistice propose; sistemi deterministici persistono**. L'informazione figura nella parte dispositiva. [Dieci comandamenti dell'uso del LLM](/blog/tencommandments) codificare queste regole. [L'architettura di DiSE](/blog/dise-architecture-overview) li implementa per l'evoluzione del codice. [Detezione del bot](/blog/botdetection-introduction) li implementa per classificare le richieste. [DocSummarizer](/blog/docsummarizer-advanced-concepts) li implementa per la ricerca del documento. [ImageSummarizer](/blog/constrained-fuzzy-image-intelligence) li implementa per l'analisi delle immagini. Domeni diversi. Stesso schema. Stessa regolaM SK2 [DoomSummarizer](/blog/doomsummarizer-deep-research) implements context dragging for parallel long-form document generation - running summariesM SK2 negative prompts, entity continuityMSC4 and drift detection maintain coherence across concurrent LLM calls --- ## Next: Implementazione pratica **Parte 4** Ora è disponibile: [Summarizer Image : Un motore RAG di immagini constratte Fuzzy](/blog/constrained-fuzzy-image-intelligence). Implementa tutti i tre modelli in una onda - basato su un tubo di analisi dell'immagineM SK2ColorWave calcola i fatti, VisionLlmWave proponeMSC4 ImageLedger accumula caratteristiche salientiMST5 e la selezione deterministica limita il risultatoMst6 Lo clona da [github.comM SK1scottgal/lucidrag](https://github.com/scottgal/lucidrag).