Struct CircuitAnalyzer 

pub struct CircuitAnalyzer { /* private fields */ }

A Fancy object which counts gates in a binary circuit.

Specifically, CircuitAnalyzer stores the number of inputs, ands, xors, negations, constants, multiplication, addition, subtraction, constant operations and multiplication depth of the circuits. This information is especially useful for pre-processing authenticated garbling circuits.

Implementations

impl CircuitAnalyzer

pub fn new() -> CircuitAnalyzer

Create a new CircuitAnalyzer and sets all the gate counts to 0.

pub fn nands(&self) -> usize

Return the number of AND gates in the circuit

pub fn ninputs(&self) -> usize

Return the number of input wires of the circuit

Trait Implementations

impl Clone for CircuitAnalyzer

fn clone(&self) -> CircuitAnalyzer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CircuitAnalyzer

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

Formats the value using the given formatter.

impl Default for CircuitAnalyzer

fn default() -> CircuitAnalyzer

Returns the “default value” for a type.

impl Display for CircuitAnalyzer

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

Formats the value using the given formatter.

impl Fancy for CircuitAnalyzer

type Item = AnalyzerItem

The underlying wire datatype created by an object implementing Fancy.

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

Create a constant x with modulus q.

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

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], channel: &mut Channel<'_>, ) -> Result<Option<Vec<u16>>>

Output a slice of wires.

impl FancyArithmetic for CircuitAnalyzer

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

Add x and y.

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

Subtract x and y.

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

Multiply x times the constant c.

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

Multiply x and y.

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

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

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

Sum up a slice of wires.

fn mod_change( &mut self, x: &Self::Item, to_modulus: u16, channel: &mut Channel<'_>, ) -> Result<Self::Item>

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

impl FancyBinary for CircuitAnalyzer

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

Binary Xor

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

Binary And

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

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

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

Binary Not

fn adder( &mut self, x: &Self::Item, y: &Self::Item, carry_in: Option<&Self::Item>, channel: &mut Channel<'_>, ) -> Result<(Self::Item, Self::Item)>

Binary adder. Returns the result and the carry.

fn and_many( &mut self, args: &[Self::Item], channel: &mut Channel<'_>, ) -> Result<Self::Item>

Returns 1 if all wires equal 1.

fn or_many( &mut self, args: &[Self::Item], channel: &mut Channel<'_>, ) -> Result<Self::Item>

Returns 1 if any wire equals 1.

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

XOR many wires together.

fn mux_constant_bits( &mut self, x: &Self::Item, b1: bool, b2: bool, channel: &mut Channel<'_>, ) -> Result<Self::Item>

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, channel: &mut Channel<'_>, ) -> Result<Self::Item>

If b = 0 returns x else y.

impl FancyInput for CircuitAnalyzer

type Item = AnalyzerItem

The type that this Fancy object operates over.

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

Receive many values where the input is not known.

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

Encode many values where the actual input is known.

fn encode( &mut self, value: u16, modulus: u16, channel: &mut Channel<'_>, ) -> Result<Self::Item>

Encode a single value.

fn receive( &mut self, modulus: u16, channel: &mut Channel<'_>, ) -> Result<Self::Item>

Receive a single value.

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

Encode a bundle.

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

Receive a bundle.

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

Encode many input bundles.

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

Receive many input bundles.

fn crt_encode( &mut self, value: u128, modulus: u128, channel: &mut Channel<'_>, ) -> Result<CrtBundle<Self::Item>>

Encode a CRT input bundle.

fn crt_receive( &mut self, modulus: u128, channel: &mut Channel<'_>, ) -> Result<CrtBundle<Self::Item>>

Receive an CRT input bundle.

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

Encode many CRT input bundles.

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

Receive many CRT input bundles.

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

Encode a binary input bundle.

fn bin_receive( &mut self, nbits: usize, channel: &mut Channel<'_>, ) -> Result<BinaryBundle<Self::Item>>

Receive an binary input bundle.

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

Encode many binary input bundles.

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

Receive many binary input bundles.

impl FancyReveal for CircuitAnalyzer

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

Reveal the contents of x to all parties.

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

Reveal a slice of items to all parties.

fn reveal_bundle( &mut self, x: &Bundle<Self::Item>, channel: &mut Channel<'_>, ) -> Result<Vec<u16>>

Reveal a bundle to all parties.

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

Reveal many bundles to all parties.

fn crt_reveal( &mut self, x: &CrtBundle<Self::Item>, channel: &mut Channel<'_>, ) -> Result<u128>

Reveal a CRT bundle to all parties.

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

Reveal many CRT bundles to all parties.

fn bin_reveal( &mut self, x: &BinaryBundle<Self::Item>, channel: &mut Channel<'_>, ) -> Result<u128>

Reveal a binary bundle to all parties.

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

Reveal many binary bundles to all parties.

impl Ord for CircuitAnalyzer

fn cmp(&self, other: &CircuitAnalyzer) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for CircuitAnalyzer

fn eq(&self, other: &CircuitAnalyzer) -> 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 PartialOrd for CircuitAnalyzer

fn partial_cmp(&self, other: &CircuitAnalyzer) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for CircuitAnalyzer

impl StructuralPartialEq for CircuitAnalyzer