fhelium.experimental.bootstrap.polynomial.approximation

Polynomial values and numerical Chebyshev interpolation.

PolynomialBasis

type alias View source

PolynomialBasis = Literal['power', 'chebyshev']

PolynomialApproximation

class View source

PolynomialApproximation(basis: PolynomialBasis, coefficients: tuple[complex, ...], domain: tuple[float, float] = (-1.0, 1.0), name: str = 'polynomial', max_error: float | None = None)

An immutable polynomial produced independently of its evaluation DAG.

The coefficient convention is ascending degree. For basis="power",

$$p(x)=\sum _{n=0}^d{a}_n{x}^n,$$

while basis="chebyshev" means

$$p(x)=\sum _{n=0}^d{a}_n{T}_n(x),T_0(x)=1,T_1(x)=x.$$

domain=(a, b) records the physical interval used to design the approximation. The evaluator input is nevertheless normalized $x$ unless (a, b) == (-1, 1); the caller owns the affine map.

Attributes

• basis: Basis in which coefficients are expressed.
• coefficients: Ascending coefficients: entry i multiplies either $x^i$ or $T_i(x)$.
• domain: Plaintext interval on which the approximation was designed.
• name: Human-readable diagnostic name.
• max_error: Optional sampled or certified approximation error.

Attributes

Name	Type	Default/value
basis	PolynomialBasis
coefficients	tuple[complex, ...]
domain	tuple[float, float]	(-1.0, 1.0)
name	str	'polynomial'
max_error	float | None	None

degree

property

degree: int

Return the algebraic degree including trailing zero entries.

evaluate_plaintext

method

def evaluate_plaintext(values: np.ndarray) -> np.ndarray: ...

Evaluate $p(x)$ elementwise without homomorphic arithmetic.

values may have any NumPy-broadcastable shape, which is preserved in the output. They are coordinates in the polynomial's basis domain. For a Chebyshev approximation created on a physical interval other than $[-1,1]$, callers must first apply the same affine normalization described by the approximator. This method is a numerical oracle; it does not model CKKS rounding or depth consumption.

ChebyshevInterpolator

class View source

ChebyshevInterpolator(degree: int, error_samples: int = 8193)

Fit a degree-limited Chebyshev series at first-kind nodes.

degree controls both the number of interpolation nodes and the highest returned term $T_d$. error_samples controls only the dense grid used to report max_error; that sampled value is not a proof of the uniform error between grid points.

Attributes

Name	Type	Default/value
degree	int
error_samples	int	8193

approximate

method

def approximate(function: Callable[[np.ndarray], np.ndarray], *, domain: tuple[float, float]=(-1.0, 1.0), name: str='polynomial') -> PolynomialApproximation: ...

Interpolate after mapping physical $t\in [a,b]$ to $x\in [-1,1]$.

If domain=(a, b), first-kind nodes $x_j$ are evaluated physically at

$$t_j=a+(x_j+1)(b-a)/2.$$

Coefficients in the returned object are functions of normalized $x$, not directly of physical $t$. The consuming evaluator must therefore normalize its ciphertext to $x$ and account for any depth spent on that affine map.

max_error is measured on error_samples equally spaced normalized coordinates after fitting. Approximation runs on CPU binary64/complex128 arrays and returns no encrypted tensor.