• self : The KeccakState instance to be initialized.

• self: target polynomial (modified in place) / 目标多项式（原地修改）
• other: polynomial to add / 要相加的多项式

• self : The polynomial whose coefficients will be conditionally adjusted in place.

let poly = Poly::new()
// Assume some coefficients are negative after operations
poly.caddq() // All negative coefficients now have Q added to them

• self : The polynomial to be filled with challenge coefficients. All coefficients will be set to 0 initially, then tau positions will be set to either -1 or +1.
• seed : A byte array used as the seed for the SHAKE256 hash function. This seed determines the challenge polynomial generation.

1. Initializing all polynomial coefficients to zero
2. Using SHAKE256 to generate pseudorandom bytes from the seed
3. Extracting sign bits for the nonzero coefficients
4. Using rejection sampling to select tau distinct positions
5. Setting the selected positions to -1 or +1 based on the extracted sign bits

• self: polynomial to check / 要检查的多项式
• b: bound to check against / 要检查的界限

• self : The polynomial to copy.

let poly1 = Poly::new()
poly1.coeffs[0] = 42
let poly2 = poly1.copy()
poly2.coeffs[0] = 100
// poly1.coeffs[0] is still 42, poly2.coeffs[0] is 100

• self: input polynomial, gets high bits (modified in place) / 输入多项式，获得高位（原地修改）
• other: output polynomial for low bits / 低位的输出多项式

• h: output hint polynomial / 输出提示多项式
• a0: low bits polynomial / 低位多项式
• a1: high bits polynomial / 高位多项式

• self : The polynomial whose coefficients will be transformed in place.

let poly = Poly::new()
// ... initialize polynomial coefficients ...
poly.ntt() // Transform coefficients to NTT domain

• self : The polynomial whose coefficients will be packed. Coefficients are assumed to lie in the range [Q-ETA, Q+ETA].

• self : The polynomial whose coefficients will be packed. Coefficients must be in the range [-2^{D-1}, 2^{D-1}].

• self : The polynomial containing coefficients to be packed. Input coefficients are assumed to be standard representatives fitting within 10 bits.

let poly = Poly::new()
// Assume poly has been populated with valid coefficients
let packed_bytes = poly.pack_t1()

• self : The polynomial containing coefficients in the range [0, 15] that are assumed to be standard representatives.

• self: result polynomial (modified in place) / 结果多项式（原地修改）
• other: polynomial to multiply with / 要相乘的多项式

• self : The polynomial to fill with uniformly random coefficients in [-η, η].
• seed : The seed bytes used to initialize the SHAKE256 pseudo-random stream.
• nonce : A 16-bit nonce value used along with the seed for stream initialization to ensure different outputs for the same seed.

• self : The polynomial whose coefficients will be reduced in-place.

let poly = Poly::new()
// ... populate polynomial with coefficients ...
poly.reduce() // All coefficients are now in range [0, 2*Q]

• self: target polynomial (modified in place) / 目标多项式（原地修改）
• other: polynomial to subtract / 要减去的多项式

• self : The polynomial to fill with uniform random coefficients.
• seed : The seed bytes used to initialize the pseudo-random stream.
• nonce : A 16-bit nonce value used along with the seed for stream initialization.

• self : The polynomial to store the unpacked coefficients. Its coefficients will be modified in place.
• a : The packed byte array containing the encoded polynomial coefficients.

• This function will panic if the length of the input byte array a doesn't match the expected size for the current eta parameter.

• For eta = 2: Each group of 3 bytes encodes 8 polynomial coefficients using 3-bit values
• For eta = 4: Each byte encodes 2 polynomial coefficients using 4-bit values

• self : The polynomial to be modified with the unpacked coefficients.
• a : The byte array containing the packed polynomial data. Must have length N/8 * 13 bytes.

• self : The polynomial to store the unpacked coefficients in.
• a : The byte array containing the packed polynomial coefficients. Must contain at least 5 * (N / 4) bytes where every 5 consecutive bytes encode 4 coefficients.

• Uses 18-bit representation per coefficient (mask 0x3FFFF)
• Packs 4 coefficients into 9 bytes (4.5 bytes per coefficient)
• Each group of 4 coefficients requires 72 bits total

• Uses 20-bit representation per coefficient (mask 0xFFFFF)
• Packs 2 coefficients into 5 bytes (2.5 bytes per coefficient)
• Each group of 2 coefficients requires 40 bits total

• self : The polynomial whose coefficients will be modified in place with the unpacked values.
• a : The byte array containing the bit-packed polynomial data.

• self: input/output polynomial with corrected high bits / 具有修正高位的输入/输出多项式
• h: hint polynomial / 提示多项式

• w : The first polynomial vector that will store the result of the addition.
• v : The second polynomial vector to be added to the first.

• If either w or v has fewer than K polynomials, where K is determined by the current Dilithium parameter set.

• v : The polynomial vector of length K whose negative coefficients will be converted to positive form.

• self : The polynomial vector to copy.

• v : The polynomial vector of length K to transform. Input coefficients must be less than 2*Q.

• h : The output hint vector where computed hints will be stored.
• v0 : The first input polynomial vector containing low bits from decomposition.
• v1 : The second input polynomial vector containing high bits from decomposition.

• v : The polynomial vector of length K to transform in-place.

let polyvec = Polyveck::default()
// ... initialize polynomials in polyvec ...
Polyveck::ntt(polyvec)
// All polynomials in polyvec are now in NTT domain

• self : The polynomial vector containing the polynomials whose w1 components will be packed.
• r : The output byte array where the packed w1 data will be stored.

• r : The output vector where results are stored.
• a : The polynomial to multiply with each element of the input vector.
• v : The input vector of polynomials.

• v : The polynomial vector of length K whose coefficients will be reduced.

• v : The polynomial vector of length K to be filled with uniform random coefficients.
• seed : The random seed bytes used for generating the uniform distribution.
• nonce : The starting nonce value used for randomness generation, incremented for each polynomial.

• w : The polynomial vector whose high bits will be corrected in-place.
• h : The hint vector containing correction information for each polynomial.

let w = Polyveck::default()
let h = Polyveck::default()
// ... populate w and h with appropriate values ...
w.use_hint(h)
// w now has its high bits corrected based on the hint vector h

• w : The first polynomial vector that will store the result of the addition.
• v : The second polynomial vector to be added to the first vector.

let w = Polyvecl::default()
let v = Polyvecl::default()
// Assume both vectors have been initialized with some polynomial values
w.add(v) // w now contains the element-wise sum of the original w and v

• self : The polynomial vector to copy.

• v : The vector of polynomials to transform. Each polynomial in the vector will be modified in-place.

• v : The polynomial vector of length L whose polynomials will be transformed in-place.

let polyvec = Polyvecl::default()
// ... initialize polynomials in polyvec ...
polyvec.ntt() // Transform all polynomials to NTT domain

• result : The output vector of polynomials where the results will be stored.
• polynomial : The single polynomial to multiply with each polynomial in the input vector.
• input_vector : The input vector of polynomials to be multiplied.

• v : The polynomial vector of length L whose coefficients will be reduced.

let v : Polyvecl = Polyvecl::default()
// ... populate v with polynomial data ...
Polyvecl::reduce(v)
// All polynomials in v now have reduced coefficients

• v : The polynomial vector of length L to be filled with uniform random polynomials.
• seed : The random seed bytes used for generating the uniform distribution.
• nonce : The starting nonce value used to ensure different randomness for each polynomial in the vector.

• v : The polynomial vector of length L to populate with uniform gamma1 coefficients.
• seed : The cryptographic seed used for random number generation.
• nonce : The base nonce value used to ensure different randomness for each polynomial.