Struct FheProgramNode

pub struct FheProgramNode<T: NumCiphertexts, S = ()> {
    pub ids: &'static [NodeIndex],
    /* private fields */
}

A type that wraps an FheType during graph construction. It is an implementation detail and you should not construct these directly. Outside of very specific semantics, use-after-free and other undefined behaviors may occur.

Remarks

This type serves as an anchor so users can apply +, *, -, /, <<, and >> operators on types inside an FHE program function. If the underlying type T implements the GraphCipherAdd, GraphCipherMul, etc trait, then FheProgramNode<T> implements std::ops::Add, std::ops::Mul, etc and proxies to T’s underlying implementation.

This type impls the Copy trait so users don’t have to call .clone() all the time. Unfortunately, this rules out the clean implementation of using a Vec<NodeIndex> to store the graph nodes T represents; Vec does not impl Copy, and thus it cannot exist in this type. To circumvent this limitation, we use a threadlocal arena of NodeIndex to allocate and copy slices. This requires we lie about the lifetime of ids, which isn’t actually ’static, but rather until we clear the arena. We clean the arena in the FHE program macro after FHE program construction and thus after all FheProgramNodes have gone out of scope.

You should never explicitly construct these outside of e.g. FHE type GraphCipherPlainAdd traits, which run during graph construction.

Undefined behavior

These types must be constructed while CURRENT_FHE_CTX refers to a valid FheContext. Furthermore, no FheProgramNode should outlive the said context. Violating any of these conditions may result in memory corruption or use-after-free.

Fields

ids: &'static [NodeIndex]

The ids on this node. The ’static lifetime on this slice is a lie. The sunscreen compiler must ensure that no FheProgramNode exists after FHE program construction.

Implementations

impl<T: NumCiphertexts> FheProgramNode<T>

pub fn new(ids: &[NodeIndex]) -> Self

Creates a new FHE program node with the given node index.

These are an implementation detail needed while constructing the FHE program graph and should not be constructed at any other time. You should never need to directly create a FheProgramNode.

Remarks

This type internally captures a slice rather than directly storing its own Vec. We do this so the type can impl Copy and composing FHE programs is natural without the user needing to call clone() all the time.

Undefined behavior

This type references memory in a bump allocator. Failing to ensure FheProgramNodes never outlive the backing context, will result in use-after-free.

impl<T: NumCiphertexts, S> FheProgramNode<T, S>

pub fn get_plain_modulus() -> u64

Returns the plain modulus parameter for the given BFV scheme

Trait Implementations

impl<L, T> Add<FheProgramNode<Cipher<T>>> for FheProgramNode<Indeterminate<L, T>, Stage>

where T: FheType + GraphCipherPlainAdd<Left = T, Right = T> + GraphCipherAdd<Left = T, Right = T>, L: FheLiteral,

type Output = FheProgramNode<Indeterminate<L, T>, Stage>

The resulting type after applying the + operator.

fn add(self, rhs: FheProgramNode<Cipher<T>>) -> Self::Output

Performs the + operation.

impl<T> Add<FheProgramNode<Cipher<T>>> for FheProgramNode<T>

where T: FheType + GraphCipherPlainAdd<Left = T, Right = T>,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the + operator.

fn add(self, rhs: FheProgramNode<Cipher<T>>) -> Self::Output

Performs the + operation.

impl<T> Add<FheProgramNode<Cipher<T>>> for f64

where T: FheType + GraphCipherConstAdd<Left = T, Right = f64> + TryFrom<f64>,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the + operator.

fn add(self, rhs: FheProgramNode<Cipher<T>>) -> Self::Output

Performs the + operation.

impl<T> Add<FheProgramNode<Cipher<T>>> for i64

where T: FheType + GraphCipherConstAdd<Left = T, Right = i64> + TryFrom<i64>,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the + operator.

fn add(self, rhs: FheProgramNode<Cipher<T>>) -> Self::Output

Performs the + operation.

impl<T> Add<FheProgramNode<Cipher<T>>> for u64

where T: FheType + GraphCipherConstAdd<Left = T, Right = u64> + TryFrom<u64>,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the + operator.

fn add(self, rhs: FheProgramNode<Cipher<T>>) -> Self::Output

Performs the + operation.

impl<L, T> Add<FheProgramNode<Indeterminate<L, T>, Stage>> for FheProgramNode<Cipher<T>>

where T: FheType + GraphCipherPlainAdd<Left = T, Right = T> + GraphCipherAdd<Left = T, Right = T>, L: FheLiteral,

type Output = FheProgramNode<Indeterminate<L, T>, Stage>

The resulting type after applying the + operator.

fn add(self, rhs: FheProgramNode<Indeterminate<L, T>, Stage>) -> Self::Output

Performs the + operation.

impl<T> Add<FheProgramNode<T>> for FheProgramNode<Cipher<T>>

where T: FheType + GraphCipherPlainAdd<Left = T, Right = T>,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the + operator.

fn add(self, rhs: FheProgramNode<T>) -> Self::Output

Performs the + operation.

impl<T, U> Add<T> for FheProgramNode<Cipher<U>>

where U: FheType + GraphCipherConstAdd<Left = U, Right = T>, T: FheLiteral,

type Output = FheProgramNode<Cipher<U>>

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl<T> Add for FheProgramNode<Cipher<T>>

where T: FheType + GraphCipherAdd<Left = T, Right = T>,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<T: Clone + NumCiphertexts, S: Clone> Clone for FheProgramNode<T, S>

fn clone(&self) -> FheProgramNode<T, S>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<L, T> Coerce<FheProgramNode<Cipher<T>>> for FheProgramNode<Indeterminate<L, T>, Stage>

where L: FheLiteral, T: FheType,

fn coerce(self) -> FheProgramNode<Cipher<T>>

Coerce one FheProgramNode to another. The underlying value stays the same, but the types change. This function is allowed to panic on invalid coercions, which will result in a failed Err state when compiling the FHE program.

impl<T: NumCiphertexts, S> Coerce<FheProgramNode<T, S>> for FheProgramNode<T, S>

fn coerce(self) -> Self

Coerce one FheProgramNode to another. The underlying value stays the same, but the types change. This function is allowed to panic on invalid coercions, which will result in a failed Err state when compiling the FHE program.

impl<T: Debug + NumCiphertexts, S: Debug> Debug for FheProgramNode<T, S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<L, T> Div<FheProgramNode<Cipher<T>>> for FheProgramNode<Indeterminate<L, T>, Stage>

where T: FheType + GraphCipherPlainDiv<Left = T, Right = T> + GraphCipherDiv<Left = T, Right = T>, L: FheLiteral,

type Output = FheProgramNode<Indeterminate<L, T>, Stage>

The resulting type after applying the / operator.

fn div(self, rhs: FheProgramNode<Cipher<T>>) -> Self::Output

Performs the / operation.

impl<T> Div<FheProgramNode<Cipher<T>>> for FheProgramNode<T>

where T: FheType + GraphPlainCipherDiv<Left = T, Right = T>,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the / operator.

fn div(self, rhs: FheProgramNode<Cipher<T>>) -> Self::Output

Performs the / operation.

impl<T> Div<FheProgramNode<Cipher<T>>> for f64

where T: FheType + GraphConstCipherDiv<Left = f64, Right = T> + TryFrom<f64>,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the / operator.

fn div(self, rhs: FheProgramNode<Cipher<T>>) -> Self::Output

Performs the / operation.

impl<T> Div<FheProgramNode<Cipher<T>>> for i64

where T: FheType + GraphConstCipherDiv<Left = i64, Right = T> + TryFrom<f64>,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the / operator.

fn div(self, rhs: FheProgramNode<Cipher<T>>) -> Self::Output

Performs the / operation.

impl<T> Div<FheProgramNode<Cipher<T>>> for u64

where T: FheType + GraphConstCipherDiv<Left = u64, Right = T> + TryFrom<f64>,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the / operator.

fn div(self, rhs: FheProgramNode<Cipher<T>>) -> Self::Output

Performs the / operation.

impl<L, T> Div<FheProgramNode<Indeterminate<L, T>, Stage>> for FheProgramNode<Cipher<T>>

where T: FheType + GraphCipherPlainDiv<Left = T, Right = T> + GraphCipherDiv<Left = T, Right = T>, L: FheLiteral,

type Output = FheProgramNode<Indeterminate<L, T>, Stage>

The resulting type after applying the / operator.

fn div(self, rhs: FheProgramNode<Indeterminate<L, T>, Stage>) -> Self::Output

Performs the / operation.

impl<T> Div<FheProgramNode<T>> for FheProgramNode<Cipher<T>>

where T: FheType + GraphCipherPlainDiv<Left = T, Right = T>,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the / operator.

fn div(self, rhs: FheProgramNode<T>) -> Self::Output

Performs the / operation.

impl<T, U> Div<U> for FheProgramNode<Cipher<T>>

where U: FheLiteral, T: FheType + GraphCipherConstDiv<Left = T, Right = U>,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the / operator.

fn div(self, rhs: U) -> Self::Output

Performs the / operation.

impl<T> Div for FheProgramNode<Cipher<T>>

where T: FheType + GraphCipherDiv<Left = T, Right = T>,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<L, T> From<FheProgramNode<Indeterminate<L, T>, Stage>> for FheProgramNode<Cipher<T>>

where L: FheLiteral, T: FheType,

fn from(value: FheProgramNode<Indeterminate<L, T>, Stage>) -> Self

Converts to this type from the input type.

impl<T> Input for FheProgramNode<T>

where T: NumCiphertexts + TypeName,

type Output = FheProgramNode<T>

The type returned by the input fn`.

fn input() -> Self

Creates a new FheProgramNode denoted as an input to an Fhe Program graph.

impl<T> LaneCount for FheProgramNode<Cipher<T>>

where T: FheType + LaneCount,

fn lane_count() -> usize

The number of lanes.

impl<L, T> Mul<FheProgramNode<Cipher<T>>> for FheProgramNode<Indeterminate<L, T>, Stage>

where T: FheType + GraphCipherPlainMul<Left = T, Right = T> + GraphCipherMul<Left = T, Right = T>, L: FheLiteral,

type Output = FheProgramNode<Indeterminate<L, T>, Stage>

The resulting type after applying the * operator.

fn mul(self, rhs: FheProgramNode<Cipher<T>>) -> Self::Output

Performs the * operation.

impl<T> Mul<FheProgramNode<Cipher<T>>> for FheProgramNode<T>

where T: FheType + GraphCipherPlainMul<Left = T, Right = T>,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the * operator.

fn mul(self, rhs: FheProgramNode<Cipher<T>>) -> Self::Output

Performs the * operation.

impl<T> Mul<FheProgramNode<Cipher<T>>> for f64

where T: FheType + GraphCipherConstMul<Left = T, Right = f64> + TryFrom<f64>,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the * operator.

fn mul(self, rhs: FheProgramNode<Cipher<T>>) -> Self::Output

Performs the * operation.

impl<T> Mul<FheProgramNode<Cipher<T>>> for i64

where T: FheType + GraphCipherConstMul<Left = T, Right = i64> + TryFrom<i64>,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the * operator.

fn mul(self, rhs: FheProgramNode<Cipher<T>>) -> Self::Output

Performs the * operation.

impl<T> Mul<FheProgramNode<Cipher<T>>> for u64

where T: FheType + GraphCipherConstMul<Left = T, Right = u64> + TryFrom<u64>,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the * operator.

fn mul(self, rhs: FheProgramNode<Cipher<T>>) -> Self::Output

Performs the * operation.

impl<L, T> Mul<FheProgramNode<Indeterminate<L, T>, Stage>> for FheProgramNode<Cipher<T>>

where T: FheType + GraphCipherPlainMul<Left = T, Right = T> + GraphCipherMul<Left = T, Right = T>, L: FheLiteral,

type Output = FheProgramNode<Indeterminate<L, T>, Stage>

The resulting type after applying the * operator.

fn mul(self, rhs: FheProgramNode<Indeterminate<L, T>, Stage>) -> Self::Output

Performs the * operation.

impl<T> Mul<FheProgramNode<T>> for FheProgramNode<Cipher<T>>

where T: FheType + GraphCipherPlainMul<Left = T, Right = T>,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the * operator.

fn mul(self, rhs: FheProgramNode<T>) -> Self::Output

Performs the * operation.

impl<T, U> Mul<T> for FheProgramNode<Cipher<U>>

where U: FheType + GraphCipherConstMul<Left = U, Right = T> + TryFrom<T>, T: FheLiteral,

type Output = FheProgramNode<Cipher<U>>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<T> Mul for FheProgramNode<Cipher<T>>

where T: FheType + GraphCipherMul<Left = T, Right = T>,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<T> Neg for FheProgramNode<Cipher<T>>

where T: FheType + GraphCipherNeg<Val = T>,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T, S> NumCiphertexts for FheProgramNode<T, S>

where T: NumCiphertexts,

const NUM_CIPHERTEXTS: usize = T::NUM_CIPHERTEXTS

The number of ciphertexts this type decomposes into.

impl<T> Output for FheProgramNode<T>

where T: NumCiphertexts,

type Output = FheProgramNode<T>

The captured object return type.

fn output(&self) -> Self::Output

Denote this object is an output by appending an appropriate output FHE program nodes

impl<T: PartialEq + NumCiphertexts, S: PartialEq> PartialEq for FheProgramNode<T, S>

fn eq(&self, other: &FheProgramNode<T, S>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Shl<u64> for FheProgramNode<Cipher<T>>

where T: FheType + GraphCipherRotateLeft,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the << operator.

fn shl(self, x: u64) -> Self

Performs the << operation.

impl<T> Shr<u64> for FheProgramNode<Cipher<T>>

where T: FheType + GraphCipherRotateRight,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the >> operator.

fn shr(self, x: u64) -> Self

Performs the >> operation.

impl<L, T> Sub<FheProgramNode<Cipher<T>>> for FheProgramNode<Indeterminate<L, T>, Stage>

where T: FheType + GraphCipherPlainSub<Left = T, Right = T> + GraphCipherSub<Left = T, Right = T>, L: FheLiteral,

type Output = FheProgramNode<Indeterminate<L, T>, Stage>

The resulting type after applying the - operator.

fn sub(self, rhs: FheProgramNode<Cipher<T>>) -> Self::Output

Performs the - operation.

impl<T> Sub<FheProgramNode<Cipher<T>>> for FheProgramNode<T>

where T: FheType + GraphPlainCipherSub<Left = T, Right = T>,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the - operator.

fn sub(self, rhs: FheProgramNode<Cipher<T>>) -> Self::Output

Performs the - operation.

impl<T> Sub<FheProgramNode<Cipher<T>>> for f64

where T: FheType + GraphConstCipherSub<Left = f64, Right = T>,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the - operator.

fn sub(self, rhs: FheProgramNode<Cipher<T>>) -> Self::Output

Performs the - operation.

impl<T> Sub<FheProgramNode<Cipher<T>>> for i64

where T: FheType + GraphConstCipherSub<Left = i64, Right = T>,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the - operator.

fn sub(self, rhs: FheProgramNode<Cipher<T>>) -> Self::Output

Performs the - operation.

impl<T> Sub<FheProgramNode<Cipher<T>>> for u64

where T: FheType + GraphConstCipherSub<Left = u64, Right = T>,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the - operator.

fn sub(self, rhs: FheProgramNode<Cipher<T>>) -> Self::Output

Performs the - operation.

impl<L, T> Sub<FheProgramNode<Indeterminate<L, T>, Stage>> for FheProgramNode<Cipher<T>>

where T: FheType + GraphCipherPlainSub<Left = T, Right = T> + GraphCipherSub<Left = T, Right = T>, L: FheLiteral,

type Output = FheProgramNode<Indeterminate<L, T>, Stage>

The resulting type after applying the - operator.

fn sub(self, rhs: FheProgramNode<Indeterminate<L, T>, Stage>) -> Self::Output

Performs the - operation.

impl<T> Sub<FheProgramNode<T>> for FheProgramNode<Cipher<T>>

where T: FheType + GraphCipherPlainSub<Left = T, Right = T>,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the - operator.

fn sub(self, rhs: FheProgramNode<T>) -> Self::Output

Performs the - operation.

impl<T, U> Sub<T> for FheProgramNode<Cipher<U>>

where U: FheType + GraphCipherConstSub<Left = U, Right = T>, T: FheLiteral,

type Output = FheProgramNode<Cipher<U>>

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl<T> Sub for FheProgramNode<Cipher<T>>

where T: FheType + GraphCipherSub<Left = T, Right = T>,

type Output = FheProgramNode<Cipher<T>>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<T> SwapRows for FheProgramNode<Cipher<T>>

where T: FheType + GraphCipherSwapRows,

type Output = FheProgramNode<Cipher<T>>

The result type. Typically, this should just be Self.

fn swap_rows(self) -> Self::Output

Performs a row swap.

impl<T, S> TypeName for FheProgramNode<T, S>

where T: TypeName + NumCiphertexts,

fn type_name() -> Type

Returns the Type of the &self. Lives only on the instance so you can be object-safe for use in dyn TypeName.

impl<T: Copy + NumCiphertexts, S: Copy> Copy for FheProgramNode<T, S>

impl<T: Eq + NumCiphertexts, S: Eq> Eq for FheProgramNode<T, S>

impl<T: NumCiphertexts, S> StructuralPartialEq for FheProgramNode<T, S>