# Note Modified to match the semantics of zkVM division. --- Elementwise divides a tensor with a const integer element. # Arguments `a` - Tensor `b`

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

Convert transaction to one-hot encoded vector

Flatten the tensor shape ``` use atlas_onnx_tracer::tensor::Tensor; let mut a = Tensor::<f32>::new(None, &[3, 3, 3]).unwrap(); a.flatten(); assert_eq!

Returns a map of miscellaneous operator names to their handler functions.

Gives the hasher object with the running seed and index added To load hash you must call finalize, after appending u8 vectors

Gives the hasher object with the running seed and index added To load hash you must call finalize, after appending u8 vectors

Converts an integer value to a bitvector (all values {0,1}) of field elements. Note: ordering has the MSB in the highest index. All of the following r

The fused mean-of-squares divisor `D = N · 2^S`, where `N` (= `op.count`) is the product of the reduced-axis sizes (the mean denominator) and `2^S` is

Get the index of the computation node these operands are associated with.

The length of the polynomial before it was bound

Pads the tensor to power of 2 dimensions. Always pads with zeros.

Set one single value on the tensor. ``` use atlas_onnx_tracer::tensor::Tensor; let mut a = Tensor::<i32>::new(None, &[3, 3, 3]).unwrap(); a.set(&[0,

Convert `i32` trace values to `LookupBits` with the given bit-width.

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

Compare quantized `actual` vs `expected`, print summary stats, and enforce a worst-error bound. Intended for operator precision tests where outputs a

Builds a one-hot polynomial witness for the `d`-th dimension of a read-after-decompose (RaD) address polynomial. This pattern appears in every operan

The committed one-hot decomposition polynomials a clamped node must commit to (empty for scalar nodes, which prove the clamp directly).

Combines prefix and suffix evaluations to reconstruct the full lookup table MLE value.

Computes lookup table indices from operand tensors. # Arguments `operand_tensors` - Slice of operand tensors to compute indices from `is_interleaved_

Compute the sumcheck polynomial for the current round. Uses big-endian indexing: pairs (i, i+half) differ in the MSB.

Create verifier sumcheck instances for a node (for IOP transcript replay).

Evaluate the product of 8 linear polynomials on the internal interpolation grid used by the higher-degree kernels. Returns 9 values: the first 8 corr

The arithmetic sumcheck's initial claim: the raw accumulation `acc(r)`. For a fused op this is `rescaled(r)·2^S + R(r)`, recovered from the pre-clamp

Generate decomposed exp sub-tables for the given scale. The base B is chosen as the power-of-two closest to √(active_range) to minimize total sub-tab

Gets the final internal index for an ONNX node. # Arguments `onnx_idx` - The original ONNX node index # Returns The corresponding internal node in

Returns the broadcasted shape of two tensors ``` use atlas_onnx_tracer::tensor::get_broadcasted_shape; let a = vec![2, 3]; let b = vec![2, 3]; let c =

Returns the cached prefix polynomial for `key`, computing and inserting it via `f` if absent.

Returns true if the output of this node is a scalar (i.e., has exactly one element).

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

Return all input tensors feeding the provided computation node.

Print a numbered step header.

Re-runs the decomposed softmax trace for a `SoftmaxLastAxis` node. Returns the full [`SoftmaxLastAxisTrace`] from which the individual lookup indices

Sums a tensor. # Arguments `a` - Tensor `b` - Single value # Examples ``` use atlas_onnx_tracer::tensor::Tensor; use atlas_onnx_tracer::tensor::ops::

Verify a scalar node's clamp directly: `output_claim == SatClamp(combined)`, where `combined` is the in-the-clear accumulation (`left ± right`, or the

Access the underlying accumulator reference held by this claim accessor.

Append an advice opening with its claimed value to the prover accumulator at an explicit opening point.

Append an arbitrary opening with its claimed value to the prover accumulator. The opening ID can be either virtual or committed, and is appended at t

Returns the axis along which the sum is performed (0 or 1).

Clamp a tensor to a given range.

Clamp each element of a `Tensor<i64>` into `[i32::MIN, i32::MAX]`.

Add a cosine activation node.

Add a cube node.

we require eval(0) + eval(1) = hint, so we can solve for the linear term as: linear_term = hint - 2 * constant_term - deg2 term - deg3 term

Dot product of two tensors. # Arguments `inputs` - Vector of tensors of length 2. # Examples ``` use atlas_onnx_tracer::tensor::Tensor; use atlas_onn

Floor-divide (Euclidean) each element of a raw i64 accumulation by `2^bits`, returning the pre-clamp rescaled `i64` value. Floor (rather than truncat