Markdown for LLMs

Execution rounds: boundaries

The source Markdown for this article. Copy it into your assistant or download it as a text file.

# Execution rounds: boundaries

What the construct does NOT do: limits, reserved values, neighbouring constructs and the selection rule.
Below, "in 0.2" means "on the installed engine, a `0.2` query executes under the current revision".

## Does not do

- **Not execute the reserve.** A `stage` node with `status: "reserved"` (empty
  body) is rejected with `NON_EXECUTABLE_STAGE` in every revision, including
  0.2.4 and 0.3. The reserve is a named place for future
  stratification, not a switched-off round.
- **Not execute the body on former revisions.** A query with an explicit
  `0.2.0`, `0.2.1`, `0.2.2`, `0.2.3` tail (and without a query — a CLIR envelope
  with such a `semanticVersion`) on an executable body answers the former
  `NON_EXECUTABLE_STAGE`. A semantically live
  possibility unknown to the named revision is a hard error.
- **Not express process branching and jurisdiction collisions.**
  Procedures and the L7 level are not expressed via `stage`;
  closures over round predicates are the named boundary
  (`LDC-E4125`).
- **Not cache phase setups nor move `focused_truth`.** Round phase setups
  are not cached by program kind; `focused_truth` over a cone above a program
  with `stage` was not considered.
- **Not show indexed `why_not` in the Lean mechanization.**
  Order over rule instances with an index was proved, but
  `why_not` with an index, round-carrier effects and positions and
  "round–outside" edges did not enter the slice.
- **Not substitute finiteness with a limit.** Neither `maxStages` nor the argumentation limit
  gives finiteness: it follows from the declaration-set domain. A domain wider than the limit refuses predictably on round
  `maxStages + 1` (`RESOURCE_LIMIT`).

## Only works in the current revision (former "0.3")

The executable `stage` body (index, domain, ranks, three rule classes,
order, `attributes.stage`), the `Date` calendar index with the `{count, unit}`
step object, transitive closure of upper rules,
several disjoint `stage`, norms and effects as producers of
their own round, the round form in `why_not`, the
nonmonotone-read refusal with an underived shift. Version check by own
run during this research: both examples with the `version "0.2"` header
executed rounds (`law test` 4/4), the reserve answered `NON_EXECUTABLE_STAGE`
(see `README.md`, section 4). What of this list would be unavailable on a
`0.2.3` envelope — see `pitfalls.md`, item 8.

## Reserved and closed

- The index direction is closed: `ascending` (default, `from ≤ to`) or
  `descending` (`from ≥ to`); anything else — `LDC-E4122 STAGE_DOMAIN_EMPTY`.
- `Date` step units closed under the `add_calendar_period` calendar units
  (`calendar_day`, `calendar_week`, `calendar_month`, `calendar_year`);
  `count` — an integer no less than one.
- There is no calendar step backwards: a `Date` shift is only
  `add_calendar_period(d, <count> <unit>)` of the declaration step and only
  under `ascending`.
- The `maxStages` counter is seventh in the fixed resource order, set by the case
  (`options.limits.maxStages`), default 4096, checked at the start of
  every round; in programs without an executable `stage` it is not counted and
  does not enter the manifest.

## Neighbours and the selection rule

- `stage` vs a strict-rule chain: round closure vs conclusion
  in one stratum. See the selection table in `README.md`.
- `stage` vs `priority`: set order vs conflict resolution
  inside a set; conflicts gather per round separately.
- `stage` vs `procedure`: sequential rounds of one world vs
  process branching; they do not live together (`LDC-E4126`).
- `stage` vs power effect: since revision 0.2.4 an effect with a round
  target is a producer of its own round, not a late producer;
  in a program without `stage` the remainder is as before.
- `stage` vs feeding rounds as facts: an explicit round number in case facts
  works without `stage` but gives no round closure — the reader sees an
  unfinished set. So did the corpus bypass missing rounds earlier; new
  formalizations of iterative procedures write `stage`.