Reference › Language reference › Operational & requirements

Reference › Language reference

Operational & requirements

Who uses the system, what it is for, and what it shall do.

On this page: actor · mission · requirement · verify · means · defaults · decision · deliverable

Who uses the system, what it is for, what it shall do, and the documents that say so.

actor#

An external entity that interacts with the system (actors.yaml).

  • Keywords: actor
  • Set: functional analysis & scenarios
  • Where: top level
  • Syntax: actor id "Name" { description "…" }
Property Value Meaning
description text Prose description. $…$ and $$…$$ are LaTeX math; a ```latex block is kept as LaTeX.
actor driver "Driver" { description "Supervises the vehicle and can take over." }

mission#

A high-level goal the system must fulfil (missions.yaml).

  • Keywords: mission (old spelling: goal)
  • Set: functional analysis & scenarios
  • Where: top level
  • Syntax: mission id "Name" { involves [actors] }
Property Value Meaning
description text Prose description. $…$ and $$…$$ are LaTeX math; a ```latex block is kept as LaTeX.
involves list of actor names Actors involved.
mission reach-destination "Reach the destination safely" { involves driver, passenger }

requirement#

A requirement. Top-level ones go to requirements.yaml; nested ones stay on their element.

  • Keywords: requirement (old spelling: req)
  • Set: the model
  • Where: top level, inside component, inside system, inside port, inside fn, inside link
  • Syntax: requirement ID "Name" { text "The system shall …" priority high … }
Property Value Meaning
description text Prose description. $…$ and $$…$$ are LaTeX math; a ```latex block is kept as LaTeX.
text text The requirement statement ("shall"). LaTeX math allowed.
rationale text Why it exists.
math code A LaTeX formula that is part of the requirement.
priority low | medium | high | critical Priority.
complexity easy | medium | hard Rough complexity estimate (Arche writes Easy, Medium, Hard).
status draft | proposed | approved | implemented | verified | obsolete Lifecycle status.
category ident functional, performance, safety, interface…
method test | analysis | inspection | demonstration Verification method: test, analysis, inspection, demonstration (Arche verification).
asil any Its ISO 26262 level: QM, A … D — that of what it derives from (a safety goal, a requirement), or a decomposition of it written asil "B(D)", two or more decomposed requirements adding up to the parent's level on independent elements (archec cert).
dal A | B | C | D | E | a | b | c | d | e Its DO-178C design assurance level: A (catastrophic) … E — that of what it derives from.
ears string The requirement in EARS, about the parts of the model: when brakes receives BRAKE_CMD, brakes shall be in Braking within 50ms; while …, (state-driven), if … then (unwanted), none (ubiquitous). Checked against the parts, states and messages; it gives the text when there is none, a formal property for archec verify, and a test case (archec gen --target ears-tests).
formal string What the model checker proves of the state machines (archec verify, NuSMV): never brakes in Fault, always …, eventually …, adcu in Ready leads to adcu in Autonomous — parts by their path, in a state (or one inside it), and, or, not. eventually and leads to take a deadline, within 50ms: the monitors, archec replay and archec verify --conflicts check it; NuSMV, untimed, checks the property without it.
metric any The measured quantity that makes the requirement checkable (with limit). A message field (metric BRAKE_CMD.force) is measured in the real system's logs by archec replay.
sourced ref Every bought part of a system has a part number (product { part-number "…" }), so it can be ordered: sourced Assembly. A part is bought unless its component is made here (it has a cad or a pcb) or it comes with a bought part. Checked by archec cad, evidence for the requirement.
limit any The bound the metric must respect: "<= 12000", "0..100", or a number, a maximum. Or, by itself, a bound on what archec cad measures of a part's geometry (repeatable): limit Enclosure.size <= 120mm, 80mm, 45mm (along x, y, z), limit Enclosure.mass <= 250g, limit Enclosure.volume <= 90cm³ — recorded as evidence for the requirement (docs/cad.md).
clearance any The least distance between two parts placed by their cad geometry (at), measured by archec cad: clearance board, relay >= 2mm. Parts that touch are at 0mm; parts that run into each other fail any clearance. In a system, a clearance not kept is an error of archec cad; in a requirement, it is evidence for it.
fits any A board's mounting holes are over the standoffs of the part that holds it: fits board, box, within 0.2 mm, or fits board, box <= 0.5mm. The holes are those of the board's pcb (a KiCad board), else its hole lines; the standoffs are the mounts = {"board": [(x, y, z), …]} of the box's geometry file, under the anchor the board sits at (at box.board). Checked by archec cad; in a requirement, it is evidence for it.
derives list of requirement names Parent requirements this one derives from.
refines list of element names Elements this one refines.
verified-by list of test plan names Old form, read until 0.13: write verifies on the test plan, case or scenario that verifies it (archec fmt moves it).
satisfied-by list of element names Old form, read until 0.13: write satisfies on the element that satisfies it (archec fmt moves it).
mission list of mission names Mission it serves.
document deliverable name The deliverable it is written in: the requirement is listed in that document (Documentation page).
origin text Where it comes from: a customer reference, a document, a parent system requirement (Arche source).
source text Old name of origin (source is where code lives, on a component or a function): still read, archec fmt --simplify renames it.
owner string Who answers for it.
issue string Its issue in the tracker (Jira, GitHub, GitLab): written by archec issues sync when it opens one for a failing case or an unverified requirement, or by hand to link one.
tbc bool To be confirmed: the value or the wording is not final.
tags list of tag names Tags from the tag catalog.
requirement REQ-BRK-001 "Emergency braking distance" {
  text "The vehicle shall stop within $d \le \frac{v^2}{2\mu g} + v\,t_r$."
  priority critical
  method test
}

verify#

How it is verified (IVV): at which level, with which means, by which procedure, and the test cases that do it.

  • Keywords: verify (old spelling: ivv)
  • Set: the model
  • Where: inside requirement, inside component, inside system, inside link
  • Syntax: verify { level integration; means "…"; procedure "…" }
Property Value Meaning
level ident unit, integration, system, acceptance…
means any The means (bench, simulator, tool): a text, or the name of a means declared once.
procedure text What is done, and what is expected.
tests list of case names The test cases that verify it. In a requirement, an old form read until 0.13: write verifies on each case (from 0.13 the requirement's ivv lists them).
verify {
  level integration
  means "Integration bench" fr "Banc d'intégration"
  procedure "Type POINT 10 20: one OK line."
}

means#

A means of verification (a bench, a simulator, a tool) named once: verify { means bench } then says it by name, and Arche gets its text (and translations) as if written there.

  • Keywords: means
  • Set: functional analysis & scenarios
  • Where: top level
  • Syntax: means id "What it is" [en "…"]
means bench "Banc d'intégration KR260" en "KR260 integration bench"

defaults#

Values the requirements (or verify blocks…) of this file share, written once: each one that does not set a property takes it from here. At the top of a file it covers the whole file; inside a component or system, that block and what it contains, in this file. The nearest defaults wins, and an element's own value always does. The generated project is the same as if each element wrote them.

  • Keywords: defaults
  • Set: the model
  • Where: top level, inside component, inside system
  • Syntax: defaults requirement { status draft; method test; document SRS }
defaults requirement { status draft; method test; document SRS }

decision#

A design decision (an architecture decision record): the context, the options weighed, the one chosen and why, what it answers and what it affects. Written to Arche as a requirement of category decision — listed, linked and documented with the requirements — with answers as a derives trace and affects as satisfies traces from the elements that carry it out.

  • Keywords: decision (old spelling: adr)
  • Set: safety, security & design space
  • Where: top level
  • Syntax: decision ADR-n "Title" { status accepted; context "…"; option "A"; option "B"; chosen "A"; because "…"; answers REQ-…; affects element… }
Property Value Meaning
description text Prose description. $…$ and $$…$$ are LaTeX math; a ```latex block is kept as LaTeX.
status proposed | accepted | rejected | superseded | deprecated Where it stands.
context text The situation that asks for a decision.
option text An option weighed (repeatable).
chosen text The option taken.
because text Why (Arche rationale).
consequences text What follows from it, good and bad.
answers list of requirement names The requirements it answers.
affects list of element names The elements that carry it out.
supersedes list of requirement names Earlier decisions it replaces.
date string When it was taken, YYYY-MM-DD.
owner string Who took it.
tags list of tag names Tags from the tag catalog.
decision ADR-007 "A lockstep core owns the brake path" {
  status accepted
  context "The emergency brake must survive a single core fault."
  option "Lockstep core"
  option "Two independent MCUs"
  chosen "Lockstep core"
  because "One part, diagnostics in hardware, no voting software."
  answers REQ-SAF-001
  affects Car.adcu.brakes_path
}

deliverable#

A document the project delivers — a specification, an ICD, a design (deliverables.yaml). The Documentation page assembles each one from the model: the requirements whose document names it and what it covers.

  • Keywords: deliverable
  • Set: functional analysis & scenarios
  • Where: top level
  • Syntax: deliverable ID "Name" { group "Software" kind specification status draft covers [REQ-1] }
Property Value Meaning
description text Prose description. $…$ and $$…$$ are LaTeX math; a ```latex block is kept as LaTeX.
group string The heading it is listed under on the Documentation page.
kind ident What it is: specification, ICD, design… (free text, not the kinds catalog). A mock-up is shown, not read, and is left out of the Documentation page.
status planned | in-progress | draft | review | approved | delivered | blocked Where it stands.
progress number Percent done, when someone has said.
version string Its version.
due string Due date, YYYY-MM-DD.
owner string Who writes it.
file string The document itself: a project file or a URL (deliverables.yaml document).
covers list of element names What it has to answer: requirements (read in full in the document) or any other element.
notes text Free notes, shown under its fields.
deliverable SRS "Software Requirements Specification" {
  kind specification
  status draft
  group "Software"
  version "0.3"
}