fhelium.backend.ckks.crypto._key_generation

CKKS secret, public, rotation, conjugation, and key-switch key generation.

KeyGenerationResource

class View source

KeyGenerationResource(config: CkksConfig, rng: Csprng, rns_context: RnsContext, ntt_context: NttContext, p_product_montgomery_q: torch.Tensor)

Bind context, arithmetic, and random resources for one key device.

Attributes

Name	Type	Default/value
config	CkksConfig
rng	Csprng
rns_context	RnsContext
ntt_context	NttContext
p_product_montgomery_q	torch.Tensor

create

method

def create(*, config: CkksConfig, rng: Csprng, rns_context: RnsContext, ntt_context: NttContext) -> KeyGenerationResource: ...

Build key-generation scalars on one concrete context device.

device

property

device: torch.device

Return the concrete device shared by all key-generation resources.

CkksKeyGenerator

class View source

CkksKeyGenerator()

Construct dense CKKS keys from caller-supplied device resources.

Key payloads use configured integral dtype and prime-row order. Secret-key data is [limb, ntt_index]; public keys are [key_component, limb, ntt_index]; key-switch keys are [key_digit, key_component, limb, ntt_index]. Returned keys are always NTT/Montgomery/lazy at depth zero in the stated Q or QP basis and own their payload storage. Local digit_index is resolved to stable key_digit_index before key tensor indexing.

create_secret_key

method

def create_secret_key(resources: KeyGenerationResource, *, modulus_basis: ModulusBasis='QP') -> SecretKey: ...

Sample ternary $s(X)$ and return its depth-zero NTT/Montgomery RNS.

Output shape is [limb, ntt_index] with Q or QP prime_ids selected by modulus_basis. Sampling and all temporary transitions are functional from the caller's perspective.

create_public_key

method

def create_public_key(resources: KeyGenerationResource, secret_key: SecretKey, *, modulus_basis: ModulusBasis='Q', uniform_component: torch.Tensor | None=None, error_coefficients: torch.Tensor | None=None) -> PublicKey: ...

Generate (k_0,k_1) satisfying $k_0+k_{1}s=e$ modulo the basis.

Output is integral [key_component=2, limb, ntt_index] in depth-zero NTT/Montgomery form with Q or QP rows. secret_key and optional sampled uniform/error coefficients are read-only and never alias the returned stacked tensor. When error coefficients are omitted, the generator samples its configured discrete Gaussian.

create_key_switch_key

method

def create_key_switch_key(resources: KeyGenerationResource, source_secret_key: SecretKey, destination_secret_key: SecretKey, *, uniform_component_by_key_digit: torch.Tensor | None=None, error_coefficients_by_key_digit: torch.Tensor | None=None) -> KeySwitchKey: ...

Create a hybrid-RNS key from source to destination secret relation.

Each hybrid digit is constructed through a public-key encryption.

Stable key digit $d$ satisfies, on that digit's embedded source rows, $k_{d,0}+k_{d,1}{s}_{\mathrm{dst}}=P{s}_{\mathrm{src}}+e_d$. Output is integral [key_digit, key_component=2, QP_limb, ntt_index] in NTT/Montgomery lazy form and depth-zero QP order. Input keys and optional sampled uniform/error coefficients are not mutated or aliased.

create_relinearization_key

method

def create_relinearization_key(resources: KeyGenerationResource, secret_key: SecretKey) -> RelinearizationKey: ...

Return QP key material that switches the $s^2$ phase term to $s$.

The returned state and layout equal create_key_switch_key; the input secret key remains NTT/Montgomery QP and is not mutated.

create_rotation_key

method

def create_rotation_key(resources: KeyGenerationResource, rotation_step: int, *, uniform_component_by_key_digit: torch.Tensor | None=None, secret_key: SecretKey) -> RotationKey: ...

Construct QP key material from ${\sigma }_g(s)$ back to $s$.

rotation_step follows signed slot displacement and is stored as metadata. The distinct galois_element $g$ selects polynomial automorphism ${\sigma }_g$. Output uses key-switch-key axes and NTT/Montgomery QP state; input secret/uniform tensors are not mutated.

create_conjugation_key

method

def create_conjugation_key(resources: KeyGenerationResource, secret_key: SecretKey) -> ConjugationKey: ...

Construct QP key material from ${\sigma }_{2N-1}(s)$ back to $s$.

Output uses key-switch-key axes and NTT/Montgomery QP state; the input secret key remains unchanged.