Ambiguity Register¶
A standing register — instantiates Grammar-Guided Structure Recovery
The standing record of every ambiguity the parser could not resolve, each entry tagged with its competing readings and a route to whoever or whatever decides it.
The Ambiguity Register is the archetype's memory for what recovery could not settle. It does not resolve anything; it captures each surviving ambiguity as a durable entry — the location in the input, the competing readings, why the ambiguity survived — and assigns each one an escalation path to a resolver: a human reviewer, a request for a new grammar rule, or an accepted-but-flagged default. Where the Controlled Disambiguation Test tries to kill an ambiguity, the register accepts that some will survive and insists they be made visible and tracked rather than silently defaulted. Its defining move is to treat residual ambiguity as first-class data to be logged and dispositioned — the archetype's own principle that ambiguity is information about the limits of the input, not a defect to hide.
Example¶
A data-integration service parses millions of user-submitted mailing addresses a day. Most resolve cleanly; a steady fraction do not — a Springfield with no state, a token that is equally a street name and a city, a unit number indistinguishable from a PO box. Instead of guessing, the pipeline writes each unresolved case to the register: the raw span, the candidate parses, the reason for the tie, and an escalation route chosen by policy. High-volume recurring patterns become a grammar-rule request; low-volume cases with a customer order waiting go to a human review queue; low-stakes cases accept a flagged default and move on.
By the end of the week the register has done something no single parse could: its top recurring patterns are the prioritized backlog for grammar improvement, and every address that shipped with a guess is auditable back to the entry that flagged it. The register turned a stream of silent guesses into a governed, countable work queue.
How it works¶
On an unresolved ambiguity the register appends an entry — location, competing readings, cause, timestamp, and a link back to the parse provenance — and assigns it a disposition by policy, keyed on volume, stakes, and whether a downstream consumer is blocked. Entries stay open until dispositioned, and resolutions (a human decision, a new rule, an accepted default) are recorded back against them. Because it is append-first and never overwrites, the register doubles as an audit trail; and because it aggregates, the same log that captures one-off oddities also surfaces the recurring patterns worth a permanent fix.
Tuning parameters¶
- Capture threshold — how uncertain a case must be before it is logged. Log everything and the register drowns in noise; log only the severe and real ambiguities slip through unrecorded.
- Escalation policy — the routing rules that map an entry to human review, a rule-request, or default-and-flag — the register's core behavior.
- Aggregation window — keep entries per-item, or cluster them into recurring patterns; clustering is what converts the log into a prioritized backlog.
- Retention & closure — when an open entry is retired: resolved, expired, or accepted-as-is.
- Default stance — whether an un-escalated entry blocks downstream use or passes it through with a flag.
When it helps, and when it misleads¶
Its value is that nothing ambiguous is silently guessed: every unresolved case is visible, counted, and routed, and the aggregate becomes a roadmap for where the grammar or schema most needs work. Its failure modes are organizational as much as technical. A register nobody triages becomes a graveyard — entries logged, never dispositioned; over-capture buries the important ambiguities under trivia; and a permissive default stance quietly lets flagged-but-unresolved items flow downstream as though they were clean. The classic misuse is using the register as an alibi: logging an ambiguity to look like it was handled while the escalation path in fact goes nowhere. The discipline that guards against this is to give every entry an owner and a closure target, and to measure the register by its throughput — the rate at which entries are resolved — not by how many it holds.[n1]
How it implements the components¶
The Ambiguity Register realizes the tracking-and-routing side of the ambiguity machinery — recording what survives resolution and steering it to a resolver:
residual_ambiguity_log— the append-only record of every unresolved ambiguity, each with its competing readings and cause.ambiguity_escalation_path— each entry's assigned route to a resolver: human review, a grammar-rule request, or an accepted-and-flagged default.
It does not itself attempt to resolve the ambiguities it holds (that is the Controlled Disambiguation Test), and it does not score per-node confidence during parsing (that is the Controlled Disambiguation Test and Probabilistic Grammar Parsing); it records what those steps leave behind.
Also instantiates¶
Context-Bounded Meaning Recovery — The primary facet logs structural ambiguity — parses the grammar could not settle. This archetype turns the register toward interpretive ambiguity: a statute, dashboard, icon, or model output that supports more than one warranted reading depending on the framework brought to it. Recovery here is a governed conversion from substrate to meaning, and its explicit invariant is that ambiguity and uncertainty must not be erased — so readings that stay genuinely open after interpretation are written to the register rather than silently collapsed to the most convenient one. The register becomes the archetype's guard against framework smuggling and relativist collapse alike: each surviving reading is kept visible, bounded, and routed to a resolver rather than passed off as the meaning.
alternative_reading_set— each entry carries the rival readings that survived interpretation, not a single chosen one.evidence_mark_trace— a logged reading points back to the marks in the substrate or the declared context that leave it undecided.admissible_reading_boundary— the register marks which readings are supported versus speculative, undecidable, or out of scope, preserving plurality without "anything goes."validation_or_uptake_check— the escalation route sends open entries to expert review, stakeholder meaning checks, or precedent for a decision.
Observational Equivalence Resolution — Here the ambiguity is neither syntactic nor interpretive but causal: the same observation — a symptom, metric, trace, or outcome — could have been produced by several hidden generators that the current frame cannot tell apart. The archetype names this an observational equivalence class and warns against premature closure on the vivid or convenient candidate. The Ambiguity Register is exactly the mechanism it calls for to implement the unresolved branch: it holds cases where candidates remain indistinguishable, keeps the live alternatives visible in the record, and governs the decision under stated ambiguity rather than converting an underdetermined case into a false final answer.
candidate_explanation_set— each entry logs the plausible rival generators for the shared observation, so no single story is treated as the only one.observational_equivalence_class— the entry records why the candidates are indistinguishable under the current frame.uncertainty_label— the register is the record that preserves the unresolved ambiguity instead of laundering it away.decision_rule_under_ambiguity— each open entry's disposition routes to a robust, reversible, or deferred action until a discriminating observation arrives.
Related¶
- Instantiates: Grammar-Guided Structure Recovery — the register is the archetype's governed memory of unresolved structure.
- Consumes: Controlled Disambiguation Test hands it the cases it could not settle.
- Sibling mechanisms: Controlled Disambiguation Test · Chart Parsing · Probabilistic Grammar Parsing · Interpretation Walkthrough · Grammar Rule Set · Semantic Schema Validation
Editorial Notes¶
Form Classification¶
Form family: Record, Log & Register
Rationale: The standing record of every ambiguity the parser could not resolve, each entry tagged with its competing readings and a route to whoever or whatever decides it, making its operative form a durable account of actual events, decisions, or transitions whose value depends on history or provenance.
Independent corroboration: The frozen evidence defines Ambiguity Register as 'The standing record of every ambiguity the parser could not resolve, each entry tagged with its competing readings and a route to whoever or whatever decides it', so its operative form is Record, Log & Register.
Review outcome: Independent reviewer agreement; high confidence.
Origin Attribution¶
Primary origin: Computer Science & Software Engineering
Origin pattern: Cross-disciplinary synthesis
Present-day reach: Multi-domain
Rationale: Parsing and requirements practice in computer science supplies the direct need to inventory unresolved meanings that block deterministic interpretation.
Related originating lineages:
- Library & Information Science — Authority control and metadata qualification institutionalize explicit uncertainty records.
- Linguistics & Semiotics — Lexical, syntactic, and pragmatic ambiguity provide the underlying classification vocabulary.
- Philosophy — Logic and philosophy of language contribute distinctions among ambiguity, vagueness, and indeterminacy.
Review resolution: The primary software and requirements lineage is shared. Cataloging uncertainty, linguistic ambiguity analysis, and philosophical epistemic qualification materially inform the register, whose combined artifact is an Encyclopedia synthesis.
Attribution caveat: The register format is an encyclopedia synthesis; similar artifacts arise independently in requirements, linguistics, and cataloguing.
Encyclopedia synthesis: The exact catalogued form synthesizes established practice rather than reproducing a single standard historical label.
Review outcome: Reconciled after independent review; medium confidence.
Notes¶
The register is a record, not a resolver, and its health is measured by closure rate rather than entry count. A log that grows while its closure rate stays flat is a warning sign — ambiguities are accumulating faster than anyone is dispositioning them — not evidence that the parser is being careful.
[n1] Routing an unresolved case to a person rather than forcing an automated guess is the standard human-in-the-loop pattern: the machine handles the confident majority and escalates the genuinely uncertain remainder to human judgment, so accuracy on hard cases is bought without stalling the easy ones. ↩