Move axis of the tensor ``` use atlas_onnx_tracer::tensor::Tensor; let mut a = Tensor::<f32>::new(None, &[3, 3, 3]).unwrap(); let b = a.move_axis(0, 2

Mean squared error.

Negates a tensor. # Arguments `a` - Tensor # Examples ``` use atlas_onnx_tracer::tensor::Tensor; use atlas_onnx_tracer::tensor::ops::neg; let x = Ten

Elementwise applies not to a tensor of integers. # Arguments `a` - Tensor # Examples ``` use atlas_onnx_tracer::tensor::Tensor; use atlas_onnx_tracer:

All node output is used 1 to 2 times.

Extract a short operator name from the Operator enum.

Populate the verifier accumulator with opening claims and commitments from the proof.

Returns a pretty-printed table representation of the model's computation graph

Generate a proof for the given computation node. Dispatches to the operator-specific proving implementation and returns one or more sumcheck proofs (

Stage (1)+(2): append the remainder `R` advice and discharge the clamp `output = SatClamp(rescaled)`. For a scalar node the clamp is checked in the cl

Compute the public contribution to Az(r), Bz(r), Cz(r).

Create a random tensor given the dims

Select the eval-reduction flow for this operator. `Default` uses `prove`/`verify` with reduction at the beginning. `Custom` uses `prove_with_reductio

Reset inverse count.

Virtual polynomial for the read-values value (`exp_hi` or `exp_lo`).

Saturating element-wise binary operation for [`Add`] and [`Sub`]. For each consecutive input pair: accumulates via [`sat_accumulate_pair`] (in `i64`)

Build a fused-`Cube` (scale 12 → rebase by `2^24`) model with all-`input_value` input so `x³ >> 24` saturates the i32 clamp . `x = 2^19+1` keeps `x³`

Build a `mk,kn->mn` model with all-`input_value` input and all-`const_value` constant, so the rebased accumulation `(k · input_value · const_value) >>

Build a fused-`Mul` model with all-`input_value` input and all-`const_value` constant so the rebased product `(input·const) >> S` is predictable and l

Send auxiliary vectors (max_k, exp_sum_q, argmax_k) to the transcript. These O(F) scalars let the verifier derive `inv_sum[k] = ⌊S²/exp_sum_q[k]⌋` wi

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

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

Add a slice node over one axis.

Add a softmax-last-axis node. Uses the builder's scale (set via `with_scale`) as S = 2^scale.

Store f64 inputs into the node output map.

Generic input storage — pads to power-of-2 dims when necessary.

Return vec of (token_id, logit) sorted descending by logit.

For sqrt range check: the bound is `2·v̂ + 1`, not just `v̂`.

Transposes a flattened matrix stored in row-major order. # Arguments `flat_vector` - The input vector representing a flattened matrix in row-major or

Verifier counterpart of [`prove_pre`].

Internal: same as [`verify_zk_with_pcs_capture`] plus an optional extract slot. When `extract_public_claims` is `Some`, the Input/Constant per-op chec

Return the equality table over the "active" window bits (all but the last variable in the current streaming window). This is used when projecting the

Returns the leading-dimension product `F`.

Returns the last-axis size `N`.

Adds tensors. # Arguments `self` - Tensor `rhs` - Tensor # Examples ``` use atlas_onnx_tracer::tensor::Tensor; use std::ops::Add; let x = Tensor::<i3

Add an addition node.

Add final output constraint with baked batching coefficients: final_claim = Σⱼ α_val_j · yⱼ Single constraint: (Σⱼ α_val_j · yⱼ) · u = final_claim

Adds nodes that already have their indices assigned (from reserve_indices). This is an internal method used by the parser. Handlers should use Decomp

Build constraints for a single sumcheck round with baked challenge. For g(X) = c0 + c1*X + c2*X^2 + ... + cd*X^d: 1. Sum check: g(0) + g(1) = claime

All W row commitments in order: coeff rows (padded to R_coeff) | output claims rows | regular noncoeff rows | padding to R'

Elementwise applies and to two tensors # Arguments `a` - Tensor `b` - Tensor # Examples ``` use atlas_onnx_tracer::tensor::Tensor; use atlas_onnx_trac