begränsad otydlighet : Ett kontrollsystemsmönster för sannolikhetskomponenter

Monday, 05 January 2026

2026-01-06ET14:00

Det mönster som kom fram

Det började med min blogg översättningsverktyg. Cachet bevarade bara ♫ 5 ♫ uppgifter per användare ♫ МSK2 ♫ med ♫6- ♫ timmar av absolut och ♫

De flesta utvecklare skulle se dessa som begränsningar för att arbeta kring. Men kasken blev själv-tvättande och själv-specialiserande. Den bevarade vad användaren behövde och glömde vad de inte gjorde. var systemet.

Jag extraherade det primitiva till Mostlylucid.Ephemeral: begränsad samspelning , glittrande utgångsdatum M SK2 signal -baserad koordinering mellan aktiviteterna MSC4 Samma idé generaliserade

Pattern visade sig hela tiden. I DiSE, LLM utvecklar koden , men enhetens tester och kvalitetkontroller bestämmer vad som överlever M SK2 LL: n föreslår Bot-detektor, känseldetektorer får poäng till målsättningar , men policyschwellor tvingar till slutsatsen, . i kundenintelligens, , LLM genererar beteendesegment, M SK4 men mätte mätvärden begränsar vad de kan påstå

Fyra system . Samma form. Begränsningen är alltid läraren

En begränsning förvandlar tvetydighet till en tvingad val. resurser (, storlek, ,, tid, ,, kostnad, M SK3, ibland ' epistemiska ( bevis

flowchart LR
    subgraph Constraint["The Constraint (Primitive)"]
        C1[Constrained Size]
        C2[Sliding Expiration]
    end

    subgraph Emergence["Emergent Behavior"]
        E1[Selective Forgetting]
        E2[Focus on Relevance]
        E3[Self-Optimization]
    end

    C1 --> E1
    C2 --> E1
    E1 --> E2
    E2 --> E3

    style Constraint stroke:#ef4444,stroke-width:2px
    style Emergence stroke:#22c55e,stroke-width:2px

Detta är grundinsikten Semantisk intelligens och DiSE (Inriktad syntetisk evolution):

Begränsningar don't limitera intelligensen . Begränsande skapa ett användbart beteende i system som annars driftar

LRU-skiffern under tryck . LLM begränsad av beräknings fakta. Heuristiska modell begränsade av policyschwellor. Varje begränsning tvingar systemet att fatta beslutMSC3 Dessa beslut skapar urvaltrycketM SK4

System ♫	♫ Begränsning ♫( ♫ Primitiv ♫
LRU Cache			Storleksgränsen	+	Ruttrande utgång	МSK3	glömmer irrelevanta mönster
LLM sammanfattare	Det måste citera källskivor ♫	♫ Kan ♫ ' ♫ hallucinera osupporterade påståenden ♫
Bot Detector	Politiska tröskeln		(0.3/0.95)	Skrattar bara när det är verkligt osäkra
Image Captioner	Beräknad färgpalette	Kan m' uppfinna färger som inte finns M' existerar

Samma mönster

TL;DR: Låt probabilistiska modeller föreslå; låter deterministiska system bestämma. Beräkna fakta som du kan bedöma , låta AI tolka dem , och sedan validera varje påstående mot de fakta som är bevisade

Pattern Kaart


Intens	Använd sannolikhetskomponenter säkrat i system med riktiga garantera
Krafter	Höga - varierande utgångspunkter , tystna misslyckanden M SK3 begränsad databeräkningar
Lösningen	Aggregat	fakta	МSK2	→	författaren	(	osäkerhet	)	→	motverkare	validera	SMK8	skriva om	SKS9	budget	MVK10	SVK11	utfall	VMK12	fallback	MMK13
Konsequenser	Mer ingenjörskonst i förspetsningen ; dramatiskt säkrare utveckling och operationer

Vad får du:

Klarare misslyckande former ( nedbrytna utgångar med revīzijasspår , inte tyst korruption
Säkerare evolution ( omvandla förslaget fria ♫ ♫ ; ♫ hindren fångar fel ♫
Modell-agnostik arkitektur M SK1swap 7B för gränsen utan strukturella förändringar)

Vad det kostar:

Mer röra framifrån : du bygger bevisutvinning och mätningar innan du ser vinsten

Begränsad otydighet

Begränsat här betyder begränsat: hårda gränser som tillämpas mekaniskt snarare än genom att förhandlas med hjälp av instruktioner, . budgetar, M SK2, invarianter, ,, och konstrainer, (, validera, ♫ +, omskriva dörrarna igen, ), som fysiskt förhindrar överskridande, MSC7, inte ", vissa bevakningsvägar, МSK9 eller ", de bästa,-, ansträngning av kraften,

Efter att ha byggt system i väldigt olika områden (document Summarization, bildanalysM SK2 botdetektorn , dataqueryingMSC4 så fortsatte den här arkitekturen att framträda

flowchart TB
    subgraph Input
        I[Input Data]
    end

    subgraph Truth["Deterministic Substrate (Truth Layer)"]
        T1[Compute Facts]
        T2[Extract Evidence]
        T3[Calculate Metrics]
    end

    subgraph Fuzzy["Fuzzy Proposer (Creativity Layer)"]
        F1[Generate Proposals]
        F2[Score/Rank]
        F3[Synthesize Output]
    end

    subgraph Constrain["Constrainer (Contract Layer)"]
        B1{Acceptable?}
        B2[Rewrite/Hedge]
        B3[Enforce Limits]
    end

    subgraph Output
        O[Constrained Result]
        D[Degraded Fallback]
    end

    I --> T1 --> T2 --> T3
    T3 --> F1 --> F2 --> F3
    F3 --> B1
    B1 -->|"Full"| B3 --> O
    B1 -->|"Partial"| B2 --> B3
    B1 -->|"None"| D

    T3 -.->|"Evidence"| B1

    style Truth stroke:#22c55e,stroke-width:3px
    style Fuzzy stroke:#f59e0b,stroke-width:3px
    style Constrain stroke:#ef4444,stroke-width:3px

Kerninsikten: låta sannolikhetskomponenterna föreslå ",", men aldrig låta dem bestämma. Använd dem för vad de är bra på

Vad som gör detta mönster kraftfullt är dess flexibilitet.

En LLM som genererar sammanfattningar av naturliga språk
En heuristisk modell med lärde vikter som ger en robot sannolikhet att få poäng
Ett synmodell som föreslår bildcaptioner
En samling svaga klassificerer som röstar på ett beslut

Architekturen är densamma. Bara komponenterna ändras.

Problemet: Begränsade system misslyckas tyst

Utan begränsningar, misslyckas probabilistiska system på sätt som är svåra att upptäcka och omöjligt att förhindra

flowchart LR
    subgraph Unconstrained["❌ Unconstrained System"]
        U1[Input] --> U2[LLM/Model]
        U2 --> U3[Output]
    end

    subgraph Constrained["✓ Constrained System"]
        B1[Input] --> B2[Compute Facts]
        B2 --> B3[LLM/Model]
        B3 --> B4{Validate}
        B4 -->|Pass| B5[Output]
        B4 -->|Fail| B6[Fallback]
    end

    style Unconstrained stroke:#ef4444,stroke-width:2px
    style Constrained stroke:#22c55e,stroke-width:2px

Oändliga avbrottsmodi:

LLM beskriver colors som inte existerar i bilden
sammanfattningar citerar fakta som inte dyker upp någonstans i källmaterialet
Bot-detektorresultat fluktuerar enormt baserat på orelevanta signaler
En lärd heuristisk drift när trafikbilder förändras och tyst blockerar legitima användare
SQL-sökningar inkluderar UPDATE och DELETE-uttalande när du bara ville läsa
kostnaderna spiraliserar när marginalfall konsumerar oändliga resurser

Instinkt är att lägga till mer uppmuntrande, mer exempel, mer mjuka bevakningsvägar, . Men sannolikhetssystem kan inte lita på att de respekterar mjuka gränser.

De tio budorden

Pattern kristalliserades till operationella regler som koderifierar begränsad fuzziness (selekteradM SK1

Kommandot	Begränsad fuzziness översättning
I. LLMs ska inte äga stat	Staten lever i substratet , inte som förespråkare
II. LLMs ska inte vara den enda orsaken till	Konstrainern lovar ; som LLM föreslog
IV. Använd LLM där sannolikheten är accepterad	Klassifiering, sammanfattningM SK2 klassificering
V. Säg aldrig till en LLM att bestämma om en deribar booleer	Om du kan beräkna det, beräknat det.
VIII. Demotera LLM till rådgivaren , inte agent	Förespråkare, inte beslutare

Belöningen du behöver inga gränsmodeller. En liten lokal LLM på handelshardware blir en kraft multiplikator när den gör klassificering och hypotes generation, ,, utan att låtsas vara en databas eller statmaskin.

Kontrolteorins koppling

Pattern har djupa rötter i kontrollteori: den administratör som begränsar en hög förändringsprocess

Classical Control:       Steam Engine → Governor → Constrained Speed
Constrained Fuzziness:   LLM/Heuristic → Constrainer → Constrained Output

Du får inte motorn att explodera. Du hindrar den fysiskt.

Förknippade verk för den akademiskt riktade:

Herbert Simon's begränsad rationalitet - beslut
"En övergripande undersökning av RAG" (2024) | | - | sökning | - | ökade gener
Mitchell's | " | Behovet av fördomar i lärande Generaliseringar | | " |

Vad sägs om Frontier-modeller?

Den uppenbara motsägelsen, men GPT, skulle vara så bra att dessa begränsningar skulle klara sig.

Kanske. Frontier-modeller kan papper över många luckor som mindre system exponerar.

Men "färre än vanligt " är inte

Den små modeller artikel utforskar detta i djupet, men den grundläggande insikten är gränsmodeller misslyckas annorlunda, inte mindre. Deras misslyckanden är semantiska snarare än strukturella. svårare att upptäcka

Mer viktigt: prompt engineering kan inte ersätta ingenjörskonst. Oavsett hur bra modellen blir , kvarstår dessa problem

Problemet	Varför kan prompting lösa det?
Stadsstyrning	Modeller har ingen uthärdlig minne över samtalen
Nebeneffekter	Modeller kan rekommendera handlingar men kan inte garantiera Execution
Vridbarhet		"	Modellet sade så	"	är inte ett accepterat auditspår
Determinism	Samma prompt kan generera olika utgångar
kostnaderna i skala			Per	-	prismönster med volym	МSK3

Även om en gränsmodell skulle kunna pålitligt producera rätt utgång 99.9% av tiden , behöver du fortfarande

Validering för att fånga 0.1%
Fallbacks när validering misslyckas
Att logga in för att förstå vad som hände
Metrik för att spåra drift över tid

Att "'" är konstrainerlayern, ".", Du , ' , bygger den ändå.

Skillnaden är huruvida du bygger den före misslyckanden lär dig varför det är viktigt efter. Konsträngd Fuzziness säger: :, bygg den först , ., så blir modellens storlek ett tillvägagångsval, ,, inte en arkitektonisk modell, .. Ett 7, B-modell med bra begränsningar presterar ofta bättre än ett gränsmodell med dåliga begränsingar,

Modellvalsförändringar hur ofta du träffar konstrainern.

Implementering av begränsad fuzziness

1. Definiera dina invarianter

Vad måste aldrig ska överträdas?

public class SummaryInvariants
{
    public bool ValidateSummary(Summary summary, SourceDocument source)
    {
        // No claims without evidence pointers (e.g., "[chunk-3]" must exist in source)
        if (summary.Claims.Any(c => !source.ChunkIds.Contains(c.EvidenceChunkId)))
            return false;

        // No color assertions unless we computed a palette from the image
        if (summary.ColorClaims.Any() && !source.HasComputedPalette)
            return false;

        // No PII in output
        if (PiiDetector.ContainsPii(summary.Text))
            return false;

        return true;
    }
}

De vanliga invarianterna är::

Inga påståenden utan bevissfoster
Inga färger förutom de kommer från paletsstatistiker
Ingen PII-utsläpp
Inga skrivningar, bara läsad- endast SQL
Ingen identitets-attribution om inte det är explicitt grundat

2. ordnar hårda budgeter

Vad måste alltid vara begränsad?

public record ProcessingBudget(
    int MaxContextTokens = 4000,
    int MaxModelCalls = 5,
    TimeSpan MaxLatency = default,  // e.g., 30 seconds
    int MaxVramMb = 2048,
    decimal MaxCostUsd = 0.10m
)
{
    public ProcessingBudget() : this(MaxLatency: TimeSpan.FromSeconds(30)) { }
}

Budjetet är inte en föreställning, det är en strömbrytare. När det överskrids, så bryts systemet graciöst, istället för att fortsätta smälta resurserna.

3. Att bygga dina grindsorter

vanliga trepunktstrainer du kommer att återanvända över olika system

Schema-grind: JSON-schemat + typsvalidation

public class SchemaGate<T>
{
    public (bool Valid, T? Result, string? Error) Validate(string json)
    {
        try
        {
            var result = JsonSerializer.Deserialize<T>(json, _options);
            return (true, result, null);
        }
        catch (JsonException ex)
        {
            return (false, default, ex.Message);
        }
    }
}

Evidence Gate: Varje claim måste länka till källskivor

public class EvidenceGate
{
    public Summary EnforceEvidence(Summary proposed, IReadOnlySet<string> sourceChunkIds)
    {
        // Keep only claims that reference chunks we actually have
        var validClaims = proposed.Claims
            .Where(claim => sourceChunkIds.Contains(claim.EvidenceChunkId))
            .ToList();

        return proposed with { Claims = validClaims };
    }
}

Politiska grinden: Privatsphäre Budgetgate: tid Omskriv gaten igen: Omvandla påståenden till riskfyllda deklarationer

4. Definiera felbehandling

När den otydliga delen misslyckas, don ' inte kraschar. Degrader

public async Task<SummaryResult> SummarizeWithFallback(Document doc)
{
    try
    {
        var proposed = await _llm.GenerateSummary(doc);
        var constrained = _constrainer.Enforce(proposed, doc);

        if (constrained.Claims.Count > 0)
            return SummaryResult.Success(constrained);

        // LLM output was entirely invalid. Fall back to extractive
        return SummaryResult.Degraded(
            _extractiveSummarizer.Summarize(doc),
            reason: "LLM claims failed validation");
    }
    catch (BudgetExceededException ex)
    {
        // Log for evolution, return deterministic-only
        _logger.LogWarning(ex, "Budget exceeded for {DocId}", doc.Id);
        return SummaryResult.Degraded(
            _extractiveSummarizer.Summarize(doc),
            reason: ex.Message);
    }
}

Huvudprinciperna:

Degradera elegant till deterministiska
Ge tillbaka den delaktiga utgången med explicita osäkerhetsmarkörer
Protokollera oäkta förslag som utbildningssignaler för snabb utveckling

verkliga-World exempel

LLM-Based Systems (BriefM SK2

System ♫	♫ Substrate ♫	♫ Förespråkare ♫
DocSummarizer	BERT `[chunk-N]`)
Beeldskapande	ImageSharp-paletten/ mätdata	FlorenceM SK3LLaVA-beteckningen ♫	Färger på färg måste matcha beräkningspalettet ♫
DataSummarizer	DuckDB-schema			LLM	МSK2	SQL	Inga skrivningar	,	Tabellens tillåtelselista
Mediaanalys	scentidstämpningarM SK1 transkription	LLM beat sheet	Körer måste citera tidstämpning/ citat

Patternet är alltid samma.

Bot-detektorn: Den icke--LLM-exemplet

Denna sektion är avsiktligt detaljerad eftersom den visar mönstret utan någon LLM alls.

Mitt robotdetektionssystem (Detektorn) visar att begränsad fuzziness är inte limited till LLM-baserade system.

De tre lagerna:

Ytan (Truth Layer): Individuella detektörer bearbetar objektsignaler från HTTP-behov
- UserAgent analys: ua.is_bot, ua.contains_automation_keyword
- Headeranalys: hdr.accept_language_count, hdr.missing_standard_headers
- IP-analys: ip.is_datacenter, ip.reputation_score
- Behavioral analys: beh.requests_per_minute, beh.path_entropy

Förespråkare (Creativity Layer): Heuristisk modell aggregerar signaler via viktade sigmoider

// Each detector emits a contribution, not a verdict
DetectionContribution.Bot(
    source: "UserAgent",
    category: "BotSignature",
    confidence: 0.85,
    reason: "Contains 'Googlebot' signature",
    weight: 1.0
);

// Aggregation via weighted sigmoid
var weightedSum = contributions.Sum(c => c.ConfidenceDelta * c.Weight);
var botProbability = 1.0 / (1.0 + Math.Exp(-weightedSum));

Konstruenter (Kontraktslayer): Politisk motor tvingar på hårda trösklar och handlingar

public record DetectionPolicy(
    double EarlyExitThreshold = 0.3,      // Exit if < 30% = confident human
    double ImmediateBlockThreshold = 0.95, // Block only if 95%+ certain
    double AiEscalationThreshold = 0.6     // Escalate if risk unclear
);

Den viktigaste insikten

Varje detektor bidrar till den slutliga besluten utan att ta beslutet själv. DetectionContribution rekordinsamlingar:

ConfidenceDelta: Hur mycket detta trycker mot en robot (+) eller en människa
Weight: Hur stor påverkan har denna detektor
Signals: Den beräknade fakta ( aldrig rå PII
Reason: Människo

Denna separation betyder att du kan

Add/dröva detektorer utan att ändra agregationslogiken
Tune vikter oberoende av detektorlogiken
Lär dig optimala vikter från feedback över tid

LLM Escalation optionellt

Här, ', är det som blir intressant. : stödjer mönstret optional escalation till LLM när hanuristisk modellen är osäkerhetsbar. Detta konfigureras via policy:

// Default policy: fast heuristics only
var defaultPolicy = new DetectionPolicy {
    FastPath = ["UserAgent", "Header", "Ip", "Behavioral"],
    EscalateToAi = false
};

// High-security policy: escalate uncertain cases to LLM
var strictPolicy = new DetectionPolicy {
    FastPath = ["UserAgent", "Header", "Ip"],
    SlowPath = ["Behavioral", "ClientSide"],
    AiPath = ["Onnx", "Llm"],  // Optional ML/LLM detectors
    EscalateToAi = true,
    AiEscalationThreshold = 0.4  // Escalate when 40-60% uncertain
};

När eskalationen utlöser, får LLM de ansamlade signalerna och ger en analys av språket , men konstrainern sätter fortfarande tröskeln på samma gång . Opinionen i LLM' påverkar poängen M SK4 så överrider det inte policyn MSC5

Wave-baserad orkestrering

Systemet kör detektörer i vågor, med senare våger som aktiveras av tidigare signaler :

flowchart LR
    subgraph Wave0["Wave 0: Fast & Free"]
        W0A[UserAgent]
        W0B[Header]
        W0C[IP]
    end

    C1{Consensus?}

    subgraph Wave1["Wave 1: Expensive"]
        W1A[Behavioral]
        W1B[ClientSide]
    end

    C2{Still Uncertain?}

    subgraph Wave2["Wave 2: AI"]
        W2A[ONNX Model]
        W2B[LLM]
    end

    subgraph Policy["Policy Enforcement"]
        P1{Score > 0.95?}
        P2[Block]
        P3[Allow]
        P4[Log & Learn]
    end

    Wave0 --> C1
    C1 -->|"Yes: 3+ agree"| Policy
    C1 -->|"No"| Wave1
    Wave1 --> C2
    C2 -->|"No"| Policy
    C2 -->|"Yes + AI enabled"| Wave2
    Wave2 --> Policy

    P1 -->|Yes| P2
    P1 -->|No| P3
    P3 --> P4

    style Wave0 stroke:#22c55e,stroke-width:2px
    style Wave1 stroke:#f59e0b,stroke-width:2px
    style Wave2 stroke:#ef4444,stroke-width:2px
    style Policy stroke:#8b5cf6,stroke-width:2px

Det här är begränsad förvirring med progressiv eskalation: billiga heuristiker hanterar tydliga fall, , dyr AI hanterar randliga fall,

Att lära sig utan risk

Eftersom konstrainern kräver säkerhet oavsett vad detektorerna utsätter, kan systemet utan tvekan lära sig,

// After each request, submit learning event (non-blocking)
LearningCoordinator.TrySubmit("ua.pattern", new LearningEvent {
    Features = extractedFeatures,
    Label = actualOutcome,  // Was it actually a bot?
    Confidence = detectionConfidence
});

// Background: EMA weight update
var alpha = 0.1;  // Learning rate
newWeight = existingWeight * (1 - alpha) + observedDelta * alpha;

Weights converge toward true patterns over time. High - Beräkningar av självförtroende har mer inverkan

Varför det här spelar roll

BotDetection bevisar att begränsad oförklarhet inte handlar om LLMs specifikt, utan om alla system där

Flera osäkra signaler måste kombineras
Skillnade signaler har olika tillförlitlighet
Svåra begränsningar måste tillämpas oavsett poäng
Systemet borde lära sig och förbättras över tid
Den dyra analysen borde bara fungera när den billiga inte är tillräckligt

LLM är bara ett möjligt fuzzy-komponent.

När inte använda begränsad fuzziness

Pattern har en kostnad.

Skip it when:

Uppgiften är helt deterministisk Om du kan skriva if X then Y, du behöver inte ' behöver inte en föreslagare . Bara skriva koden
Du'var prototypare. Du vet inte vad begränsningar betyder.
Utgången är utfallslös. Brainstorming
Iblanda misslyckanden är acceptabla. Om 5% hallucinationsfrekvensen är bra för ditt användandefall , kan ansträngningskostnaden överträffa kostnaden för misslyckanden
Du har inget substrat Om du kan "'", kan du inte bearbeta gräsligt sanning, ,", så kan du "'", inte begränsa det, . "Don, ', du kan inte låtsas med det." ., du behöver antingen hitta beräkningsbara fakta eller acceptera oförklarheten.

Pattern är för system där:

Probabilistiska resultat når användare eller andra system utan att bli omvärderade av människor.
Förluster är tysta, dyra, eller sammansättning
Du behöver lära dig att utvecklas utan att riskera produktion

Om det inte är din situation, så kan du vinna med enklare metoder.

Integration med evolutionära system

Begränsad Fuzziness blir ännu mer kraftfull när den kombineras med DiSE. (Inriktad syntetisk evolution

Generera flera felaktiga förslag
Bekräftelse mot invarianter
Score baserat på tillfredsställelse med begränsningar +
Håll den bästa, släng resten
Accumulera misslyckanden som utbildningssignaler för snabb utveckling

Den viktigaste insikten du kan utveckla förslaget utan att riskera systemet, eftersom konstrainern kräver säkerhet och korrekthet oberoende av vad som väljare ger ut

public async Task<EvolvedPrompt> EvolvePromptAsync(
    Prompt current,
    IReadOnlyList<FailureCase> failures)
{
    // Failures are safe to collect because constrainers caught them
    var patterns = AnalyzeFailurePatterns(failures);

    // Generate candidate prompt mutations
    var candidates = await _llm.GeneratePromptVariants(current, patterns);

    // Test each against held-out validation set
    var scored = await Task.WhenAll(candidates.Select(async c =>
    {
        var results = await RunValidationSet(c);
        return (Prompt: c, Score: CalculateScore(results));
    }));

    return scored.OrderByDescending(x => x.Score).First().Prompt;
}

Definitionen av One-Sentence

"Konsträngt Fuzziness är praxis med att låta sannolikhetskomponenter föreslå mening medan deterministiska system tvingar sanning

slutsats : Gouvernören, Inte motorn

Tillbaka till den LRU-キャッシュen som blev smartare när minnet gick slut.

Bestämningen var "'", det gav inte mer kapacitet ".". Bestämpningen var att låta begränsningen göra sitt jobb. Den begränsade storleken tvingade till att välja . Den glittrande utgångslängden tvingade att glömma

Detta är den viktigaste insikten. du kan inte fixa sannolikhetssystem genom att göra dem mindre probabilistisk. Du fixar dem genom att inte låta sannolikheten fly in i dina garantera

flowchart LR
    E[🔥 High-Variance<br/>Engine] --> G[⚙️ Governor] --> O[✓ Constrained<br/>Output]

    style E stroke:#ef4444,stroke-width:2px
    style G stroke:#22c55e,stroke-width:3px
    style O stroke:#3b82f6,stroke-width:2px

Dammmotorn förstår inte ", ", den ska inte explodera. Regern hindrar den fysiskt. ., LLM: n förstår inte', ", ", den borde ha hallucinationer av färger. M SK10, konduktören hindrar det komputativt.

Samma mönster

Nästa gång du är tvungen att lägga till en annan punkt i din system-prop, hoppades att modellen kommer förstå en begränsning. kan jag beräkna den begränsningen?

Om ja, beräkna det. så begränsa modellen till det .

Hard boundaries beat soft suggestions. Varje gång

Serien

del	mönster ♫ ♫	♫ Axel ♫
1			begränsad oförklarhet ♫	denna artikel ♫
2	Begränsad Fuzzy MoM	Flera komponenter
3	Begränsat Fuzzy Kontexttdragning	tid / minne
4	Image Summarizer	Praktisk implementation

Del 2 sträcker ut den här arkitekturen till flera system.

Del 3 sträcker den längs tidens axeln.

Del 4 visar alla tre mönster som implementeras i ImageSummarizer—, en våg, -, ett bildanalysrör där ColorWave bearbetar fakta, M SK2, VisionLlmWave föreslår , och deterministisk urval begränsar utgången.