Struct Params 

pub struct Params { /* private fields */ }

Fixed ring settings used by cryptographic constructions over R_q = Z_q[x] / (f(x)).

Construction validates:

• polynomial metadata and modulus,
• modulus polynomial properties,
• NTT suitability for multiplying degree-bounded polynomials,
• primitive root compatibility with the chosen NTT length.

Implementations

impl Params

pub fn new( max_degree: usize, modulus: u64, modulus_poly_coeffs: &[u64], primitive_root: u64, ) -> Result<Self, ParamsError>

Builds validated ring parameters.

modulus_poly_coeffs must define a non-constant polynomial whose degree equals max_degree, with invertible leading coefficient in Z_q.

pub fn max_degree(&self) -> usize

Maximum supported polynomial degree.

Examples found in repository

examples/common/codec.rs (line 137)

pub fn decode_message_scaled_bits_example(
    element: &RingElem,
    output_len_bytes: usize,
) -> Result<Vec<u8>, CodecError> {
    // Decode limit follows the same bit-capacity convention used at encode time.
    let capacity_bits = element.params().max_degree();
    let requested_bits = output_len_bytes.saturating_mul(8);
    if requested_bits > capacity_bits {
        return Err(CodecError::DecodeLengthTooLong {
            requested_bits,
            capacity_bits,
        });
    }

    let q = element.params().modulus();
    // Threshold window near middle of modulus range.
    // Values in `[q/4, 3q/4)` decode to 1; others decode to 0.
    let lower = q / 4;
    let upper = (3 * q) / 4;

    let mut out = vec![0_u8; output_len_bytes];
    for bit_index in 0..requested_bits {
        let coeff = element.coefficients()[bit_index];
        let bit = coeff >= lower && coeff < upper;
        if bit {
            // Restore little-endian bit position.
            out[bit_index / 8] |= 1_u8 << (bit_index % 8);
        }
    }

    Ok(out)
}

pub fn modulus(&self) -> u64

Coefficient modulus q.

Examples found in repository

examples/common/codec.rs (line 146)

pub fn decode_message_scaled_bits_example(
    element: &RingElem,
    output_len_bytes: usize,
) -> Result<Vec<u8>, CodecError> {
    // Decode limit follows the same bit-capacity convention used at encode time.
    let capacity_bits = element.params().max_degree();
    let requested_bits = output_len_bytes.saturating_mul(8);
    if requested_bits > capacity_bits {
        return Err(CodecError::DecodeLengthTooLong {
            requested_bits,
            capacity_bits,
        });
    }

    let q = element.params().modulus();
    // Threshold window near middle of modulus range.
    // Values in `[q/4, 3q/4)` decode to 1; others decode to 0.
    let lower = q / 4;
    let upper = (3 * q) / 4;

    let mut out = vec![0_u8; output_len_bytes];
    for bit_index in 0..requested_bits {
        let coeff = element.coefficients()[bit_index];
        let bit = coeff >= lower && coeff < upper;
        if bit {
            // Restore little-endian bit position.
            out[bit_index / 8] |= 1_u8 << (bit_index % 8);
        }
    }

    Ok(out)
}

/// Compresses one coefficient into `bits` bits.
pub fn compress_coefficient_example(value: u64, modulus: u64, bits: u8) -> Result<u16, CodecError> {
    validate_compression_bits(bits)?;

    // Quantization levels = 2^bits.
    let levels = 1_u128 << bits;
    let q = modulus as u128;
    let v = (value % modulus) as u128;

    // Rounded scaling from `[0, q)` into `[0, 2^bits)`.
    let compressed = ((v * levels + (q / 2)) / q) % levels;
    Ok(compressed as u16)
}

/// Decompresses one `bits`-bit coefficient back into `Z_q`.
pub fn decompress_coefficient_example(
    compressed: u16,
    modulus: u64,
    bits: u8,
) -> Result<u64, CodecError> {
    validate_compression_bits(bits)?;

    let levels = 1_u128 << bits;
    let q = modulus as u128;
    let c = (compressed as u128) % levels;

    // Rounded inverse scaling from `[0, 2^bits)` back into `[0, q)`.
    let decompressed = (c * q + (levels / 2)) / levels;
    Ok((decompressed % q) as u64)
}

/// Compresses all coefficients of a ring element into `bits` bits each.
pub fn compress_ring_elem_example(element: &RingElem, bits: u8) -> Result<Vec<u16>, CodecError> {
    validate_compression_bits(bits)?;

    let q = element.params().modulus();
    // Compress each coefficient independently.
    let mut packed = Vec::with_capacity(element.coefficients().len());
    for &coeff in element.coefficients() {
        packed.push(compress_coefficient_example(coeff, q, bits)?);
    }
    Ok(packed)
}

pub fn modulus_poly(&self) -> &Polynomial

Ring modulus polynomial f(x).

pub fn primitive_root(&self) -> u64

Primitive root used to derive NTT roots of unity.

pub fn ntt_length(&self) -> usize

NTT length derived from max_degree for exact product convolutions.

Trait Implementations

impl Clone for Params

fn clone(&self) -> Params

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Params

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Params

fn eq(&self, other: &Params) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Params

impl StructuralPartialEq for Params