update quotient to ensure ideal defined with a grobner basis

src/circuit/quotient.rs

@@ -1,20 +1,32 @@
 use super::dag::{Circuit, Node, NodeId};
-use crate::poly::{flat::Poly, var::Var};
-
-use itertools::Itertools;
+use crate::poly::{
+    flat::Poly,
+    ideal::{Generators, GroebnerBasis, Ideal},
+    var::Var,
+};
 
 use std::fmt::{self, Display};
 
 #[derive(Clone, Debug)]
 pub struct Quotient<V: Var> {
-    basis: Vec<Poly<V>>,
+    basis: Ideal<V, GroebnerBasis>,
     circuit: Circuit<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> FromIterator<Poly<V>> for Quotient<V> {
     fn from_iter<T: IntoIterator<Item = Poly<V>>>(iter: T) -> Self {
+        let ideal: Ideal<V, Generators> = iter.into_iter().collect();
         Quotient {
-            basis: iter.into_iter().collect(),
+            basis: ideal.groebner_basis(),
             circuit: Default::default(),
         }
     }
@@ -22,11 +34,7 @@ impl<V: Var> FromIterator<Poly<V>> for Quotient<V> {
 
 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(",")
-        )
+        write!(fmt, "C/{}", self.basis)
     }
 }
 

src/poly/ideal.rs

@@ -5,11 +5,14 @@ use super::flat::Poly;
 use super::var::Var;
 
 /// Marker: the ideal's generators are arbitrary polynomials.
+#[derive(Clone, Debug)]
 pub struct Generators;
 
 /// Marker: the ideal's generators form a Gröbner basis.
+#[derive(Clone, Debug)]
 pub struct GroebnerBasis;
 
+#[derive(Clone, Debug)]
 pub struct Ideal<V: Var, S> {
     generators: Vec<Poly<V>>,
     _state: PhantomData<S>,