Toplevel query (#1187)

* `ToplevelQuery` added

* Progress on `ToplevelQuery`

* Content added to Query and Scope

* WIP toplevel

* WIP eval

* More toplevel methods

* Progress on eval

* Finished eval

* Coroutine eval test

* Toplevel synthesize started

* Some progress on synthesize

* More progress on synthesize

* Synthesize `Ctrl`

* Prove refactor

* LEM coroutine prove

* Bugfixes, test assertions

* Coroutine size test

* synthesis file added

* More operations

* Synthesis done

* Use MatchValue

* `from_ptr` now takes content

Fixed toplevel's from_ptr

* Prove sum list test

* Rebase fixes

* Renaming

Author: gabriel-barrett

src/coroutine/memoset/demo.rs

@@ -26,6 +26,7 @@ pub(crate) enum DemoCircuitQuery<F: LurkField> {
 
 impl<F: LurkField> Query<F> for DemoQuery<F> {
     type CQ = DemoCircuitQuery<F>;
+    type RD = ();
 
     fn eval(&self, scope: &mut Scope<Self, LogMemo<F>, F>) -> Ptr {
         match self {
@@ -55,7 +56,7 @@ impl<F: LurkField> Query<F> for DemoQuery<F> {
         }
     }
 
-    fn from_ptr(s: &Store<F>, ptr: &Ptr) -> Option<Self> {
+    fn from_ptr(_: &Self::RD, s: &Store<F>, ptr: &Ptr) -> Option<Self> {
         let (head, body) = s.car_cdr(ptr).expect("query should be cons");
         let sym = s.fetch_sym(&head).expect("head should be sym");
 
@@ -87,21 +88,21 @@ impl<F: LurkField> Query<F> for DemoQuery<F> {
         }
     }
 
-    fn dummy_from_index(s: &Store<F>, index: usize) -> Self {
+    fn dummy_from_index(_: &Self::RD, s: &Store<F>, index: usize) -> Self {
         match index {
             0 => Self::Factorial(s.num(0.into())),
             _ => unreachable!(),
         }
     }
 
-    fn index(&self) -> usize {
+    fn index(&self, _: &Self::RD) -> usize {
         match self {
             Self::Factorial(_) => 0,
             _ => unreachable!(),
         }
     }
 
-    fn count() -> usize {
+    fn count(_: &Self::RD) -> usize {
         1
     }
 }
@@ -131,6 +132,7 @@ impl<F: LurkField> RecursiveQuery<F> for DemoCircuitQuery<F> {
 }
 
 impl<F: LurkField> CircuitQuery<F> for DemoCircuitQuery<F> {
+    type RD = ();
     fn synthesize_args<CS: ConstraintSystem<F>>(
         &self,
         _cs: &mut CS,
@@ -147,7 +149,7 @@ impl<F: LurkField> CircuitQuery<F> for DemoCircuitQuery<F> {
         cs: &mut CS,
         g: &GlobalAllocator<F>,
         store: &Store<F>,
-        scope: &mut CircuitScope<F, LogMemoCircuit<F>>,
+        scope: &mut CircuitScope<F, LogMemoCircuit<F>, Self::RD>,
         acc: &AllocatedPtr<F>,
         allocated_key: &AllocatedPtr<F>,
     ) -> Result<((AllocatedPtr<F>, AllocatedPtr<F>), AllocatedPtr<F>), SynthesisError> {
@@ -198,11 +200,11 @@ impl<F: LurkField> CircuitQuery<F> for DemoCircuitQuery<F> {
     }
 
     fn from_ptr<CS: ConstraintSystem<F>>(cs: &mut CS, s: &Store<F>, ptr: &Ptr) -> Option<Self> {
-        DemoQuery::from_ptr(s, ptr).map(|q| q.to_circuit(cs, s))
+        DemoQuery::from_ptr(&(), s, ptr).map(|q| q.to_circuit(cs, s))
     }
 
     fn dummy_from_index<CS: ConstraintSystem<F>>(cs: &mut CS, s: &Store<F>, index: usize) -> Self {
-        DemoQuery::dummy_from_index(s, index).to_circuit(cs, s)
+        DemoQuery::dummy_from_index(&(), s, index).to_circuit(cs, s)
     }
 
     fn symbol(&self) -> Symbol {
@@ -230,7 +232,7 @@ mod test {
         let four = s.num(F::from_u64(4));
         let six = s.num(F::from_u64(6));
         let twenty_four = s.num(F::from_u64(24));
-        let mut scope: Scope<DemoQuery<F>, LogMemo<F>, F> = Scope::new(1, s);
+        let mut scope: Scope<DemoQuery<F>, LogMemo<F>, F> = Scope::new(1, s, ());
         assert_eq!(one, DemoQuery::Factorial(zero).eval(&mut scope));
         assert_eq!(one, DemoQuery::Factorial(one).eval(&mut scope));
         assert_eq!(two, DemoQuery::Factorial(two).eval(&mut scope));

src/coroutine/memoset/env.rs

@@ -27,6 +27,7 @@ pub(crate) enum EnvCircuitQuery<F: LurkField> {
 
 impl<F: LurkField> Query<F> for EnvQuery<F> {
     type CQ = EnvCircuitQuery<F>;
+    type RD = ();
 
     fn eval(&self, scope: &mut Scope<Self, LogMemo<F>, F>) -> Ptr {
         let s = scope.store.as_ref();
@@ -55,7 +56,7 @@ impl<F: LurkField> Query<F> for EnvQuery<F> {
         }
     }
 
-    fn from_ptr(s: &Store<F>, ptr: &Ptr) -> Option<Self> {
+    fn from_ptr(_: &Self::RD, s: &Store<F>, ptr: &Ptr) -> Option<Self> {
         let (head, body) = s.car_cdr(ptr).expect("query should be cons");
         let sym = s.fetch_sym(&head).expect("head should be sym");
 
@@ -94,21 +95,21 @@ impl<F: LurkField> Query<F> for EnvQuery<F> {
         }
     }
 
-    fn dummy_from_index(s: &Store<F>, index: usize) -> Self {
+    fn dummy_from_index(_: &Self::RD, s: &Store<F>, index: usize) -> Self {
         match index {
             0 => Self::Lookup(s.num(0.into()), s.num(0.into())),
             _ => unreachable!(),
         }
     }
 
-    fn index(&self) -> usize {
+    fn index(&self, _: &Self::RD) -> usize {
         match self {
             Self::Lookup(_, _) => 0,
             _ => unreachable!(),
         }
     }
 
-    fn count() -> usize {
+    fn count(_: &Self::RD) -> usize {
         1
     }
 }
@@ -125,6 +126,7 @@ impl<F: LurkField> RecursiveQuery<F> for EnvCircuitQuery<F> {
 }
 
 impl<F: LurkField> CircuitQuery<F> for EnvCircuitQuery<F> {
+    type RD = ();
     fn synthesize_args<CS: ConstraintSystem<F>>(
         &self,
         cs: &mut CS,
@@ -148,7 +150,7 @@ impl<F: LurkField> CircuitQuery<F> for EnvCircuitQuery<F> {
         cs: &mut CS,
         g: &GlobalAllocator<F>,
         store: &Store<F>,
-        scope: &mut CircuitScope<F, LogMemoCircuit<F>>,
+        scope: &mut CircuitScope<F, LogMemoCircuit<F>, Self::RD>,
         acc: &AllocatedPtr<F>,
         allocated_key: &AllocatedPtr<F>,
     ) -> Result<((AllocatedPtr<F>, AllocatedPtr<F>), AllocatedPtr<F>), SynthesisError> {
@@ -206,11 +208,11 @@ impl<F: LurkField> CircuitQuery<F> for EnvCircuitQuery<F> {
     }
 
     fn from_ptr<CS: ConstraintSystem<F>>(cs: &mut CS, s: &Store<F>, ptr: &Ptr) -> Option<Self> {
-        EnvQuery::from_ptr(s, ptr).map(|q| q.to_circuit(cs, s))
+        EnvQuery::from_ptr(&(), s, ptr).map(|q| q.to_circuit(cs, s))
     }
 
     fn dummy_from_index<CS: ConstraintSystem<F>>(cs: &mut CS, s: &Store<F>, index: usize) -> Self {
-        EnvQuery::dummy_from_index(s, index).to_circuit(cs, s)
+        EnvQuery::dummy_from_index(&(), s, index).to_circuit(cs, s)
     }
 
     fn symbol(&self) -> Symbol {
@@ -255,7 +257,7 @@ mod test {
         let t = s.intern_t();
         let nil = s.intern_nil();
 
-        let mut scope: Scope<EnvQuery<F>, LogMemo<F>, F> = Scope::new(1, s);
+        let mut scope: Scope<EnvQuery<F>, LogMemo<F>, F> = Scope::new(1, s, ());
         let mut test = |var, env, found| {
             let expected = if let Some(val) = found {
                 scope.store.cons(val, t)
@@ -358,7 +360,7 @@ mod test {
             expected.assert_eq(&computed.to_string());
         };
 
-        let mut scope: Scope<EnvQuery<F>, LogMemo<F>, F> = Scope::new(1, s.clone());
+        let mut scope: Scope<EnvQuery<F>, LogMemo<F>, F> = Scope::new(1, s.clone(), ());
 
         let make_query = |sym, env| EnvQuery::Lookup(sym, env).to_ptr(s);