core_utils/circuit/

gate.rs

use std::{
    collections::HashMap,
    ops::{Add, AddAssign, Index, IndexMut},
};

use macros::GateMethods;
use primitives::algebra::{
    elliptic_curve::{Curve, Point, Scalar},
    BoxedUint,
};
use serde::{Deserialize, Serialize};

use crate::circuit::{
    AlgebraicType,
    Batched,
    BitShareBinaryOp,
    BitShareUnaryOp,
    FieldPlaintextBinaryOp,
    FieldPlaintextUnaryOp,
    FieldShareBinaryOp,
    FieldShareUnaryOp,
    FieldType,
    GateIndex,
    Input,
    PointPlaintextBinaryOp,
    PointPlaintextUnaryOp,
    PointShareBinaryOp,
    PointShareUnaryOp,
    ShareOrPlaintext,
};

/// Gate operations, where the operation arguments correspond to _wire_ label.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize, GateMethods)]
#[serde(bound(
    serialize = "Scalar<C>: Serialize, Point<C>: Serialize",
    deserialize = "Scalar<C>: Deserialize<'de>, Point<C>: Deserialize<'de>"
))]
pub enum Gate<C: Curve> {
    /// Input a wire
    Input {
        input_type: Input<C>,
    },
    /// Field share unary operations
    FieldShareUnaryOp {
        x: GateIndex,
        op: FieldShareUnaryOp,
        field_type: FieldType,
    },
    /// Field share binary operations, where the second wire may be a plaintext.
    FieldShareBinaryOp {
        x: GateIndex,
        y: GateIndex,
        y_form: ShareOrPlaintext,
        op: FieldShareBinaryOp,
        field_type: FieldType,
    },
    BatchSummation {
        x: GateIndex,
        x_form: ShareOrPlaintext,
        algebraic_type: AlgebraicType,
    },
    BitShareUnaryOp {
        x: GateIndex,
        op: BitShareUnaryOp,
    },
    BitShareBinaryOp {
        x: GateIndex,
        y: GateIndex,
        y_form: ShareOrPlaintext,
        op: BitShareBinaryOp,
    },
    /// Operations with elliptic curve points
    PointShareUnaryOp {
        p: GateIndex,
        op: PointShareUnaryOp,
    },
    PointShareBinaryOp {
        p: GateIndex,
        y: GateIndex,
        p_form: ShareOrPlaintext,
        y_form: ShareOrPlaintext,
        op: PointShareBinaryOp,
    },
    /// Field plaintext unary operations
    FieldPlaintextUnaryOp {
        x: GateIndex,
        op: FieldPlaintextUnaryOp,
        field_type: FieldType,
    },
    /// Field plaintext binary operations
    FieldPlaintextBinaryOp {
        x: GateIndex,
        y: GateIndex,
        op: FieldPlaintextBinaryOp,
        field_type: FieldType,
    },
    BitPlaintextUnaryOp {
        x: GateIndex,
        op: FieldPlaintextUnaryOp,
    },
    BitPlaintextBinaryOp {
        x: GateIndex,
        y: GateIndex,
        op: FieldPlaintextBinaryOp,
    },
    PointPlaintextUnaryOp {
        p: GateIndex,
        op: PointPlaintextUnaryOp,
    },
    PointPlaintextBinaryOp {
        p: GateIndex,
        y: GateIndex,
        op: PointPlaintextBinaryOp,
    },
    /// Request a daBit
    DaBit {
        field_type: FieldType,
        batched: Batched,
    },
    GetDaBitFieldShare {
        x: GateIndex,
        field_type: FieldType,
    },
    GetDaBitSharedBit {
        x: GateIndex,
        field_type: FieldType,
    },
    /// Base field exponentiation operation
    BaseFieldPow {
        x: GateIndex,
        exp: BoxedUint,
    },
    /// Bit plaintext conversion operations
    BitPlaintextToField {
        x: GateIndex,
        field_type: FieldType,
    },
    FieldPlaintextToBit {
        x: GateIndex,
        field_type: FieldType,
    },
    /// Get the element at a certain index of a batched wire
    BatchGetIndex {
        x: GateIndex,
        x_type: AlgebraicType,
        x_form: ShareOrPlaintext,
        index: usize,
    },
    CollectToBatch {
        wires: Vec<GateIndex>,
        x_type: AlgebraicType,
        x_form: ShareOrPlaintext,
    },
    PointFromPlaintextExtendedEdwards {
        wires: Vec<GateIndex>,
    },
    PlaintextPointToExtendedEdwards {
        point: GateIndex,
    },
    PlaintextKeccakF1600 {
        wires: Vec<GateIndex>,
    },
    CompressPlaintextPoint {
        point: GateIndex,
    },
    KeyRecoveryPlaintextComputeErrors {
        d_minus_one: GateIndex,
        syndromes: GateIndex,
    },
}

impl<C: Curve> Gate<C> {
    /// Gathers all the `GateIndex` inside the gate.
    pub fn get_gate_indices(&self) -> Vec<GateIndex> {
        let mut gate_indices = Vec::new();
        self.for_each_gate_index(|idx| gate_indices.push(idx));
        gate_indices
    }

    pub fn add_to_required_preprocessing(
        &self,
        batched: Batched,
        circuit_preprocessing: &mut CircuitPreprocessing,
    ) {
        match self {
            Gate::Input { input_type } => match input_type {
                Input::SecretPlaintext {
                    algebraic_type: AlgebraicType::ScalarField | AlgebraicType::Point,
                    batched,
                    ..
                } => circuit_preprocessing.scalar.singlets += batched.count(),
                Input::SecretPlaintext {
                    algebraic_type: AlgebraicType::BaseField,
                    batched,
                    ..
                } => circuit_preprocessing.base_field.singlets += batched.count(),
                Input::SecretPlaintext {
                    algebraic_type: AlgebraicType::Mersenne107,
                    ..
                } => circuit_preprocessing.mersenne107.singlets += batched.count(),
                Input::SecretPlaintext {
                    algebraic_type: AlgebraicType::Bit,
                    batched,
                    ..
                } => circuit_preprocessing.bit_singlets += batched.count(),
                Input::RandomShare {
                    algebraic_type,
                    batched,
                } => match algebraic_type {
                    AlgebraicType::ScalarField | AlgebraicType::Point => {
                        circuit_preprocessing.scalar.singlets += batched.count();
                    }
                    AlgebraicType::BaseField => {
                        circuit_preprocessing.base_field.singlets += batched.count();
                    }
                    AlgebraicType::Bit => {
                        circuit_preprocessing.bit_singlets += batched.count();
                    }
                    AlgebraicType::Mersenne107 => {
                        circuit_preprocessing.mersenne107.singlets += batched.count();
                    }
                },
                Input::Share { .. }
                | Input::Scalar { .. }
                | Input::ScalarBatch { .. }
                | Input::BaseField { .. }
                | Input::Mersenne107 { .. }
                | Input::Bit { .. }
                | Input::Point { .. }
                | Input::BaseFieldBatch { .. }
                | Input::Mersenne107Batch { .. }
                | Input::BitBatch { .. }
                | Input::PointBatch { .. } => (),
            },
            Gate::FieldShareBinaryOp {
                y_form: ShareOrPlaintext::Share,
                op,
                field_type,
                ..
            } => match op {
                FieldShareBinaryOp::Mul => {
                    circuit_preprocessing[*field_type].triples += batched.count();
                }
                FieldShareBinaryOp::Add => (),
            },
            Gate::FieldShareUnaryOp { op, field_type, .. } => match op {
                FieldShareUnaryOp::MulInverse | FieldShareUnaryOp::IsZero => {
                    circuit_preprocessing[*field_type].triples += batched.count();
                    circuit_preprocessing[*field_type].singlets += batched.count();
                }
                FieldShareUnaryOp::Open | FieldShareUnaryOp::Neg => (),
            },
            Gate::PointShareUnaryOp { op, .. } => match op {
                PointShareUnaryOp::IsZero => {
                    circuit_preprocessing.scalar.triples += batched.count();
                    circuit_preprocessing.scalar.singlets += batched.count();
                }
                PointShareUnaryOp::Open | PointShareUnaryOp::Neg => (),
            },
            Gate::PointShareBinaryOp {
                p_form: ShareOrPlaintext::Share,
                y_form: ShareOrPlaintext::Share,
                op,
                ..
            } => match op {
                PointShareBinaryOp::ScalarMul => {
                    circuit_preprocessing.scalar.triples += batched.count();
                }
                PointShareBinaryOp::Add => (),
            },
            Gate::BitShareBinaryOp {
                y_form: ShareOrPlaintext::Share,
                op,
                ..
            } => match op {
                BitShareBinaryOp::And | BitShareBinaryOp::Or => {
                    circuit_preprocessing.bit_triples += batched.count();
                }
                BitShareBinaryOp::Xor => (),
            },
            Gate::BaseFieldPow { exp, .. } => {
                *circuit_preprocessing
                    .base_field_pow_pairs
                    .entry(exp.clone())
                    .or_insert(0) += batched.count();
                circuit_preprocessing.base_field.triples += batched.count();
            }
            Gate::DaBit {
                field_type,
                batched,
            } => circuit_preprocessing[*field_type].dabits += batched.count(),
            Gate::BatchSummation { .. }
            | Gate::BitShareUnaryOp { .. }
            | Gate::BitShareBinaryOp {
                y_form: ShareOrPlaintext::Plaintext,
                ..
            }
            | Gate::PointShareBinaryOp {
                p_form: ShareOrPlaintext::Plaintext,
                ..
            }
            | Gate::PointShareBinaryOp {
                p_form: ShareOrPlaintext::Share,
                y_form: ShareOrPlaintext::Plaintext,
                ..
            }
            | Gate::FieldPlaintextUnaryOp { .. }
            | Gate::FieldPlaintextBinaryOp { .. }
            | Gate::BitPlaintextUnaryOp { .. }
            | Gate::BitPlaintextBinaryOp { .. }
            | Gate::PointPlaintextUnaryOp { .. }
            | Gate::PointPlaintextBinaryOp { .. }
            | Gate::GetDaBitFieldShare { .. }
            | Gate::GetDaBitSharedBit { .. }
            | Gate::BitPlaintextToField { .. }
            | Gate::FieldPlaintextToBit { .. }
            | Gate::BatchGetIndex { .. }
            | Gate::CollectToBatch { .. }
            | Gate::PointFromPlaintextExtendedEdwards { .. }
            | Gate::PlaintextPointToExtendedEdwards { .. }
            | Gate::PlaintextKeccakF1600 { .. }
            | Gate::CompressPlaintextPoint { .. }
            | Gate::FieldShareBinaryOp {
                y_form: ShareOrPlaintext::Plaintext,
                ..
            }
            | Gate::KeyRecoveryPlaintextComputeErrors { .. } => (),
        };
    }
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct FieldCircuitPreprocessing {
    pub singlets: usize,
    pub triples: usize,
    pub dabits: usize,
}

impl AddAssign for FieldCircuitPreprocessing {
    fn add_assign(&mut self, rhs: Self) {
        self.singlets += rhs.singlets;
        self.triples += rhs.triples;
        self.dabits += rhs.dabits;
    }
}

impl Add for FieldCircuitPreprocessing {
    type Output = Self;
    fn add(self, rhs: Self) -> Self::Output {
        let mut res = self;
        res += rhs;
        res
    }
}

#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct CircuitPreprocessing {
    pub base_field_pow_pairs: HashMap<BoxedUint, usize>,
    pub bit_singlets: usize,
    pub bit_triples: usize,
    pub base_field: FieldCircuitPreprocessing,
    pub scalar: FieldCircuitPreprocessing,
    pub mersenne107: FieldCircuitPreprocessing,
}

impl AddAssign for CircuitPreprocessing {
    fn add_assign(&mut self, rhs: Self) {
        self.bit_singlets += rhs.bit_singlets;
        self.bit_triples += rhs.bit_triples;
        self.base_field += rhs.base_field;
        self.scalar += rhs.scalar;
        self.mersenne107 += rhs.mersenne107;
        for (k, v) in rhs.base_field_pow_pairs {
            *self.base_field_pow_pairs.entry(k).or_insert(0) += v;
        }
    }
}

impl Add for CircuitPreprocessing {
    type Output = Self;

    fn add(self, other: Self) -> Self::Output {
        let mut res = self;
        res += other;
        res
    }
}

impl Index<FieldType> for CircuitPreprocessing {
    type Output = FieldCircuitPreprocessing;

    fn index(&self, index: FieldType) -> &Self::Output {
        match index {
            FieldType::BaseField => &self.base_field,
            FieldType::ScalarField => &self.scalar,
            FieldType::Mersenne107 => &self.mersenne107,
        }
    }
}

impl IndexMut<FieldType> for CircuitPreprocessing {
    fn index_mut(&mut self, index: FieldType) -> &mut Self::Output {
        match index {
            FieldType::BaseField => &mut self.base_field,
            FieldType::ScalarField => &mut self.scalar,
            FieldType::Mersenne107 => &mut self.mersenne107,
        }
    }
}

#[cfg(test)]
mod tests {
    use std::collections::HashSet;

    use primitives::algebra::elliptic_curve::Curve25519Ristretto as C;

    use super::*;
    use crate::circuit::FieldShareBinaryOp;

    #[test]
    fn test_ser_gate() {
        let no_curve_gate: Gate<C> = Gate::FieldShareBinaryOp {
            x: 1,
            y: 3,
            y_form: ShareOrPlaintext::Share,
            op: FieldShareBinaryOp::Add,
            field_type: FieldType::ScalarField,
        };
        let scalar_gate: Gate<C> = Gate::FieldShareBinaryOp {
            x: 1,
            y: 3,
            y_form: ShareOrPlaintext::Plaintext,
            op: FieldShareBinaryOp::Add,
            field_type: FieldType::ScalarField,
        };
        let point_gate: Gate<C> = Gate::PointShareBinaryOp {
            p: 1,
            y: 3,
            p_form: ShareOrPlaintext::Share,
            y_form: ShareOrPlaintext::Plaintext,
            op: PointShareBinaryOp::Add,
        };

        let no_curve_gate_ser = bincode::serialize(&no_curve_gate).unwrap();
        let scalar_gate_ser = bincode::serialize(&scalar_gate).unwrap();
        let point_gate_ser = bincode::serialize(&point_gate).unwrap();

        let no_curve_gate_de: Gate<C> = bincode::deserialize(&no_curve_gate_ser).unwrap();
        let scalar_gate_de: Gate<C> = bincode::deserialize(&scalar_gate_ser).unwrap();
        let point_gate_de: Gate<C> = bincode::deserialize(&point_gate_ser).unwrap();

        assert_eq!(no_curve_gate, no_curve_gate_de);
        assert_eq!(scalar_gate, scalar_gate_de);
        assert_eq!(point_gate, point_gate_de);
        let set = HashSet::from([
            no_curve_gate,
            no_curve_gate_de,
            scalar_gate,
            scalar_gate_de,
            point_gate,
            point_gate_de,
        ]);
        assert_eq!(set.len(), 3)
    }

    #[test]
    fn test_circuit_preprocessing_add() {
        let a = CircuitPreprocessing {
            bit_singlets: 0,
            bit_triples: 1,
            base_field: FieldCircuitPreprocessing {
                singlets: 3,
                triples: 4,
                dabits: 2,
            },
            scalar: FieldCircuitPreprocessing {
                singlets: 1,
                triples: 2,
                dabits: 1,
            },
            base_field_pow_pairs: vec![
                (BoxedUint::from(vec![21]), 5),
                (BoxedUint::from(vec![14]), 6),
            ]
            .into_iter()
            .collect(),
            mersenne107: FieldCircuitPreprocessing {
                singlets: 0,
                triples: 0,
                dabits: 0,
            },
        };
        let b = CircuitPreprocessing {
            bit_singlets: 3,
            bit_triples: 4,
            base_field: FieldCircuitPreprocessing {
                singlets: 0,
                triples: 5,
                dabits: 3,
            },
            scalar: FieldCircuitPreprocessing {
                singlets: 2,
                triples: 3,
                dabits: 2,
            },
            base_field_pow_pairs: vec![
                (BoxedUint::from(vec![21]), 6),
                (BoxedUint::from(vec![13]), 7),
            ]
            .into_iter()
            .collect(),
            mersenne107: FieldCircuitPreprocessing {
                singlets: 3,
                triples: 2,
                dabits: 0,
            },
        };

        let c = a + b;

        assert_eq!(c.scalar.singlets, 3);
        assert_eq!(c.scalar.triples, 5);
        assert_eq!(c.base_field.singlets, 3);
        assert_eq!(c.base_field.triples, 9);
        assert_eq!(c.bit_singlets, 3);
        assert_eq!(c.bit_triples, 5);
        assert_eq!(c.mersenne107.dabits, 0);
        assert_eq!(c.mersenne107.singlets, 3);
        assert_eq!(c.mersenne107.triples, 2);
        assert_eq!(c.scalar.dabits, 3);
        assert_eq!(c.base_field.dabits, 5);
        assert_eq!(
            c.base_field_pow_pairs.get(&BoxedUint::from(vec![21])),
            Some(&11)
        );
        assert_eq!(
            c.base_field_pow_pairs.get(&BoxedUint::from(vec![14])),
            Some(&6)
        );
        assert_eq!(
            c.base_field_pow_pairs.get(&BoxedUint::from(vec![13])),
            Some(&7)
        );
    }
}