# Atlas walk controls

> Find the next state of the Atlas Explorer view from the button pressed. Then each walk through the E8 orbit can be replayed step by step.

Inspired by afflom/atlas-explorer (https://github.com/afflom/atlas-explorer), live at https://afflom.github.io/atlas-explorer/. An interactive explorer of the UOR Atlas inside E8: 120 root classes, the 48-class Atlas instances and their reflection orbit. Pattern: State machine, OMG UML 2.5.1 behavioral state machine. To write one of your own, follow How to build a state machine app (../../guides/state-machine/index.md). The prompt below is data, quoted from the example.

**Figure: The Atlas walk controls state machine.** Each box is a state and each arrow a step a rule can take. A run starts at home. Dashed arrows go back to an earlier state.

| From | Link | To |
| --- | --- | --- |
| home | 3 rules | home |
| home | REQ-009 | away |
| home | REQ-006 | walking |
| away | 2 rules | home |
| away | 2 rules | away |
| away | REQ-006 | walking |
| away | REQ-010 | returning |
| walking | REQ-003 | walking |
| walking | REQ-001 | home |
| walking | REQ-002 | away |
| returning | REQ-005 | returning |
| returning | REQ-004 | home |

Verified by prismpm verify in the pinned SDK. Fingerprint: 5cfff7a15213b61f2a400fbae06c4dd667f2ce39ae5edeeb7cf2abe3940056b6. Acceptance vectors: 41. Claims: 8.

## The prompt

```json
{
  "schema": "prism/prompt/1",
  "goal": "Find the next state of the Atlas Explorer view from the button pressed. Then each walk through the E8 orbit can be replayed step by step.",
  "pattern": "stateMachine",
  "machine": {
    "state": "state",
    "initial": "home",
    "final": []
  },
  "repository": "afflom/atlas-explorer",
  "app": {
    "name": "atlas-explorer-walk",
    "title": "Atlas walk controls",
    "purpose": "Decide where the Atlas instance stands after a Dynamics control event: at A0, away from it, in a random walk, or walking home.",
    "fields": [
      {
        "name": "state",
        "kind": "choice",
        "values": [
          "home",
          "away",
          "walking",
          "returning"
        ],
        "means": "where the instance stands now: A0, another instance, a running random walk, or a running walk home"
      },
      {
        "name": "event",
        "kind": "choice",
        "values": [
          "reflect",
          "walk",
          "walk-home",
          "reset",
          "finish"
        ],
        "means": "the control used, or the end of a running word"
      },
      {
        "name": "orbit",
        "kind": "choice",
        "values": [
          "mapping",
          "mapped"
        ],
        "means": "whether the census of all 75,600 instances has finished"
      },
      {
        "name": "lands",
        "kind": "choice",
        "values": [
          "a0",
          "other"
        ],
        "means": "whether the instance the event ends on is A0"
      }
    ],
    "outcomes": [
      "home",
      "away",
      "walking",
      "returning"
    ],
    "meanings": {
      "home": "the instance is A0, the canonical 48 classes",
      "away": "the instance is another of the 75,600 in the orbit",
      "walking": "a random word of 12 simple reflections is running and the controls are disabled",
      "returning": "the path back to A0 from the orbit map is running and the controls are disabled"
    },
    "rules": [
      {
        "when": [
          {
            "field": "state",
            "op": "is",
            "value": "walking"
          },
          {
            "field": "event",
            "op": "is",
            "value": "finish"
          },
          {
            "field": "lands",
            "op": "is",
            "value": "a0"
          }
        ],
        "then": "home",
        "why": "index.html runWord done: the walk ends at A0 when live.isA0"
      },
      {
        "when": [
          {
            "field": "state",
            "op": "is",
            "value": "walking"
          },
          {
            "field": "event",
            "op": "is",
            "value": "finish"
          }
        ],
        "then": "away",
        "why": "index.html runWord done: the walk ends at another instance"
      },
      {
        "when": [
          {
            "field": "state",
            "op": "is",
            "value": "walking"
          }
        ],
        "then": "walking",
        "why": "index.html setBusy: walk, reset and the simple reflection buttons are disabled while busy"
      },
      {
        "when": [
          {
            "field": "state",
            "op": "is",
            "value": "returning"
          },
          {
            "field": "event",
            "op": "is",
            "value": "finish"
          }
        ],
        "then": "home",
        "why": "index.html homeBtn: the pathToRoot word ends with the 48 classes A0 again"
      },
      {
        "when": [
          {
            "field": "state",
            "op": "is",
            "value": "returning"
          }
        ],
        "then": "returning",
        "why": "index.html setBusy: the controls stay disabled while the walk home runs"
      },
      {
        "when": [
          {
            "field": "event",
            "op": "is",
            "value": "walk"
          }
        ],
        "then": "walking",
        "why": "index.html walkBtn: runWord with 12 random simple reflections"
      },
      {
        "when": [
          {
            "field": "event",
            "op": "is",
            "value": "reset"
          }
        ],
        "then": "home",
        "why": "index.html resetBtn: loc is restored to the identity, which is A0"
      },
      {
        "when": [
          {
            "field": "event",
            "op": "is",
            "value": "reflect"
          },
          {
            "field": "lands",
            "op": "is",
            "value": "a0"
          }
        ],
        "then": "home",
        "why": "index.html applyReflection: a reflection can carry the 48 classes back onto A0"
      },
      {
        "when": [
          {
            "field": "event",
            "op": "is",
            "value": "reflect"
          }
        ],
        "then": "away",
        "why": "index.html applyReflection: a simple reflection carries the Atlas to another instance"
      },
      {
        "when": [
          {
            "field": "state",
            "op": "is",
            "value": "away"
          },
          {
            "field": "event",
            "op": "is",
            "value": "walk-home"
          },
          {
            "field": "orbit",
            "op": "is",
            "value": "mapped"
          }
        ],
        "then": "returning",
        "why": "index.html: homeBtn is enabled only when orbit.done and the instance is not A0"
      },
      {
        "when": [
          {
            "field": "state",
            "op": "is",
            "value": "away"
          }
        ],
        "then": "away",
        "why": "index.html: walk home is disabled until the orbit is mapped, and finish does nothing when no word runs"
      }
    ],
    "otherwise": "home",
    "otherwiseWhy": "at A0, walk home is disabled and finish does nothing, so the instance stays home",
    "properties": [
      {
        "kind": "never",
        "when": [
          {
            "field": "state",
            "op": "is",
            "value": "home"
          }
        ],
        "then": "returning",
        "why": "index.html: homeBtn is disabled when live.isA0"
      },
      {
        "kind": "never",
        "when": [
          {
            "field": "state",
            "op": "is",
            "value": "away"
          },
          {
            "field": "orbit",
            "op": "is",
            "value": "mapping"
          }
        ],
        "then": "returning",
        "why": "index.html: walk home needs the orbit map to find the path to A0"
      },
      {
        "kind": "always",
        "when": [
          {
            "field": "state",
            "op": "is",
            "value": "walking"
          },
          {
            "field": "event",
            "op": "is",
            "value": "reflect"
          }
        ],
        "then": "walking",
        "why": "index.html setBusy: reflections are disabled during a walk"
      },
      {
        "kind": "always",
        "when": [
          {
            "field": "event",
            "op": "is",
            "value": "reset"
          },
          {
            "field": "state",
            "op": "is not",
            "value": "walking"
          },
          {
            "field": "state",
            "op": "is not",
            "value": "returning"
          }
        ],
        "then": "home",
        "why": "reset always restores A0 when it is enabled"
      },
      {
        "kind": "never",
        "when": [
          {
            "field": "state",
            "op": "is",
            "value": "returning"
          },
          {
            "field": "event",
            "op": "is",
            "value": "finish"
          }
        ],
        "then": "away",
        "why": "the walk home always ends at A0"
      }
    ],
    "examples": [
      {
        "request": "home walk mapping other",
        "response": "walking"
      },
      {
        "request": "walking finish mapped other",
        "response": "away"
      },
      {
        "request": "away walk-home mapped a0",
        "response": "returning"
      },
      {
        "request": "returning finish mapped a0",
        "response": "home"
      },
      {
        "request": "away walk-home mapping other",
        "response": "away"
      },
      {
        "request": "walking reset mapped a0",
        "response": "walking"
      },
      {
        "request": "home reflect mapping other",
        "response": "away"
      }
    ]
  },
  "stakeholders": [
    {
      "name": "Visitor",
      "text": "Explores the E8 reflection orbit of the Atlas and needs every control to do what it says, and nothing while a walk runs.",
      "concerns": [
        "Correct answers"
      ]
    },
    {
      "name": "Mathematician",
      "text": "Checks that the walk home always returns the 48 classes to A0 and that block reorderings are gauge transformations.",
      "concerns": [
        "Proved guarantees"
      ]
    }
  ],
  "components": [
    {
      "name": "UOR Atlas Explorer page",
      "text": "The single-page explorer on GitHub Pages that draws the 120 classes and runs the reflection walks.",
      "kind": "staticSite"
    }
  ],
  "threats": [
    {
      "name": "Walk home without a map",
      "text": "Walk home is pressed before the orbit census finishes, so there is no path to A0.",
      "stride": "denialOfService",
      "asset": "answer",
      "likelihood": "low",
      "impact": "minor",
      "control": {
        "name": "Map before home",
        "text": "Walk home leaves away only once the orbit is mapped.",
        "evidence": [
          {
            "kind": "proof",
            "reference": "AtlasExplorerWalkProofs::inv002Holds"
          },
          {
            "kind": "review",
            "reference": "index.html setBusy"
          }
        ]
      }
    },
    {
      "name": "Overlapping words",
      "text": "A control starts a second reflection word while one runs, so the instance shown is not the one the word reaches.",
      "stride": "tampering",
      "asset": "answer",
      "likelihood": "medium",
      "impact": "minor",
      "control": {
        "name": "Busy lock",
        "text": "While a word runs, every control leaves the state as it is.",
        "evidence": [
          {
            "kind": "proof",
            "reference": "AtlasExplorerWalkProofs::inv003Holds"
          },
          {
            "kind": "review",
            "reference": "index.html runWord"
          }
        ]
      }
    },
    {
      "name": "Plane click during a walk",
      "text": "A click on the plane in Dynamics mode applies a reflection without checking busy.",
      "stride": "tampering",
      "asset": "answer",
      "likelihood": "low",
      "impact": "minor",
      "accepted": "The machine models the Dynamics buttons that setBusy disables; the plane click handler in index.html is not gated by busy and is outside this model."
    }
  ],
  "quality": [
    {
      "characteristic": "Interaction capability",
      "subcharacteristic": "User error protection",
      "requirement": "Disabled controls stay disabled",
      "text": "No button press changes the state while a walk or a walk home runs.",
      "measure": "Button transitions during a word",
      "measureText": "Requests in walking or returning, other than finish, that answer a different state.",
      "threshold": 0
    },
    {
      "characteristic": "Functional suitability",
      "subcharacteristic": "Functional completeness",
      "requirement": "Every state reachable",
      "text": "Each of the four states is reachable from home.",
      "measure": "Unreachable states",
      "measureText": "States no sequence of events reaches from the initial state.",
      "threshold": 0
    }
  ],
  "journeys": [
    {
      "stakeholder": "Visitor",
      "steps": [
        "REQ-006",
        "REQ-003",
        "REQ-002",
        "REQ-007"
      ]
    },
    {
      "stakeholder": "Mathematician",
      "steps": [
        "REQ-009",
        "REQ-010",
        "REQ-004",
        "INV-005"
      ]
    }
  ],
  "axioms": {
    "inv003Holds": [
      "Classical.choice",
      "Quot.sound",
      "propext"
    ],
    "inv004Holds": [
      "Classical.choice",
      "Quot.sound",
      "propext"
    ]
  },
  "concerns": [],
  "license": "MIT OR Apache-2.0"
}
```

## Claims

- AE-01: The app never answers returning when state is home
- AE-02: The app never answers returning when state is away and orbit is mapping
- AE-03: The app always answers walking when state is walking and event is reflect
- AE-04: The app always answers home when event is reset and state is not walking and state is not returning
- AE-05: The app never answers away when state is returning and event is finish
- AE-06: The architecture description declares every stakeholder, concern, component, edge, viewpoint and view it references
- AE-07: The ISO/IEC 25010 quality model numbers every characteristic, subcharacteristic, requirement and measure, and every parent it names is declared
- AE-08: Every compliance obligation is numbered in order and names its evidence

## Pattern

State machine: OMG UML 2.5.1 behavioral state machine. The answer is the next state, given the current state and an event. This is a UML state machine written as one pure function. The state travels in the request, so the app keeps nothing between requests. The builder proves what holds over every run.

| Pattern | Standard | Answers |
| --- | --- | --- |
| State machine | OMG UML 2.5.1 behavioral state machine | home, away, walking, returning |

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

|  | rules |
| --- | --- |
| home | 4 |
| away | 3 |
| walking | 2 |
| returning | 2 |

## Behavior

A request is state, event, orbit, lands, separated by spaces. The first rule that matches decides. If none matches, the answer is home. A request over 112 bytes, or in any other form, is answered invalid.

| Rule | When | Answer | Why |
| --- | --- | --- | --- |
| REQ-001 | state is walking and event is finish and lands is a0 | home | index.html runWord done: the walk ends at A0 when live.isA0 |
| REQ-002 | state is walking and event is finish | away | index.html runWord done: the walk ends at another instance |
| REQ-003 | state is walking | walking | index.html setBusy: walk, reset and the simple reflection buttons are disabled while busy |
| REQ-004 | state is returning and event is finish | home | index.html homeBtn: the pathToRoot word ends with the 48 classes A0 again |
| REQ-005 | state is returning | returning | index.html setBusy: the controls stay disabled while the walk home runs |
| REQ-006 | event is walk | walking | index.html walkBtn: runWord with 12 random simple reflections |
| REQ-007 | event is reset | home | index.html resetBtn: loc is restored to the identity, which is A0 |
| REQ-008 | event is reflect and lands is a0 | home | index.html applyReflection: a reflection can carry the 48 classes back onto A0 |
| REQ-009 | event is reflect | away | index.html applyReflection: a simple reflection carries the Atlas to another instance |
| REQ-010 | state is away and event is walk-home and orbit is mapped | returning | index.html: homeBtn is enabled only when orbit.done and the instance is not A0 |
| REQ-011 | state is away | away | index.html: walk home is disabled until the orbit is mapped, and finish does nothing when no word runs |
| otherwise | no rule matches | home | at A0, walk home is disabled and finish does nothing, so the instance stays home |

## State machine

The state is state, and the answer is the next state. A run feeds each answer back in as the next state, starting from home (OMG UML 2.5.1, clause 14). All 80 requests of the spec's sample were stepped to find the states a run can reach. Every state can be reached and none is final, so every state is allowed in a run.

| State | Kind | Meaning |
| --- | --- | --- |
| home | initial, reachable | the instance is A0, the canonical 48 classes |
| away | reachable | the instance is another of the 75,600 in the orbit |
| walking | reachable | a random word of 12 simple reflections is running and the controls are disabled |
| returning | reachable | the path back to A0 from the orbit map is running and the controls are disabled |

## Transitions

Every step a reachable state can take, and the rule that takes it.

| From | To | By |
| --- | --- | --- |
| home | home | REQ-007 |
| home | home | REQ-008 |
| home | home | otherwise |
| home | away | REQ-009 |
| home | walking | REQ-006 |
| away | home | REQ-007 |
| away | home | REQ-008 |
| away | away | REQ-009 |
| away | away | REQ-011 |
| away | walking | REQ-006 |
| away | returning | REQ-010 |
| walking | walking | REQ-003 |
| walking | home | REQ-001 |
| walking | away | REQ-002 |
| returning | returning | REQ-005 |
| returning | home | REQ-004 |

## 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 returning when state is home. | AtlasExplorerWalkProofs::inv001Holds | index.html: homeBtn is disabled when live.isA0 |
| INV-002 | It never answers returning when state is away and orbit is mapping. | AtlasExplorerWalkProofs::inv002Holds | index.html: walk home needs the orbit map to find the path to A0 |
| INV-003 | It always answers walking when state is walking and event is reflect. | AtlasExplorerWalkProofs::inv003Holds | index.html setBusy: reflections are disabled during a walk |
| INV-004 | It always answers home when event is reset and state is not walking and state is not returning. | AtlasExplorerWalkProofs::inv004Holds | reset always restores A0 when it is enabled |
| INV-005 | It never answers away when state is returning and event is finish. | AtlasExplorerWalkProofs::inv005Holds | the walk home always ends at A0 |

## Architecture

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

| Stakeholder | Who they are | Concerns |
| --- | --- | --- |
| Mathematician | Checks that the walk home always returns the 48 classes to A0 and that block reorderings are gauge transformations. | Proved guarantees |
| 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 |
| Visitor | Explores the E8 reflection orbit of the Atlas and needs every control to do what it says, and nothing while a walk runs. | Correct answers |

## 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 home 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 |
| Proved guarantees | Each of the 5 properties of the spec holds for every request, proved by the Lean kernel. | quality |
| Refused malformed requests | A request that is not the 4 fields in order, or is longer than 112 bytes, is answered invalid and never guessed. | security |

## Components

7 components and 9 edges between them.

| Component | Kind | What it is |
| --- | --- | --- |
| Atlas walk controls guest | service | The Core-Wasm guest built from the model: it answers one request of at most 112 bytes with one answer of at most 64. |
| Atlas walk controls page | staticSite | The page the template publishes: the holo, its fingerprint, its provenance and its acceptance vectors. |
| Browser | externalSystem | The visitor's web browser, which loads the page and runs the Atlas walk controls guest. |
| GitHub Pages | externalSystem | Serves the page and the holo from the repository Pages workflow. |
| 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. |
| UOR Atlas Explorer page | staticSite | The single-page explorer on GitHub Pages that draws the 120 classes and runs the reflection walks. |

## Design views

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

| View | Diagram | Viewpoint |
| --- | --- | --- |
| Deciding a Atlas walk controls request | opmObjectProcess | Visitor: Correct answers |
| Components of Atlas walk controls | umlComponent | Verifier: Integrity of the published app |
| Answering a Atlas walk controls request | umlSequence | Visitor: Correct answers |
| States of the Atlas walk controls guest | umlStateMachine | Verifier: Refused malformed requests |
| The Atlas walk controls state machine | umlStateMachine | Visitor: Correct answers |

## Features and journeys

18 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 state is walking and event is finish and lands is a0, the answer is home. | AtlasExplorerWalk::rule1, AtlasExplorerWalk::judge | AtlasExplorerWalk::application |
| When state is walking and event is finish, the answer is away. | AtlasExplorerWalk::rule2, AtlasExplorerWalk::judge | AtlasExplorerWalk::application |
| When state is walking, the answer is walking. | AtlasExplorerWalk::rule3, AtlasExplorerWalk::judge | AtlasExplorerWalk::application |
| When state is returning and event is finish, the answer is home. | AtlasExplorerWalk::rule4, AtlasExplorerWalk::judge | AtlasExplorerWalk::application |
| When state is returning, the answer is returning. | AtlasExplorerWalk::rule5, AtlasExplorerWalk::judge | AtlasExplorerWalk::application |
| When event is walk, the answer is walking. | AtlasExplorerWalk::rule6, AtlasExplorerWalk::judge | AtlasExplorerWalk::application |
| When event is reset, the answer is home. | AtlasExplorerWalk::rule7, AtlasExplorerWalk::judge | AtlasExplorerWalk::application |
| When event is reflect and lands is a0, the answer is home. | AtlasExplorerWalk::rule8, AtlasExplorerWalk::judge | AtlasExplorerWalk::application |
| When event is reflect, the answer is away. | AtlasExplorerWalk::rule9, AtlasExplorerWalk::judge | AtlasExplorerWalk::application |
| When state is away and event is walk-home and orbit is mapped, the answer is returning. | AtlasExplorerWalk::rule10, AtlasExplorerWalk::judge | AtlasExplorerWalk::application |
| When state is away, the answer is away. | AtlasExplorerWalk::rule11, AtlasExplorerWalk::judge | AtlasExplorerWalk::application |
| When no rule matches, the answer is home. | AtlasExplorerWalk::judge | AtlasExplorerWalk::application |
| A request that is not state, event, orbit, lands in order, separated by single spaces, or is over 112 bytes, is answered invalid. | AtlasExplorerWalk::dispatch, AtlasExplorerWalk::decodeField1 | AtlasExplorerWalk::application |
| It never answers returning when state is home. | AtlasExplorerWalk::judge | AtlasExplorerWalkProofs::inv001Holds |
| It never answers returning when state is away and orbit is mapping. | AtlasExplorerWalk::judge | AtlasExplorerWalkProofs::inv002Holds |
| It always answers walking when state is walking and event is reflect. | AtlasExplorerWalk::judge | AtlasExplorerWalkProofs::inv003Holds |
| It always answers home when event is reset and state is not walking and state is not returning. | AtlasExplorerWalk::judge | AtlasExplorerWalkProofs::inv004Holds |
| It never answers away when state is returning and event is finish. | AtlasExplorerWalk::judge | AtlasExplorerWalkProofs::inv005Holds |

## Journeys

The ordered features each stakeholder takes.

| Stakeholder | Steps |
| --- | --- |
| Mathematician | REQ-009 → REQ-010 → REQ-004 → INV-005 |
| Verifier | refuse → INV-001 → INV-002 → INV-003 → INV-004 → INV-005 |
| Visitor | REQ-006 → REQ-003 → REQ-002 → REQ-007 |

## Security and threat model

14 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 AtlasExplorerWalkProofs::inv001Holds |
| Answer that breaks INV-002 | repudiation | Answer | medium likelihood, critical impact | Proof of INV-002: proof AtlasExplorerWalkProofs::inv002Holds |
| Answer that breaks INV-003 | repudiation | Answer | medium likelihood, critical impact | Proof of INV-003: proof AtlasExplorerWalkProofs::inv003Holds |
| Answer that breaks INV-004 | repudiation | Answer | medium likelihood, critical impact | Proof of INV-004: proof AtlasExplorerWalkProofs::inv004Holds |
| Answer that breaks INV-005 | repudiation | Answer | medium likelihood, critical impact | Proof of INV-005: proof AtlasExplorerWalkProofs::inv005Holds |
| 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 |
| Overlapping words | tampering | Answer | medium likelihood, minor impact | Busy lock: proof AtlasExplorerWalkProofs::inv003Holds; review index.html runWord |
| 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 |
| Plane click during a walk | tampering | Answer | low likelihood, minor impact | accepted: The machine models the Dynamics buttons that setBusy disables; the plane click handler in index.html is not gated by busy and is outside this model. |
| 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 |
| Walk home without a map | denialOfService | Answer | low likelihood, minor impact | Map before home: proof AtlasExplorerWalkProofs::inv002Holds; review index.html setBusy |

## 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 224 bytes for one request. | Performance efficiency: Resource utilization | Guest allocation bytes | 224 |
| Bounded request: A request over 112 bytes is refused before any field is read. | Performance efficiency: Time behaviour | Request bytes read | 112 |
| Disabled controls stay disabled: No button press changes the state while a walk or a walk home runs. | Interaction capability: User error protection | Button transitions during a word | 0 |
| Every property proved: All 5 properties are theorems the Lean kernel checks. | Security: Integrity | Unproved properties | 0 |
| Every request answered: Every request gets an answer: a rule, home otherwise, or invalid. | Functional suitability: Functional completeness | Unanswered requests | 0 |
| Every state reachable: Each of the four states is reachable from home. | Functional suitability: Functional completeness | Unreachable states | 0 |
| Every vector replays: All 41 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 7 examples of the spec is answered as it states. | Functional suitability: Functional correctness | Example mismatches | 0 |

## 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, Design::viewUmlMachine |
| 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 UML 2.5.1 behavioral state machine | State machine | AtlasExplorerWalk::judge |
| OpenSpec | Requirements | AtlasExplorerWalk::application |
| SPDX MIT OR Apache-2.0 | Licensing | AtlasExplorerWalk::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 Atlas walk controls request
Viewpoint: Architecture::viewpointVisitorCorrectAnswers
Notation: ISO/PAS 19450:2015 OPM, Prism OPL profile

componentAtlasWalkControlsGuest is an object.
componentAtlasWalkControlsGuest can be stateDeciding or stateIdle.
componentBrowser is an object.
processDecide is a process.
processEncodeAnswer is a process.
processJudge is a process.
processParseRequest is a process.
componentAtlasWalkControlsGuest 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 Atlas walk controls
component "componentAtlasWalkControlsGuest" as c0
component "componentAtlasWalkControlsPage" as c1
component "componentBrowser" as c2
component "componentGitHubPages" as c3
component "componentPrismBuild" as c4
component "componentSourceRepository" as c5
component "componentUORAtlasExplorerPage" as c6
c0 --> c2 : edgeAtlasWalkControlsGuestToBrowser
c0 --> c6 : edgeAtlasWalkControlsGuestToUORAtlasExplorerPage
c1 --> c3 : edgeAtlasWalkControlsPageToGitHubPages
c2 --> c0 : edgeBrowserToAtlasWalkControlsGuest
c3 --> c2 : edgeGitHubPagesToBrowser
c4 --> c0 : edgePrismBuildToAtlasWalkControlsGuest
c4 --> c1 : edgePrismBuildToAtlasWalkControlsPage
c5 --> c4 : edgeSourceRepositoryToPrismBuild
c6 --> c0 : edgeUORAtlasExplorerPageToAtlasWalkControlsGuest
@enduml

```

### design/Design.viewUmlMachine.puml

```
@startuml
' UML 2.5.1 state machine diagram
' view: Design::viewUmlMachine
' viewpoint: Architecture::viewpointVisitorCorrectAnswers
title The Atlas walk controls state machine
state "stateMachineAway" as s0
state "stateMachineHome" as s1
state "stateMachineReturning" as s2
state "stateMachineWalking" as s3
[*] --> s1
s1 --> s1 : processRule7
s1 --> s1 : processRule8
s1 --> s1 : processOtherwise
s1 --> s0 : processRule9
s1 --> s3 : processRule6
s0 --> s1 : processRule7
s0 --> s1 : processRule8
s0 --> s0 : processRule9
s0 --> s0 : processRule11
s0 --> s3 : processRule6
s0 --> s2 : processRule10
s3 --> s3 : processRule3
s3 --> s1 : processRule1
s3 --> s0 : processRule2
s2 --> s2 : processRule5
s2 --> s1 : processRule4
@enduml

```

### design/Design.viewUmlRequest.puml

```
@startuml
' UML 2.5.1 sequence diagram
' view: Design::viewUmlRequest
' viewpoint: Architecture::viewpointVisitorCorrectAnswers
title Answering a Atlas walk controls request
participant "componentBrowser" as p0
participant "componentAtlasWalkControlsGuest" 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 Atlas walk controls guest
state "stateAnsweredAway" as s0
state "stateAnsweredHome" as s1
state "stateAnsweredReturning" as s2
state "stateAnsweredWalking" as s3
state "stateDeciding" as s4
state "stateIdle" as s5
state "stateRefused" as s6
[*] --> s5
s5 --> s4 : processParseRequest
s5 --> s6 : processParseRequest
s4 --> s1 : processRule1
s4 --> s0 : processRule2
s4 --> s3 : processRule3
s4 --> s1 : processRule4
s4 --> s2 : processRule5
s4 --> s3 : processRule6
s4 --> s1 : processRule7
s4 --> s1 : processRule8
s4 --> s0 : processRule9
s4 --> s2 : processRule10
s4 --> s0 : processRule11
s4 --> s1 : processOtherwise
s1 --> s5 : processEncodeAnswer
s0 --> s5 : processEncodeAnswer
s3 --> s5 : processEncodeAnswer
s2 --> s5 : processEncodeAnswer
s6 --> s5 : processEncodeAnswer
@enduml

```

## Prism source

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

- app/src/Architecture.lex.tex (357 lines)
- app/src/Compliance.lex.tex (56 lines)
- app/src/Design.lex.tex (822 lines)
- app/src/Features.lex.tex (193 lines)
- app/src/Quality.lex.tex (382 lines)
- app/src/Security.lex.tex (635 lines)
- app/src/AtlasExplorerWalk.lex.tex (323 lines)
- app/src/AtlasExplorerWalkProofs.lex.tex (269 lines)
- app/lexlean.toml (43 lines)
- app/prompt.json (481 lines)
- model/ids.toml (71 lines)
- features/suites/atlas\_explorer\_walk.feature (50 lines)
- crates/conformance/tests/atlas\_explorer\_walk.rs (142 lines)
- site/app.json (125 lines)
- openspec/specs/atlas-explorer-walk/spec.md (262 lines)
