`fhelium.ir.dialects.rns`

Logical residue-number-system operations used below CKKS lowering.

A residue number system (RNS) stores a polynomial row modulo each active ciphertext prime in Q. The QP basis appends special P primes used by hybrid key switching. A hybrid digit is one selected group of Q rows lifted together during that procedure. Montgomery representation stores residue $x_{i}$ as $x_{i} R_{i} mod q_{i}$ ; number-theoretic-transform (NTT) form stores the negacyclic transform of each polynomial row.

Each operation defines one complete transformation of an RNS bundle. The operations contain no CPU, CUDA, Triton, kernel, radix, or fusion selection. Their parameter and table operands carry numerical Tensors supplied by Eager or bound to a Program before execution.

`AddStandardOp`

class View source

python

AddStandardOp(lhs: SSAValue | Operation, rhs: SSAValue | Operation, parameters: SSAValue | Operation, result_type: Attribute, *, attributes: Mapping[str, Attribute] | None=None)

Bases: IRDLOperation

Add two standard-residue polynomial bundles row by row.

An RNS (residue number system) row stores one polynomial modulo an active prime $q_{i}$ . For every component, coefficient, and row, this operation computes $z_{i} = (x_{i} + y_{i}) mod q_{i}$ . Both operands use the same Q or QP prime rows and store values in the standard range $[0, q_{i})$ . Component shape, depth, basis, polynomial domain, Montgomery factor, and scale are unchanged.

Attributes

Name	Type	Default/value
`name`		`'fhelium_rns.add_standard'`
`lhs`		`operand_def(RnsBundleType)`
`rhs`		`operand_def(RnsBundleType)`
`parameters`		`operand_def()`
`result`		`result_def(RnsBundleType)`
`traits`		`traits_def(Pure())`

`dependencies`

method

python

def dependencies() -> OperationDependencies: ...

Describe result reads in this operation's value coordinates.

`AddPlaintextOp`

class View source

python

AddPlaintextOp()

Bases: _CiphertextPlaintextOp

Add a prepared plaintext polynomial to ciphertext component zero.

For ciphertext $(c_{0}, \dots, c_{k - 1})$ and plaintext polynomial $p$ , each active-prime row computes $c_{0}^{'} = c_{0} + p (\mod q_{i})$ and $c_{j}^{'} = c_{j}$ for $j > 0$ . With coefficient/standard ciphertext input, the prepared plaintext uses coefficient-domain Montgomery residues and the operation returns standard residues. With NTT/Montgomery input, both operands and the result remain NTT/Montgomery. Depth, component count, and ciphertext scale are preserved.

Attributes

Name	Type	Default/value
`name`		`'fhelium_rns.add_plaintext'`
`polynomial_domain`		`attr_def(StringAttr, default_value=StringAttr('coefficient'))`

`dependencies`

method

python

def dependencies() -> OperationDependencies: ...

Describe result reads in this operation's value coordinates.

`SumStandardBatchOp`

class View source

python

SumStandardBatchOp(value: SSAValue | Operation, parameters: SSAValue | Operation, result_type: Attribute, *, dim: int | IntegerAttr)

Bases: IRDLOperation

Reduce one leading batch axis of a standard-residue bundle.

The operand is $[* o u t e r, n, * i n n e r, limb, coefficient]$ with standard residues $x_{j, i}^{(k)} \in [0, q_{i})$ . dim selects the reduced axis of length $n$ ; the result keeps the remaining axes and computes $z_{j, i} = \sum_{k < n} x_{j, i}^{(k)} mod q_{i}$ with every partial sum reduced to $[0, q_{i})$ . The reduction is the modular sum of the selected axis: component, limb, coefficient, depth, scale, polynomial domain, and residue representation are preserved while the selected axis leaves the batch shape.

Attributes

Name	Type	Default/value
`name`		`'fhelium_rns.sum_standard_batch'`
`value`		`operand_def(RnsBundleType)`
`parameters`		`operand_def()`
`result`		`result_def(RnsBundleType)`
`dim`		`attr_def(IntegerAttr)`
`traits`		`traits_def(Pure())`

`dependencies`

method

python

def dependencies() -> OperationDependencies: ...

Describe result reads in this operation's value coordinates.

`AddMontgomeryLazyOp`

class View source

python

AddMontgomeryLazyOp(lhs: SSAValue | Operation, rhs: SSAValue | Operation, parameters: SSAValue | Operation, result_type: Attribute)

Bases: IRDLOperation

Accumulate two Montgomery bundles without full standard reduction.

For each active prime $q_{i}$ or $p_{i}$ , the represented result is $z = x + y (\mod q_{i})$ while storage may remain in the implementation's lazy range, currently bounded modulo $2 q_{i}$ . Polynomial domain, Montgomery factor, prime rows, component axes, depth, and scale are preserved.

Attributes

Name	Type	Default/value
`name`		`'fhelium_rns.add_montgomery_lazy'`
`lhs`		`operand_def(RnsBundleType)`
`rhs`		`operand_def(RnsBundleType)`
`parameters`		`operand_def()`
`result`		`result_def(RnsBundleType)`
`traits`		`traits_def(Pure())`

`dependencies`

method

python

def dependencies() -> OperationDependencies: ...

Describe result reads in this operation's value coordinates.

`CoefficientAutomorphismOp`

class View source

python

CoefficientAutomorphismOp(value: SSAValue | Operation, parameters: SSAValue | Operation, result_type: Attribute, *, galois_element: int | IntegerAttr)

Bases: IRDLOperation

Apply the negacyclic ring automorphism $σ_{g}$ .

For odd galois_element $g$ , $σ_{g}$ substitutes $X \mapsto X^{g}$ in $R_{q} = Z_{q} [X] / (X^{N} + 1)$ . A coefficient $a_{j} X^{j}$ moves to index $g j mod N$ and changes sign when reduction of $g j$ modulo $2 N$ crosses $N$ . The same permutation is applied to every component and prime row. Depth, scale, basis, and residue form remain unchanged.

Attributes

Name	Type	Default/value
`name`		`'fhelium_rns.coefficient_automorphism'`
`value`		`operand_def(RnsBundleType)`
`parameters`		`operand_def()`
`result`		`result_def(RnsBundleType)`
`galois_element`		`attr_def(IntegerAttr)`
`traits`		`traits_def(Pure())`

`dependencies`

method

python

def dependencies() -> OperationDependencies: ...

Describe result reads in this operation's value coordinates.

`verify_`

method

python

def verify_() -> None: ...

`ExtractComponentOp`

class View source

python

ExtractComponentOp(value: SSAValue | Operation, result_type: Attribute, *, component: int | IntegerAttr)

Bases: IRDLOperation

Select one ciphertext-component polynomial without arithmetic.

For an RNS bundle $(c_{0}, \dots, c_{k - 1})$ , component=j returns $c_{j}$ with the same coefficient values, active prime rows, polynomial domain, Montgomery state, depth, and scale.

Attributes

Name	Type	Default/value
`name`		`'fhelium_rns.extract_component'`
`value`		`operand_def(RnsBundleType)`
`result`		`result_def(RnsBundleType)`
`component`		`attr_def(IntegerAttr)`
`traits`		`traits_def(Pure())`

`dependencies`

method

python

def dependencies() -> OperationDependencies: ...

Describe result reads in this operation's value coordinates.

`verify_`

method

python

def verify_() -> None: ...

`NegateStandardOp`

class View source

python

NegateStandardOp(value: SSAValue | Operation, parameters: SSAValue | Operation, result_type: Attribute)

Bases: IRDLOperation

Negate a standard-residue polynomial bundle row by row.

For every active prime $q_{i}$ , component, and coefficient, the result is $z_{i} = (- x_{i}) mod q_{i}$ . Component shape and all represented CKKS state are preserved.

Attributes

Name	Type	Default/value
`name`		`'fhelium_rns.negate_standard'`
`value`		`operand_def(RnsBundleType)`
`parameters`		`operand_def()`
`result`		`result_def(RnsBundleType)`
`traits`		`traits_def(Pure())`

`dependencies`

method

python

def dependencies() -> OperationDependencies: ...

Describe result reads in this operation's value coordinates.

`HybridModUpDigitOp`

class View source

python

HybridModUpDigitOp(source: SSAValue | Operation, parameters: Sequence[SSAValue | Operation], result_type: Attribute, *, attributes: Mapping[str, Attribute] | None=None, digit_index: int=0)

Bases: IRDLOperation

Extend one hybrid-RNS digit from active Q rows to active QP rows.

A hybrid digit is a selected group of Q-prime residues used in key switching. For each coefficient, the selected rows are reconstructed as one integer class $d$ modulo their product and basis-extended so every active Q and special P row stores $d R_{i} mod q_{i}$ or $d R_{i} mod p_{i}$ . The result is coefficient-domain Montgomery data; it does not change the source ciphertext scale.

Attributes

Name	Type	Default/value
`name`		`'fhelium_rns.hybrid_modup_digit'`
`source`		`operand_def(RnsBundleType)`
`parameters`		`var_operand_def()`
`result`		`result_def(RnsBundleType)`
`digit_index`		`attr_def(IntegerAttr)`
`traits`		`traits_def(Pure())`

`dependencies`

method

python

def dependencies() -> OperationDependencies: ...

Describe result reads in this operation's value coordinates.

`verify_`

method

python

def verify_() -> None: ...

`KeySwitchDigitProductOp`

class View source

python

KeySwitchDigitProductOp(digit: SSAValue | Operation, key: SSAValue | Operation, parameters: SSAValue | Operation, result_type: Attribute, *, key_digit_index: int, key_row_start: int=0)

Bases: IRDLOperation

Multiply one lifted digit by its evaluation-key pair.

For NTT/Montgomery digit $d$ and key digit $(k_{d, 0}, k_{d, 1})$ , the result has two components $(d k_{d, 0}, d k_{d, 1})$ in every active QP prime row. Products use Montgomery pointwise multiplication and remain NTT/Montgomery. The operation forms one summand of hybrid key switching and leaves CKKS depth and scale unchanged.

Attributes

Name	Type	Default/value
`name`		`'fhelium_rns.key_switch_digit_product'`
`digit`		`operand_def(RnsBundleType)`
`key`		`operand_def()`
`parameters`		`operand_def()`
`result`		`result_def(RnsBundleType)`
`key_digit_index`		`attr_def(IntegerAttr)`
`key_role`		`opt_attr_def(StringAttr)`
`traits`		`traits_def(Pure())`

`dependencies`

method

python

def dependencies() -> OperationDependencies: ...

Describe result reads in this operation's value coordinates.

`verify_`

method

python

def verify_() -> None: ...

`ModDownQpToQOp`

class View source

python

ModDownQpToQOp(value: SSAValue | Operation, parameters: Sequence[SSAValue | Operation], result_type: Attribute, *, attributes: Mapping[str, Attribute] | None=None)

Bases: IRDLOperation

Remove the special-prime product P from a key-switch accumulator.

Let $P = \prod_{j} p_{j}$ for the special P rows. For each coefficient of each accumulator component, one P prime $p_{d}$ is removed at a time. If $d = x mod p_{d}$ , every surviving row becomes $(x_{i} - d) p_{d}^{- 1} mod q_{i}$ or $(x_{i} - d) p_{d}^{- 1} mod p_{i}$ . Repeating this residue-algebra division removes all P rows and returns active-Q residues. This is the ModDown stage of hybrid key switching; key construction supplies the factor P, so CKKS message scale and depth do not change.

Attributes

Name	Type	Default/value
`name`		`'fhelium_rns.moddown_qp_to_q'`
`value`		`operand_def(RnsBundleType)`
`parameters`		`var_operand_def()`
`result`		`result_def(RnsBundleType)`
`traits`		`traits_def(Pure())`

`dependencies`

method

python

def dependencies() -> OperationDependencies: ...

Describe result reads in this operation's value coordinates.

`ModDownNttQpToQOp`

class View source

python

ModDownNttQpToQOp(value: SSAValue | Operation, parameters: Sequence[SSAValue | Operation], result_type: Attribute, *, attributes: Mapping[str, Attribute] | None=None)

Bases: IRDLOperation

Remove P from two QP accumulators and retain NTT/Montgomery Q rows.

The input has shape [2, *batch, |Q|+|P|, N]; the result has shape [2, *batch, |Q|, N]. The NTT-plan operand supplies the transforms for the same RNS context as the parameters and key-switch plan.

Let $r \in [0, P)$ be the coefficient representative reconstructed from ${INTT}_{P} ({\hat{x}}_{P})$ . The result is ${\hat{x}}_{Q} P^{- 1} + {NTT}_{Q} (- r P^{- 1}) mod q_{i}$ . This equals coefficient-domain ModDown followed by forward NTT, without inverting the Q rows. Output drops P, preserves active Q rows and N, and remains in Montgomery representation. It does not rescale CKKS values.

Attributes

Name	Type	Default/value
`name`		`'fhelium_rns.moddown_ntt_qp_to_q'`
`value`		`operand_def(RnsBundleType)`
`parameters`		`var_operand_def()`
`result`		`result_def(RnsBundleType)`
`traits`		`traits_def(Pure())`

`dependencies`

method

python

def dependencies() -> OperationDependencies: ...

Describe result reads in this operation's value coordinates.

`MontgomeryToStandardOp`

class View source

python

MontgomeryToStandardOp()

Bases: _ResidueConversionOp

Remove the Montgomery factor from coefficient residues.

For every active prime $q_{i}$ , the operation maps stored $x_{i} R_{i} mod q_{i}$ to $x_{i} mod q_{i}$ by Montgomery reduction. Polynomial coefficients, prime rows, depth, basis, and CKKS scale are preserved.

Attributes

Name	Type	Default/value
`name`		`'fhelium_rns.montgomery_to_standard'`

`dependencies`

method

python

def dependencies() -> OperationDependencies: ...

Describe result reads in this operation's value coordinates.

`MontgomeryMultiplyOp`

class View source

python

MontgomeryMultiplyOp(lhs: SSAValue | Operation, rhs: SSAValue | Operation, parameters: SSAValue | Operation, result_type: Attribute)

Bases: IRDLOperation

Multiply NTT/Montgomery polynomial bundles pointwise.

For active prime $q_{i}$ , transform index $k$ , and Montgomery radix $R_{i}$ , the operation computes $z_{i, k} = x_{i, k} y_{i, k} R_{i}^{- 1} mod q_{i}$ . The result remains NTT/Montgomery and represents polynomial multiplication in $Z_{q_{i}} [X] / (X^{N} + 1)$ . Prime rows and structural axes are preserved.

Attributes

Name	Type	Default/value
`name`		`'fhelium_rns.montgomery_multiply'`
`lhs`		`operand_def(RnsBundleType)`
`rhs`		`operand_def(RnsBundleType)`
`parameters`		`operand_def()`
`result`		`result_def(RnsBundleType)`
`traits`		`traits_def(Pure())`

`dependencies`

method

python

def dependencies() -> OperationDependencies: ...

Describe result reads in this operation's value coordinates.

`MontgomeryWeightedSumOp`

class View source

python

MontgomeryWeightedSumOp(parameters: SSAValue | Operation, ciphertexts: tuple[SSAValue | Operation, ...], plaintexts: tuple[SSAValue | Operation, ...], result_type: Attribute)

Bases: IRDLOperation

Sum ciphertext/plaintext products in NTT/Montgomery representation.

For $T$ ciphertext bundles $c_{t}$ followed by $T$ plaintext bundles $p_{t}$ , each component, batch element, active-prime row, and NTT index computes

y = \sum_{t = 0}^{T - 1} c_{t} p_{t} (\mod q_{i}) .

Every term uses the same component and batch shape, depth, prime rows, ciphertext scale, and plaintext scale. term_count separates the two equal operand ranges. The result keeps the ciphertext shape, depth, and NTT/Montgomery representation; its CKKS scale is the product of the common ciphertext and plaintext scales. The operation chooses no grouping, platform, kernel, or execution schedule.

Attributes

Name	Type	Default/value
`name`		`'fhelium_rns.montgomery_weighted_sum'`
`parameters`		`operand_def()`
`terms`		`var_operand_def(RnsBundleType)`
`result`		`result_def(RnsBundleType)`
`term_count`		`attr_def(IntegerAttr)`
`traits`		`traits_def(Pure())`

`dependencies`

method

python

def dependencies() -> OperationDependencies: ...

Describe each term's NTT positions and its output component mapping.

`verify_`

method

python

def verify_() -> None: ...

`MontgomeryWeightedSumsOp`

class View source

python

MontgomeryWeightedSumsOp(parameters: SSAValue | Operation, ciphertexts: tuple[SSAValue | Operation, ...], plaintexts: tuple[SSAValue | Operation, ...], result_type: Attribute, *, group_count: int)

Bases: IRDLOperation

Apply a dense plaintext matrix to shared ciphertext terms.

For $T$ ciphertext bundles $c_{t}$ and $G T$ plaintext bundles $p_{g, t}$ , the operation returns $G$ independent bundles

y_{g} = \sum_{t = 0}^{T - 1} c_{t} p_{g, t} (\mod q_{i}) .

Operands after parameters contain the $T$ ciphertexts followed by the group-major plaintext matrix. Every ciphertext has one NTT/Montgomery component, batch, depth, and prime-row layout; every plaintext has the matching row and batch layout and one common scale. The results keep the ciphertext state and have scale $Δ_{c} Δ_{p}$ . term_count and group_count describe the supplied matrix; the operation does not choose its groups, platform, kernel, or execution schedule.

Attributes

Name	Type	Default/value
`name`		`'fhelium_rns.montgomery_weighted_sums'`
`parameters`		`operand_def()`
`terms`		`var_operand_def(RnsBundleType)`
`result`		`result_def(RnsBundleType)`
`term_count`		`attr_def(IntegerAttr)`
`group_count`		`attr_def(IntegerAttr)`
`traits`		`traits_def(Pure())`

`dependencies`

method

python

def dependencies() -> OperationDependencies: ...

Describe each term's NTT positions and its output component mapping.

`verify_`

method

python

def verify_() -> None: ...

`MultiplyPlaintextOp`

class View source

python

MultiplyPlaintextOp()

Bases: _CiphertextPlaintextOp

Multiply every ciphertext component by a prepared plaintext.

The ciphertext and plaintext are NTT-domain Montgomery bundles on matching prime rows. For each component $j$ , prime $q_{i}$ , and transform index $k$ , Montgomery multiplication computes $c_{j, i, k}^{'} = c_{j, i, k} p_{i, k} R_{i}^{- 1} mod q_{i}$ . Thus the polynomial meaning is $c_{j}^{'} = c_{j} p$ in $R_{q_{i}}$ . Component count and depth remain; the CKKS result scale is the product of operand scales.

Attributes

Name	Type	Default/value
`name`		`'fhelium_rns.multiply_plaintext'`

`dependencies`

method

python

def dependencies() -> OperationDependencies: ...

Describe result reads in this operation's value coordinates.

`OPERATION_SPECS`

constant View source

python

OPERATION_SPECS: tuple[OperationSpec, ...] = tuple((registered_operation_spec(operation_type, 'rns', validator=flat_with_attributes(*_RNS_ATTRIBUTES[operation_type]) if operation_type in _RNS_ATTRIBUTES else flat_without_attributes) for operation_type in _RNS_OPERATION_TYPES))

`PackTwoComponentsOp`

class View source

python

PackTwoComponentsOp(component0: SSAValue | Operation, component1: SSAValue | Operation, result_type: Attribute)

Bases: IRDLOperation

Stack two polynomial bundles as $(c_{0}, c_{1})$ .

No residue arithmetic is performed. Both inputs retain their active prime rows and representation; a new leading component axis forms a two-component ciphertext-shaped bundle.

Attributes

Name	Type	Default/value
`name`		`'fhelium_rns.pack_two_components'`
`component0`		`operand_def(RnsBundleType)`
`component1`		`operand_def(RnsBundleType)`
`result`		`result_def(RnsBundleType)`
`traits`		`traits_def(Pure())`

`dependencies`

method

python

def dependencies() -> OperationDependencies: ...

Describe result reads in this operation's value coordinates.

`PackThreeComponentsOp`

class View source

python

PackThreeComponentsOp(component0: SSAValue | Operation, component1: SSAValue | Operation, component2: SSAValue | Operation, result_type: Attribute)

Bases: IRDLOperation

Stack three polynomial bundles as $(c_{0}, c_{1}, c_{2})$ .

No residue arithmetic is performed. Matching prime rows and representation are preserved while a new leading component axis forms a three-component ciphertext-shaped bundle.

Attributes

Name	Type	Default/value
`name`		`'fhelium_rns.pack_three_components'`
`component0`		`operand_def(RnsBundleType)`
`component1`		`operand_def(RnsBundleType)`
`component2`		`operand_def(RnsBundleType)`
`result`		`result_def(RnsBundleType)`
`traits`		`traits_def(Pure())`

`dependencies`

method

python

def dependencies() -> OperationDependencies: ...

Describe result reads in this operation's value coordinates.

`SubtractStandardOp`

class View source

python

SubtractStandardOp(lhs: SSAValue | Operation, rhs: SSAValue | Operation, parameters: SSAValue | Operation, result_type: Attribute)

Bases: IRDLOperation

Subtract standard-residue polynomial bundles row by row.

For each active prime $q_{i}$ , component, and coefficient, the result is $z_{i} = (x_{i} - y_{i}) mod q_{i}$ . The operation preserves component shape, prime rows, depth, modulus basis, polynomial domain, and scale.

Attributes

Name	Type	Default/value
`name`		`'fhelium_rns.subtract_standard'`
`lhs`		`operand_def(RnsBundleType)`
`rhs`		`operand_def(RnsBundleType)`
`parameters`		`operand_def()`
`result`		`result_def(RnsBundleType)`
`traits`		`traits_def(Pure())`

`dependencies`

method

python

def dependencies() -> OperationDependencies: ...

Describe result reads in this operation's value coordinates.

`FHEliumRns`

data View source

python

FHEliumRns = Dialect('fhelium_rns', [*_RNS_OPERATION_TYPES], [RnsBundleType, RnsParametersType])

`RescaleDropLeadingPrimesOp`

class View source

python

RescaleDropLeadingPrimesOp(value: SSAValue | Operation, parameters: Sequence[SSAValue | Operation], result_type: Attribute, *, drop_count: int=1, rounding: str | StringAttr='nearest', polynomial_domain: Literal['coefficient', 'ntt']='coefficient', attributes: Mapping[str, Attribute] | None=None)

Bases: IRDLOperation

Divide-round by the product of a leading prime group and remove its rows.

For the first drop_count primes, let $M$ be their product and $r = x mod M$ in $[0, M)$ . Floor quotient uses $t = r$ ; nearest quotient uses $t = r - M$ when $r > M / 2$ , otherwise $t = r$ . Each surviving row is $y_{i} = (x_{i} - t) M^{- 1} mod q_{i}$ . Component count and polynomial domain are preserved. NTT/Montgomery input may retain surviving evaluations while constructing the rounded coefficient correction from dropped rows. The caller supplies resulting CKKS depth and scale; this RNS operation describes a row-group quotient, not a count of CKKS transitions.

Attributes

Name	Type	Default/value
`name`		`'fhelium_rns.rescale_drop_leading_primes'`
`value`		`operand_def(RnsBundleType)`
`parameters`		`var_operand_def()`
`result`		`result_def(RnsBundleType)`
`drop_count`		`attr_def(IntegerAttr, default_value=IntegerAttr(1, 64))`
`rounding`		`opt_attr_def(StringAttr)`
`input_domain`		`attr_def(StringAttr, default_value=StringAttr('coefficient'))`
`output_domain`		`attr_def(StringAttr, default_value=StringAttr('coefficient'))`
`traits`		`traits_def(Pure())`

`dependencies`

method

python

def dependencies() -> OperationDependencies: ...

Describe the rounded quotient in its represented polynomial domain.

`verify_`

method

python

def verify_() -> None: ...

Accept only the represented CKKS quotient-rounding rules.

`RestrictDepthOp`

class View source

python

RestrictDepthOp(value: SSAValue | Operation, result_type: Attribute, *, target_depth: int | IntegerAttr)

Bases: IRDLOperation

Select the suffix of prime rows belonging to a later depth.

If depth $ℓ$ uses active rows $(q_{ℓ}, \dots, q_{L})$ , restriction to $t \geq ℓ$ discards $(q_{ℓ}, \dots, q_{t - 1})$ and copies the remaining rows. No division or rounding occurs, so the actual scale and every surviving residue are unchanged. P rows remain when the modulus basis is QP.

Attributes

Name	Type	Default/value
`name`		`'fhelium_rns.restrict_depth'`
`value`		`operand_def(RnsBundleType)`
`result`		`result_def(RnsBundleType)`
`target_depth`		`attr_def(IntegerAttr)`
`traits`		`traits_def(Pure())`

`dependencies`

method

python

def dependencies() -> OperationDependencies: ...

Describe result reads in this operation's value coordinates.

`ReinterpretScaleOp`

class View source

python

ReinterpretScaleOp(value: SSAValue | Operation, result_type: Attribute, *, scale: float | FloatAttr)

Bases: IRDLOperation

Replace scale metadata without changing an RNS payload.

The result refers to the same residue classes and polynomial representation but records the supplied actual scale $Δ^{'}$ . Consequently decoding interprets the represented coefficients as $x / Δ^{'}$ rather than $x / Δ$ ; no modular arithmetic, row selection, or depth transition is performed.

Attributes

Name	Type	Default/value
`name`		`'fhelium_rns.reinterpret_scale'`
`value`		`operand_def(RnsBundleType)`
`result`		`result_def(RnsBundleType)`
`scale`		`attr_def(FloatAttr)`
`traits`		`traits_def(Pure())`

`dependencies`

method

python

def dependencies() -> OperationDependencies: ...

Describe result reads in this operation's value coordinates.

`RnsBundleType`

class View source

python

RnsBundleType()

Bases: OpenStateType

RNS components with partial arithmetic, layout, and placement state.

Attributes

Name	Type	Default/value
`name`		`'fhelium_rns.bundle'`

`RnsParametersType`

class View source

python

RnsParametersType()

Bases: OpenStateType

CKKS-parameter-specific RNS moduli and Montgomery parameters.

Attributes

Name	Type	Default/value
`name`		`'fhelium_rns.parameters'`

`StandardToMontgomeryOp`

class View source

python

StandardToMontgomeryOp()

Bases: _ResidueConversionOp

Convert coefficient residues to Montgomery representation.

For every active prime $q_{i}$ and stored residue $x_{i}$ , the result is $x_{i} R_{i} mod q_{i}$ , where $R_{i}$ is the Montgomery radix. Polynomial coefficients, prime rows, depth, basis, and CKKS scale otherwise do not change.

Attributes

Name	Type	Default/value
`name`		`'fhelium_rns.standard_to_montgomery'`

`dependencies`

method

python

def dependencies() -> OperationDependencies: ...

Describe result reads in this operation's value coordinates.

fhelium.ir.dialects.rns ​

AddStandardOp ​

Attributes ​

dependencies ​

AddPlaintextOp ​

Attributes ​

dependencies ​

SumStandardBatchOp ​

Attributes ​

dependencies ​

AddMontgomeryLazyOp ​

Attributes ​

dependencies ​

CoefficientAutomorphismOp ​

Attributes ​

dependencies ​

verify_ ​

ExtractComponentOp ​

Attributes ​

dependencies ​

verify_ ​

NegateStandardOp ​

Attributes ​

dependencies ​

HybridModUpDigitOp ​

Attributes ​

dependencies ​

verify_ ​

KeySwitchDigitProductOp ​

Attributes ​

dependencies ​

verify_ ​

ModDownQpToQOp ​

Attributes ​

dependencies ​

ModDownNttQpToQOp ​

Attributes ​

dependencies ​

MontgomeryToStandardOp ​

Attributes ​

dependencies ​

MontgomeryMultiplyOp ​

Attributes ​

dependencies ​

MontgomeryWeightedSumOp ​

Attributes ​

dependencies ​

verify_ ​

MontgomeryWeightedSumsOp ​

Attributes ​

dependencies ​

verify_ ​

MultiplyPlaintextOp ​

Attributes ​

dependencies ​

OPERATION_SPECS ​

PackTwoComponentsOp ​

Attributes ​

dependencies ​

PackThreeComponentsOp ​

Attributes ​

dependencies ​

SubtractStandardOp ​

Attributes ​

dependencies ​

FHEliumRns ​

RescaleDropLeadingPrimesOp ​

Attributes ​

dependencies ​

verify_ ​

RestrictDepthOp ​

Attributes ​

dependencies ​

ReinterpretScaleOp ​

Attributes ​

dependencies ​

RnsBundleType ​

Attributes ​

RnsParametersType ​

Attributes ​

`fhelium.ir.dialects.rns`

`AddStandardOp`

Attributes

`dependencies`

`AddPlaintextOp`

Attributes

`dependencies`

`SumStandardBatchOp`

Attributes

`dependencies`

`AddMontgomeryLazyOp`

Attributes

`dependencies`

`CoefficientAutomorphismOp`

Attributes

`dependencies`

`verify_`

`ExtractComponentOp`

Attributes

`dependencies`

`verify_`

`NegateStandardOp`

Attributes

`dependencies`

`HybridModUpDigitOp`

Attributes

`dependencies`

`verify_`

`KeySwitchDigitProductOp`

Attributes

`dependencies`

`verify_`

`ModDownQpToQOp`

Attributes

`dependencies`

`ModDownNttQpToQOp`

Attributes

`dependencies`

`MontgomeryToStandardOp`

Attributes

`dependencies`

`MontgomeryMultiplyOp`

Attributes

`dependencies`

`MontgomeryWeightedSumOp`

Attributes

`dependencies`

`verify_`

`MontgomeryWeightedSumsOp`

Attributes

`dependencies`

`verify_`

`MultiplyPlaintextOp`

Attributes

`dependencies`

`OPERATION_SPECS`

`PackTwoComponentsOp`

Attributes

`dependencies`

`PackThreeComponentsOp`

Attributes

`dependencies`

`SubtractStandardOp`

Attributes

`dependencies`

`FHEliumRns`

`RescaleDropLeadingPrimesOp`

Attributes

`dependencies`

`verify_`

`RestrictDepthOp`

Attributes

`dependencies`

`ReinterpretScaleOp`

Attributes

`dependencies`

`RnsBundleType`

Attributes

`RnsParametersType`

Attributes