Whether `node`'s (padded) output is a single element (`log_T = 0`). Such "scalar" `Add`/`Sub` nodes skip the clamp lookup: the one-hot PCS opening re

Add a ReLU activation node.

Broadcasts the tensor to a given shape ``` use atlas_onnx_tracer::tensor::Tensor; let mut a = Tensor::<i32>::new(Some(&[1, 2, 3]), &[3, 1]).unwrap();

Finalize prover state after the last challenge has been ingested, but before [`Self::cache_openings`] is called. This hook is useful for sumcheck imp

Get a slice from the Tensor. ``` use atlas_onnx_tracer::tensor::Tensor; let mut a = Tensor::<i32>::new(Some(&[1, 2, 3]), &[3]).unwrap(); let mut b = T

Gets the index for a node at the given offset from base. # Arguments `offset` - The offset from the base index (0-based) # Returns The absolute in

Returns the dimensions of the left operand.

Run ZK eval reduction for a node: commit h polynomial via Pedersen.

Add a hyperbolic tangent (tanh) activation node.

Append a node I/O opening with its claimed value to the prover accumulator at an explicit opening point.

Add an einsum node (general tensor contraction).

Add a sum reduction node.

Automatically inserts broadcast nodes if input shapes don't match output shape. This should typically be called first, before adding any operators.

Pops the most significant bit from `self`, decrementing `len`.

Run a batched ZK sumcheck (multiple instances) and collect stage data.

Execute the graph and capture every node's output tensor.

Verify ZK eval reduction for a node: absorb h commitment, skip claim checks.

Check satisfaction and return the first failing constraint index if any

Compute the quadratic polynomial s(X) = l(X) * q(X), where l(X) is the current (linear) Dao-Thaler eq polynomial and q(X) = c + dx - c, the constant t

Compute the cubic polynomial s(X) = l(X) * q(X), where l(X) is the current (linear) eq polynomial and q(X) = c + dX + eX^2, given the following: - c,

Splits a 64-bit value into two 32-bit values by separating even and odd bits. The even bits (indices 0,2,4,...) go into the first returned value, and

Access the underlying mutable accumulator reference held by this claim accessor, if any.

Returns the dimensions of the right operand.

Convert `i32` trace values to usize indices.

Adds a node to the decomposition. # Arguments `node` - The computation node to add

Compute powers of scalar q : (1, q, q^2, ..., q^(len-1))

Apply an element-wise f64 operation, returning a new tensor with the same shape.

Read an opening claim from an explicit opening identifier. This is useful when the caller has already constructed an `OpeningId` (for example, for vi

Materialize the lookup table with cosine values. Creates a lookup table where indices represent teleported remainders in [0, 8π), and values are `cos

Returns a reference to the map of computation nodes in the graph. Each node is identified by its index in the computation graph.

M'[j - col_start] = Σ_row M[row,j] · eq_row[row] Projects out rows via `eq_row` weighting, keeping only columns in `[col_start .. col_start + out_len

Run a single-instance ZK sumcheck and collect stage data. Returns the ZK sumcheck proof for inclusion in the bundle.

Converts a scale (logarithm base 2) to a fixed-point multiplier. This function computes the actual multiplier value from a logarithmic scale paramete

Setup tracing based on command-line arguments. Looks for `--trace` (Chrome JSON output) or `--trace-terminal` (terminal output) in the command-line a

Enable or disable power-of-2 dimension padding # Example ``` use atlas_onnx_tracer::model::RunArgs; let run_args = RunArgs::default().with_padding(tr

Read modular multiplication count.

Returns the indices of output nodes in the computation graph.

Pads the tensor to specific target dimensions with zeros. Only supports growing dimensions (target must be >= current for each dimension). # Argument

Reset modular multiplication count.

Helper: build a small softmax test at the given scale.

Get the model's scale.

Add a constraint: a * b = c

Bind the model's public input tensors into the Fiat-Shamir transcript before* any challenge is derived. The input tensors are supplied by the prover

Build a one-hot RaD witness for an identity range-check or Shout ra polynomial, given raw lookup indices and the log2 of the table / range-check size.

Converts an n-bit signed integer to its usize index representation. This is the inverse of `usize_to_n_bits`. It converts a signed n-bit integer in t

Rebase width `S` (in bits) of an operator's fused rescaling division, or `None` if the operator does not fuse a rescale. `Mul`/`Square` are at scale

Add a reciprocal square root (rsqrt) node.

Add a variable to the RunArgs # Example ``` use atlas_onnx_tracer::model::RunArgs; let run_args = RunArgs::default() .with("sequence_length", 512) .w