TODO: Auto do ra_one_hot_checks_aswell

Convert a row-major linear index into coordinates for the given dimensions.

Returns log2 of the last-axis size `N`.

Elementwise applies min to a tensor of integers. # Arguments `a` - Tensor `b` - scalar # Examples ``` use atlas_onnx_tracer::tensor::Tensor; use atlas

Multiplication of a field element and a power of 2. Split into chunks of 64 bits, then multiply and accumulate.

Helper: naive einsum via nested loops for ground-truth verification

Pad a vector in-place to the next power of two with zeros.

Returns the effective minimum parallel chunk length for the given enabled case. When parallel execution is enabled, this returns `enabled_min_len`. W

Returns the prefix components used in this lookup table's decomposition.

Print the comparison metrics between two logit vectors.

Prove `output = SatClamp(acc)` for a non-scalar node: the clamp read-raf lookup ([`ProofType::Execution`]) plus the read-address one-hot checks ([`Pro

The operator's rescaling remainder `R = acc mod 2^S`, padded to the node-output cycle domain. Dispatches to the per-operator re-execution kernel (no t

Resets this table to be length 1, containing only the given `value`.

Retrieves the existing opening for the given virtual opening id from the accumulator, with special handling for `VirtualPoly::NodeOutput`, where we re

Computes the round offset for this instance within a batched sumcheck. Instances with fewer rounds start later in the batched protocol.

Run `BatchedSumcheck::prove` with the standard boilerplate.

Drive a single batched-sumcheck stage given pre-built verifier instances.

Broadcast-expand `lhs` and `rhs`, apply `combine` element-wise in `i64`, and return the unclamped intermediate as `Tensor<i64>`. This is the re-execu

Add a sine activation node.

Returns the suffix components used in this lookup table's decomposition.

Extracts and normalizes sum operation dimensions from a computation node. This function processes a sum operation from the ONNX model, extracting the

Verifier counterpart of [`prove_clamp_lookup`].

Return the last vector from `E_in_vec` as a slice. Invariant: always returns at least `[1]` when fully bound.

Return the (E_out, E_in) tables corresponding to a streaming window of the given `window_size`, using an explicit slice-based factorisation of the cur

Opening id for a node's accumulation (`ClampAcc`) polynomial.

Σ_{row,col} M[row,col] · eq_row[row] · eq_col[col - col_start]

Build a reshape selector vector over the padded input domain. For each raw input position `t`, this computes the padded input index corresponding to

Loads arbitrary byte lengths using ceil(out/32) invocations of 32 byte randoms Discards top bits when the size is less than 32 bytes

Re-execute the node's saturating accumulation and return the **padded** i64 intermediate (pre-clamp) tensor — the `raf`/lookup-index polynomial. - `A

64-bit clamp lookup indices: each i64 accumulation value reinterpreted as the `u64` (two's-complement) address into [`SatClampTable`].

Flattens a tensor of tensors ``` use atlas_onnx_tracer::tensor::Tensor; let mut a = Tensor::<i32>::new(Some(&[1, 2, 3, 4, 5, 6]), &[2, 3]).unwrap(); l

From the read indexes, computes the bound ra vector.

Compute one-hot read-address evaluations from signed n-bit two's-complement values. This variant is used by lookup-table ops where signed quotient va