Maps a function to tensors ``` use atlas_onnx_tracer::tensor::Tensor; let mut a = Tensor::<i32>::new(Some(&[1, 4]), &[2]).unwrap(); let mut c = a.map(

Unwraps the optional checkpoint value, panicking if None.

Returns the shared minimum parallel chunk length. When parallel execution is enabled, this returns `1`, which is effectively Rayon default behavior.

Returns the tensor's dimensions.

Get a single value from the Tensor. ``` use atlas_onnx_tracer::tensor::Tensor; let mut a = Tensor::<i32>::new(None, &[2, 3, 5]).unwrap(); a[1*15 + 1

Returns the number of elements in the tensor.

Convert this accessor into a prover provider that can append openings to the accumulator using `transcript` and `opening_point`.

Add an input node with the given output dimensions.

Run the prove-and-verify workflow, returning the execution IO.

Mark a wire as an output of the model.

Append a node I/O opening with its claimed value to the prover accumulator at the provider's current opening point.

Read an advice opening for the current node.

Read the reduced opening claim for the current node.

Reshape the tensor ``` use atlas_onnx_tracer::tensor::Tensor; let mut a = Tensor::<f32>::new(None, &[3, 3, 3]).unwrap(); a.reshape(&[9, 3]); assert_eq

Append an advice opening with its claimed value to the prover accumulator at the provider's current opening point.

Add a concat node with an arbitrary number of inputs.

Get the inner values

Get the model

Create `value * u` where u is the relaxation scalar.

Returns a cloned tensor padded to power-of-two dimensions with zeros.

Maps a function to tensors and enumerates in parallel ``` use atlas_onnx_tracer::tensor::{Tensor, TensorError}; let mut a = Tensor::<i32>::new(Some(&[

Read a node I/O opening for the selected target.

Verify a ZK proof bundle for an ONNX model execution.

The current length of the polynomial

Prove an ONNX model execution with zero-knowledge (single pass). `pedersen_gens` must have at least `max(poly_degree + 1, hyrax_C)` message generator

Compute matrix-vector product: result = M * z

Computes the total number of output elements produced by this node after mapping each output dimension to its next power of two. For example, if `out

Convenience method for the common case of opening an input/current node output in this builder's default sumcheck context.

Run the prove-and-verify workflow, returning the execution IO.

Allocate a new node ID.

Insert a node into the graph and return its wire.

Build and consume the builder, returning the constructed `Model`.

Single MSM including blinding.

Returns the normalized dimension information for the sum operation.

Build the three RA one-hot sumcheck **provers** (RaVirtual, HammingWeight, Booleanity) from an [`RaOneHotEncoding`] and pre-computed `lookup_indices`.

Adds a simple operator that uses the handler's input indices directly. This is the main operator for simple handlers like Add, Sub, etc.

Helper to verify a ZK sumcheck given verifier instances.

Build an advice opening for the current node in this builder's default sumcheck context.

Take the openings, removing the points to reduce proof size # Returns: `Openings<F>` - The openings with points removed

Build the three RA one-hot sumcheck **verifiers** (RaVirtual, HammingWeight, Booleanity) from an [`RaOneHotEncoding`]. Transcript challenge draw orde

Splits `self` into a tuple (prefix, suffix) of `LookupBits`, where `suffix.len() == suffix_len`.

Assign the witness to the Z vector for R1CS satisfaction checking The Z vector layout is: ```text Z = [u, challenges..., initial_claim, witness_vars.

Elementwise raise a tensor to the nth power. # Arguments `self` - Tensor `b` - Single value # Examples ``` use atlas_onnx_tracer::tensor::Tensor; use

Load tokenizer, encode prompt, run Tract f32 + quantized i32 forward passes, and extract last-position logits from both.

Computes quotient and remainder for neural teleportation division. Returns (quotient, remainder) where input = DIVISOR * quotient + remainder

Checks if the number of elements in tensor is 0.