# Integer neural fields: conformance corpus

Vectors for `wai.field.int_grid` and its levels, `wai.field.int_refine`
([neural-fields](../../extensions/neural-fields.md)). The criterion is **field-equivalence**: a
conforming sink computes, from each scene's `WIG1` payload and every prefix of its `WIL1`
levels, exactly the values it states at its points and exactly the frame it states at each view,
by SHA-256, with no tolerance; it refuses every fault payload with the code stated; and it gives
every level and every layer it is offered the outcome stated.

**Provenance.** Generated here, with no capture and no download. The scenes are written by
`tools/wai_int_field_export.py demo scenes/` (`--check` requires these bytes); everything else
is derived from them by `wai_int_field_vectors gen`.

## Layout

- `scenes/<name>.wig1`, `scenes/<name>.l<k>.wil1`: the payloads.
  - `orb`: fitted to a procedural scene (a ball and a box of absorbing medium, coloured by
    position); four levels of four features, the two finer read through the spatial hash; the
    payload carries the two coarser levels and declares the other two, which are its
    refinements `orb.l2.wil1` and `orb.l3.wil1`: three stages, each presentable.
  - `mlp`: three levels of two features, two of them hashed, and a three-layer network, all
    seeded random: the network's general case, every level carried.
  - `edge`: one level and one layer with weights of no fraction bits: a density past the
    32-bit clamp that makes the medium opaque within one sample, colours past both ends of
    their range, and a view partly outside the domain.
- `vectors.json`: for each scene, its points (corners, faces, the centre, points just outside
  the domain, and 24 seeded points inside), the extra views it is rendered at, and, for each
  stage (each prefix of its levels), the levels held, the values at every point, their values
  digest, and the frame digest at the scene's own view and at each extra view (an `edge` view
  starts inside the domain, another has fewer units of length than samples); `refusals`, one
  fault payload for every check of §8, `WIG1` and `WIL1`, each with what it plants and its code;
  `geometry`, levels applied to the orb in order, out of order, twice, past its levels and in
  the wrong shape, each with its outcome (§7.3); and `staged`, envelopes offered to the orb's
  stage set in order (§7.4, a hold bound of zero), each with the stage it reaches or the reason
  it is not applied, and the final stage, freeze and stage hash.
- `faults/<name>.wig1`, `faults/<name>.wil1`: the fault payloads, and the levels of the wrong
  shape `geometry` applies.
- `staged/orb.<name>.wai`: the base and the layers, as `WAI1` envelopes.

## Running

```
cd ../../wai-rs
cargo run --no-default-features --features field_int --bin wai_int_field_vectors -- verify ../volumetric-conformance/fields
cargo run --no-default-features --features field_int --bin wai_int_field_vectors -- gen    ../volumetric-conformance/fields   # regenerate
cd ../volumetric-conformance
python3 -I field_verify.py fields
```

`verify` derives every file again and requires the committed bytes, recomputes every
statement, and requires each fault of §11 planted in the decode to fail at least one.
`field_verify.py` is the second implementation, written from the extension's text and sharing
no code with wai-rs: it parses, applies the levels, computes the values, renders and stage
hashes with its own integer arithmetic, checks every refusal and level outcome, and plants each
fault of §11 in its own decode. It reads the staged sequences' final stages, not their
envelopes.