The encoders enforce the mathematical layout

Define success before you read the code

Let's set our expectations. For a query, coefficient i has to equal round(Δ * qᵢ) for 0 ≤ i < D, and everything else must be zero. For corpus vector j, coefficient Dj + D − 1 − i has to equal round(Δ * vⱼ,ᵢ). Also, we can't try to pack more than N/D vectors into a single polynomial. If we turn those statements into code, they become our test assertions.

Start with the simplest version in Python

The Python model lays out the logic cleanly, without any cryptography getting in the way:

def encode_query(q_vec: list[float]) -> list[int]:
    coeffs = [0] * N
    for i, v in enumerate(q_vec):
        coeffs[i] = round(v * DELTA)
    return coeffs

def encode_db_poly(vecs: list[list[float]]) -> list[int]:
    coeffs = [0] * N
    for j, vec in enumerate(vecs):
        for i, v in enumerate(vec):
            coeffs[D * j + (D - 1 - i)] = round(v * DELTA)
    return coeffs

It matches our math perfectly. The query goes straight into physical position i. The corpus vector goes into position Dj + D − 1 − i. Both get multiplied by our scale factor Δ and rounded to integers.

def assert_query_layout(q, coeffs, D, delta):
    assert len(q) <= D
    assert coeffs[:len(q)] == [round(x * delta) for x in q]
    assert all(x == 0 for x in coeffs[len(q):])

def assert_corpus_slot(vec, coeffs, j, D, delta):
    for i, value in enumerate(vec):
        assert coeffs[D*j + D-1-i] == round(value * delta)

How the production Rust client handles it

/// vector j, element i lands at coefficient D·j + D − 1 − i,
/// so the negacyclic product with a query carries ⟨q, v_j⟩·Δ² at
/// coefficient D·j + D − 1 with no rotations.
pub fn encrypt_corpus_block(
    &self,
    vectors: &[&[f32]],
    block: ScoreDimension,
) -> Result<Ciphertext, Error>

The Rust code does the exact same math, but wraps it in production-grade safety: checking for empty inputs, ensuring the block width is supported, enforcing the N/D vector limit, and making sure no individual vector overflows the dimension D.

def pack(vectors,n,d,scale):
    out=[0]*n
    for j,v in enumerate(vectors):
        for i,value in enumerate(v):
            out[j*d+d-1-i]=round(scale*value)
    return out