Builds a unit tensor used for broadcast operation # Returns A tensor of dimensions equal to the broadcasted dimensions, filled with ones.

Builds Square(x) = x²/S to maintain scale S. The fused i64 [`Square`] kernel accumulates, floor-rescales by `1 << scale`, and saturating-clamps in on

Build stage 1 sumcheck instances without running the sumcheck.

Build stage 2 sumcheck instances without running the sumcheck.

Build stage 3 sumcheck instances without running the sumcheck.

Build stage 4 sumcheck instances without running the sumcheck.

Builds a one-hot RaD witness for neural-teleport activation lookups (tanh/erf). Both activations share the exact same witness construction pipeline:

Cache the R (remainder) polynomial to the accumulator.

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

Loads exactly 32 bytes from the transcript by hashing the seed with the round constant

Loads exactly 32 bytes from the transcript by hashing the seed with the round constant

Check if the witness satisfies the relaxed R1CS: (AZ)∘(BZ) = u·(CZ) + E Z = [u, W...]

combined_blinding = Sum_i eq(ry_row, i) * row_blindings[i]

combined[k] = Sum_i eq(ry_row, i) * flat[i*cols + k]

Commit rows of a flat vector interpreted as an R × C grid.

Computes the univariate polynomial `g(X) = sum_j eq((r', X, j), r) * prod_i mle_i(X, j)`. Note `claim` should equal `g(0) + g(1)`.

Compute one-hot read-address evaluations from direct non-negative indices. This variant is used by trigonometric teleportation ops (`cos` and `sin`),

Concatenates a list of tensors along a specified axis. # Arguments `inputs` - A slice of tensors to concatenate. `axis` - The axis along which to conc

Add a constant tensor node.

Applies convolution over a 3D tensor of shape C x H x W (and adds a bias). # Arguments `inputs` - A vector of tensors holding in order: input image,

Elementwise applies cosine to a tensor of integers. # Arguments `a` - Tensor `scale_input` - Single value `scale_output` - Single value # Examples ```

The sumcheck degree implied by this schedule.

Dequantize an i32 tensor to f64 using the given scale.

Determines the rebase factor based on settings and operator traits.

Computes the dot product of the polynomial's coefficients and a vector of field elements.

Accumulate and **rebase** by floor-dividing (Euclidean) the raw `i64` accumulation by `1 << scale`, returning the pre-cast `i64` rescaled value. Floo

Returns the raw ONNX einsum equation for a computation node, panicking if the node is not an Einsum operator.

Compute eq(tau, r)

Chebyshev coefficients

Evaluate the product of linear polynomials on the grid `U_D = [1, 2, ..., D - 1, ∞]`. - `D` is `pairs.len()`. - Each pair satisfies `pairs[j] = (p_j(

Shared evaluation for the periodic trig operators ([`Sin`], [`Cos`]). Both reduce the input modulo a `4π` approximation before applying their nonline

eval = Sum_k combined_row[k] * eq(ry_col, k)

Evaluate the polynomial at a point using Horner's method

Expected outer sumcheck claim: eq(tau, r) * [Az(r)*Bz(r) - u*Cz(r) - E(r)]

Extract the final-node f64 logits from a shadow trace.

Read inverse count.

Get a mutable array index from rows / columns indices. ``` use atlas_onnx_tracer::tensor::Tensor; let mut a = Tensor::<i32>::new(None, &[2, 3, 5]).un

Return the number of parameters in the model. For non-embedding count (default), the position embeddings get subtracted. The

Return the number of parameters in the model. For non-embedding count (default), the position embeddings get subtracted. The

Get the virtual polynomial representing the range-check read-address (Ra) output.

Elementwise greater than # Arguments `a` - Tensor `b` - Single value # Examples ``` use atlas_onnx_tracer::tensor::Tensor; use atlas_onnx_tracer::ten

Add a Iff node.

Returns the indices of input nodes in the computation graph.

Intercalates values into a tensor along a given axis. ``` use atlas_onnx_tracer::tensor::Tensor; use atlas_onnx_tracer::tensor::ops::intercalate_value

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

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

Look up the canonical [`EinsumConfig`] for a raw ONNX einsum `equation`. Panics if the pattern is not registered, i.e. not supported by the Einsum pr

Returns the MLE of `LT(j, r)` evaluated at all Boolean `j ∈ {0,1}^n`. The less-than MLE is defined as: `LT(x, y) = Σ_i (1 - x_i) · y_i · eq(x[i+1:],

Wraps evals into a `CachedPolynomial` with standard cache capacity.

Prepare f64 shadow input tensors: `[input_ids, position_ids, attention_mask]`.

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

Re-execute a fused [`MeanOfSquares`] node's pre-clamp rescaled intermediate `rescaled = (Σx²) / (N·2^S)` (floor; `Σx² ≥ 0` so floor = truncation) — th

Re-execute a fused [`MeanOfSquares`] node's rescaling remainder `R = (Σx²) mod (N·2^S) ∈ [0, N·2^S)` . The fused reduction binds `Σx² = rescaled·D + R