fhelium.experimental.bootstrap.linear.radix2

Radix-2 synthesis of CKKS coefficient/slot transforms.

TransformDirection

type alias View source

TransformDirection = Literal['coeffs_to_slots', 'slots_to_coeffs']

Radix2FourierTransformCompiler

class View source

Radix2FourierTransformCompiler(stage_count: int, imaginary_unit_correction: bool = False)

Synthesize CKKS basis transforms from radix-2 butterflies.

Let $C$ be the unscaled coeffs_to_slots map and $T$ the unscaled slots_to_coeffs map in the engine's cyclotomic slot order. The compiler's convention is

$$T(C(x))=Sx.$$

Consequently a plaintext round trip uses forward scale=1 and inverse scale=1/S. The supplied scale multiplies the numerical map; it is not a CKKS metadata scale and does not change the diagonal plaintext encoding scale selected later by the evaluator.

stage_count controls only algebraic layer collapse. A smaller value consumes fewer CKKS depths but materializes more diagonals in each stage; a larger value retains sparse butterflies but spends more depths. The choice of direct, BSGS, distributed, or custom execution remains independent.

Attributes

Name	Type	Default/value
stage_count	int
imaginary_unit_correction	bool	False

compile

method

def compile(*, slots: int, direction: TransformDirection, generator: int, scale: float=1.0) -> tuple[DiagonalLinearTransform, ...]: ...

Compile $C$ or $T$ into ordered cyclic-diagonal stages.

Compilation proceeds in four steps:

1. validate the cyclotomic slot orbit and build root tables;
2. construct one three-diagonal transform per radix-2 layer;
3. compose adjacent layers according to stage_count;
4. fold scale into the first forward stage or final inverse stage so the normalization is applied once in the complete transform.

slots is $S$ and every stored diagonal has axes [slot]. generator must enumerate $S$ distinct odd cyclotomic exponents modulo $4S$. direction chooses $C$ or $T$. Returns immutable CPU complex128 stages in online execution order; compilation performs no encryption.