Struct fancy_garbling::depth_informer::DepthInformer

pub struct DepthInformer { /* private fields */ }

Fancy Object which computes information about the circuit of interest to FHE.

Implementations

impl DepthInformer

pub fn new() -> DepthInformer

Create a new DepthInformer

Trait Implementations

impl Clone for DepthInformer

fn clone(&self) -> DepthInformer

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DepthInformer

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

Formats the value using the given formatter.

impl Display for DepthInformer

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

Formats the value using the given formatter.

impl Fancy for DepthInformer

type Item = DepthItem

The underlying wire datatype created by an object implementing Fancy.

type Error = DepthError

Errors which may be thrown by the users of Fancy.

fn constant(&mut self, _val: u16, q: u16) -> Result<Self::Item, Self::Error>

Create a constant x with modulus q.

fn output(&mut self, x: &Self::Item) -> Result<Option<u16>, Self::Error>

Process this wire as output. Some Fancy implementers don’t actually return output, but they need to be involved in the process, so they can return None.

fn outputs(&mut self, xs: &[Self::Item]) -> Result<Option<Vec<u16>>, Self::Error>

Output a slice of wires.

impl FancyArithmetic for DepthInformer

fn add(
    &mut self,
    x: &Self::Item,
    y: &Self::Item
) -> Result<Self::Item, Self::Error>

Add x and y.

fn sub(
    &mut self,
    x: &Self::Item,
    y: &Self::Item
) -> Result<Self::Item, Self::Error>

Subtract x and y.

fn cmul(&mut self, x: &Self::Item, _y: u16) -> Result<Self::Item, Self::Error>

Multiply x times the constant c.

fn mul(
    &mut self,
    x: &Self::Item,
    y: &Self::Item
) -> Result<Self::Item, Self::Error>

Multiply x and y.

fn proj(
    &mut self,
    _x: &Self::Item,
    _q: u16,
    _tt: Option<Vec<u16>>
) -> Result<Self::Item, Self::Error>

Project x according to the truth table tt. Resulting wire has modulus q.

fn add_many(&mut self, args: &[Self::Item]) -> Result<Self::Item, Self::Error>

Sum up a slice of wires.

fn mod_change(
    &mut self,
    x: &Self::Item,
    to_modulus: u16
) -> Result<Self::Item, Self::Error>

Change the modulus of x to to_modulus using a projection gate.

impl FancyBinary for DepthInformer

fn xor(
    &mut self,
    x: &Self::Item,
    y: &Self::Item
) -> Result<Self::Item, Self::Error>

Binary Xor

fn and(
    &mut self,
    x: &Self::Item,
    y: &Self::Item
) -> Result<Self::Item, Self::Error>

Binary And

fn negate(&mut self, x: &Self::Item) -> Result<Self::Item, Self::Error>

Binary Not

fn or(
    &mut self,
    x: &Self::Item,
    y: &Self::Item
) -> Result<Self::Item, Self::Error>

Uses Demorgan’s Rule implemented with an and gate and negation.

fn adder(
    &mut self,
    x: &Self::Item,
    y: &Self::Item,
    carry_in: Option<&Self::Item>
) -> Result<(Self::Item, Self::Item), Self::Error>

Binary adder. Returns the result and the carry.

fn and_many(&mut self, args: &[Self::Item]) -> Result<Self::Item, Self::Error>

Returns 1 if all wires equal 1.

fn or_many(&mut self, args: &[Self::Item]) -> Result<Self::Item, Self::Error>

Returns 1 if any wire equals 1.

fn xor_many(&mut self, args: &[Self::Item]) -> Result<Self::Item, Self::Error>

XOR many wires together

fn mux_constant_bits(
    &mut self,
    x: &Self::Item,
    b1: bool,
    b2: bool
) -> Result<Self::Item, Self::Error>

If x = 0 returns the constant b1 else return b2. Folds constants if possible.

fn mux(
    &mut self,
    b: &Self::Item,
    x: &Self::Item,
    y: &Self::Item
) -> Result<Self::Item, Self::Error>

If b = 0 returns x else y.

impl FancyInput for DepthInformer

type Item = DepthItem

The type that this Fancy object operates over.

type Error = DepthError

The type of error that this Fancy object emits.

fn receive_many(
    &mut self,
    moduli: &[u16]
) -> Result<Vec<Self::Item>, Self::Error>

Receive many values where the input is not known.

fn encode_many(
    &mut self,
    _values: &[u16],
    moduli: &[u16]
) -> Result<Vec<Self::Item>, Self::Error>

Encode many values where the actual input is known.

fn encode(&mut self, value: u16, modulus: u16) -> Result<Self::Item, Self::Error>

Encode a single value.

fn receive(&mut self, modulus: u16) -> Result<Self::Item, Self::Error>

Receive a single value.

fn encode_bundle(
    &mut self,
    values: &[u16],
    moduli: &[u16]
) -> Result<Bundle<Self::Item>, Self::Error>

Encode a bundle.

fn receive_bundle(
    &mut self,
    moduli: &[u16]
) -> Result<Bundle<Self::Item>, Self::Error>

Receive a bundle.

fn encode_bundles(
    &mut self,
    values: &[Vec<u16>],
    moduli: &[Vec<u16>]
) -> Result<Vec<Bundle<Self::Item>>, Self::Error>

Encode many input bundles.

fn receive_many_bundles(
    &mut self,
    moduli: &[Vec<u16>]
) -> Result<Vec<Bundle<Self::Item>>, Self::Error>

Receive many input bundles.

fn crt_encode(
    &mut self,
    value: u128,
    modulus: u128
) -> Result<CrtBundle<Self::Item>, Self::Error>

Encode a CRT input bundle.

fn crt_receive(
    &mut self,
    modulus: u128
) -> Result<CrtBundle<Self::Item>, Self::Error>

Receive an CRT input bundle.

fn crt_encode_many(
    &mut self,
    values: &[u128],
    modulus: u128
) -> Result<Vec<CrtBundle<Self::Item>>, Self::Error>

Encode many CRT input bundles.

fn crt_receive_many(
    &mut self,
    n: usize,
    modulus: u128
) -> Result<Vec<CrtBundle<Self::Item>>, Self::Error>

Receive many CRT input bundles.

fn bin_encode(
    &mut self,
    value: u128,
    nbits: usize
) -> Result<BinaryBundle<Self::Item>, Self::Error>

Encode a binary input bundle.

fn bin_receive(
    &mut self,
    nbits: usize
) -> Result<BinaryBundle<Self::Item>, Self::Error>

Receive an binary input bundle.

fn bin_encode_many(
    &mut self,
    values: &[u128],
    nbits: usize
) -> Result<Vec<BinaryBundle<Self::Item>>, Self::Error>

Encode many binary input bundles.

fn bin_receive_many(
    &mut self,
    ninputs: usize,
    nbits: usize
) -> Result<Vec<BinaryBundle<Self::Item>>, Self::Error>

Receive many binary input bundles.

impl FancyReveal for DepthInformer

fn reveal(&mut self, _x: &Self::Item) -> Result<u16, Self::Error>

Reveal the contents of x to all parties.

fn reveal_many(&mut self, xs: &[Self::Item]) -> Result<Vec<u16>, Self::Error>

Reveal a slice of items to all parties.

fn reveal_bundle(
    &mut self,
    x: &Bundle<Self::Item>
) -> Result<Vec<u16>, Self::Error>

Reveal a bundle to all parties.

fn reveal_many_bundles(
    &mut self,
    xs: &[Bundle<Self::Item>]
) -> Result<Vec<Vec<u16>>, Self::Error>

Reveal many bundles to all parties.

fn crt_reveal(&mut self, x: &CrtBundle<Self::Item>) -> Result<u128, Self::Error>

Reveal a CRT bundle to all parties.

fn crt_reveal_many(
    &mut self,
    xs: &[CrtBundle<Self::Item>]
) -> Result<Vec<u128>, Self::Error>

Reveal many CRT bundles to all parties.

fn bin_reveal(
    &mut self,
    x: &BinaryBundle<Self::Item>
) -> Result<u128, Self::Error>

Reveal a binary bundle to all parties.

fn bin_reveal_many(
    &mut self,
    xs: &[BinaryBundle<Self::Item>]
) -> Result<Vec<u128>, Self::Error>

Reveal many binary bundles to all parties.