---
title: "computing-execution — Mova code model"
description: "Mova code model of models/computing-execution.groupant: components with their labels, obernants and the model text."
url: "https://groupants.elamur.ai/free/en/mova/models/computing-execution.groupant/"
---
Elamur: [Mova](https://md.mova.elamur.ai/free/en/) · [Dictionary](https://md.dictionary.elamur.ai/free/en/) · [Research](https://md.research.elamur.ai/free/en/) · **Groupants**

This page as HTML: <https://groupants.elamur.ai/free/en/mova/models/computing-execution.groupant/>

# computing-execution

The groupant beside models/computing-execution.groupant in the Mova repository: what the code computes, what it never does, how to go back from its outputs, its invariants, cost and checks.

## Facts

- **kind:** groupant_group
- **status:** partial descriptive instance
- **bound sources:** 20
- **repository folder:** [`models/computing-execution.groupant`](https://github.com/ElamurAI/mova-free/tree/main/models/computing-execution.groupant)
- **repository commit:** `855da7bd4a7b`

> **Implementation material.** A Mova code model describes this code at one source revision: partial models, finite checks and their stated scope. It is not a reviewed general exposition, and its labels are shown as written, never raised.

## Components

| component | label | where |
|---|---|---|
| **approximant** | partial | [forward](#forward) |
| **ast** | not materialized |  |
| **composition** | partial | [composition](#composition) |
| **cost** | symbolic source derived | [cost](#cost) |
| **descriptant** | present | [descriptant](#descriptant) |
| **invariant** | partial | [invariant](#invariant) |
| **tests** | see source local evidence | [checks](#checks) |

## Obernants

The typed relations around the forward model: the behaviour complement (what the code never does), the reverse reconstruction (every input compatible with an output) and specialised views.

| id | type | label | where |
|---|---|---|---|
| `behavior-complement` | behavior_complement | partial source derived model | [behavior-complement](#behavior-complement) |
| `reverse-reconstruction` | reverse_reconstruction | partial source derived model | [reverse-reconstruction](#reverse-reconstruction) |
| `frame-register-transport` | representation_transport | partial source derived model | [frame-register-transport](#frame-register-transport) |
| `parse-runtime-boundary` | failure_precedence | partial source derived model | [parse-runtime-boundary](#parse-runtime-boundary) |
| `scenario-gate-join` | observation_relation | partial source derived model | [scenario-gate-join](#scenario-gate-join) |
| `separate-routing-selection` | stable_selection | partial source derived model | [separate-routing-selection](#separate-routing-selection) |
| `wave31-virtual-filesystem-state-backend-dispatch` | tagged_union | partial composition model | [wave31-virtual-filesystem-state-backend-dispatch](#wave31-virtual-filesystem-state-backend-dispatch) |
| `wave31-virtual-filesystem-state-state-trace-split` | snapshot_projection | partial composition model | [wave31-virtual-filesystem-state-state-trace-split](#wave31-virtual-filesystem-state-state-trace-split) |
| `wave31-virtual-filesystem-state-failure-effects` | effect_boundary | partial composition model | [wave31-virtual-filesystem-state-failure-effects](#wave31-virtual-filesystem-state-failure-effects) |
| `wave31-virtual-filesystem-state-caller-join` | representation_transport | partial composition model | [wave31-virtual-filesystem-state-caller-join](#wave31-virtual-filesystem-state-caller-join) |
| `wave31-wasi-guest-runtime-vfs-coordinate-transport` | representation_transport | partial composition model | [wave31-wasi-guest-runtime-vfs-coordinate-transport](#wave31-wasi-guest-runtime-vfs-coordinate-transport) |
| `wave31-wasi-guest-runtime-failure-order` | failure_precedence | partial composition model | [wave31-wasi-guest-runtime-failure-order](#wave31-wasi-guest-runtime-failure-order) |
| `wave31-wasi-guest-runtime-resource-product` | resource_boundary | partial composition model | [wave31-wasi-guest-runtime-resource-product](#wave31-wasi-guest-runtime-resource-product) |
| `wave31-wasi-guest-runtime-test-scope` | evidence_projection | partial composition model | [wave31-wasi-guest-runtime-test-scope](#wave31-wasi-guest-runtime-test-scope) |

## Model text


### descriptant

#### computing-execution: wave30

Interp::run calls vm::run_program only after registration; VM Fallback invokes Interp::exec and DynEval invokes eval_multi through sync_out/sync_in. lib.rs exposes item identities consumed by tests. suite::run_fs consumes parser scenarios and feeds captured output to check; vm_gate compares engines independently of expected answers, so shared broken builtins can pass equivalence. layers/lib.rs is a separate tagged routing relation to math/global and Domain callbacks, with no mlab caller/callee edge; grouping does not imply runtime transport.

This source-bound partial group organizes existing Mova code. Native evidence and excluded effects are recorded in source sidecars and the root wave30 report. Registration is not a universal proof or whole-system runtime claim.

### model

## computing-execution

### forward

For mlab, parse(text)=Err implies no statement/function-registration effects; otherwise Interp registers functions and dispatches tree or VM. VM compile produces prototypes, imports workspace, executes native instructions with tree fallback/dynamic synchronization, then exports workspace even on returned runtime error. suite.parse produces Scenario(code,expect); run_fs executes each in a new interpreter/FS then check(expect,captured_output). vm_gate compares fresh tree/VM outputs, stops first differing scenario. Independent tagged relation layers.route(q,C): normalize explanation phrases for exact global math; otherwise stable finite-score descending domain attempts at score>=threshold under a finite threshold; otherwise Escalate value.

### invariant

The admitted synthetic programs preserve tree/VM expected output, prefix state on runtime error, no prefix state on parse error, matrix alias independence and short-circuit effects. Fresh suite scenarios do not share default workspace/FS. Gate line offsets are1-based and totals count visited prefix. Finite equal routing scores preserve registration order, global math precedes scoring. These are source-derived and finitely checked relations, not universal proofs.

### cost

mlab costs parse+compile+executed instructions plus delegated matrix/builtin operations, register/frame synchronization and COW copies; loops lack fuel limits, function depth is256. Suite parse/check linear in text/expectation/output; gate twice execution per visited scenario. layers adds global calc under five-second Limits, all D coverage callbacks, O(D log D) stable sorting, attempted solvers and logs. Public callbacks, allocation and wide integer casts preclude a general resource guarantee.

### composition

Interp::run calls vm::run_program only after registration; VM Fallback invokes Interp::exec and DynEval invokes eval_multi through sync_out/sync_in. lib.rs exposes item identities consumed by tests. suite::run_fs consumes parser scenarios and feeds captured output to check; vm_gate compares engines independently of expected answers, so shared broken builtins can pass equivalence. layers/lib.rs is a separate tagged routing relation to math/global and Domain callbacks, with no mlab caller/callee edge; grouping does not imply runtime transport.

### domain

CPU-only bounded synthetic programs, in-memory Vfs, valid parser-generated AST/VM prototypes and well-formed Value matrices within integer/memory limits; finite coverage scores and finite threshold for stable threshold claims. Empty programs/scenarios/output, zero-length loops and missing-variable errors explicitly represented.

### limitations

No frozen VMM/Octave/Boost/NIST or mlab suite evaluation, corpus, Monte Carlo defaults, teacher, GPU, real model or host filesystem execution. Nonfinite coverage ordering, arbitrary malformed public bytecode, overflow/allocation exhaustion and unrestricted Domain callbacks remain outside checked claims. f64 arithmetic admits NaN/Inf; no blanket finite-output guarantee.

### checks

- native-commands.json: 12 exact named tests twice debug and twice release; sorted outcomes equal
- negative-controls.json: five compiled assertion mutants, exit101, exact restoration and positive rerun
- Seven lexical source projections generated twice identically; source/fragment hashes bound in manifests
- source-test-map.json separates lib.rs compile/type evidence from actual interpreter, VM, suite, SHA and routing execution

### wave31-virtual-filesystem-state

Actual callers: mlab/src/interp.rs owns Box<dyn vfs::FileSystem>, mlab/src/builtins/files.rs and table.rs call it; open selects backend. Memory path->error->journal joins tested. wasi-host is sibling consumer of Vfs/Errno projections, not owned here. snapbench and test fixtures are independent observation paths, not production callers.

### wave31-wasi-guest-runtime

Real join: Ctx::path_open resolves through Vfs, allocates descriptor; fd_write/read use canonical stored path and Vfs::write_at/read_at, with Vfs errno and journal propagation. Tests observe holes/append/read-only/limits/escape effects. main constructs Ctx from imported Vfs, Host::run returns same context for gated exports. Tagged independent paths: example mlab_gate and tests/mlab compare external mlab::Interp to Host, neither is called by main. Memory-unit tests bypass add_wasi ABI wrappers; tiny guests have no imports, so complete linker wiring is not claimed.

### catalog

### behavior-complement

Parse failure excludes prefix effects; short-circuit false&&/true|| excludes RHS calls; invalid fast indices exclude direct writes; mismatch excludes remaining gate scenarios. Global math success excludes domain callbacks; finite below-threshold score excludes solve. Equivalent engine output does not exclude shared bugs.

### reverse-reconstruction

Preimage of (captured bytes,final workspace) contains all source/initial-state/fault triples yielding those observations; suppressed writes and overwritten locals make it many-to-one. Scenario parsing drops ignored text and trailing blank code, so inverse is set-valued. A route value admits many queries and declining-domain histories; Domain may supply arbitrary Answer.by.

### frame-register-transport

sync_out(regs,names) moves defined values into frame and removes U names; sync_in removes frame values back into Reg. Fallback wraps actual tree execution with this transport, including returned errors. Reg scalar packing is bit-sensitive for logical0/1 and preserves f64 scalar observations.

### parse-runtime-boundary

Entire parse precedes registration/execution. Runtime failure follows already executed assignments and precedes remaining statements. Ordinary indexed '=' assignment orders RHS type, target type, then indices; compound indexed assignment first reads the indexed old value and applies its binary operation, then invokes the assignment helper, evaluating indices again; user calls order excess inputs, excess outputs, depth.

### scenario-gate-join

run_fs maps each Scenario to fresh engine output and compares expected exact/prefix lines; vm_gate compares tree bytes to VM bytes without expectations. check strips exactly one terminal LF; first difference is1-based. Gate total increments before first mismatch break.

### separate-routing-selection

For finite scores and finite threshold, stable descending sort retains equal-score registration order; a0.9 solver returning None permits0.5 first solver at threshold0.5, and raising threshold0.5001 yields escalation. This relation is tagged separately and has no mlab transport edge.

### wave31-virtual-filesystem-state-backend-dispatch

open(mem,limits) installs Vfs, real ignores limits, dir canonicalizes root; shared trait does not imply identical journals or metadata.

### wave31-virtual-filesystem-state-state-trace-split

Snapshot includes root,cwd,clock,next_ino,usage,tmp and excludes limits,journal,fault. Restoration equality applies to dump projection.

### wave31-virtual-filesystem-state-failure-effects

Single-file quota preflight precedes tick; mkdir_all/import/export can preserve a successful prefix. No parent-wide rollback follows.

### wave31-virtual-filesystem-state-caller-join

mlab file/table builtins use Interp.fs trait; sibling WASI translates errno via wasi number while host Display uses Linux number. Do not identify these numeric coordinate systems.

### wave31-wasi-guest-runtime-vfs-coordinate-transport

Relative UTF8 path + directory fd -> canonical Vfs path -> descriptor carrying path/offset/flags -> iovec bytes -> Vfs read_at/write_at -> copied output/count. Explicit positioned writes override append and preserve fd position; implicit append uses file size. Finite direct-helper fixtures exercise this actual caller join.

### wave31-wasi-guest-runtime-failure-order

Validation precedes CLI imports; import failure precedes guest; export gate follows run; first export failure precedes journal. Within helpers clock/seek/read/write/open effects can precede output FAULT, so success-only adapters cannot infer atomicity.

### wave31-wasi-guest-runtime-resource-product

Fuel, memory ceiling, descriptor count and Vfs byte/file limits form separate axes. One axis cannot stand in for others: fuel counts engine work while host IO/copies and imported tree size require independent accounting.

### wave31-wasi-guest-runtime-test-scope

Nine helper/tiny-engine and two integration tests produce11 named observations per profile. Example compile and freshness metadata tests do not imply native/guest frozen-suite equality; mlab remains a tagged external reference.