# UTQC row honesty

> Decide if a row of the UOR Atlas UTQC dictionary passes the honesty check, so no row claims more than its source shows.

Inspired by afflom/UOR-Atlas-UTQC (https://github.com/afflom/UOR-Atlas-UTQC), live at https://afflom.github.io/UOR-Atlas-UTQC/. A parametric, BDD-driven, V&V-gated realization of the UOR Atlas UTQC on holospaces, with an honesty gate over every claim. Pattern: Decision table, OMG DMN 1.5, hit policy FIRST. To write one of your own, follow How to build a decision table app (../../guides/decision-table/index.md). The prompt below is data, quoted from the example.

**Figure: What the UTQC row honesty app does.** A request goes in, the rules decide, and the Lean kernel has already proved what the rules promise.

| Step | What happens |
| --- | --- |
| 1. Request | status, source, oracle, tier, cited, disclosed |
| 2. 5 rules | the first that matches wins |
| 3. Answer | admitted, anchor-missing, oracle-misused, tier-violated, citation-refused |
| 4. Proved | 4 theorems, 53 tests |

Verified by prismpm verify in the pinned SDK. Fingerprint: 3ec1ed16d2681ae68fdf538152596d36111d190b7c4c22253679baf46b2c97a4. Acceptance vectors: 53. Claims: 7.

## The prompt

```json
{
  "schema": "prism/prompt/1",
  "goal": "Decide if a row of the UOR Atlas UTQC dictionary passes the honesty check, so no row claims more than its source shows.",
  "pattern": "decisionTable",
  "repository": "afflom/UOR-Atlas-UTQC",
  "license": "MIT",
  "app": {
    "name": "utqc-row-honesty",
    "title": "UTQC row honesty",
    "purpose": "Decide whether one dictionary row is admitted by the honesty audit, or which status-discipline rule it breaks first.",
    "fields": [
      {
        "name": "status",
        "kind": "choice",
        "values": [
          "some-true",
          "build",
          "open"
        ],
        "means": "the honesty level of the row in model/status.toml"
      },
      {
        "name": "source",
        "kind": "choice",
        "values": [
          "anchored",
          "parenthetical"
        ],
        "means": "whether the source is an external anchor or a parenthetical in-repo derivation"
      },
      {
        "name": "oracle",
        "kind": "choice",
        "values": [
          "external",
          "exact-algebra"
        ],
        "means": "whether the oracle is external or the in-repo exact-algebra certificate"
      },
      {
        "name": "tier",
        "kind": "choice",
        "values": [
          "suite",
          "target"
        ],
        "means": "whether the feature is a gating suite or a non-gating target"
      },
      {
        "name": "cited",
        "kind": "number",
        "means": "cited classical lemmas the row declares"
      },
      {
        "name": "disclosed",
        "kind": "number",
        "means": "cited lemmas that appear verbatim in the row atlas prose"
      }
    ],
    "outcomes": [
      "admitted",
      "anchor-missing",
      "oracle-misused",
      "tier-violated",
      "citation-refused"
    ],
    "meanings": {
      "admitted": "the row passes the honesty meta-gate and its feature may run at its tier",
      "anchor-missing": "a some-true row has an in-repo derivation for its source",
      "oracle-misused": "a some-true row is backed by the in-repo exact-algebra oracle",
      "tier-violated": "an open row is placed in a gating suite",
      "citation-refused": "cited lemmas are declared by a non-asserting row or are not disclosed in its prose"
    },
    "rules": [
      {
        "when": [
          {
            "field": "status",
            "op": "is",
            "value": "some-true"
          },
          {
            "field": "source",
            "op": "is",
            "value": "parenthetical"
          }
        ],
        "then": "anchor-missing",
        "why": "crates/tqc-conformance/src/honesty.rs: some-true requires an external source anchor, never (derived)"
      },
      {
        "when": [
          {
            "field": "status",
            "op": "is",
            "value": "some-true"
          },
          {
            "field": "oracle",
            "op": "is",
            "value": "exact-algebra"
          }
        ],
        "then": "oracle-misused",
        "why": "crates/tqc-conformance/src/honesty.rs: the in-repo exact-algebra oracle cannot back a some-true row"
      },
      {
        "when": [
          {
            "field": "status",
            "op": "is",
            "value": "open"
          },
          {
            "field": "tier",
            "op": "is",
            "value": "suite"
          }
        ],
        "then": "tier-violated",
        "why": "crates/tqc-conformance/src/honesty.rs and model/status.toml: open is non-gating and may not be a gating suite"
      },
      {
        "when": [
          {
            "field": "status",
            "op": "is",
            "value": "open"
          },
          {
            "field": "cited",
            "op": ">",
            "value": 0
          }
        ],
        "then": "citation-refused",
        "why": "crates/tqc-conformance/src/honesty.rs: a non-asserting status may not declare cited lemmas"
      },
      {
        "when": [
          {
            "field": "disclosed",
            "op": "<",
            "value": {
              "field": "cited"
            }
          }
        ],
        "then": "citation-refused",
        "why": "crates/tqc-conformance/src/honesty.rs: each cited lemma must appear verbatim in the row atlas prose"
      }
    ],
    "otherwise": "admitted",
    "otherwiseWhy": "docs/conceptual-model/03-status-discipline.md: the status is a contract the row keeps",
    "properties": [
      {
        "kind": "never",
        "when": [
          {
            "field": "status",
            "op": "is",
            "value": "some-true"
          },
          {
            "field": "source",
            "op": "is",
            "value": "parenthetical"
          }
        ],
        "then": "admitted",
        "why": "03-status-discipline.md external-anchor rule: derived constructions belong at build"
      },
      {
        "kind": "never",
        "when": [
          {
            "field": "status",
            "op": "is",
            "value": "open"
          },
          {
            "field": "tier",
            "op": "is",
            "value": "suite"
          }
        ],
        "then": "admitted",
        "why": "03-status-discipline.md: an open claim is measured and reported, never green"
      },
      {
        "kind": "never",
        "when": [
          {
            "field": "status",
            "op": "is",
            "value": "open"
          },
          {
            "field": "cited",
            "op": ">",
            "value": 0
          }
        ],
        "then": "admitted",
        "why": "an open row asserts nothing, so it rests on no cited lemma"
      },
      {
        "kind": "always",
        "when": [
          {
            "field": "status",
            "op": "is",
            "value": "build"
          },
          {
            "field": "cited",
            "op": "=",
            "value": 0
          }
        ],
        "then": "admitted",
        "why": "a build row validated against the MTC axioms or an exact certificate may use any source and oracle"
      }
    ],
    "examples": [
      {
        "request": "some-true anchored external suite 0 0",
        "response": "admitted"
      },
      {
        "request": "some-true parenthetical external suite 0 0",
        "response": "anchor-missing"
      },
      {
        "request": "some-true anchored exact-algebra suite 0 0",
        "response": "oracle-misused"
      },
      {
        "request": "open anchored external suite 0 0",
        "response": "tier-violated"
      },
      {
        "request": "open anchored external target 1 1",
        "response": "citation-refused"
      },
      {
        "request": "build parenthetical exact-algebra suite 2 1",
        "response": "citation-refused"
      },
      {
        "request": "build anchored exact-algebra suite 2 2",
        "response": "admitted"
      },
      {
        "request": "open parenthetical external target 0 0",
        "response": "admitted"
      }
    ]
  },
  "stakeholders": [
    {
      "name": "Reader",
      "text": "Reads the UOR Atlas whitepaper and needs every established claim to rest on an external anchor and every cited lemma to be disclosed.",
      "concerns": [
        "Proved guarantees",
        "No status inflation"
      ]
    },
    {
      "name": "Maintainer",
      "text": "Adds dictionary rows and feature files and needs to know which rule a row breaks before CI does.",
      "concerns": [
        "Correct answers"
      ]
    }
  ],
  "concerns": [
    {
      "name": "No status inflation",
      "text": "No in-repo derivation or open measurement is billed as some-true or as a gating suite.",
      "model": "quality"
    }
  ],
  "components": [
    {
      "name": "F1 Atlas formalization",
      "text": "The Lean formalization of the UOR Atlas whose theorems anchor some-true rows.",
      "kind": "externalSystem"
    },
    {
      "name": "holospaces",
      "text": "The content-addressing substrate whose vv witnesses anchor some-true rows.",
      "kind": "externalSystem"
    },
    {
      "name": "uor-addr",
      "text": "The realized composition operations that anchor some-true rows.",
      "kind": "externalSystem"
    }
  ],
  "threats": [
    {
      "name": "Status inflation",
      "text": "A derived construction is recorded as some-true to make it read as established.",
      "stride": "elevationOfPrivilege",
      "asset": "answer",
      "likelihood": "medium",
      "impact": "major",
      "control": {
        "name": "External-anchor rule",
        "text": "A some-true row with a parenthetical source is never admitted.",
        "evidence": [
          {
            "kind": "proof",
            "reference": "UtqcRowHonestyProofs::inv001Holds"
          },
          {
            "kind": "gate",
            "reference": "just vv"
          }
        ]
      }
    },
    {
      "name": "Open claim gated as established",
      "text": "The advantage row, open and measured, is moved into a gating suite.",
      "stride": "tampering",
      "asset": "answer",
      "likelihood": "medium",
      "impact": "major",
      "control": {
        "name": "Tier discipline",
        "text": "An open row in a gating suite is never admitted.",
        "evidence": [
          {
            "kind": "proof",
            "reference": "UtqcRowHonestyProofs::inv002Holds"
          },
          {
            "kind": "gate",
            "reference": "crates/tqc-conformance/src/honesty.rs"
          }
        ]
      }
    },
    {
      "name": "Undisclosed trust boundary",
      "text": "A conclusion rests on a classical lemma the row cites but its prose does not name.",
      "stride": "repudiation",
      "asset": "source",
      "likelihood": "low",
      "impact": "major",
      "control": {
        "name": "Cited-lemma disclosure",
        "text": "Every cited lemma must appear verbatim in the row prose.",
        "evidence": [
          {
            "kind": "gate",
            "reference": "crates/tqc-conformance/src/honesty.rs"
          },
          {
            "kind": "review",
            "reference": "model/dictionary.toml"
          }
        ]
      }
    }
  ],
  "quality": [
    {
      "characteristic": "Functional suitability",
      "subcharacteristic": "Functional correctness",
      "requirement": "No inflated row admitted",
      "text": "No some-true row with a parenthetical source and no open row in a suite is admitted.",
      "measure": "Inflated rows admitted",
      "measureText": "Requests breaking the external-anchor or tier rule that answer admitted.",
      "threshold": 0
    },
    {
      "characteristic": "Maintainability",
      "subcharacteristic": "Analysability",
      "requirement": "Three honesty levels",
      "text": "Every row is decided against exactly the three levels model/status.toml declares.",
      "measure": "Status levels",
      "measureText": "Choices of the status field.",
      "threshold": 3
    }
  ],
  "journeys": [
    {
      "stakeholder": "Reader",
      "steps": [
        "REQ-001",
        "REQ-003",
        "INV-001",
        "INV-002"
      ]
    },
    {
      "stakeholder": "Maintainer",
      "steps": [
        "REQ-002",
        "REQ-005",
        "INV-004",
        "otherwise"
      ]
    }
  ],
  "axioms": {
    "inv001Holds": [
      "Classical.choice",
      "Quot.sound",
      "propext"
    ],
    "inv002Holds": [
      "Classical.choice",
      "Quot.sound",
      "propext"
    ],
    "inv003Holds": [
      "Classical.choice",
      "Quot.sound",
      "propext"
    ]
  }
}
```

## Claims

- UR-01: The app never answers admitted when status is some-true and source is parenthetical
- UR-02: The app never answers admitted when status is open and tier is suite
- UR-03: The app never answers admitted when status is open and cited is above 0
- UR-04: The app always answers admitted when status is build and cited equals 0
- UR-05: The architecture description declares every stakeholder, concern, component, edge, viewpoint and view it references
- UR-06: The ISO/IEC 25010 quality model numbers every characteristic, subcharacteristic, requirement and measure, and every parent it names is declared
- UR-07: Every compliance obligation is numbered in order and names its evidence

## Pattern

Decision table: OMG DMN 1.5, hit policy FIRST. The rules are tried in order, and the first one that matches gives the answer. If none matches, the default answer applies. This is a DMN decision table with the FIRST hit policy.

| Pattern | Standard | Answers |
| --- | --- | --- |
| Decision table | OMG DMN 1.5, hit policy FIRST | admitted, anchor-missing, oracle-misused, tier-violated, citation-refused |

**Figure: Rules for each answer.** Each bar counts the rules that give one answer. When no rule matches, the answer is admitted.

|  | rules |
| --- | --- |
| admitted | 0 |
| anchor-missing | 1 |
| oracle-misused | 1 |
| tier-violated | 1 |
| citation-refused | 2 |

## Behavior

A request is status, source, oracle, tier, cited, disclosed, separated by spaces. The first rule that matches decides. If none matches, the answer is admitted. A request over 160 bytes, or in any other form, is answered invalid.

| Rule | When | Answer | Why |
| --- | --- | --- | --- |
| REQ-001 | status is some-true and source is parenthetical | anchor-missing | crates/tqc-conformance/src/honesty.rs: some-true requires an external source anchor, never (derived) |
| REQ-002 | status is some-true and oracle is exact-algebra | oracle-misused | crates/tqc-conformance/src/honesty.rs: the in-repo exact-algebra oracle cannot back a some-true row |
| REQ-003 | status is open and tier is suite | tier-violated | crates/tqc-conformance/src/honesty.rs and model/status.toml: open is non-gating and may not be a gating suite |
| REQ-004 | status is open and cited is above 0 | citation-refused | crates/tqc-conformance/src/honesty.rs: a non-asserting status may not declare cited lemmas |
| REQ-005 | disclosed is below cited | citation-refused | crates/tqc-conformance/src/honesty.rs: each cited lemma must appear verbatim in the row atlas prose |
| otherwise | no rule matches | admitted | docs/conceptual-model/03-status-discipline.md: the status is a contract the row keeps |

## Properties Lean proves

Each property is a theorem about the same definitions the app is built from. It is proved for every request, not only the tested ones.

| Property | Statement | Theorem | Why |
| --- | --- | --- | --- |
| INV-001 | It never answers admitted when status is some-true and source is parenthetical. | UtqcRowHonestyProofs::inv001Holds | 03-status-discipline.md external-anchor rule: derived constructions belong at build |
| INV-002 | It never answers admitted when status is open and tier is suite. | UtqcRowHonestyProofs::inv002Holds | 03-status-discipline.md: an open claim is measured and reported, never green |
| INV-003 | It never answers admitted when status is open and cited is above 0. | UtqcRowHonestyProofs::inv003Holds | an open row asserts nothing, so it rests on no cited lemma |
| INV-004 | It always answers admitted when status is build and cited equals 0. | UtqcRowHonestyProofs::inv004Holds | a build row validated against the MTC axioms or an exact certificate may use any source and oracle |

## Architecture

Stakeholders and the concerns each one views the app through (ISO/IEC/IEEE 42010).

| Stakeholder | Who they are | Concerns |
| --- | --- | --- |
| Maintainer | Adds dictionary rows and feature files and needs to know which rule a row breaks before CI does. | Correct answers |
| Reader | Reads the UOR Atlas whitepaper and needs every established claim to rest on an external anchor and every cited lemma to be disclosed. | Proved guarantees, No status inflation |
| Verifier | Anyone who loads the holo, checks its fingerprint and replays its acceptance vectors before trusting an answer. | Integrity of the published app, Refused malformed requests, Proved guarantees |

## Concerns

What the stakeholders care about, and the model each is viewed in.

| Concern | What it means | Model |
| --- | --- | --- |
| Correct answers | Every well-formed request is answered by the first rule that matches it, or admitted when none does, as the spec states. | quality |
| Integrity of the published app | What a visitor runs is the holo the build verified, with its fingerprint and signed provenance beside it. | security |
| No status inflation | No in-repo derivation or open measurement is billed as some-true or as a gating suite. | quality |
| Proved guarantees | Each of the 4 properties of the spec holds for every request, proved by the Lean kernel. | quality |
| Refused malformed requests | A request that is not the 6 fields in order, or is longer than 160 bytes, is answered invalid and never guessed. | security |

## Components

9 components and 13 edges between them.

| Component | Kind | What it is |
| --- | --- | --- |
| Browser | externalSystem | The visitor's web browser, which loads the page and runs the UTQC row honesty guest. |
| F1 Atlas formalization | externalSystem | The Lean formalization of the UOR Atlas whose theorems anchor some-true rows. |
| GitHub Pages | externalSystem | Serves the page and the holo from the repository Pages workflow. |
| holospaces | externalSystem | The content-addressing substrate whose vv witnesses anchor some-true rows. |
| Prism build | cliAdapter | prismpm verify in the SDK image prismpm.lock pins: it checks every theorem, builds the guest and replays every vector. |
| Source repository | externalSystem | The repository that holds the prompt, the model and its gate. |
| UTQC row honesty guest | service | The Core-Wasm guest built from the model: it answers one request of at most 160 bytes with one answer of at most 64. |
| UTQC row honesty page | staticSite | The page the template publishes: the holo, its fingerprint, its provenance and its acceptance vectors. |
| uor-addr | externalSystem | The realized composition operations that anchor some-true rows. |

## Design views

The SDK checks each view against the system model and draws it as OPL and PlantUML.

| View | Diagram | Viewpoint |
| --- | --- | --- |
| Deciding a UTQC row honesty request | opmObjectProcess | Maintainer: Correct answers |
| Components of UTQC row honesty | umlComponent | Verifier: Integrity of the published app |
| Answering a UTQC row honesty request | umlSequence | Maintainer: Correct answers |
| States of the UTQC row honesty guest | umlStateMachine | Verifier: Refused malformed requests |

## Features and journeys

11 features. Each names the definitions that do the work and the tests that accept it. Each stakeholder has one journey.

| Feature | Calls | Accepted by |
| --- | --- | --- |
| When status is some-true and source is parenthetical, the answer is anchor-missing. | UtqcRowHonesty::rule1, UtqcRowHonesty::judge | UtqcRowHonesty::application |
| When status is some-true and oracle is exact-algebra, the answer is oracle-misused. | UtqcRowHonesty::rule2, UtqcRowHonesty::judge | UtqcRowHonesty::application |
| When status is open and tier is suite, the answer is tier-violated. | UtqcRowHonesty::rule3, UtqcRowHonesty::judge | UtqcRowHonesty::application |
| When status is open and cited is above 0, the answer is citation-refused. | UtqcRowHonesty::rule4, UtqcRowHonesty::judge | UtqcRowHonesty::application |
| When disclosed is below cited, the answer is citation-refused. | UtqcRowHonesty::rule5, UtqcRowHonesty::judge | UtqcRowHonesty::application |
| When no rule matches, the answer is admitted. | UtqcRowHonesty::judge | UtqcRowHonesty::application |
| A request that is not status, source, oracle, tier, cited, disclosed in order, separated by single spaces, or is over 160 bytes, is answered invalid. | UtqcRowHonesty::dispatch, UtqcRowHonesty::decodeField1 | UtqcRowHonesty::application |
| It never answers admitted when status is some-true and source is parenthetical. | UtqcRowHonesty::judge | UtqcRowHonestyProofs::inv001Holds |
| It never answers admitted when status is open and tier is suite. | UtqcRowHonesty::judge | UtqcRowHonestyProofs::inv002Holds |
| It never answers admitted when status is open and cited is above 0. | UtqcRowHonesty::judge | UtqcRowHonestyProofs::inv003Holds |
| It always answers admitted when status is build and cited equals 0. | UtqcRowHonesty::judge | UtqcRowHonestyProofs::inv004Holds |

## Journeys

The ordered features each stakeholder takes.

| Stakeholder | Steps |
| --- | --- |
| Maintainer | REQ-002 → REQ-005 → INV-004 → otherwise |
| Reader | REQ-001 → REQ-003 → INV-001 → INV-002 |
| Verifier | refuse → INV-001 → INV-002 → INV-003 → INV-004 |

## Security and threat model

13 threats against 4 assets. Each has a STRIDE category, and either a control with evidence or a risk that is accepted on purpose.

| Threat | STRIDE | Asset | Risk | Answered by |
| --- | --- | --- | --- | --- |
| Answer that breaks INV-001 | repudiation | Answer | medium likelihood, critical impact | Proof of INV-001: proof UtqcRowHonestyProofs::inv001Holds |
| Answer that breaks INV-002 | repudiation | Answer | medium likelihood, critical impact | Proof of INV-002: proof UtqcRowHonestyProofs::inv002Holds |
| Answer that breaks INV-003 | repudiation | Answer | medium likelihood, critical impact | Proof of INV-003: proof UtqcRowHonestyProofs::inv003Holds |
| Answer that breaks INV-004 | repudiation | Answer | medium likelihood, critical impact | Proof of INV-004: proof UtqcRowHonestyProofs::inv004Holds |
| Granted capability | informationDisclosure | Answer | low likelihood, major impact | No capability granted: gate prism-code check refuses an ungranted guest import |
| Malformed request | tampering | Request bytes | high likelihood, major impact | Strict decoder: gate malformed-request acceptance vectors, replayed in the compiled guest by prismpm verify |
| Open claim gated as established | tampering | Answer | medium likelihood, major impact | Tier discipline: proof UtqcRowHonestyProofs::inv002Holds; gate crates/tqc-conformance/src/honesty.rs |
| Oversized request | denialOfService | Request bytes | medium likelihood, minor impact | Bounded request: gate acceptance vectors at the request bound, one byte over it, and at the guest allocation bound, replayed by prismpm verify |
| Status inflation | elevationOfPrivilege | Answer | medium likelihood, major impact | External-anchor rule: proof UtqcRowHonestyProofs::inv001Holds; gate just vv |
| Substituted holo | spoofing | Published holo | low likelihood, critical impact | Fingerprint and provenance: gate actions/attest-build-provenance in the pages workflow; gate prism-code check of the holo identities in the page |
| Substituted host | spoofing | Published holo | low likelihood, critical impact | accepted: A page cannot defend against its own host. The holo carries signed build provenance a visitor can check, and the app can be rebuilt from its prompt. |
| Tampered model | tampering | Model source | low likelihood, major impact | Regenerated from the prompt: gate prismpm verify in the SDK image prismpm.lock pins; review app/prompt.json |
| Undisclosed trust boundary | repudiation | Model source | low likelihood, major impact | Cited-lemma disclosure: gate crates/tqc-conformance/src/honesty.rs; review model/dictionary.toml |

## Quality

ISO/IEC 25010:2023 requirements. Each has a measure and a threshold that a theorem pins.

| Requirement | Characteristic | Measure | Threshold |
| --- | --- | --- | --- |
| Bounded allocation: The guest allocates at most 320 bytes for one request. | Performance efficiency: Resource utilization | Guest allocation bytes | 320 |
| Bounded request: A request over 160 bytes is refused before any field is read. | Performance efficiency: Time behaviour | Request bytes read | 160 |
| Every property proved: All 4 properties are theorems the Lean kernel checks. | Security: Integrity | Unproved properties | 0 |
| Every request answered: Every request gets an answer: a rule, admitted otherwise, or invalid. | Functional suitability: Functional completeness | Unanswered requests | 0 |
| Every vector replays: All 53 acceptance vectors replay in the compiled guest, the shortest 0 bytes long. | Reliability: Faultlessness | Failed vectors | 0 |
| Examples answered as stated: Every one of the 8 examples of the spec is answered as it states. | Functional suitability: Functional correctness | Example mismatches | 0 |
| No inflated row admitted: No some-true row with a parenthetical source and no open row in a suite is admitted. | Functional suitability: Functional correctness | Inflated rows admitted | 0 |
| Three honesty levels: Every row is decided against exactly the three levels model/status.toml declares. | Maintainability: Analysability | Status levels | 3 |

## Compliance

One obligation per standard, each naming its evidence.

| Standard | Subject | Evidence |
| --- | --- | --- |
| ISO/IEC/IEEE 42010:2022 | Architecture description | Architecture::architectureDescriptionHolds |
| ISO/PAS 19450:2015 and OMG UML 2.5.1 | Design views | Design::viewOpmDecide, Design::viewUmlComponents, Design::viewUmlRequest, Design::viewUmlStates |
| ISO/IEC 25010:2023 | Product quality | Quality::qualityModelHolds |
| ISO/IEC 27034-1:2011 and ISO/IEC 27005:2022 | Application security and risk | Security::controlSet |
| OMG DMN 1.5, hit policy FIRST | Decision table | UtqcRowHonesty::judge |
| OpenSpec | Requirements | UtqcRowHonesty::application |
| SPDX MIT | Licensing | UtqcRowHonesty::application |

## Rendered design views

Written by the SDK from the design records when it verified the app.

### design/Design.viewOpmDecide.opl

```
View: Design::viewOpmDecide
Title: Deciding a UTQC row honesty request
Viewpoint: Architecture::viewpointMaintainerCorrectAnswers
Notation: ISO/PAS 19450:2015 OPM, Prism OPL profile

componentBrowser is an object.
componentUTQCRowHonestyGuest is an object.
componentUTQCRowHonestyGuest can be stateDeciding or stateIdle.
processDecide is a process.
processEncodeAnswer is a process.
processJudge is a process.
processParseRequest is a process.
componentUTQCRowHonestyGuest handles processDecide.
processParseRequest requires componentBrowser.
processEncodeAnswer affects componentBrowser.
processJudge invokes processEncodeAnswer.
processParseRequest invokes processJudge.
processDecide zooms into processParseRequest, processJudge, and processEncodeAnswer, in that sequence.

```

### design/Design.viewUmlComponents.puml

```
@startuml
' UML 2.5.1 component diagram
' view: Design::viewUmlComponents
' viewpoint: Architecture::viewpointVerifierIntegrityOfThePublishedApp
title Components of UTQC row honesty
component "componentBrowser" as c0
component "componentF1AtlasFormalization" as c1
component "componentGitHubPages" as c2
component "componentHolospaces" as c3
component "componentPrismBuild" as c4
component "componentSourceRepository" as c5
component "componentUTQCRowHonestyGuest" as c6
component "componentUTQCRowHonestyPage" as c7
component "componentUorAddr" as c8
c0 --> c6 : edgeBrowserToUTQCRowHonestyGuest
c1 --> c6 : edgeF1AtlasFormalizationToUTQCRowHonestyGuest
c2 --> c0 : edgeGitHubPagesToBrowser
c3 --> c6 : edgeHolospacesToUTQCRowHonestyGuest
c4 --> c6 : edgePrismBuildToUTQCRowHonestyGuest
c4 --> c7 : edgePrismBuildToUTQCRowHonestyPage
c5 --> c4 : edgeSourceRepositoryToPrismBuild
c6 --> c0 : edgeUTQCRowHonestyGuestToBrowser
c6 --> c1 : edgeUTQCRowHonestyGuestToF1AtlasFormalization
c6 --> c3 : edgeUTQCRowHonestyGuestToHolospaces
c6 --> c8 : edgeUTQCRowHonestyGuestToUorAddr
c7 --> c2 : edgeUTQCRowHonestyPageToGitHubPages
c8 --> c6 : edgeUorAddrToUTQCRowHonestyGuest
@enduml

```

### design/Design.viewUmlRequest.puml

```
@startuml
' UML 2.5.1 sequence diagram
' view: Design::viewUmlRequest
' viewpoint: Architecture::viewpointMaintainerCorrectAnswers
title Answering a UTQC row honesty request
participant "componentBrowser" as p0
participant "componentUTQCRowHonestyGuest" as p1
p0 -> p1 : processDecide
p1 --> p0 : processDecide
@enduml

```

### design/Design.viewUmlStates.puml

```
@startuml
' UML 2.5.1 state machine diagram
' view: Design::viewUmlStates
' viewpoint: Architecture::viewpointVerifierRefusedMalformedRequests
title States of the UTQC row honesty guest
state "stateAnsweredAdmitted" as s0
state "stateAnsweredAnchorMissing" as s1
state "stateAnsweredCitationRefused" as s2
state "stateAnsweredOracleMisused" as s3
state "stateAnsweredTierViolated" as s4
state "stateDeciding" as s5
state "stateIdle" as s6
state "stateRefused" as s7
[*] --> s6
s6 --> s5 : processParseRequest
s6 --> s7 : processParseRequest
s5 --> s1 : processRule1
s5 --> s3 : processRule2
s5 --> s4 : processRule3
s5 --> s2 : processRule4
s5 --> s2 : processRule5
s5 --> s0 : processOtherwise
s0 --> s6 : processEncodeAnswer
s1 --> s6 : processEncodeAnswer
s3 --> s6 : processEncodeAnswer
s4 --> s6 : processEncodeAnswer
s2 --> s6 : processEncodeAnswer
s7 --> s6 : processEncodeAnswer
@enduml

```

## Prism source

Every file the builder wrote, laid out as a repository created from UOR-Foundation/template; the download prism-utqc-row-honesty.zip has them all.

- app/src/Architecture.lex.tex (420 lines)
- app/src/Compliance.lex.tex (56 lines)
- app/src/Design.lex.tex (626 lines)
- app/src/Features.lex.tex (137 lines)
- app/src/Quality.lex.tex (382 lines)
- app/src/Security.lex.tex (607 lines)
- app/src/UtqcRowHonesty.lex.tex (269 lines)
- app/src/UtqcRowHonestyProofs.lex.tex (165 lines)
- app/lexlean.toml (43 lines)
- app/prompt.json (427 lines)
- model/ids.toml (65 lines)
- features/suites/utqc\_row\_honesty.feature (44 lines)
- crates/conformance/tests/utqc\_row\_honesty.rs (132 lines)
- site/app.json (115 lines)
- openspec/specs/utqc-row-honesty/spec.md (188 lines)
