improve api and simplify SumProdCircuit creation

examples/dag.rs

@@ -1,23 +1,22 @@
 use std::cell::RefCell;
 use std::rc::Rc;
-
-use circuit_cas::circuit::dag::{Circuit, CircuitExt};
-use circuit_cas::var;
+use circuit_cas::circuit::probabilistic::ProbCircuit;
+use circuit_cas::circuit::dag::CircuitExt;
 
 fn main() {
-    let circuit = Rc::new(RefCell::new(Circuit::new()));
+    let circuit: Rc<RefCell<ProbCircuit>> = ProbCircuit::new();
 
     // Build (x + y) * (x + z)
-    let x = circuit.leaf(var!("x"));
-    let y = circuit.leaf(var!("y"));
-    let z = circuit.leaf(var!("z"));
+    let x = circuit.var("x");
+    let y = circuit.var("y");
+    let z = circuit.var("z");
 
-    let x_plus_y = circuit.leaf(var!("x")) + y;
-    let x_plus_z = circuit.leaf(var!("x")) + z;
+    let x_plus_y = circuit.var("x") + y;
+    let x_plus_z = circuit.var("x") + z;
     let expr = x_plus_y * x_plus_z;
 
     // Deduplication: both x leaves share the same NodeId
-    let x2 = circuit.leaf(var!("x"));
+    let x2 = circuit.var("x");
     assert_eq!(x.id, x2.id);
 
     println!("(x + y) * (x + z) root node id: {:?}", expr.id);

examples/quotient.rs

@@ -1,8 +1,8 @@
 use std::cell::RefCell;
 use std::rc::Rc;
-
-use circuit_cas::circuit::quotient::Quotient;
-use circuit_cas::poly::var::StaticVar;
+use circuit_cas::circuit::dag::CircuitExt;
+use circuit_cas::circuit::quotient::QuotientCircuit;
+use circuit_cas::circuit::traits::Circuit;
 use circuit_cas::var;
 
 fn main() {
@@ -15,7 +15,15 @@ fn main() {
         1 * ((&x ^ 1) * (&nx ^ 1)) - 1 * (&x ^ 1),
     ];
 
-    let mut quotient: Quotient<StaticVar> = idem.into_iter().collect();
+    let quotient: Rc<RefCell<QuotientCircuit>> = idem.into_iter().collect();
 
-    println!("{quotient}");
+    // Build x * x̄ + x in the DAG
+    let xn   = quotient.var("x");
+    let nxn  = quotient.var("x\u{0304}");
+    let prod = xn * nxn;
+    let xn2  = quotient.var("x");
+    let expr = prod + xn2;
+
+    println!("dag size: {}", quotient.borrow().len());
+    println!("expr node id: {:?}", expr.id);
 }

src/circuit/dag.rs

@@ -1,57 +1,29 @@
 use slotmap::{SlotMap, new_key_type};
 use std::cell::RefCell;
 use std::collections::HashMap;
-use std::ops::{Add, Mul};
 use std::rc::Rc;
 
-use crate::poly::var::Var;
+use super::traits::{Circuit, Node};
 
 new_key_type! { pub struct NodeId; }
 
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub enum Node<V: Var> {
-    Leaf(V),
-    Scale(NodeId, i32),
-    Sum(NodeId, NodeId),
-    Prod(NodeId, NodeId),
-}
-
-impl<V: Var> Node<V> {
-    pub fn children(&self) -> impl Iterator<Item = NodeId> {
-        match self {
-            Node::Leaf(_) => [None, None],
-            Node::Scale(n, _) => [Some(*n), None],
-            Node::Sum(l, r) | Node::Prod(l, r) => [Some(*l), Some(*r)],
-        }
-        .into_iter()
-        .flatten()
-    }
-}
-
 #[derive(Clone, Debug)]
-pub struct Circuit<V: Var> {
-    nodes: SlotMap<NodeId, Node<V>>,
-    intern: HashMap<Node<V>, NodeId>,
+pub struct Dag<N: Node> {
+    nodes: SlotMap<NodeId, N>,
+    intern: HashMap<N, NodeId>,
 }
 
-impl<V: Var> Default for Circuit<V> {
+impl<N: Node> Default for Dag<N> {
     fn default() -> Self {
-        Circuit {
+        Dag {
             nodes: Default::default(),
             intern: Default::default(),
         }
     }
 }
 
-impl<V: Var> Circuit<V> {
-    pub fn new() -> Self {
-        Circuit {
-            nodes: SlotMap::with_key(),
-            intern: HashMap::new(),
-        }
-    }
-
-    pub fn node(&mut self, n: Node<V>) -> NodeId {
+impl<N: Node> Dag<N> {
+    pub(super) fn node(&mut self, n: N) -> NodeId {
         if let Some(&id) = self.intern.get(&n) {
             return id;
         }
@@ -60,90 +32,33 @@ impl<V: Var> Circuit<V> {
         id
     }
 
-    pub fn get(&self, id: NodeId) -> Option<&Node<V>> {
+    pub(super) fn get(&self, id: NodeId) -> Option<&N> {
         self.nodes.get(id)
     }
 
-    pub fn add(&mut self, left: NodeId, right: NodeId) -> NodeId {
-        let (l, r) = if left <= right {
-            (left, right)
-        } else {
-            (right, left)
-        };
-        self.node(Node::Sum(l, r))
-    }
-
-    pub fn mul(&mut self, left: NodeId, right: NodeId) -> NodeId {
-        let (l, r) = if left <= right {
-            (left, right)
-        } else {
-            (right, left)
-        };
-        self.node(Node::Prod(l, r))
-    }
-
-    pub fn len(&self) -> usize {
+    pub(super) fn len(&self) -> usize {
         self.nodes.len()
     }
 
-    pub fn children(&self, id: NodeId) -> impl Iterator<Item = NodeId> + '_ {
+    pub(super) fn children(&self, id: NodeId) -> impl Iterator<Item = NodeId> + '_ {
         self.nodes.get(id).into_iter().flat_map(Node::children)
     }
 
-    pub fn remove(&mut self, id: NodeId) {
+    pub(super) fn remove(&mut self, id: NodeId) {
         if let Some(node) = self.nodes.remove(id) {
             self.intern.remove(&node);
         }
     }
 }
 
-pub struct CircuitNode<V: Var> {
+pub struct RefNode<C: Circuit> {
     pub id: NodeId,
-    circuit: Rc<RefCell<Circuit<V>>>,
-}
-pub trait CircuitExt<V: Var> {
-    fn leaf(&self, v: V) -> CircuitNode<V>;
-    fn get_node(&self, id: NodeId) -> Option<CircuitNode<V>>;
+    pub(super) circuit: Rc<RefCell<C>>,
 }
 
-impl<V: Var> CircuitExt<V> for Rc<RefCell<Circuit<V>>> {
-    fn leaf(&self, v: V) -> CircuitNode<V> {
-        let id = self.borrow_mut().node(Node::Leaf(v));
-        CircuitNode {
-            id,
-            circuit: self.clone(),
-        }
-    }
 
-    fn get_node(&self, id: NodeId) -> Option<CircuitNode<V>> {
-        self.borrow().get(id)?;
-        Some(CircuitNode {
-            id,
-            circuit: self.clone(),
-        })
-    }
-}
-
-impl<V: Var> Add for CircuitNode<V> {
-    type Output = Self;
-
-    fn add(self, rhs: Self) -> Self {
-        let id = self.circuit.borrow_mut().add(self.id, rhs.id);
-        CircuitNode {
-            id,
-            circuit: self.circuit,
-        }
-    }
-}
-
-impl<V: Var> Mul for CircuitNode<V> {
-    type Output = Self;
-
-    fn mul(self, rhs: Self) -> Self {
-        let id = self.circuit.borrow_mut().mul(self.id, rhs.id);
-        CircuitNode {
-            id,
-            circuit: self.circuit,
-        }
-    }
+pub trait CircuitExt {
+    type C: Circuit;
+    type Var;
+    fn var(&self, v: impl Into<Self::Var>) -> RefNode<Self::C>;
 }

src/circuit/mod.rs

@@ -1,4 +1,6 @@
+pub mod traits;
 pub mod dag;
+pub mod probabilistic;
 pub mod quotient;
 
 #[cfg(test)]

src/circuit/probabilistic.rs

@@ -0,0 +1,68 @@
+use std::cell::RefCell;
+use std::ops::{Deref, DerefMut};
+use std::rc::Rc;
+
+use crate::poly::var::{StaticVar, Var};
+use super::dag::{Dag, NodeId};
+use super::traits::{Node, SumProdCircuit};
+
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum PNode<V: Var> {
+    Var(V),
+    Sum(NodeId, NodeId),
+    Prod(NodeId, NodeId),
+}
+
+impl<V: Var> Node for PNode<V> {
+    fn children(&self) -> impl Iterator<Item = NodeId> {
+        match self {
+            Self::Var(_) => [None, None],
+            Self::Sum(l, r) | Self::Prod(l, r) => [Some(*l), Some(*r)],
+        }
+        .into_iter()
+        .flatten()
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct ProbCircuit<V: Var = StaticVar> {
+    dag: Dag<PNode<V>>,
+}
+
+impl<V: Var> Default for ProbCircuit<V> {
+    fn default() -> Self { ProbCircuit { dag: Dag::default() } }
+}
+
+impl<V: Var> ProbCircuit<V> {
+    pub fn new() -> Rc<RefCell<Self>> {
+        Rc::new(RefCell::new(Self::default()))
+    }
+}
+
+impl<V: Var> SumProdCircuit for ProbCircuit<V> {
+    type Var = V;
+
+    fn var(&mut self, v: V) -> NodeId { self.node(PNode::Var(v)) }
+
+    fn add(&mut self, l: NodeId, r: NodeId) -> NodeId {
+        let (l, r) = if l <= r { (l, r) } else { (r, l) };
+        self.node(PNode::Sum(l, r))
+    }
+
+    fn mul(&mut self, l: NodeId, r: NodeId) -> NodeId {
+        let (l, r) = if l <= r { (l, r) } else { (r, l) };
+        self.node(PNode::Prod(l, r))
+    }
+}
+
+impl<V: Var> Deref for ProbCircuit<V> {
+    type Target = Dag<PNode<V>>;
+    fn deref(&self) -> &Self::Target { &self.dag }
+}
+
+impl<V: Var> DerefMut for ProbCircuit<V> {
+    fn deref_mut(&mut self) -> &mut Self::Target { &mut self.dag }
+}
+
+

src/circuit/quotient.rs

@@ -1,52 +1,85 @@
-use super::dag::{Circuit, Node, NodeId};
-use crate::poly::{
-    flat::Poly,
-    ideal::{Generators, GroebnerBasis, Ideal},
-    var::Var,
-};
+use std::cell::RefCell;
+use std::ops::{Deref, DerefMut};
+use std::rc::Rc;
 
-use std::fmt::{self, Display};
+use crate::poly::var::{StaticVar, Var};
+use crate::poly::flat::Poly;
+use crate::poly::ideal::{Generators, GroebnerBasis, Ideal};
+use super::dag::{Dag, NodeId};
+use super::traits::{Node, SumProdCircuit};
+
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum QNode<V: Var> {
+    Var(V),
+    Sum(NodeId, NodeId),
+    Prod(NodeId, NodeId),
+    DivStep(NodeId, NodeId),
+}
+
+impl<V: Var> Node for QNode<V> {
+    fn children(&self) -> impl Iterator<Item = NodeId> {
+        match self {
+            Self::Var(_) => [None, None],
+            Self::Sum(l, r) | Self::Prod(l, r) | Self::DivStep(l, r) => [Some(*l), Some(*r)],
+        }
+        .into_iter()
+        .flatten()
+    }
+}
 
 #[derive(Clone, Debug)]
-pub struct Quotient<V: Var> {
+pub struct QuotientCircuit<V: Var = StaticVar> {
     basis: Ideal<V, GroebnerBasis>,
-    circuit: Circuit<V>,
+    dag: Dag<QNode<V>>,
 }
 
-impl<V: Var> From<Ideal<V, GroebnerBasis>> for Quotient<V> {
-    fn from(basis: Ideal<V, GroebnerBasis>) -> Self {
-        Quotient {
-            basis,
-            circuit: Default::default(),
-        }
-    }
+impl<V: Var> QuotientCircuit<V> {
+    pub fn from_ideal(basis: Ideal<V, GroebnerBasis>) -> Rc<RefCell<Self>> {
+        Rc::new(RefCell::new(Self { basis, dag: Default::default() }))
     }
 
-impl<V: Var> FromIterator<Poly<V>> for Quotient<V> {
-    fn from_iter<T: IntoIterator<Item = Poly<V>>>(iter: T) -> Self {
+    pub fn from_polys(iter: impl IntoIterator<Item = Poly<V>>) -> Rc<RefCell<Self>> {
         let ideal: Ideal<V, Generators> = iter.into_iter().collect();
-        Quotient {
-            basis: ideal.groebner_basis(),
-            circuit: Default::default(),
-        }
-    }
-}
-
-impl<V: Var> Display for Quotient<V> {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
-        write!(fmt, "C/{}", self.basis)
+        Rc::new(RefCell::new(Self { basis: ideal.groebner_basis(), dag: Default::default() }))
     }
 }
 
-impl<V: Var> Quotient<V> {
-    pub fn node(&mut self, n: Node<V>) -> NodeId {
-        self.circuit.node(n)
+impl<V: Var> From<Ideal<V, GroebnerBasis>> for Rc<RefCell<QuotientCircuit<V>>> {
+    fn from(basis: Ideal<V, GroebnerBasis>) -> Self {
+        QuotientCircuit::from_ideal(basis)
+    }
 }
 
-    pub fn add(&mut self, left: NodeId, right: NodeId) -> NodeId {
-        self.circuit.add(left, right)
-    }
-    pub fn mul(&mut self, left: NodeId, right: NodeId) -> NodeId {
-        self.circuit.mul(left, right)
+impl<V: Var> FromIterator<Poly<V>> for Rc<RefCell<QuotientCircuit<V>>> {
+    fn from_iter<T: IntoIterator<Item = Poly<V>>>(iter: T) -> Self {
+        QuotientCircuit::from_polys(iter)
     }
 }
+
+impl<V: Var> Deref for QuotientCircuit<V> {
+    type Target = Dag<QNode<V>>;
+    fn deref(&self) -> &Self::Target { &self.dag }
+}
+
+impl<V: Var> DerefMut for QuotientCircuit<V> {
+    fn deref_mut(&mut self) -> &mut Self::Target { &mut self.dag }
+}
+
+impl<V: Var> SumProdCircuit for QuotientCircuit<V> {
+    type Var = V;
+
+    fn var(&mut self, v: V) -> NodeId { self.node(QNode::Var(v)) }
+
+    fn add(&mut self, l: NodeId, r: NodeId) -> NodeId {
+        let (l, r) = if l <= r { (l, r) } else { (r, l) };
+        self.node(QNode::Sum(l, r))
+    }
+
+    fn mul(&mut self, l: NodeId, r: NodeId) -> NodeId {
+        let (l, r) = if l <= r { (l, r) } else { (r, l) };
+        self.node(QNode::Prod(l, r))
+    }
+}
+
+

src/circuit/tests.rs

@@ -1,50 +1,48 @@
 use std::cell::RefCell;
 use std::rc::Rc;
-
-use super::dag::{Circuit, CircuitExt};
-use crate::poly::var::StaticVar;
-
+use super::probabilistic::ProbCircuit;
+use super::dag::CircuitExt;
 #[test]
 fn test_deduplication() {
-    let circuit = Rc::new(RefCell::new(Circuit::new()));
+    let circuit: Rc<RefCell<ProbCircuit>> = ProbCircuit::new();
 
     // Same leaf constructed twice returns the same NodeId
-    let x1 = circuit.leaf(StaticVar::from("x"));
-    let x2 = circuit.leaf(StaticVar::from("x"));
+    let x1 = circuit.var("x");
+    let x2 = circuit.var("x");
     assert_eq!(x1.id, x2.id);
     assert_eq!(circuit.borrow().len(), 1);
 
     // Same sum constructed twice returns the same NodeId
-    let _y = circuit.leaf(StaticVar::from("y"));
-    let sum1 = circuit.leaf(StaticVar::from("x")) + circuit.leaf(StaticVar::from("y"));
-    let sum2 = circuit.leaf(StaticVar::from("x")) + circuit.leaf(StaticVar::from("y"));
+    let _y = circuit.var("y");
+    let sum1 = circuit.var("x") + circuit.var("y");
+    let sum2 = circuit.var("x") + circuit.var("y");
     assert_eq!(sum1.id, sum2.id);
     assert_eq!(circuit.borrow().len(), 3); // x, y, x+y
 
     // Shared subexpression: (x + y) * (x + y) reuses the x+y node
-    let xy = circuit.leaf(StaticVar::from("x")) + circuit.leaf(StaticVar::from("y"));
-    let xy2 = circuit.leaf(StaticVar::from("x")) + circuit.leaf(StaticVar::from("y"));
+    let xy = circuit.var("x") + circuit.var("y");
+    let xy2 = circuit.var("x") + circuit.var("y");
     let _sq = xy * xy2;
     assert_eq!(circuit.borrow().len(), 4); // x, y, x+y, (x+y)*(x+y)
 
     // Commutativity: x+y and y+x are the same node
-    let xy = circuit.leaf(StaticVar::from("x")) + circuit.leaf(StaticVar::from("y"));
-    let yx = circuit.leaf(StaticVar::from("y")) + circuit.leaf(StaticVar::from("x"));
+    let xy = circuit.var("x") + circuit.var("y");
+    let yx = circuit.var("y") + circuit.var("x");
     assert_eq!(xy.id, yx.id);
 
     // Associativity: (x+y)+z and x+(y+z) are distinct nodes
-    let _z = circuit.leaf(StaticVar::from("z"));
-    let xy_z = (circuit.leaf(StaticVar::from("x")) + circuit.leaf(StaticVar::from("y")))
-        + circuit.leaf(StaticVar::from("z"));
-    let x_yz = circuit.leaf(StaticVar::from("x"))
-        + (circuit.leaf(StaticVar::from("y")) + circuit.leaf(StaticVar::from("z")));
+    let _z = circuit.var("z");
+    let xy_z = (circuit.var("x") + circuit.var("y"))
+        + circuit.var("z");
+    let x_yz = circuit.var("x")
+        + (circuit.var("y") + circuit.var("z"));
     assert_ne!(xy_z.id, x_yz.id);
 
     // Deep shared structure: (x+y)*z appears twice in ((x+y)*z) + ((x+y)*z)
-    let xyz1 = (circuit.leaf(StaticVar::from("x")) + circuit.leaf(StaticVar::from("y")))
-        * circuit.leaf(StaticVar::from("z"));
-    let xyz2 = (circuit.leaf(StaticVar::from("x")) + circuit.leaf(StaticVar::from("y")))
-        * circuit.leaf(StaticVar::from("z"));
+    let xyz1 = (circuit.var("x") + circuit.var("y"))
+        * circuit.var("z");
+    let xyz2 = (circuit.var("x") + circuit.var("y"))
+        * circuit.var("z");
     assert_eq!(xyz1.id, xyz2.id);
     let _sum = xyz1 + xyz2;
     // x, y, z, x+y(==y+x), (x+y)*z, (x+y)+z, y+z, x+(y+z), (x+y)*z+(x+y)*z, sq

src/circuit/traits.rs

@@ -0,0 +1,63 @@
+use std::cell::RefCell;
+use std::hash::Hash;
+use std::ops::{Add, DerefMut, Mul};
+use std::rc::Rc;
+
+use super::dag::{CircuitExt, Dag, NodeId, RefNode};
+
+pub trait Node: Clone + PartialEq + Eq + Hash {
+    fn children(&self) -> impl Iterator<Item = NodeId>;
+}
+
+pub trait Circuit: Clone + DerefMut<Target = Dag<Self::Node>> {
+    type Node: Node;
+
+    fn node(&mut self, n: Self::Node) -> NodeId { (**self).node(n) }
+    fn remove(&mut self, id: NodeId) { (**self).remove(id) }
+    fn get(&self, id: NodeId) -> Option<&Self::Node> { (**self).get(id) }
+    fn len(&self) -> usize { (**self).len() }
+    fn children(&self, id: NodeId) -> impl Iterator<Item = NodeId> + '_ { (**self).children(id) }
+}
+
+impl<T, N> Circuit for T
+where
+    T: Clone + DerefMut<Target = Dag<N>>,
+    N: Node,
+{
+    type Node = N;
+}
+
+pub trait SumProdCircuit: Circuit {
+    type Var;
+    fn var(&mut self, v: Self::Var) -> NodeId;
+    fn add(&mut self, l: NodeId, r: NodeId) -> NodeId;
+    fn mul(&mut self, l: NodeId, r: NodeId) -> NodeId;
+}
+
+impl<C: SumProdCircuit> Add for RefNode<C> {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self {
+        let id = self.circuit.borrow_mut().add(self.id, rhs.id);
+        RefNode { id, circuit: self.circuit }
+    }
+}
+
+impl<C: SumProdCircuit> Mul for RefNode<C> {
+    type Output = Self;
+
+    fn mul(self, rhs: Self) -> Self {
+        let id = self.circuit.borrow_mut().mul(self.id, rhs.id);
+        RefNode { id, circuit: self.circuit }
+    }
+}
+
+impl<C: SumProdCircuit> CircuitExt for Rc<RefCell<C>> {
+    type C = C;
+    type Var = C::Var;
+
+    fn var(&self, v: impl Into<C::Var>) -> RefNode<C> {
+        let id = self.borrow_mut().var(v.into());
+        RefNode { id, circuit: self.clone() }
+    }
+}