Recursively copies data from a source tensor layout to a (larger) destination layout, preserving multi-dimensional structure. Copies contiguous slices

Crops the tensor to specific target dimensions. Only supports shrinking dimensions (target must be <= current for each dimension). # Arguments `targe

Raw i64 accumulation of an element-wise cube, `acc = x³`. The shared pre-rebase value behind [`cube_intermediate`] and [`cube_remainder`]; the fused [

Rebase width (in bits) for a cube: `x³` is at scale `3S` and rebases to `S`, so the divisor is `2^(2·scale)`.

Add an error function (erf) activation node.

Computes the table of evaluations: `{ eq(r, x) : x ∈ {0, 1}^n }`. ### Index / bit order: Big-endian The returned vector is ordered by interpreting `

Evaluates the multilinear extension (MLE) of the lookup table at point `r`.

Extracts the raw values from a tract tensor and converts them to f32. Handles various data types (F16, F32, F64, integer types, Bool, TDim) and conve

Finishes building and returns the nodes. Consumes the builder and returns all accumulated computation nodes. # Returns A vector of all computation

Floor-rebase a raw i64 accumulation by `2^bits` then saturate to `i32`. This is the fused replacement for `op + ScalarConstDiv(2^bits)`: it avoids th

Whether a node fuses the rescaling division (`bits > 0`). A `bits == 0` op is a raw product (no rebase, no clamp) — e.g. the building-block `Mul`/`Sq

Add a gather node.

Generate a single synthetic transaction with realistic authorization patterns

Get the array index from rows / columns indices. ``` use atlas_onnx_tracer::tensor::Tensor; let a = Tensor::<f32>::new(None, &[3, 3, 3]).unwrap(); a

Get a node's input nodes Panics if any input node index is missing from the graph.

Get the virtual polynomials representing the input operands for range-checking.

Whether this schedule carries an `EQ` factor (degree 3 vs degree 2).

IFF operation. # Arguments `mask` - Tensor of 0s and 1s `a` - Tensor `b` - Tensor # Examples ``` use atlas_onnx_tracer::tensor::Tensor; use atlas_onnx

Combines two 32-bit values into a single 64-bit value by interleaving their bits. Takes even bits from the first argument and odd bits from the second

Returns log2 of the leading-dimension product `F`.

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

Materializes a single entry of the lookup table at the given index.

`[m, n]` input, reduce the last axis (size `n`, a power of two) → `[m, 1]`.

Elementwise multiplies tensors. # Arguments `self` - Tensor `rhs` - Tensor # Examples ``` use atlas_onnx_tracer::tensor::Tensor; use std::ops::Mul; l

Add a multiplication node.

Raw i64 accumulation of a (broadcast) binary multiply, `acc = left · right`. This is the shared pre-rebase value behind [`mul_intermediate`] and [`mu

Returns the operand dims for this sum operation.

Returns the dimensions of the output.

Print top-k predicted tokens from *two* logit vectors side by side.

Append the accumulation (`ClampAcc`) opening at the node output point `r`, returning the (padded) i64 intermediate for reuse. Shared by the clamp loo

The rescaling **remainder** `R = acc mod 2^bits ∈ [0, 2^bits)` (Euclidean), where the fused identity is `acc = rescaled·2^bits + R`. `R` fits `i32` fo

Recover the signed integer encoded by a field element known to be a small-magnitude `i32`/`i64` embedding (e.g. `left ± right` for `i32` operands, whi

Add a scalar constant division node.

Serialize a proof to bytes (compressed).

Set the quantization scale for the RunArgs. The scale is the denominator in the fixed-point representation used when quantizing the model.

Add a sigmoid activation node.

Raw i64 accumulation of an element-wise square, `acc = x²` (always fits i64 for i32 inputs). The shared pre-rebase value behind [`square_intermediate`

Verify a proof for the given computation node. Dispatches to the operator-specific verification implementation to check the sumcheck proof and update

Verifier counterpart of [`prove_append_acc`]: append the `ClampAcc` opening point (claim is loaded from the proof's opening claims).

Returns `[F, N]`.

Add general sum-of-products constraint with baked challenge values. Challenges resolve to constants (baked into matrix coefficients) instead of varia

Computes the floored (Euclidean-style) remainder of `a / b`. This matches Python's `%` semantics: the result always has the same sign as `b` (or is z

Add a bitwise AND node.