Polynomial¶

Check if this ring is a quotient of another ring, or equivalently whether this ring's modulus divides the other ring's modulus.

Create a Poly from coefficient data.

Parameters:

Random coefficients uniformly distributed in [-bound, bound].

Random coefficients uniformly distributed modulo q.

Ternary coefficients {-1, 0, 1} with probabilities (1/4, 1/2, 1/4).

Sparse ternary coefficients {-1, 0, 1} with exactly h +-1 coefficients and n-h 0 coefficients. The locations of the nonzero coefficients are chosen as a uniformly random size-h subset of {0, ..., n-1}, and each coefficient in those locations is independently set to -1 or 1 with probability 1/2.

Create a polynomial with coefficients drawn from the given distribution.

Create a constant (degree-0) polynomial.

Create a monomial c * X^k.

Convert polynomial to a new ring. Backend picks the algorithm based on the relationship between source and target rings, while preserving the requested residue system when arithmetic lifting is required.

Multiply each RNS limb by a per-prime scalar.

Unlike polynomial multiplication, this scales all coefficients in limb i by scalars[i]. This is used for embedding masks in keyswitching where different RNS primes need different scaling factors.

Mathematically, this multiplies by the ring element specified in factored coordinates of the product ring Z_q ≅ ∏Z_{pi}. The tuple (s0, s1, ..., sk-1) represents the unique S ∈ Z_q where S ≡ si (mod pi).

Rescale into a lower-modulus ring by approximately applying the modulus ratio between the source and destination bases.

Multiplies a polynomial by X^k

Return a value-equivalent polynomial backed by fresh storage.

Return a contiguous poly.

This should be called before accessing .buffer when view ops may be present.

Realize this polynomial and any additional ones together.

Triggers computation if needed. After calling realize(), nodes are updated to buffer-backed versions via apply_map_to_polys.

Parameters:

Returns:

Return a zero-copy memoryview over the raw RNS limb bytes.

The layout is little-endian coefficient limbs in prime-major order with shape (len(ring.moduli), ring.n). The returned view is tied to the polynomial's buffer — do not mutate it.

Raises :class:RuntimeError for constant polynomials (use :meth:tobytes instead, or serialize via the "const" encoding).

Return raw RNS limb bytes for this polynomial (always copies).

The layout is little-endian coefficient limbs in prime-major order with shape (len(ring.moduli), ring.n). This exports the polynomial in its current domain.

Build a polynomial from raw RNS limb bytes.

Accepts any bytes-like object. The underlying buffer is referenced without copying, so callers must not mutate or resize mutable inputs (for example bytearray or writable memoryview) while the resulting polynomial is still alive.

Pickle as a materialized poly: realize and store concrete bytes (or a const value) plus ring/domain, never the lazy IR graph.

Reconstruct coefficients as the balanced [-Q/2, Q/2) representative.

This is the native output of Op.FROM_RNS. Reconstruction runs on the source device's backend (the GPU for cuda polys); only the resulting limb buffer is copied to host for the final big-int combine. tolist() derives [0, Q) from this.

Reconstruct integer coefficients in [0, Q), derived from to_centered_list().

Check if two polynomials are equal.

This returns True if and only if the two polynomials have the same RingSpec and the same coefficients. (In particular it does not care about which domain the polys are in.)

Create a CONST node.

Parameters:

Per-limb modular reduction (val % p_i) happens at codegen, not here.

Create a BUFFER node wrapping an existing allocated Buffer, optionally with (ring, domain) semantics attached.

Each call creates a fresh node; because the BUFFER key embeds a unique node it can never be shared, so it is constructed uncached instead of paying the intern cache's lookup and registration.

Attach ring semantics without changing storage.

Parameters:

If already AS_RING, updates metadata instead of nesting.

Create a SINK node aggregating one or more outputs.

Reconstruct integer coefficients from RNS limbs as raw uint32 limbs.

Output is the balanced [-Q/2, Q/2) representative, encoded as signed two's-complement packed little-endian into limb_count = ceil(bitlen(Q)/32) uint32 words -- the same signed-limb encoding TO_RNS consumes, so the two ops are exact structural inverses.

Create INDEX node: self[idx].

Create LOAD from this INDEX.

Create STORE: store value at this location.

Check if this node is backed by an allocated buffer.

Create a new node with selectively replaced properties.

Any property not specified in kwargs is preserved from self.

Topological visit with memoized results.

Computes visitor(node) once all children have been processed, storing results in the provided cache.

Content-based structural hash.

Replace nodes according to mapping in a single bottom-up pass.

Create a BUFFERIZE node capturing this node's materialization metadata.

Ensure this node has contiguous buffer access.

Create an AFTER node: use this value after dependencies complete.

AFTER(value, *deps) passes through value but establishes ordering dependencies on deps. Used for: - Buffer dependencies: buffer.after(store) means "use buffer after store" - Parallel execution: independent ops without AFTER can run in parallel - Correct scheduling ordering on toposort

Return a multi-line computation trace showing the full DAG.