diff --git a/examples/quotient.rs b/examples/quotient.rs
index c0e92af..67ed28d 100644
--- a/examples/quotient.rs
+++ b/examples/quotient.rs
@@ -6,16 +6,16 @@ use circuit_cas::poly::var::StaticVar;
 use circuit_cas::var;
 
 fn main() {
-    let x=var!("x");
-    let nx=var!("x\u{0304}");
+    let x = var!("x");
+    let nx = var!("x\u{0304}");
 
     let idem = vec![
-        1*(&x^2)-1*(&x^1),
-        1*(&nx^2)-1*(&nx^1),
-        1*((&x^1)*(&nx^1))-1*(&x^1),
+        1 * (&x ^ 2) - 1 * (&x ^ 1),
+        1 * (&nx ^ 2) - 1 * (&nx ^ 1),
+        1 * ((&x ^ 1) * (&nx ^ 1)) - 1 * (&x ^ 1),
     ];
 
-    let mut quotient:Quotient<StaticVar>=idem.into_iter().collect();
+    let mut quotient: Quotient<StaticVar> = idem.into_iter().collect();
 
     println!("{quotient}");
 }
diff --git a/src/circuit/dag.rs b/src/circuit/dag.rs
index 33c6a9a..dc2d4cf 100644
--- a/src/circuit/dag.rs
+++ b/src/circuit/dag.rs
@@ -20,7 +20,7 @@ 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::Scale(n, _) => [Some(*n), None],
             Node::Sum(l, r) | Node::Prod(l, r) => [Some(*l), Some(*r)],
         }
         .into_iter()
@@ -34,11 +34,11 @@ pub struct Circuit<V: Var> {
     intern: HashMap<Node<V>, NodeId>,
 }
 
-impl<V:Var> Default for Circuit<V>{
-    fn default()->Self{
-        Circuit{
-            nodes:Default::default(),
-            intern:Default::default()
+impl<V: Var> Default for Circuit<V> {
+    fn default() -> Self {
+        Circuit {
+            nodes: Default::default(),
+            intern: Default::default(),
         }
     }
 }
diff --git a/src/circuit/mod.rs b/src/circuit/mod.rs
index 9c994c2..e0e3241 100644
--- a/src/circuit/mod.rs
+++ b/src/circuit/mod.rs
@@ -3,4 +3,3 @@ pub mod quotient;
 
 #[cfg(test)]
 mod tests;
-
diff --git a/src/circuit/quotient.rs b/src/circuit/quotient.rs
index 67c8f0d..c676cb2 100644
--- a/src/circuit/quotient.rs
+++ b/src/circuit/quotient.rs
@@ -1,12 +1,12 @@
-use crate::poly::{flat::Poly,var::Var};
-use super::dag::Circuit;
+use super::dag::{Circuit, NodeId};
+use crate::poly::{flat::Poly, var::Var};
 
 use itertools::Itertools;
 
-use std::fmt::{self,Display};
+use std::fmt::{self, Display};
 
 #[derive(Clone, Debug)]
-pub struct Quotient<V:Var>{
+pub struct Quotient<V: Var> {
     basis: Vec<Poly<V>>,
     circuit: Circuit<V>,
 }
@@ -14,15 +14,31 @@ pub struct Quotient<V:Var>{
 impl<V: Var> FromIterator<Poly<V>> for Quotient<V> {
     fn from_iter<T: IntoIterator<Item = Poly<V>>>(iter: T) -> Self {
         Quotient {
-            basis:iter.into_iter().collect(),
-            circuit:Default::default()
+            basis: iter.into_iter().collect(),
+            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.iter().map(|p| format!("{p}")).join(","))
+impl<V: Var> Display for Quotient<V> {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        write!(
+            fmt,
+            "C/<{}>",
+            self.basis.iter().map(|p| format!("{p}")).join(",")
+        )
     }
 }
 
+impl<V: Var> Quotient<V> {
+    pub fn node(&mut self, n: Node<V>) -> NodeId {
+        self.circuit.node(n)
+    }
+
+    pub fn add(left: NodeId, right: NodeId) {
+        self.circuit.add(left, right)
+    }
+    pub fn mul(left: NodeId, right: NodeId) {
+        self.circuit.mul(left, right)
+    }
+}
diff --git a/src/circuit/tests.rs b/src/circuit/tests.rs
index 58c1184..201dfa7 100644
--- a/src/circuit/tests.rs
+++ b/src/circuit/tests.rs
@@ -1,4 +1,3 @@
-
 use std::cell::RefCell;
 use std::rc::Rc;
 
diff --git a/src/poly/fmt.rs b/src/poly/fmt.rs
index ee87310..29967af 100644
--- a/src/poly/fmt.rs
+++ b/src/poly/fmt.rs
@@ -33,10 +33,10 @@ impl<V: Var> Display for Poly<V> {
                 "{}",
                 self.mono
                     .iter()
-                    .map(|(m, c)| match c{
-                        1=>format!("{}", m),
-                        -1=>format!("-{}", m),
-                        _=>format!("{}{}", c, m),
+                    .map(|(m, c)| match c {
+                        1 => format!("{}", m),
+                        -1 => format!("-{}", m),
+                        _ => format!("{}{}", c, m),
                     })
                     .join(" + ")
             ),