Trait FancyBinary

pub trait FancyBinary: Fancy {
    // Required methods
    fn xor(
        &mut self,
        x: &Self::Item,
        y: &Self::Item,
    ) -> Result<Self::Item, Self::Error>;
    fn and(
        &mut self,
        x: &Self::Item,
        y: &Self::Item,
    ) -> Result<Self::Item, Self::Error>;
    fn negate(&mut self, x: &Self::Item) -> Result<Self::Item, Self::Error>;

    // Provided methods
    fn or(
        &mut self,
        x: &Self::Item,
        y: &Self::Item,
    ) -> Result<Self::Item, Self::Error> { ... }
    fn adder(
        &mut self,
        x: &Self::Item,
        y: &Self::Item,
        carry_in: Option<&Self::Item>,
    ) -> Result<(Self::Item, Self::Item), Self::Error> { ... }
    fn and_many(
        &mut self,
        args: &[Self::Item],
    ) -> Result<Self::Item, Self::Error> { ... }
    fn or_many(
        &mut self,
        args: &[Self::Item],
    ) -> Result<Self::Item, Self::Error> { ... }
    fn xor_many(
        &mut self,
        args: &[Self::Item],
    ) -> Result<Self::Item, Self::Error> { ... }
    fn mux_constant_bits(
        &mut self,
        x: &Self::Item,
        b1: bool,
        b2: bool,
    ) -> Result<Self::Item, Self::Error> { ... }
    fn mux(
        &mut self,
        b: &Self::Item,
        x: &Self::Item,
        y: &Self::Item,
    ) -> Result<Self::Item, Self::Error> { ... }
}

Fancy DSL providing binary operations

Required Methods

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

Provided Methods

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.

Implementors

impl FancyBinary for CircuitBuilder<ArithmeticCircuit>

impl FancyBinary for CircuitBuilder<BinaryCircuit>

impl FancyBinary for DepthInformer

impl FancyBinary for Dummy

impl<C: AbstractChannel> FancyBinary for fancy_garbling::Evaluator<C, AllWire>

impl<C: AbstractChannel> FancyBinary for fancy_garbling::Evaluator<C, WireMod2>

impl<C: AbstractChannel, RNG, OT> FancyBinary for fancy_garbling::twopac::semihonest::Evaluator<C, RNG, OT, AllWire>

impl<C: AbstractChannel, RNG, OT> FancyBinary for fancy_garbling::twopac::semihonest::Evaluator<C, RNG, OT, WireMod2>

impl<C: AbstractChannel, RNG: CryptoRng + Rng, OT> FancyBinary for fancy_garbling::twopac::semihonest::Garbler<C, RNG, OT, AllWire>

impl<C: AbstractChannel, RNG: CryptoRng + Rng, OT> FancyBinary for fancy_garbling::twopac::semihonest::Garbler<C, RNG, OT, WireMod2>

impl<C: AbstractChannel, RNG: RngCore + CryptoRng> FancyBinary for fancy_garbling::Garbler<C, RNG, AllWire>

impl<C: AbstractChannel, RNG: RngCore + CryptoRng> FancyBinary for fancy_garbling::Garbler<C, RNG, WireMod2>

impl<F: FancyBinary> FancyBinary for Informer<F>