diff --git a/Cargo.toml b/Cargo.toml
index 52397129..31ce1f3e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -20,6 +20,13 @@ hashbrown = "0.12.0"
 csv = { version = "1.1", optional = true }
 serde = { version = "1.0", optional = true }
 impl-trait-for-tuples = "0.2"
+deepsize = "0.2.0"
+deepsize_derive = "0.1.2"
+textwrap = "0.15.0"
+
+# TODO: eliminate dependency on timely-dataflow by cloning relevant
+# parts.
+timely = "0.12.0"
 
 [[bench]]
 name = "galen"
diff --git a/benches/galen.rs b/benches/galen.rs
index a56cb50c..5b828089 100644
--- a/benches/galen.rs
+++ b/benches/galen.rs
@@ -3,11 +3,15 @@
 
 use csv::{Reader as CsvReader, ReaderBuilder};
 use dbsp::{
-    algebra::{FiniteMap, HasZero, ZSetHashMap},
+    algebra::HasZero,
     circuit::{trace::SchedulerEvent, GlobalNodeId, Root, Runtime, Stream},
     monitor::TraceMonitor,
     operator::{CsvSource, DelayedFeedback},
     profile::CPUProfiler,
+    trace::{
+        ord::{OrdIndexedZSet, OrdZSet, OrdZSetSpine},
+        BatchReader,
+    },
 };
 use std::{collections::HashMap, fmt::Write, fs, fs::File, path::PathBuf};
 
@@ -37,9 +41,9 @@ q(?x,?e,?o) :- q(?x,?y,?z),r(?y,?u,?e),q(?z,?u,?o).
 type Number = u32;
 type Weight = isize;
 
-fn csv_source<T>(file: &str) -> CsvSource<File, ZSetHashMap<T, Weight>, T>
+fn csv_source<T>(file: &str) -> CsvSource<File, T, Weight, OrdZSet<T, Weight>>
 where
-    T: Clone,
+    T: Clone + Ord,
 {
     let path: PathBuf = ["benches", "galen_data", file].iter().collect();
 
@@ -56,6 +60,7 @@ fn main() {
         let monitor = TraceMonitor::new_panic_on_error();
 
         let root = Root::build(|circuit| {
+            /*
             let cpu_profiler = CPUProfiler::new();
             cpu_profiler.attach(circuit, "cpu profiler");
 
@@ -72,13 +77,14 @@ fn main() {
                             .or_insert_with(|| String::new());
                         metadata_string.clear();
                         node.summary(metadata_string);
-                        //}
-                        //SchedulerEvent::StepEnd => {
+                    }
+                    SchedulerEvent::StepEnd => {
                         let graph = monitor_clone.visualize_circuit_annotate(&|node_id| {
                             let mut metadata_string = metadata
                                 .get(node_id)
                                 .map(ToString::to_string)
                                 .unwrap_or_else(|| "".to_string());
+                            writeln!(metadata_string, "id: {}", node_id).unwrap();
                             if let Some(cpu_profile) = cpu_profiler.operator_profile(node_id) {
                                 writeln!(
                                     metadata_string,
@@ -97,6 +103,7 @@ fn main() {
                     _ => {}
                 }
             });
+            */
 
             let p_source = csv_source::<(Number, Number)>("p.txt");
             let q_source = csv_source::<(Number, Number, Number)>("q.txt");
@@ -105,133 +112,131 @@ fn main() {
             let u_source = csv_source::<(Number, Number, Number)>("u.txt");
             let s_source = csv_source::<(Number, Number)>("s.txt");
 
-            let p: Stream<_, ZSetHashMap<_, Weight>> =
+            let p: Stream<_, OrdZSet<_, Weight>> =
                 circuit.region("p", || circuit.add_source(p_source));
-            let q: Stream<_, ZSetHashMap<_, Weight>> =
+            let q: Stream<_, OrdZSet<_, Weight>> =
                 circuit.region("q", || circuit.add_source(q_source));
-            let r: Stream<_, ZSetHashMap<_, Weight>> =
+            let r: Stream<_, OrdZSet<_, Weight>> =
                 circuit.region("r", || circuit.add_source(r_source));
-            let c: Stream<_, ZSetHashMap<_, Weight>> =
+            let c: Stream<_, OrdZSet<_, Weight>> =
                 circuit.region("c", || circuit.add_source(c_source));
-            let u: Stream<_, ZSetHashMap<_, Weight>> =
+            let u: Stream<_, OrdZSet<_, Weight>> =
                 circuit.region("u", || circuit.add_source(u_source));
-            let s: Stream<_, ZSetHashMap<_, Weight>> =
+            let s: Stream<_, OrdZSet<_, Weight>> =
                 circuit.region("s", || circuit.add_source(s_source));
 
             let (outp, outq) = circuit
-                .iterate_with_conditions(|child| {
-                    let pvar: DelayedFeedback<_, ZSetHashMap<(Number, Number), Weight>> =
+                .fixedpoint(|child| {
+                    let pvar: DelayedFeedback<_, OrdZSet<(Number, Number), Weight>> =
                         DelayedFeedback::new(child);
-                    let qvar: DelayedFeedback<_, ZSetHashMap<(Number, Number, Number), Weight>> =
+                    let qvar: DelayedFeedback<_, OrdZSet<(Number, Number, Number), Weight>> =
                         DelayedFeedback::new(child);
 
-                    let p_by_1: Stream<_, ZSetHashMap<_, _>> = pvar.stream().index();
-                    let p_by_2: Stream<_, ZSetHashMap<_, _>> =
-                        pvar.stream().index_with(|&(x, y)| (y, x));
-                    let p_by_12: Stream<_, ZSetHashMap<_, _>> =
-                        pvar.stream().index_with(|&(x, y)| ((x, y), ()));
-                    let u_by_1: Stream<_, ZSetHashMap<_, _>> =
-                        u.delta0(child).index_with(|&(x, y, z)| (x, (y, z)));
-                    let q_by_1: Stream<_, ZSetHashMap<_, _>> =
-                        qvar.stream().index_with(|&(x, y, z)| (x, (y, z)));
-                    let q_by_2: Stream<_, ZSetHashMap<_, _>> =
-                        qvar.stream().index_with(|&(x, y, z)| (y, (x, z)));
-                    let q_by_12: Stream<_, ZSetHashMap<_, _>> =
-                        qvar.stream().index_with(|&(x, y, z)| ((x, y), z));
-                    let q_by_23: Stream<_, ZSetHashMap<_, _>> =
-                        qvar.stream().index_with(|&(x, y, z)| ((y, z), x));
-                    let c_by_2: Stream<_, ZSetHashMap<_, _>> =
-                        c.delta0(child).index_with(|&(x, y, z)| (y, (x, z)));
-                    let r_by_1: Stream<_, ZSetHashMap<_, _>> =
-                        r.delta0(child).index_with(|&(x, y, z)| (x, (y, z)));
-                    let s_by_1: Stream<_, ZSetHashMap<_, _>> = s.delta0(child).index();
+                    let p_by_1 = pvar.stream().index::<OrdIndexedZSet<_, _, _>>();
+                    let p_by_2 = pvar
+                        .stream()
+                        .index_with::<OrdIndexedZSet<_, _, _>, _>(|&(x, y)| (y, x));
+                    let p_by_12 = pvar
+                        .stream()
+                        .index_with::<OrdIndexedZSet<_, _, _>, _>(|&(x, y)| ((x, y), ()));
+                    let u_by_1 = u
+                        .delta0(child)
+                        .index_with::<OrdIndexedZSet<_, _, _>, _>(|&(x, y, z)| (x, (y, z)));
+                    let q_by_1 = qvar
+                        .stream()
+                        .index_with::<OrdIndexedZSet<_, _, _>, _>(|&(x, y, z)| (x, (y, z)));
+                    let q_by_2 = qvar
+                        .stream()
+                        .index_with::<OrdIndexedZSet<_, _, _>, _>(|&(x, y, z)| (y, (x, z)));
+                    let q_by_12 = qvar
+                        .stream()
+                        .index_with::<OrdIndexedZSet<_, _, _>, _>(|&(x, y, z)| ((x, y), z));
+                    let q_by_23 = qvar
+                        .stream()
+                        .index_with::<OrdIndexedZSet<_, _, _>, _>(|&(x, y, z)| ((y, z), x));
+                    let c_by_2 = c
+                        .delta0(child)
+                        .index_with::<OrdIndexedZSet<_, _, _>, _>(|&(x, y, z)| (y, (x, z)));
+                    let r_by_1 = r
+                        .delta0(child)
+                        .index_with::<OrdIndexedZSet<_, _, _>, _>(|&(x, y, z)| (x, (y, z)));
+                    let s_by_1 = s.delta0(child).index::<OrdIndexedZSet<_, _, _>>();
 
                     // IR1: p(x,z) :- p(x,y), p(y,z).
-                    let ir1 = child.region("IR1", || {
-                        p_by_2.join_incremental_nested(&p_by_1, |&_y, &x, &z| (x, z))
-                    });
-                    ir1.inspect(|zs: &ZSetHashMap<_, _>| println!("ir1: {}", zs.support_size()));
+                    let ir1 =
+                        child.region("IR1", || p_by_2.join_trace(&p_by_1, |&_y, &x, &z| (x, z)));
+                    ir1.inspect(|zs: &OrdZSet<_, _>| println!("ir1: {}", zs.len()));
 
                     // IR2: q(x,r,z) := p(x,y), q(y,r,z)
                     let ir2 = child.region("IR2", || {
-                        p_by_2.join_incremental_nested(&q_by_1, |&_y, &x, &(r, z)| (x, r, z))
+                        p_by_2.join_trace(&q_by_1, |&_y, &x, &(r, z)| (x, r, z))
                     });
 
-                    ir2.inspect(|zs: &ZSetHashMap<_, _>| println!("ir2: {}", zs.support_size()));
+                    ir2.inspect(|zs: &OrdZSet<_, _>| println!("ir2: {}", zs.len()));
 
                     // IR3: p(x,z) := p(y,w), u(w,r,z), q(x,r,y)
                     let ir3 = child.region("IR3", || {
                         p_by_2
-                            .join_incremental_nested::<_, _, _, _, _, _, _, ZSetHashMap<_, _>>(
-                                &u_by_1,
-                                |&_w, &y, &(r, z)| ((r, y), z),
-                            )
-                            .index::<_, _, _, ZSetHashMap<_, _>>()
-                            .join_incremental_nested(&q_by_23, |&(_r, _y), &z, &x| (x, z))
+                            .join_trace::<_, _, OrdZSet<_, _>>(&u_by_1, |&_w, &y, &(r, z)| {
+                                ((r, y), z)
+                            })
+                            .index::<OrdIndexedZSet<_, _, _>>()
+                            .join_trace(&q_by_23, |&(_r, _y), &z, &x| (x, z))
                     });
-                    ir3.inspect(|zs: &ZSetHashMap<_, _>| println!("ir3: {}", zs.support_size()));
+                    ir3.inspect(|zs: &OrdZSet<_, _>| println!("ir3: {}", zs.len()));
 
                     // IR4: p(x,z) := c(y,w,z), p(x,w), p(x,y)
                     let ir4_1 = child.region("IR4-1", || {
-                        c_by_2.join_incremental_nested::<_, _, _, _, _, _, _, ZSetHashMap<_, _>>(
-                            &p_by_2,
-                            |&_w, &(y, z), &x| ((x, y), z),
-                        )
+                        c_by_2.join_trace::<_, _, OrdZSet<_, _>>(&p_by_2, |&_w, &(y, z), &x| {
+                            ((x, y), z)
+                        })
                     });
-                    ir4_1
-                        .inspect(|zs: &ZSetHashMap<_, _>| println!("ir4_1: {}", zs.support_size()));
+                    ir4_1.inspect(|zs: &OrdZSet<_, _>| println!("ir4_1: {}", zs.len()));
 
                     let ir4 = child.region("IR4-2", || {
                         ir4_1
-                            .index::<_, _, _, ZSetHashMap<_, _>>()
-                            .join_incremental_nested(&p_by_12, |&(x, _y), &z, &()| (x, z))
+                            .index::<OrdIndexedZSet<_, _, _>>()
+                            .join_trace(&p_by_12, |&(x, _y), &z, &()| (x, z))
                     });
-                    ir4.inspect(|zs: &ZSetHashMap<_, _>| println!("ir4: {}", zs.support_size()));
+                    ir4.inspect(|zs: &OrdZSet<_, _>| println!("ir4: {}", zs.len()));
 
                     // IR5: q(x,q,z) := q(x,r,z), s(r,q)
                     let ir5 = child.region("IR5", || {
-                        q_by_2.join_incremental_nested(&s_by_1, |&_r, &(x, z), &q| (x, q, z))
+                        q_by_2.join_trace(&s_by_1, |&_r, &(x, z), &q| (x, q, z))
                     });
-                    ir5.inspect(|zs: &ZSetHashMap<_, _>| println!("ir5: {}", zs.support_size()));
+                    ir5.inspect(|zs: &OrdZSet<_, _>| println!("ir5: {}", zs.len()));
 
                     // IR6: q(x,e,o) := q(x,y,z), r(y,u,e), q(z,u,o)
-                    let ir6 = child.region("IR6", || {
+                    let ir6_1 = child.region("IR6_1", || {
                         q_by_2
-                            .join_incremental_nested::<_, _, _, _, _, _, _, ZSetHashMap<_, _>>(
-                                &r_by_1,
-                                |&_y, &(x, z), &(u, e)| ((z, u), (x, e)),
-                            )
-                            .index::<_, _, _, ZSetHashMap<_, _>>()
-                            .join_incremental_nested(&q_by_12, |&(_z, _u), &(x, e), &o| (x, e, o))
+                            .join_trace::<_, _, OrdZSet<_, _>>(&r_by_1, |&_y, &(x, z), &(u, e)| {
+                                ((z, u), (x, e))
+                            })
+                            .index::<OrdIndexedZSet<_, _, _>>()
+                    });
+                    let ir6 = child.region("IR6", || {
+                        ir6_1.join_trace(&q_by_12, |&(_z, _u), &(x, e), &o| (x, e, o))
                     });
-                    ir6.inspect(|zs: &ZSetHashMap<_, _>| println!("ir6: {}", zs.support_size()));
 
-                    let p = p
-                        .delta0(child)
-                        .sum([&ir1, &ir3, &ir4])
-                        .distinct_incremental_nested();
+                    ir6.inspect(|zs: &OrdZSet<_, _>| println!("ir6: {}", zs.len()));
 
-                    let q = q
-                        .delta0(child)
-                        .sum([&ir2, &ir5, &ir6])
-                        .distinct_incremental_nested();
+                    let p = p.delta0(child).sum([&ir1, &ir3, &ir4]).distinct_trace();
+
+                    let q = q.delta0(child).sum([&ir2, &ir5, &ir6]).distinct_trace();
 
                     pvar.connect(&p);
                     qvar.connect(&q);
 
                     Ok((
-                        vec![
-                            p.condition(HasZero::is_zero),
-                            p.integrate_nested().condition(HasZero::is_zero),
-                            q.condition(HasZero::is_zero),
-                            q.integrate_nested().condition(HasZero::is_zero),
-                        ],
-                        (p.integrate().export(), q.integrate().export()),
+                        p.integrate_trace::<OrdZSetSpine<_, _>>().export(),
+                        q.integrate_trace::<OrdZSetSpine<_, _>>().export(),
                     ))
                 })
                 .unwrap();
-            outp.inspect(|zs: &ZSetHashMap<_, _>| println!("outp: {}", zs.support_size()));
-            outq.inspect(|zs: &ZSetHashMap<_, _>| println!("outq: {}", zs.support_size()));
+            outp.consolidate::<OrdZSet<_, _>>()
+                .inspect(|zs: &OrdZSet<_, _>| println!("outp: {}", zs.len()));
+            outq.consolidate::<OrdZSet<_, _>>()
+                .inspect(|zs: &OrdZSet<_, _>| println!("outq: {}", zs.len()));
         })
         .unwrap();
 
diff --git a/benches/path.rs b/benches/path.rs
index e873e5ae..067e490c 100644
--- a/benches/path.rs
+++ b/benches/path.rs
@@ -1,14 +1,22 @@
 use dbsp::{
-    algebra::{FiniteHashMap, HasZero, MapBuilder},
     circuit::{trace::SchedulerEvent, GlobalNodeId, Root, Stream},
     monitor::TraceMonitor,
     operator::{DelayedFeedback, Generator},
+    profile::CPUProfiler,
+    trace::{
+        ord::{OrdIndexedZSet, OrdZSet, OrdZSetSpine},
+        Batch,
+    },
 };
-use std::{collections::HashMap, fs, vec};
+
+use std::{collections::HashMap, fmt::Write, fs};
 
 fn main() {
     let monitor = TraceMonitor::new_panic_on_error();
     let root = Root::build(|circuit| {
+        let cpu_profiler = CPUProfiler::new();
+        cpu_profiler.attach(circuit, "cpu profiler");
+
         monitor.attach(circuit, "monitor");
         let mut metadata = <HashMap<GlobalNodeId, String>>::new();
         let mut nsteps = 0;
@@ -24,11 +32,24 @@ fn main() {
                 }
                 SchedulerEvent::StepEnd => {
                     let graph = monitor_clone.visualize_circuit_annotate(&|node_id| {
-                        metadata
+                        let mut metadata_string = metadata
                             .get(node_id)
                             .map(ToString::to_string)
-                            .unwrap_or_else(|| "".to_string())
+                            .unwrap_or_else(|| "".to_string());
+
+                        if let Some(cpu_profile) = cpu_profiler.operator_profile(node_id) {
+                            writeln!(
+                                metadata_string,
+                                "invocations: {}",
+                                cpu_profile.invocations()
+                            )
+                            .unwrap();
+                            writeln!(metadata_string, "time: {:?}", cpu_profile.total_time())
+                                .unwrap();
+                        };
+                        metadata_string
                     });
+
                     fs::write(format!("path.{}.dot", nsteps), graph.to_dot()).unwrap();
                     nsteps += 1;
                 }
@@ -38,22 +59,24 @@ fn main() {
 
         const LAYER: u32 = 200;
 
-        let mut edges: FiniteHashMap<(u32, u32), i32> = FiniteHashMap::new();
+        let mut tuples = Vec::new();
         for layer in 0..5 {
             for from in 0..LAYER {
                 for to in 0..LAYER {
-                    edges.increment(&(from + (LAYER * layer), to + LAYER * (layer + 1)), 1);
+                    tuples.push((((from + (LAYER * layer), to + LAYER * (layer + 1)), ()), 1));
                 }
             }
         }
 
-        let edges: Stream<_, FiniteHashMap<(u32, u32), i32>> =
+        let edges = <OrdZSet<(u32, u32), i32>>::from_tuples((), tuples);
+
+        let edges: Stream<_, OrdZSet<(u32, u32), i32>> =
             circuit.add_source(Generator::new(move || edges.clone()));
 
         let _paths = circuit
-            .iterate_with_conditions(|child| {
+            .fixedpoint(|child| {
                 // ```text
-                //                      distinct_incremental_nested
+                //                      distinct_trace
                 //               ┌───┐          ┌───┐
                 // edges         │   │          │   │  paths
                 // ────┬────────►│ + ├──────────┤   ├────────┬───►
@@ -66,34 +89,27 @@ fn main() {
                 //     └────────►│ X │ ◄─────────────────────┘
                 //               │   │
                 //               └───┘
-                //      join_incremental_nested
+                //            join_trace
                 // ```
                 let edges = edges.delta0(child);
-                let paths_delayed = <DelayedFeedback<_, FiniteHashMap<_, _>>>::new(child);
+                let paths_delayed = <DelayedFeedback<_, OrdZSet<_, _>>>::new(child);
 
-                let paths_inverted: Stream<_, FiniteHashMap<(u32, u32), i32>> =
+                let paths_inverted: Stream<_, OrdZSet<(u32, u32), i32>> =
                     paths_delayed.stream().map_keys(|&(x, y)| (y, x));
 
-                let paths_inverted_indexed: Stream<_, FiniteHashMap<u32, FiniteHashMap<u32, i32>>> =
+                let paths_inverted_indexed: Stream<_, OrdIndexedZSet<u32, u32, i32>> =
                     paths_inverted.index();
-                let edges_indexed: Stream<_, FiniteHashMap<u32, FiniteHashMap<u32, i32>>> =
-                    edges.index();
+                let edges_indexed: Stream<_, OrdIndexedZSet<u32, u32, i32>> = edges.index();
 
                 let paths = edges
                     .plus(
                         &paths_inverted_indexed
-                            .join_incremental_nested(&edges_indexed, |_via, from, to| (*from, *to)),
+                            .join_trace(&edges_indexed, |_via, from, to| (*from, *to)),
                     )
-                    .distinct_incremental_nested();
+                    .distinct_trace();
                 paths_delayed.connect(&paths);
-                let output = paths.integrate();
-                Ok((
-                    vec![
-                        paths.condition(HasZero::is_zero),
-                        paths.integrate_nested().condition(HasZero::is_zero),
-                    ],
-                    output.export(),
-                ))
+
+                Ok(paths.integrate_trace::<OrdZSetSpine<_, _>>().export())
             })
             .unwrap();
     })
diff --git a/src/algebra/finite_map/map_macro.rs b/src/algebra/finite_map/map_macro.rs
deleted file mode 100644
index 42128785..00000000
--- a/src/algebra/finite_map/map_macro.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-/// Allows easily creating [`FiniteHashMap`](crate::algebra::FiniteHashMap)s
-#[macro_export]
-macro_rules! finite_map {
-    // Create an empty map
-    () => {
-        $crate::algebra::FiniteHashMap::new()
-    };
-
-    // Create a map from elements
-    ($($key:expr => $value:expr),+ $(,)?) => {{
-        let mut map = $crate::algebra::FiniteHashMap::with_capacity(
-            $crate::count_elements!($($key),+),
-        );
-
-        $( <$crate::algebra::FiniteHashMap<_,_> as $crate::algebra::MapBuilder<_,_>>::increment(&mut map, &$key, $value); )+
-
-        map
-    }};
-}
-
-/// Support macro for counting the number of map elements
-#[macro_export]
-#[doc(hidden)]
-macro_rules! count_elements {
-    (@replace $_:expr) => {
-        ()
-    };
-
-    ($($_:expr),+) => {
-        <[()]>::len(&[$($crate::count_elements!(@replace $_),)+])
-    };
-}
diff --git a/src/algebra/finite_map/mod.rs b/src/algebra/finite_map/mod.rs
deleted file mode 100644
index eaea6ae6..00000000
--- a/src/algebra/finite_map/mod.rs
+++ /dev/null
@@ -1,552 +0,0 @@
-#[macro_use]
-mod map_macro;
-#[cfg(test)]
-mod tests;
-
-use crate::{
-    algebra::{
-        Add, AddAssign, AddAssignByRef, AddByRef, GroupValue, HasZero, Neg, NegByRef,
-        WithNumEntries,
-    },
-    shared_ref_self_generic, NumEntries,
-};
-use hashbrown::{
-    hash_map,
-    hash_map::{Entry, HashMap, RawEntryMut},
-};
-use std::{
-    fmt::{Debug, Formatter, Result},
-    hash::Hash,
-    iter::FromIterator,
-    mem::swap,
-};
-
-/// The properties we expect for a FiniteMap key.
-pub trait KeyProperties: 'static + Clone + Eq + Hash {}
-
-impl<T> KeyProperties for T where T: 'static + Clone + Eq + Hash {}
-
-/// A trait to iterate over keys in the support of a finite map.
-///
-/// We make this a separate trait, so as not to pollute
-/// `trait FiniteMap` with the lifetime parameter.
-pub trait WithSupport<'a, KeyType>
-where
-    KeyType: 'a,
-{
-    type SupportIterator: Iterator<Item = &'a KeyType>;
-
-    fn support(self) -> Self::SupportIterator;
-}
-
-/// Interface to build maps element-by-element.
-///
-/// This interface is functionally equivalent to `FromIterator<Key, Value>`,
-/// and can be used in contexts where (1) laziness is not required,
-/// and (2) it is simpler to push data into the map rather than have
-/// the map pull data from an iterator.
-///
-/// `MapBuilder` is a separate trait and not part of `FiniteMap`, since
-/// some implementers support only the insertion but not the querying side of
-/// the map API.  An example is `Vec<(Key, Value)>`, which implements
-/// `MapBuilder`, but not `FiniteMap`.
-pub trait MapBuilder<Key, Value> {
-    /// Create an empty map.
-    fn empty() -> Self;
-
-    /// Create an empty map with specified capacity.
-    fn with_capacity(capacity: usize) -> Self;
-
-    /// Increase the value associated with `key` by the specified `value`.
-    fn increment(&mut self, key: &Key, value: Value);
-
-    /// Increase the value associated with `key` by the specified `value`.
-    fn increment_owned(&mut self, key: Key, value: Value);
-}
-
-impl<Key, Value> MapBuilder<Key, Value> for Vec<(Key, Value)>
-where
-    Key: Clone,
-{
-    fn empty() -> Self {
-        vec![]
-    }
-
-    fn with_capacity(capacity: usize) -> Self {
-        Vec::with_capacity(capacity)
-    }
-
-    fn increment(&mut self, key: &Key, value: Value) {
-        self.push((key.clone(), value));
-    }
-
-    fn increment_owned(&mut self, key: Key, value: Value) {
-        self.push((key, value));
-    }
-}
-
-/// Finite map trait.
-///
-/// A finite map maps arbitrary values (comparable for equality)
-/// to values in a group.  It has finite support: it is non-zero
-/// only for a finite number of values.
-///
-/// `KeyType` - Type of values stored in finite map.
-/// `ValueType` - Type of results.
-pub trait FiniteMap<Key, Value>:
-    GroupValue
-    + IntoIterator<Item = (Key, Value)>
-    + FromIterator<(Key, Value)>
-    + MapBuilder<Key, Value>
-    + WithNumEntries
-where
-    Key: KeyProperties,
-{
-    /// Find the value associated to the specified key
-    fn lookup(&self, key: &Key) -> Value;
-
-    /// Find the value associated to the specified key.
-    ///
-    /// Returns `None` when `key` is not in the support of `self`.
-    fn get_in_support(&self, key: &Key) -> Option<&Value>;
-
-    /// Modify the value associated with `key`.
-    fn update<F>(&mut self, key: &Key, f: F)
-    where
-        F: FnOnce(&mut Value);
-
-    /// Modify the value associated with `key`.
-    fn update_owned<F>(&mut self, key: Key, f: F)
-    where
-        F: FnOnce(&mut Value);
-
-    /// The size of the support: number of elements for which the map does not
-    /// return zero.
-    fn support_size(&self) -> usize;
-}
-
-#[derive(Clone)]
-pub struct FiniteHashMap<Key, Value> {
-    // Unfortunately I cannot just implement these traits for
-    // HashMap since they conflict with some existing traits.
-    // We maintain the invariant that the keys (and only these keys)
-    // that have non-zero values are in this map.
-    pub(super) value: HashMap<Key, Value>,
-}
-
-shared_ref_self_generic!(<Key, Value>, FiniteHashMap<Key, Value>);
-
-impl<Key, Value> NumEntries for FiniteHashMap<Key, Value>
-where
-    Key: KeyProperties,
-    Value: GroupValue + NumEntries,
-{
-    fn num_entries(&self) -> usize {
-        match Value::const_num_entries() {
-            None => {
-                let mut res = 0;
-                for (_, v) in self.into_iter() {
-                    res += v.num_entries();
-                }
-                res
-            }
-            Some(n) => n * self.support_size(),
-        }
-    }
-    fn const_num_entries() -> Option<usize> {
-        None
-    }
-}
-
-impl<Key, Value> FiniteHashMap<Key, Value> {
-    /// Create a new map
-    pub fn new() -> Self {
-        Self {
-            value: HashMap::default(),
-        }
-    }
-
-    /// Create an empty [`FiniteHashMap`] with the capacity to hold `size`
-    /// elements without reallocating.
-    pub fn with_capacity(size: usize) -> Self {
-        Self {
-            value: HashMap::with_capacity(size),
-        }
-    }
-}
-
-impl<Key, Value> IntoIterator for FiniteHashMap<Key, Value> {
-    type Item = (Key, Value);
-    type IntoIter = hash_map::IntoIter<Key, Value>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.value.into_iter()
-    }
-}
-
-impl<'a, Key, Value> IntoIterator for &'a FiniteHashMap<Key, Value> {
-    type Item = (&'a Key, &'a Value);
-    type IntoIter = hash_map::Iter<'a, Key, Value>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.value.iter()
-    }
-}
-
-impl<Key, Value> FromIterator<(Key, Value)> for FiniteHashMap<Key, Value>
-where
-    Key: KeyProperties,
-    Value: GroupValue,
-{
-    fn from_iter<T>(iter: T) -> Self
-    where
-        T: IntoIterator<Item = (Key, Value)>,
-    {
-        let mut result = Self::new();
-        for (k, v) in iter {
-            result.increment(&k, v);
-        }
-
-        result
-    }
-}
-
-impl<Key, Value> WithNumEntries for FiniteHashMap<Key, Value> {
-    fn num_entries(&self) -> usize {
-        self.value.len()
-    }
-}
-
-impl<Key, Value> MapBuilder<Key, Value> for FiniteHashMap<Key, Value>
-where
-    Key: KeyProperties,
-    Value: GroupValue,
-{
-    fn empty() -> Self {
-        Self::new()
-    }
-
-    fn with_capacity(capacity: usize) -> Self {
-        Self::with_capacity(capacity)
-    }
-
-    fn increment(&mut self, key: &Key, value: Value) {
-        if value.is_zero() {
-            return;
-        }
-
-        match self.value.raw_entry_mut().from_key(key) {
-            RawEntryMut::Vacant(vacant) => {
-                vacant.insert(key.clone(), value);
-            }
-
-            RawEntryMut::Occupied(mut occupied) => {
-                occupied.get_mut().add_assign(value);
-                if occupied.get().is_zero() {
-                    occupied.remove_entry();
-                }
-            }
-        }
-    }
-
-    fn increment_owned(&mut self, key: Key, value: Value) {
-        if value.is_zero() {
-            return;
-        }
-
-        // This has been a known issue since 2015: https://github.com/rust-lang/rust/issues/56167
-        // We should use a different implementation or API if one becomes available.
-        match self.value.entry(key) {
-            Entry::Vacant(vacant) => {
-                vacant.insert(value);
-            }
-
-            Entry::Occupied(mut occupied) => {
-                occupied.get_mut().add_assign(value);
-                if occupied.get().is_zero() {
-                    occupied.remove_entry();
-                }
-            }
-        }
-    }
-}
-
-impl<Key, Value> FiniteMap<Key, Value> for FiniteHashMap<Key, Value>
-where
-    Key: KeyProperties,
-    Value: GroupValue,
-{
-    fn lookup(&self, key: &Key) -> Value {
-        self.value.get(key).cloned().unwrap_or_else(Value::zero)
-    }
-
-    fn get_in_support(&self, key: &Key) -> Option<&Value> {
-        self.value.get(key)
-    }
-
-    fn update<F>(&mut self, key: &Key, f: F)
-    where
-        F: FnOnce(&mut Value),
-    {
-        match self.value.raw_entry_mut().from_key(key) {
-            RawEntryMut::Occupied(mut oe) => {
-                let val = oe.get_mut();
-                f(val);
-                if val.is_zero() {
-                    oe.remove();
-                }
-            }
-            RawEntryMut::Vacant(ve) => {
-                let mut val = Value::zero();
-                f(&mut val);
-                if !val.is_zero() {
-                    ve.insert(key.clone(), val);
-                }
-            }
-        }
-    }
-
-    fn update_owned<F>(&mut self, key: Key, f: F)
-    where
-        F: FnOnce(&mut Value),
-    {
-        match self.value.entry(key) {
-            Entry::Occupied(mut oe) => {
-                let val = oe.get_mut();
-                f(val);
-                if val.is_zero() {
-                    oe.remove();
-                }
-            }
-            Entry::Vacant(ve) => {
-                let mut val = Value::zero();
-                f(&mut val);
-                ve.insert(val);
-            }
-        }
-    }
-
-    fn support_size(&self) -> usize {
-        self.value.len()
-    }
-}
-
-impl<'a, Key, Value> WithSupport<'a, Key> for &'a FiniteHashMap<Key, Value> {
-    type SupportIterator = hash_map::Keys<'a, Key, Value>;
-
-    fn support(self) -> Self::SupportIterator {
-        self.value.keys()
-    }
-}
-
-impl<Key, Value> Default for FiniteHashMap<Key, Value>
-where
-    Key: KeyProperties,
-{
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl<Key, Value> Add for FiniteHashMap<Key, Value>
-where
-    Key: KeyProperties,
-    Value: GroupValue,
-{
-    type Output = Self;
-
-    fn add(self, other: Self) -> Self {
-        fn add_inner<Key, Value>(
-            mut this: FiniteHashMap<Key, Value>,
-            other: FiniteHashMap<Key, Value>,
-        ) -> FiniteHashMap<Key, Value>
-        where
-            Key: KeyProperties,
-            Value: GroupValue,
-        {
-            for (key, value) in other.value {
-                match this.value.entry(key) {
-                    Entry::Vacant(vacant) => {
-                        vacant.insert(value);
-                    }
-
-                    Entry::Occupied(mut occupied) => {
-                        occupied.get_mut().add_assign(value);
-                        if occupied.get().is_zero() {
-                            occupied.remove_entry();
-                        }
-                    }
-                }
-            }
-
-            this
-        }
-
-        if self.support_size() > other.support_size() {
-            add_inner(self, other)
-        } else {
-            add_inner(other, self)
-        }
-    }
-}
-impl<Key, Value> AddByRef for FiniteHashMap<Key, Value>
-where
-    Key: KeyProperties,
-    Value: GroupValue,
-{
-    fn add_by_ref(&self, other: &Self) -> Self {
-        fn add_inner<Key, Value>(
-            mut this: FiniteHashMap<Key, Value>,
-            other: &FiniteHashMap<Key, Value>,
-        ) -> FiniteHashMap<Key, Value>
-        where
-            Key: KeyProperties,
-            Value: GroupValue,
-        {
-            for (key, value) in &other.value {
-                match this.value.raw_entry_mut().from_key(key) {
-                    RawEntryMut::Vacant(vacant) => {
-                        vacant.insert(key.clone(), value.clone());
-                    }
-
-                    RawEntryMut::Occupied(mut occupied) => {
-                        occupied.get_mut().add_assign_by_ref(value);
-                        if occupied.get().is_zero() {
-                            occupied.remove_entry();
-                        }
-                    }
-                }
-            }
-
-            this
-        }
-
-        if self.support_size() > other.support_size() {
-            add_inner(self.clone(), other)
-        } else {
-            add_inner(other.clone(), self)
-        }
-    }
-}
-
-impl<Key, Value> AddAssign for FiniteHashMap<Key, Value>
-where
-    Key: KeyProperties,
-    Value: GroupValue,
-{
-    fn add_assign(&mut self, other: Self) {
-        for (key, value) in other.value {
-            match self.value.entry(key) {
-                Entry::Vacant(vacant) => {
-                    vacant.insert(value);
-                }
-
-                Entry::Occupied(mut occupied) => {
-                    occupied.get_mut().add_assign(value);
-                    if occupied.get().is_zero() {
-                        occupied.remove_entry();
-                    }
-                }
-            }
-        }
-    }
-}
-
-impl<KeyType, ValueType> AddAssignByRef for FiniteHashMap<KeyType, ValueType>
-where
-    KeyType: KeyProperties,
-    ValueType: GroupValue,
-{
-    fn add_assign_by_ref(&mut self, other: &Self) {
-        for (key, value) in &other.value {
-            match self.value.raw_entry_mut().from_key(key) {
-                RawEntryMut::Vacant(vacant) => {
-                    vacant.insert(key.clone(), value.clone());
-                }
-
-                RawEntryMut::Occupied(mut occupied) => {
-                    occupied.get_mut().add_assign_by_ref(value);
-                    if occupied.get().is_zero() {
-                        occupied.remove_entry();
-                    }
-                }
-            }
-        }
-    }
-}
-
-impl<Key, Value> HasZero for FiniteHashMap<Key, Value>
-where
-    Key: KeyProperties,
-    Value: GroupValue,
-{
-    fn is_zero(&self) -> bool {
-        self.value.is_empty()
-    }
-
-    fn zero() -> Self {
-        Self::default()
-    }
-}
-
-impl<Key, Value> NegByRef for FiniteHashMap<Key, Value>
-where
-    Key: KeyProperties,
-    Value: GroupValue,
-{
-    fn neg_by_ref(&self) -> Self {
-        let mut result = self.clone();
-        for val in result.value.values_mut() {
-            let mut tmp = Value::zero();
-            swap(val, &mut tmp);
-            *val = tmp.neg();
-        }
-
-        result
-    }
-}
-
-impl<Key, Value> Neg for FiniteHashMap<Key, Value>
-where
-    Key: KeyProperties,
-    Value: GroupValue,
-{
-    type Output = Self;
-
-    fn neg(mut self) -> Self {
-        for val in self.value.values_mut() {
-            let mut tmp = Value::zero();
-            swap(val, &mut tmp);
-            *val = tmp.neg();
-        }
-
-        self
-    }
-}
-
-impl<Key, Value> PartialEq for FiniteHashMap<Key, Value>
-where
-    Key: KeyProperties,
-    Value: GroupValue,
-{
-    fn eq(&self, other: &Self) -> bool {
-        self.value.eq(&other.value)
-    }
-}
-
-impl<Key, Value> Eq for FiniteHashMap<Key, Value>
-where
-    Key: KeyProperties,
-    Value: GroupValue,
-{
-}
-
-impl<K, V> Debug for FiniteHashMap<K, V>
-where
-    K: Debug,
-    V: Debug,
-{
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        self.value.fmt(f)
-    }
-}
diff --git a/src/algebra/finite_map/tests.rs b/src/algebra/finite_map/tests.rs
deleted file mode 100644
index 9883300d..00000000
--- a/src/algebra/finite_map/tests.rs
+++ /dev/null
@@ -1,87 +0,0 @@
-use crate::algebra::{
-    AddAssignByRef, AddByRef, FiniteHashMap, FiniteMap, HasZero, MapBuilder, NegByRef, WithSupport,
-};
-use std::ops::{Add, Neg};
-
-type Map = FiniteHashMap<i64, i64>;
-
-#[test]
-fn hashmap_tests() {
-    let mut z = Map::with_capacity(5);
-    assert_eq!(0, z.support_size());
-    assert_eq!(finite_map! {}, z);
-    assert_eq!(0, z.lookup(&0)); // not present -> 0
-    assert_eq!(None, z.get_in_support(&0)); // not present -> 0
-    assert_eq!(z, Map::zero());
-    assert_eq!(z.support().cloned().collect::<Vec<i64>>(), vec![]);
-    assert!(z.is_zero());
-
-    let z2 = Map::new();
-    assert_eq!(z, z2);
-
-    z.increment(&0, 1);
-    assert_eq!(1, z.support_size());
-    assert_eq!(finite_map! { 0 => 1 }, z);
-    assert_eq!(1, z.lookup(&0));
-    assert_eq!(0, z.lookup(&1));
-    assert_eq!(Some(1), z.get_in_support(&0).cloned());
-    assert_eq!(None, z.get_in_support(&1));
-    assert_eq!(z.support().cloned().collect::<Vec<i64>>(), vec![0]);
-
-    assert_ne!(z, Map::zero());
-    assert!(!z.is_zero());
-
-    z.increment_owned(2, 0);
-    assert_eq!(1, z.support_size());
-    assert_eq!(finite_map! { 0 => 1 }, z);
-    assert_eq!(z.support().cloned().collect::<Vec<i64>>(), vec![0]);
-
-    z.increment(&1, -1);
-    assert_eq!(2, z.support_size());
-    assert_eq!(finite_map! { 0 => 1, 1 => -1 }, z);
-    let mut support = z.support().cloned().collect::<Vec<i64>>();
-    support.sort_unstable();
-    assert_eq!(support, vec![0, 1]);
-
-    z.increment_owned(-1, 1);
-    assert_eq!(3, z.support_size());
-    assert_eq!(finite_map! { -1 => 1, 0 => 1, 1 => -1 }, z);
-    let mut support = z.support().cloned().collect::<Vec<i64>>();
-    support.sort_unstable();
-    assert_eq!(support, vec![-1, 0, 1]);
-
-    let d = z.neg_by_ref();
-    assert_eq!(3, d.support_size());
-    assert_eq!(finite_map! { -1 => -1, 0 => -1, 1 => 1 }, d);
-    assert_ne!(d, z);
-    let mut support = z.support().cloned().collect::<Vec<i64>>();
-    support.sort_unstable();
-    assert_eq!(support, vec![-1, 0, 1]);
-
-    let d = z.clone().neg();
-    assert_eq!(3, d.support_size());
-    assert_eq!(finite_map! { -1 => -1, 0 => -1, 1 => 1 }, d);
-    assert_ne!(d, z);
-
-    let i: Map = d.clone().into_iter().collect();
-    assert_eq!(i, d);
-
-    z.increment(&1, 1);
-    assert_eq!(2, z.support_size());
-    assert_eq!(finite_map! { -1 => 1, 0 => 1 }, z);
-
-    let mut z2 = z.add_by_ref(&z);
-    assert_eq!(2, z2.support_size());
-    assert_eq!(finite_map! { -1 => 2, 0 => 2 }, z2);
-
-    let z2_owned = z.clone().add(z.clone());
-    assert_eq!(2, z2_owned.support_size());
-    assert_eq!(finite_map! { -1 => 2, 0 => 2 }, z2_owned);
-
-    z2.add_assign_by_ref(&z);
-    assert_eq!(2, z2.support_size());
-    assert_eq!(finite_map! { -1 => 3, 0 => 3 }, z2);
-
-    z2.increment_owned(4, 2);
-    assert_eq!(finite_map! { -1 => 3, 0 => 3, 4 => 2 }, z2);
-}
diff --git a/src/algebra/mod.rs b/src/algebra/mod.rs
index bcb6ae9d..2a68d863 100644
--- a/src/algebra/mod.rs
+++ b/src/algebra/mod.rs
@@ -1,22 +1,21 @@
 //! This module contains declarations of abstract algebraic concepts:
 //! monoids, groups, rings, etc.
 
-#[macro_use]
-pub mod finite_map;
-mod checked_int;
-mod zset;
-
-pub use checked_int::CheckedInt;
-pub use finite_map::{FiniteHashMap, FiniteMap, MapBuilder, WithSupport};
-pub use zset::{IndexedZSet, IndexedZSetHashMap, ZSet, ZSetHashMap};
-
 use std::{
     num::Wrapping,
     ops::{Add, AddAssign, Mul, Neg},
     rc::Rc,
 };
 
+#[macro_use]
+mod checked_int;
+mod zset;
+
+pub use checked_int::CheckedInt;
+pub use zset::{IndexedZSet, ZSet};
+
 /// A trait for types that have a zero value.
+///
 /// This is simlar to the standard Zero trait, but that
 /// trait depends on Add and HasZero doesn't.
 pub trait HasZero {
@@ -116,15 +115,6 @@ where
     }
 }
 
-/// A trait for objects with size.
-pub trait WithNumEntries {
-    /// Returns the number of entries in `self`.
-    ///
-    /// Container types have a well-defined notion of size
-    /// (the number of entries in the container).  Scalars have size 1.
-    fn num_entries(&self) -> usize;
-}
-
 /// Like the Add trait, but with arguments by reference.
 pub trait AddByRef {
     fn add_by_ref(&self, other: &Self) -> Self;
@@ -220,7 +210,7 @@ impl<T> GroupValue for T where
 }
 
 /// A Group with a multiplication operation is a Ring.
-pub trait RingValue: GroupValue + MulByRef + HasOne {}
+pub trait RingValue: GroupValue + Mul<Output = Self> + MulByRef + HasOne {}
 
 /// Default implementation of RingValue for all types that have the required
 /// traits.
@@ -235,6 +225,7 @@ impl<T> RingValue for T where
         + AddAssignByRef
         + Neg<Output = Self>
         + NegByRef
+        + Mul<Output = Self>
         + MulByRef
         + HasOne
 {
@@ -249,7 +240,7 @@ pub trait ZRingValue: RingValue {
     fn le0(&self) -> bool;
 }
 
-/// Default implementation of ZRingValue for all types that have the required
+/// Default implementation of `ZRingValue` for all types that have the required
 /// traits.
 impl<T> ZRingValue for T
 where
@@ -263,6 +254,7 @@ where
         + AddAssignByRef
         + Neg<Output = Self>
         + NegByRef
+        + Mul<Output = Self>
         + MulByRef
         + HasOne
         + Ord,
diff --git a/src/algebra/zset/mod.rs b/src/algebra/zset/mod.rs
index 467b6096..29a634e3 100644
--- a/src/algebra/zset/mod.rs
+++ b/src/algebra/zset/mod.rs
@@ -1,25 +1,29 @@
-#[cfg(test)]
-pub(crate) mod tests;
+#[macro_use]
+mod zset_macro;
 
-use crate::algebra::{
-    finite_map::{FiniteHashMap, FiniteMap, KeyProperties, MapBuilder},
-    ZRingValue,
+use crate::{
+    algebra::{GroupValue, HasOne, ZRingValue},
+    trace::{cursor::Cursor, Batch, Builder},
+    NumEntries, SharedRef,
 };
 
+// TODO: allow arbitrary `Time` types?
+/// An indexed Z-set maps arbitrary keys to Z-set values.
+pub trait IndexedZSet:
+    Batch<Time = ()> + GroupValue + NumEntries + SharedRef<Target = Self>
+{
+}
+
+impl<Z> IndexedZSet for Z where
+    Z: Batch<Time = ()> + GroupValue + NumEntries + SharedRef<Target = Self>
+{
+}
+
 /// The Z-set trait.
 ///
 /// A Z-set is a set where each element has a weight.
 /// Weights belong to some ring.
-///
-/// `Data` - Type of values stored in Z-set
-/// `Weight` - Type of weights.  Must be a value from a Ring.
-pub trait ZSet<Data, Weight>: FiniteMap<Data, Weight>
-where
-    Data: KeyProperties,
-    Weight: ZRingValue,
-{
-    // type KeyIterator: Iterator<Ite m= Data>;
-
+pub trait ZSet: IndexedZSet<Val = ()> {
     /// Returns a Z-set that contains all elements with positive weights from
     /// `self` with weights set to 1.
     fn distinct(&self) -> Self;
@@ -28,70 +32,30 @@ where
     fn distinct_owned(self) -> Self;
 }
 
-/// An implementation of ZSets using [`FiniteHashMap`]s
-pub type ZSetHashMap<Data, Weight> = FiniteHashMap<Data, Weight>;
-
-/// Build a Z-set from an iterator, giving each item a weight of 1.
-impl<Data, Weight> FromIterator<Data> for ZSetHashMap<Data, Weight>
-where
-    Data: KeyProperties,
-    Weight: ZRingValue,
-{
-    fn from_iter<T>(iter: T) -> Self
-    where
-        T: IntoIterator<Item = Data>,
-    {
-        Self::from_iter(iter.into_iter().map(|d| (d, Weight::one())))
-    }
-}
-
-impl<Data, Weight> ZSet<Data, Weight> for ZSetHashMap<Data, Weight>
+impl<Z> ZSet for Z
 where
-    Data: KeyProperties,
-    Weight: ZRingValue,
+    Z: IndexedZSet<Val = ()>,
+    Z::Key: Clone,
+    Z::R: ZRingValue,
 {
     fn distinct(&self) -> Self {
-        let mut result = Self::new();
-
-        for (key, value) in &self.value {
-            if value.ge0() {
-                result.increment(key, Weight::one());
+        let mut builder = Self::Builder::with_capacity((), self.len());
+        let mut cursor = self.cursor();
+
+        while cursor.key_valid(self) {
+            let key = cursor.key(self);
+            let w = cursor.weight(self);
+            if w.ge0() {
+                builder.push((key.clone(), (), HasOne::one()));
             }
+            cursor.step_key(self);
         }
 
-        result
+        builder.done()
     }
 
+    // TODO: optimized implementation for owned values
     fn distinct_owned(self) -> Self {
-        let mut result = Self::new();
-
-        for (key, value) in self.value.into_iter() {
-            if value.ge0() {
-                result.increment_owned(key, Weight::one());
-            }
-        }
-
-        result
+        self.distinct()
     }
 }
-
-/// An indexed Z-set maps arbitrary keys to Z-set values.
-pub trait IndexedZSet<Key, Value, Weight>: FiniteMap<Key, Self::ZSet>
-where
-    Key: KeyProperties,
-    Value: KeyProperties,
-    Weight: ZRingValue,
-{
-    type ZSet: ZSet<Value, Weight>;
-}
-
-pub type IndexedZSetHashMap<Key, Value, Weight> = FiniteHashMap<Key, ZSetHashMap<Value, Weight>>;
-
-impl<Key, Value, Weight> IndexedZSet<Key, Value, Weight> for IndexedZSetHashMap<Key, Value, Weight>
-where
-    Key: KeyProperties,
-    Value: KeyProperties,
-    Weight: ZRingValue,
-{
-    type ZSet = ZSetHashMap<Value, Weight>;
-}
diff --git a/src/algebra/zset/tests.rs b/src/algebra/zset/tests.rs
deleted file mode 100644
index 28836c6a..00000000
--- a/src/algebra/zset/tests.rs
+++ /dev/null
@@ -1,257 +0,0 @@
-use crate::algebra::{
-    finite_map::{FiniteMap, MapBuilder},
-    zset::{ZSet, ZSetHashMap},
-    AddAssignByRef, AddByRef, CheckedInt, HasZero, NegByRef,
-};
-
-type CheckedI64 = CheckedInt<i64>;
-
-#[test]
-fn zset_integer_tests() {
-    let mut z = ZSetHashMap::<i64, i64>::with_capacity(5);
-    assert_eq!(0, z.support_size());
-    assert_eq!(finite_map! {}, z);
-    assert_eq!(0, z.lookup(&0)); // not present -> weight 0
-    assert_eq!(z, ZSetHashMap::<i64, i64>::zero());
-    assert!(z.is_zero());
-
-    let z2 = ZSetHashMap::<i64, i64>::new();
-    assert_eq!(z, z2);
-
-    z.increment(&0, 1);
-    assert_eq!(1, z.support_size());
-    assert_eq!(finite_map! { 0 => 1 }, z);
-    assert_eq!(1, z.lookup(&0));
-    assert_eq!(0, z.lookup(&1));
-    assert_ne!(z, ZSetHashMap::<i64, i64>::zero());
-    assert!(!z.is_zero());
-
-    z.increment_owned(2, 0);
-    assert_eq!(1, z.support_size());
-    assert_eq!(finite_map! { 0 => 1 }, z);
-
-    z.increment(&1, -1);
-    assert_eq!(2, z.support_size());
-    assert_eq!(finite_map! { 0 => 1, 1 => -1 }, z);
-
-    z.increment_owned(-1, 1);
-    assert_eq!(3, z.support_size());
-    assert_eq!(finite_map! { -1 => 1, 0 => 1, 1 => -1 }, z);
-
-    let d = z.distinct();
-    assert_eq!(2, d.support_size());
-    assert_eq!(finite_map! { -1 => 1, 0 => 1 }, d);
-
-    let d = z.neg_by_ref();
-    assert_eq!(3, d.support_size());
-    assert_eq!(finite_map! { -1 => -1, 0 => -1, 1 => 1 }, d);
-    assert_ne!(d, z);
-
-    z.increment(&1, 1);
-    assert_eq!(2, z.support_size());
-    assert_eq!(finite_map! { -1 => 1, 0 => 1 }, z);
-
-    let mut z2 = z.clone().add_by_ref(&z);
-    assert_eq!(2, z2.support_size());
-    assert_eq!(finite_map! { -1 => 2, 0 => 2 }, z2);
-
-    z2.add_assign_by_ref(&z);
-    assert_eq!(2, z2.support_size());
-    assert_eq!(finite_map! { -1 => 3, 0 => 3 }, z2);
-}
-
-#[test]
-fn checked_zset_integer_weights_tests() {
-    let mut z = ZSetHashMap::<i64, CheckedI64>::with_capacity(5);
-    assert_eq!(0, z.support_size());
-    assert_eq!(finite_map! {}, z);
-    assert_eq!(CheckedI64::new(0), z.lookup(&0)); // not present -> weight 0
-    assert_eq!(z, ZSetHashMap::<i64, CheckedI64>::zero());
-    assert!(z.is_zero());
-
-    let z2 = ZSetHashMap::<i64, CheckedI64>::new();
-    assert_eq!(z, z2);
-
-    z.increment_owned(0, CheckedI64::new(1));
-    assert_eq!(1, z.support_size());
-    assert_eq!(finite_map! { 0 => CheckedI64::new(1) }, z);
-    assert_eq!(CheckedI64::new(1), z.lookup(&0));
-    assert_eq!(CheckedI64::new(0), z.lookup(&1));
-    assert_ne!(z, ZSetHashMap::<i64, CheckedI64>::zero());
-    assert!(!z.is_zero());
-
-    z.increment(&2, CheckedI64::new(0));
-    assert_eq!(1, z.support_size());
-    assert_eq!(finite_map! { 0 => CheckedI64::new(1) }, z);
-
-    z.increment_owned(1, CheckedI64::new(-1));
-    assert_eq!(2, z.support_size());
-    assert_eq!(
-        finite_map! {
-            0 => CheckedI64::new(1),
-            1 => CheckedI64::new(-1),
-        },
-        z,
-    );
-
-    z.increment(&-1, CheckedI64::from(1));
-    assert_eq!(3, z.support_size());
-    assert_eq!(
-        finite_map! {
-            -1 => CheckedI64::new(1),
-            0 => CheckedI64::new(1),
-            1 => CheckedI64::new(-1),
-        },
-        z,
-    );
-
-    let d = z.distinct();
-    assert_eq!(2, d.support_size());
-    assert_eq!(
-        finite_map! {
-            -1 => CheckedI64::new(1),
-            0 => CheckedI64::new(1),
-        },
-        d,
-    );
-
-    let d = z.neg_by_ref();
-    assert_eq!(3, d.support_size());
-    assert_eq!(
-        finite_map! {
-            -1 => CheckedI64::new(-1),
-            0 => CheckedI64::new(-1),
-            1 => CheckedI64::new(1),
-        },
-        d,
-    );
-    assert_ne!(d, z);
-
-    z.increment_owned(1, CheckedI64::new(1));
-    assert_eq!(2, z.support_size());
-    assert_eq!(
-        finite_map! {
-            -1 => CheckedI64::new(1),
-            0 => CheckedI64::new(1),
-        },
-        z,
-    );
-
-    let mut z2 = z.clone().add_by_ref(&z);
-    assert_eq!(2, z2.support_size());
-    assert_eq!(
-        finite_map! {
-            -1 => CheckedI64::new(2),
-            0 => CheckedI64::new(2),
-        },
-        z2,
-    );
-
-    z2.add_assign_by_ref(&z);
-    assert_eq!(2, z2.support_size());
-    assert_eq!(
-        finite_map! {
-            -1 => CheckedI64::new(3),
-            0 => CheckedI64::new(3),
-        },
-        z2,
-    );
-}
-
-#[test]
-fn zset_tuple_tests() {
-    let mut z = ZSetHashMap::<(i64, i64), CheckedI64>::with_capacity(5);
-    assert_eq!(0, z.support_size());
-    assert_eq!(finite_map! {}, z);
-    assert_eq!(CheckedI64::new(0), z.lookup(&(0, 0))); // not present -> weight 0
-    assert_eq!(z, ZSetHashMap::<(i64, i64), CheckedI64>::zero());
-    assert!(z.is_zero());
-
-    let z2 = ZSetHashMap::<(i64, i64), CheckedI64>::new();
-    assert_eq!(z, z2);
-
-    z.increment_owned((0, 0), CheckedI64::new(1));
-    assert_eq!(1, z.support_size());
-    assert_eq!(finite_map! { (0, 0) => CheckedI64::new(1) }, z,);
-    assert_eq!(CheckedI64::from(1), z.lookup(&(0, 0)));
-    assert_eq!(CheckedI64::from(0), z.lookup(&(0, 1)));
-    assert_ne!(z, ZSetHashMap::<(i64, i64), CheckedI64>::zero());
-    assert!(!z.is_zero());
-
-    z.increment(&(2, 0), CheckedI64::new(0));
-    assert_eq!(1, z.support_size());
-    assert_eq!(finite_map! { (0, 0) => CheckedI64::new(1) }, z,);
-
-    z.increment_owned((1, 0), CheckedI64::new(-1));
-    assert_eq!(2, z.support_size());
-    assert_eq!(
-        finite_map! {
-            (0, 0) => CheckedI64::new(1),
-            (1, 0) => CheckedI64::new(-1),
-        },
-        z,
-    );
-
-    z.increment(&(-1, 0), CheckedI64::new(1));
-    assert_eq!(3, z.support_size());
-    assert_eq!(
-        finite_map! {
-            (-1, 0) => CheckedI64::new(1),
-            (0, 0) => CheckedI64::new(1),
-            (1, 0) => CheckedI64::new(-1),
-        },
-        z,
-    );
-
-    let d = z.distinct();
-    assert_eq!(2, d.support_size());
-    assert_eq!(
-        finite_map! {
-            (-1, 0) => CheckedI64::new(1),
-            (0, 0) => CheckedI64::new(1),
-        },
-        d,
-    );
-
-    let d = z.neg_by_ref();
-    assert_eq!(3, d.support_size());
-    assert_eq!(
-        finite_map! {
-            (-1, 0) => CheckedI64::new(-1),
-            (0, 0) => CheckedI64::new(-1),
-            (1, 0) => CheckedI64::new(1),
-        },
-        d,
-    );
-    assert_ne!(d, z);
-
-    z.increment_owned((1, 0), CheckedI64::new(1));
-    assert_eq!(2, z.support_size());
-    assert_eq!(
-        finite_map! {
-            (-1, 0) => CheckedI64::new(1),
-            (0, 0) => CheckedI64::new(1),
-        },
-        z,
-    );
-
-    let mut z2 = z.clone().add_by_ref(&z);
-    assert_eq!(2, z2.support_size());
-    assert_eq!(
-        finite_map! {
-            (-1, 0) => CheckedI64::new(2),
-            (0, 0) => CheckedI64::new(2),
-        },
-        z2,
-    );
-
-    z2.add_assign_by_ref(&z);
-    assert_eq!(2, z2.support_size());
-    assert_eq!(
-        finite_map! {
-            (-1, 0) => CheckedI64::new(3),
-            (0, 0) => CheckedI64::new(3),
-        },
-        z2
-    );
-}
diff --git a/src/algebra/zset/zset_macro.rs b/src/algebra/zset/zset_macro.rs
new file mode 100644
index 00000000..574fb7aa
--- /dev/null
+++ b/src/algebra/zset/zset_macro.rs
@@ -0,0 +1,29 @@
+/// Create an indexed Z-set with specified elements.
+///
+/// This macro is used in unit tests to create reference inputs and outputs.
+/// It generates an indexed Z-set of type
+/// [`OrdIndexedZSet`](crate::trace::ord::OrdIndexedZSet)s.
+#[macro_export]
+macro_rules! indexed_zset {
+    ( $($key:expr => { $($value:expr => $weight:expr),* }),* $(,)?) => {{
+        let mut batcher = <<$crate::trace::ord::OrdIndexedZSet<_, _, _> as $crate::trace::Batch>::Batcher as $crate::trace::Batcher<_, _, _, _, _>>::new(());
+        let mut batch = ::std::vec![ $( $( (($key, $value), $weight) ),* ),* ];
+        $crate::trace::Batcher::push_batch(&mut batcher, &mut batch);
+        $crate::trace::Batcher::seal(batcher)
+    }};
+}
+
+/// Create a Z-set with specified elements.
+///
+/// This macro is used in unit tests to create reference inputs and outputs.
+/// It generates a Z-set of type [`OrdZSet`](crate::trace::ord::OrdZSet)s.
+#[macro_export]
+macro_rules! zset {
+    ( $( $key:expr => $weight:expr ),* $(,)?) => {{
+        let mut batcher = <<$crate::trace::ord::OrdZSet<_, _> as $crate::trace::Batch>::Batcher as $crate::trace::Batcher<_, _, _, _, _>>::new(());
+
+        let mut batch = ::std::vec![ $( (($key, ()), $weight) ),* ];
+        $crate::trace::Batcher::push_batch(&mut batcher, &mut batch);
+        $crate::trace::Batcher::seal(batcher)
+    }};
+}
diff --git a/src/circuit/circuit_builder.rs b/src/circuit/circuit_builder.rs
index e4f35019..9e44d9bf 100644
--- a/src/circuit/circuit_builder.rs
+++ b/src/circuit/circuit_builder.rs
@@ -1,10 +1,3 @@
-/*
-MIT License
-SPDX-License-Identifier: MIT
-
-Copyright (c) $CURRENT_YEAR VMware, Inc
-*/
-
 //! API to construct circuits.
 //!
 //! The API exposes two abstractions [`Circuit`]s and [`Stream`]s.
@@ -269,6 +262,8 @@ pub trait Node {
     /// Global node id.
     fn global_id(&self) -> &GlobalNodeId;
 
+    fn name(&self) -> Cow<'static, str>;
+
     /// `true` if the node encapsulates an asynchronous operator (see
     /// [`Operator::is_async()`](super::operator_traits::Operator::is_async)).
     /// `false` for synchronous operators and subcircuits.
@@ -320,6 +315,8 @@ pub trait Node {
     unsafe fn clock_end(&mut self, scope: Scope);
 
     fn summary(&self, output: &mut String);
+
+    fn fixedpoint(&self) -> bool;
 }
 
 /// Id of an operator, guaranteed to be unique within a circuit.
@@ -639,6 +636,15 @@ impl<P> CircuitInner<P> {
             handler(event)
         }
     }
+
+    fn fixedpoint(&self) -> bool {
+        self.nodes.iter().all(|node| {
+            node.fixedpoint()
+            /*if !res {
+                eprintln!("node {} ({})", node.global_id(), node.name());
+            }*/
+        })
+    }
 }
 
 /// A handle to a circuit.
@@ -1537,6 +1543,66 @@ where
             Ok((res, executor))
         })
     }
+
+    /// Add a child circuit that will iterate to a fixed point.
+    ///
+    /// For each parent clock cycle, the child circuit will iterate until
+    /// reaching a fixed point, i.e., a state where the outputs of all
+    /// operators are guaranteed to remain the same, should the nested clock
+    /// continue ticking.
+    ///
+    /// The fixed point check is implemented by checking the following
+    /// condition:
+    ///
+    /// * All operators in the circuit are in such a state that, if their inputs
+    ///   remain constant (i.e., all future inputs are identical to the last
+    ///   input), then their outputs remain constant too.
+    ///
+    /// This is a necessary and sufficient condition that is also easy to check
+    /// by asking each operator if it is in a stable state (via the
+    /// [`Operator::fixedpoint`](`super::operator_traits::Operator::fixedpoint`)
+    /// API.  
+    ///
+    /// # Warning
+    ///
+    /// The cost of checking this condition precisely can be high for some
+    /// operators, which implement approximate checks instead.  For instance,
+    /// delay operators ([`Z1`](`crate::operator::Z1`) and
+    /// [`Z1Nested`](`crate::operator::Z1Nested`)) require storing the last
+    /// two versions of the state instead of one and comparing them at each
+    /// cycle.  Instead, they conservatively check for _specific_ fixed points,
+    /// namely fixed points where both input and output of the operator are zero
+    /// As a result, the circuit may fail to detect other fixed points and may
+    /// iterate forever.
+    ///
+    /// The goal is to evolve the design so that circuits created using the
+    /// high-level API (`Stream::xxx` methods) implement accurate fixed point
+    /// checks, but there are currently no guardrails in the system against
+    /// constructing non-compliant circuits.
+    pub fn fixedpoint<F, T>(&self, constructor: F) -> Result<T, SchedulerError>
+    where
+        F: FnOnce(&mut Circuit<Self>) -> Result<T, SchedulerError>,
+    {
+        self.fixedpoint_with_scheduler::<F, T, DynamicScheduler>(constructor)
+    }
+
+    /// Add a child circuit that will iterate to a fixed point.
+    ///
+    /// Similar to [`fixedpoint`](`Self::fixedpoint`), but with a user-specified
+    /// [`Scheduler`] implementation.
+    pub fn fixedpoint_with_scheduler<F, T, S>(&self, constructor: F) -> Result<T, SchedulerError>
+    where
+        F: FnOnce(&mut Circuit<Self>) -> Result<T, SchedulerError>,
+        S: Scheduler + 'static,
+    {
+        self.subcircuit(true, |child| {
+            let res = constructor(child)?;
+            let child_clone = child.clone();
+            let termination_check = move || child_clone.inner().fixedpoint();
+            let executor = <IterativeExecutor<_, S>>::new(child, termination_check)?;
+            Ok((res, executor))
+        })
+    }
 }
 
 impl<P> Circuit<Circuit<P>>
@@ -1628,6 +1694,10 @@ where
     O: Clone,
     Op: ImportOperator<I, O>,
 {
+    fn name(&self) -> Cow<'static, str> {
+        self.operator.name()
+    }
+
     fn local_id(&self) -> NodeId {
         self.id.local_node_id().unwrap()
     }
@@ -1670,6 +1740,10 @@ where
     fn summary(&self, output: &mut String) {
         self.operator.summary(output);
     }
+
+    fn fixedpoint(&self) -> bool {
+        self.operator.fixedpoint()
+    }
 }
 
 struct SourceNode<C, O, Op> {
@@ -1701,6 +1775,10 @@ where
     O: Clone,
     Op: SourceOperator<O>,
 {
+    fn name(&self) -> Cow<'static, str> {
+        self.operator.name()
+    }
+
     fn local_id(&self) -> NodeId {
         self.id.local_node_id().unwrap()
     }
@@ -1737,6 +1815,10 @@ where
     fn summary(&self, output: &mut String) {
         self.operator.summary(output);
     }
+
+    fn fixedpoint(&self) -> bool {
+        self.operator.fixedpoint()
+    }
 }
 
 struct UnaryNode<C, I, O, Op> {
@@ -1776,6 +1858,10 @@ where
     O: Clone,
     Op: UnaryOperator<I, O>,
 {
+    fn name(&self) -> Cow<'static, str> {
+        self.operator.name()
+    }
+
     fn local_id(&self) -> NodeId {
         self.id.local_node_id().unwrap()
     }
@@ -1815,6 +1901,10 @@ where
     fn summary(&self, output: &mut String) {
         self.operator.summary(output);
     }
+
+    fn fixedpoint(&self) -> bool {
+        self.operator.fixedpoint()
+    }
 }
 
 struct SinkNode<C, I, Op> {
@@ -1846,6 +1936,10 @@ where
     I: Clone,
     Op: SinkOperator<I>,
 {
+    fn name(&self) -> Cow<'static, str> {
+        self.operator.name()
+    }
+
     fn local_id(&self) -> NodeId {
         self.id.local_node_id().unwrap()
     }
@@ -1885,6 +1979,10 @@ where
     fn summary(&self, output: &mut String) {
         self.operator.summary(output);
     }
+
+    fn fixedpoint(&self) -> bool {
+        self.operator.fixedpoint()
+    }
 }
 
 struct BinaryNode<C, I1, I2, O, Op> {
@@ -1932,6 +2030,10 @@ where
     O: Clone,
     Op: BinaryOperator<I1, I2, O>,
 {
+    fn name(&self) -> Cow<'static, str> {
+        self.operator.name()
+    }
+
     fn local_id(&self) -> NodeId {
         self.id.local_node_id().unwrap()
     }
@@ -1991,6 +2093,10 @@ where
     fn summary(&self, output: &mut String) {
         self.operator.summary(output);
     }
+
+    fn fixedpoint(&self) -> bool {
+        self.operator.fixedpoint()
+    }
 }
 
 struct NaryNode<C, I, O, Op>
@@ -2053,6 +2159,10 @@ where
     O: Clone,
     Op: NaryOperator<I, O>,
 {
+    fn name(&self) -> Cow<'static, str> {
+        self.operator.name()
+    }
+
     fn local_id(&self) -> NodeId {
         self.id.local_node_id().unwrap()
     }
@@ -2104,6 +2214,10 @@ where
     fn summary(&self, output: &mut String) {
         self.operator.summary(output);
     }
+
+    fn fixedpoint(&self) -> bool {
+        self.operator.fixedpoint()
+    }
 }
 
 // The output half of a feedback node.  We implement a feedback node using a
@@ -2149,6 +2263,10 @@ where
     O: Clone,
     Op: StrictUnaryOperator<I, O>,
 {
+    fn name(&self) -> Cow<'static, str> {
+        unsafe { &*self.operator.get() }.name()
+    }
+
     fn local_id(&self) -> NodeId {
         self.id.local_node_id().unwrap()
     }
@@ -2184,7 +2302,7 @@ where
     unsafe fn clock_end(&mut self, scope: Scope) {
         if scope == 0 {
             self.export_stream
-                .put((&mut *self.operator.get()).get_output())
+                .put((&mut *self.operator.get()).get_final_output())
         }
         (&mut *self.operator.get()).clock_end(scope);
     }
@@ -2194,6 +2312,10 @@ where
             (&*self.operator.get()).summary(output);
         }
     }
+
+    fn fixedpoint(&self) -> bool {
+        unsafe { (&*self.operator.get()).fixedpoint() }
+    }
 }
 
 /// The input half of a feedback node
@@ -2224,6 +2346,10 @@ where
     Op: StrictUnaryOperator<I, O>,
     I: Data,
 {
+    fn name(&self) -> Cow<'static, str> {
+        unsafe { &*self.operator.get() }.name()
+    }
+
     fn local_id(&self) -> NodeId {
         self.id.local_node_id().unwrap()
     }
@@ -2263,6 +2389,10 @@ where
             (&*self.operator.get()).summary(output);
         }
     }
+
+    fn fixedpoint(&self) -> bool {
+        unsafe { (&*self.operator.get()).fixedpoint() }
+    }
 }
 
 /// Input connector of a feedback operator.
@@ -2356,6 +2486,10 @@ impl<P> Node for ChildNode<P>
 where
     P: 'static,
 {
+    fn name(&self) -> Cow<'static, str> {
+        Cow::Borrowed("Subcircuit")
+    }
+
     fn local_id(&self) -> NodeId {
         self.id.local_node_id().unwrap()
     }
@@ -2387,6 +2521,10 @@ where
     fn summary(&self, output: &mut String) {
         output.clear();
     }
+
+    fn fixedpoint(&self) -> bool {
+        unimplemented!()
+    }
 }
 
 /// Top-level circuit with executor.
diff --git a/src/circuit/operator_traits.rs b/src/circuit/operator_traits.rs
index 49b08609..251a1ed5 100644
--- a/src/circuit/operator_traits.rs
+++ b/src/circuit/operator_traits.rs
@@ -79,8 +79,8 @@ pub trait Operator: 'static {
     /// # Arguments
     ///
     /// * `scope` - the scope whose clock is restarting.
-    fn clock_start(&mut self, scope: Scope);
-    fn clock_end(&mut self, scope: Scope);
+    fn clock_start(&mut self, _scope: Scope) {}
+    fn clock_end(&mut self, _scope: Scope) {}
 
     /// Returns `true` if `self` is an asynchronous operator.
     ///
@@ -134,6 +134,41 @@ pub trait Operator: 'static {
     {
     }
 
+    /// Check if the operator is in a stable state.
+    ///
+    /// This method is invoked as part of checking if the circuit has reached a
+    /// fixed point state, i.e., a state where the outputs of all operators will
+    /// remain constant forever
+    /// (see [`Circuit::fixedpoint`](`crate::circuit::Circuit::fixedpoint`)).
+    ///
+    /// The method is invoked at the end of a clock cycle, after
+    /// the operator has been evaluated.  It returns `true` if the operator's
+    /// output is guaranteed to remain constant (i.e., all future outputs
+    /// will be equal to the last output) as long as its inputs remain
+    /// constant.
+    ///
+    /// The check must be precise. False positives (returning `true` when the
+    /// output may change in the future) may lead to early termination before
+    /// the circuit has reached a fixed point (and hence incorrect output).
+    /// False negatives (returning `false` in a stable state) is only acceptable
+    /// for a finite number of clock cycles and will otherwise prevent the
+    /// fixedpoint computation from converging.
+    ///
+    /// # Warning
+    ///
+    /// Two operators currently violate this requirement:
+    /// [`Z1`](`crate::operator::Z1`) and
+    /// [`Z1Nested`](`crate::operator::Z1Nested`). The latter will get phased
+    /// out soon.  The former is work-in-progress. It can be safely used inside
+    /// nested circuits when carrying changes to collections across iterations
+    /// of the fixed point computation, but not as part of an integrator circuit
+    /// ([`Stream::integrate`](`crate::circuit::Stream::integrate`)).
+    fn fixedpoint(&self) -> bool;
+
+    /// Returns printable operator metadata, e.g., number of entries, heap
+    /// usage, etc.
+    // TODO: metadata is operator-specific, so we cannot use a pre-defined structure
+    // here.  A dynamic representation (e.g., JSON) may be the sweet spot.
     fn summary(&self, output: &mut String) {
         output.clear();
     }
@@ -249,6 +284,8 @@ pub trait StrictOperator<O>: Operator {
     /// state (for example [Z1](`crate::operator::Z1`) returns its inner
     /// value, leaving the operator empty).
     fn get_output(&mut self) -> O;
+
+    fn get_final_output(&mut self) -> O;
 }
 
 /// A strict unary operator that consumes a stream of inputs of type `I`
diff --git a/src/lattice.rs b/src/lattice.rs
new file mode 100644
index 00000000..9baa7b96
--- /dev/null
+++ b/src/lattice.rs
@@ -0,0 +1,231 @@
+//! Partially ordered elements with a least upper bound.
+//!
+//! All logical times in DBSP must implement the `Lattice` trait.
+
+use timely::{
+    order::PartialOrder,
+    progress::{frontier::AntichainRef, Antichain},
+};
+
+/// A bounded partially ordered type supporting joins and meets.
+pub trait Lattice: PartialOrder {
+    /// The smallest element greater than or equal to both arguments.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use timely::PartialOrder;
+    /// # use timely::order::Product;
+    /// # use dbsp::lattice::Lattice;
+    /// # fn main() {
+    ///
+    /// let time1 = Product::new(3, 7);
+    /// let time2 = Product::new(4, 6);
+    /// let join = time1.join(&time2);
+    ///
+    /// assert_eq!(join, Product::new(4, 7));
+    /// # }
+    /// ```
+    fn join(&self, other: &Self) -> Self;
+
+    /// Updates `self` to the smallest element greater than or equal to both
+    /// arguments.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use timely::PartialOrder;
+    /// # use timely::order::Product;
+    /// # use dbsp::lattice::Lattice;
+    /// # fn main() {
+    ///
+    /// let mut time1 = Product::new(3, 7);
+    /// let time2 = Product::new(4, 6);
+    /// time1.join_assign(&time2);
+    ///
+    /// assert_eq!(time1, Product::new(4, 7));
+    /// # }
+    /// ```
+    fn join_assign(&mut self, other: &Self)
+    where
+        Self: Sized,
+    {
+        *self = self.join(other);
+    }
+
+    /// The largest element less than or equal to both arguments.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use timely::PartialOrder;
+    /// # use timely::order::Product;
+    /// # use dbsp::lattice::Lattice;
+    /// # fn main() {
+    ///
+    /// let time1 = Product::new(3, 7);
+    /// let time2 = Product::new(4, 6);
+    /// let meet = time1.meet(&time2);
+    ///
+    /// assert_eq!(meet, Product::new(3, 6));
+    /// # }
+    /// ```
+    fn meet(&self, other: &Self) -> Self;
+
+    /// Updates `self` to the largest element less than or equal to both
+    /// arguments.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use timely::PartialOrder;
+    /// # use timely::order::Product;
+    /// # use dbsp::lattice::Lattice;
+    /// # fn main() {
+    ///
+    /// let mut time1 = Product::new(3, 7);
+    /// let time2 = Product::new(4, 6);
+    /// time1.meet_assign(&time2);
+    ///
+    /// assert_eq!(time1, Product::new(3, 6));
+    /// # }
+    /// ```
+    fn meet_assign(&mut self, other: &Self)
+    where
+        Self: Sized,
+    {
+        *self = self.meet(other);
+    }
+
+    /// Advances self to the largest time indistinguishable under `frontier`.
+    ///
+    /// This method produces the "largest" lattice element with the property
+    /// that for every lattice element greater than some element of
+    /// `frontier`, both the result and `self` compare identically to the
+    /// lattice element. The result is the "largest" element in
+    /// the sense that any other element with the same property (compares
+    /// identically to times greater or equal to `frontier`) must be less or
+    /// equal to the result.
+    ///
+    /// When provided an empty frontier `self` is not modified.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use timely::PartialOrder;
+    /// # use timely::order::Product;
+    /// # use dbsp::lattice::Lattice;
+    /// # fn main() {
+    ///
+    /// use timely::progress::frontier::{Antichain, AntichainRef};
+    ///
+    /// let time = Product::new(3, 7);
+    /// let mut advanced = Product::new(3, 7);
+    /// let frontier = Antichain::from(vec![Product::new(4, 8), Product::new(5, 3)]);
+    /// advanced.advance_by(frontier.borrow());
+    ///
+    /// // `time` and `advanced` are indistinguishable to elements >= an element of `frontier`
+    /// for i in 0..10 {
+    ///     for j in 0..10 {
+    ///         let test = Product::new(i, j);
+    ///         // for `test` in the future of `frontier` ..
+    ///         if frontier.less_equal(&test) {
+    ///             assert_eq!(time.less_equal(&test), advanced.less_equal(&test));
+    ///         }
+    ///     }
+    /// }
+    ///
+    /// assert_eq!(advanced, Product::new(4, 7));
+    /// # }
+    /// ```
+    #[inline]
+    fn advance_by(&mut self, frontier: AntichainRef<Self>)
+    where
+        Self: Sized,
+    {
+        let mut iter = frontier.iter();
+        if let Some(first) = iter.next() {
+            let mut result = self.join(first);
+            for f in iter {
+                result.meet_assign(&self.join(f));
+            }
+            *self = result;
+        }
+    }
+}
+
+use timely::order::Product;
+
+impl<T1: Lattice, T2: Lattice> Lattice for Product<T1, T2> {
+    #[inline]
+    fn join(&self, other: &Product<T1, T2>) -> Product<T1, T2> {
+        Product {
+            outer: self.outer.join(&other.outer),
+            inner: self.inner.join(&other.inner),
+        }
+    }
+
+    #[inline]
+    fn meet(&self, other: &Product<T1, T2>) -> Product<T1, T2> {
+        Product {
+            outer: self.outer.meet(&other.outer),
+            inner: self.inner.meet(&other.inner),
+        }
+    }
+}
+
+macro_rules! implement_lattice {
+    ($index_type:ty, $minimum:expr) => {
+        impl Lattice for $index_type {
+            #[inline]
+            fn join(&self, other: &Self) -> Self {
+                ::std::cmp::max(*self, *other)
+            }
+
+            #[inline]
+            fn meet(&self, other: &Self) -> Self {
+                ::std::cmp::min(*self, *other)
+            }
+        }
+    };
+}
+
+use std::time::Duration;
+
+implement_lattice!(Duration, Duration::new(0, 0));
+implement_lattice!(usize, 0);
+implement_lattice!(u128, 0);
+implement_lattice!(u64, 0);
+implement_lattice!(u32, 0);
+implement_lattice!(u16, 0);
+implement_lattice!(u8, 0);
+implement_lattice!(isize, 0);
+implement_lattice!(i128, 0);
+implement_lattice!(i64, 0);
+implement_lattice!(i32, 0);
+implement_lattice!(i16, 0);
+implement_lattice!(i8, 0);
+implement_lattice!((), ());
+
+impl<T: Lattice + Clone> Lattice for Antichain<T> {
+    fn join(&self, other: &Self) -> Self {
+        let mut upper = Antichain::new();
+        for time1 in self.elements().iter() {
+            for time2 in other.elements().iter() {
+                upper.insert(time1.join(time2));
+            }
+        }
+        upper
+    }
+
+    fn meet(&self, other: &Self) -> Self {
+        let mut upper = Antichain::new();
+        for time1 in self.elements().iter() {
+            upper.insert(time1.clone());
+        }
+        for time2 in other.elements().iter() {
+            upper.insert(time2.clone());
+        }
+        upper
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
index 4fa5f915..b20b576d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,11 +1,5 @@
-/*
-MIT License
-SPDX-License-Identifier: MIT
-
-Copyright (c) 2021 VMware, Inc
-*/
-
-extern crate num;
+pub mod time;
+pub use time::Timestamp;
 
 mod shared_ref;
 pub use shared_ref::SharedRef;
@@ -18,7 +12,8 @@ pub use num_entries::NumEntries;
 
 pub mod algebra;
 pub mod circuit;
+pub mod lattice;
 pub mod monitor;
 pub mod operator;
 pub mod profile;
-mod test;
+pub mod trace;
diff --git a/src/monitor/circuit_graph.rs b/src/monitor/circuit_graph.rs
index 92105925..6724091b 100644
--- a/src/monitor/circuit_graph.rs
+++ b/src/monitor/circuit_graph.rs
@@ -151,6 +151,8 @@ pub(super) enum NodeKind {
     },
     /// The input half of a strict operator.
     StrictInput { output: NodeId },
+    /// The output half of a strict operator.
+    StrictOutput,
 }
 
 /// A node in a circuit graph represents an operator or a circuit.
@@ -289,7 +291,19 @@ impl Node {
             NodeKind::Circuit { region, .. } => {
                 Some(VisNode::Cluster(region.visualize(self, annotate)))
             }
-            NodeKind::StrictInput { .. } => None,
+            NodeKind::StrictInput { output } => {
+                let annotation = annotate(&self.id);
+                Some(VisNode::Simple(SimpleNode::new(
+                    Self::node_identifier(&self.id.parent_id().unwrap().child(*output)),
+                    format!(
+                        "{}{}{}",
+                        self.name,
+                        if annotation.is_empty() { "" } else { "\\l" },
+                        annotation
+                    ),
+                )))
+            }
+            NodeKind::StrictOutput => None,
         }
     }
 }
diff --git a/src/monitor/mod.rs b/src/monitor/mod.rs
index d3237bd9..20d22f12 100644
--- a/src/monitor/mod.rs
+++ b/src/monitor/mod.rs
@@ -281,43 +281,52 @@ impl TraceMonitorInternal {
                         if children.get(&local_node_id).is_some() {
                             return Err(TraceError::NodeExists(node_id.clone()));
                         }
-                        let new_node =
-                            if event.is_operator_event() || event.is_strict_output_event() {
-                                Node::new(
-                                    node_id.clone(),
-                                    event.node_name().unwrap(),
-                                    current_region.clone(),
-                                    NodeKind::Operator,
-                                )
-                            } else if event.is_strict_input_event() {
-                                let output = event.output_node_id().unwrap();
-                                if children.get(&output).is_none() {
+                        let new_node = if event.is_operator_event() {
+                            Node::new(
+                                node_id.clone(),
+                                event.node_name().unwrap(),
+                                current_region.clone(),
+                                NodeKind::Operator,
+                            )
+                        } else if event.is_strict_output_event() {
+                            Node::new(
+                                node_id.clone(),
+                                event.node_name().unwrap(),
+                                current_region.clone(),
+                                NodeKind::StrictOutput,
+                            )
+                        } else if event.is_strict_input_event() {
+                            let output = event.output_node_id().unwrap();
+                            let output_node = match children.get(&output) {
+                                None => {
                                     return Err(TraceError::UnknownNode(GlobalNodeId::child(
                                         &parent_id, output,
                                     )));
                                 }
-
-                                Node::new(
-                                    node_id.clone(),
-                                    "",
-                                    current_region.clone(),
-                                    NodeKind::StrictInput { output },
-                                )
-                            } else {
-                                self.current_scope = node_id.clone();
-                                self.region_stack.push(RegionId::root());
-                                Node::new(
-                                    node_id.clone(),
-                                    "",
-                                    current_region.clone(),
-                                    NodeKind::Circuit {
-                                        iterative: event.is_iterative_subcircuit_event(),
-                                        children: HashMap::new(),
-                                        region: Region::new(RegionId::root(), Cow::Borrowed("")),
-                                    },
-                                )
+                                Some(node) => node,
                             };
 
+                            Node::new(
+                                node_id.clone(),
+                                &output_node.name,
+                                current_region.clone(),
+                                NodeKind::StrictInput { output },
+                            )
+                        } else {
+                            self.current_scope = node_id.clone();
+                            self.region_stack.push(RegionId::root());
+                            Node::new(
+                                node_id.clone(),
+                                "",
+                                current_region.clone(),
+                                NodeKind::Circuit {
+                                    iterative: event.is_iterative_subcircuit_event(),
+                                    children: HashMap::new(),
+                                    region: Region::new(RegionId::root(), Cow::Borrowed("")),
+                                },
+                            )
+                        };
+
                         children.insert(local_node_id, new_node);
                         region.get_region(&current_region).nodes.push(local_node_id);
                         Ok(())
diff --git a/src/num_entries.rs b/src/num_entries.rs
index b7ee483f..cdc0726f 100644
--- a/src/num_entries.rs
+++ b/src/num_entries.rs
@@ -4,17 +4,21 @@ use impl_trait_for_tuples::impl_for_tuples;
 use std::rc::Rc;
 
 /// Trait to report object size as the number of entries.
-///
-/// Scalars have size 1.  Container (e.g., vector, map) size is
-/// the sum of sizes of its elements.  If elements have constant size,
-/// container size can be efficiently measured by multiplying the
-/// number of elements by the size of each element.
 pub trait NumEntries {
     /// Returns the number of entries in `self`.
-    fn num_entries(&self) -> usize;
+    fn num_entries_shallow(&self) -> usize;
+
+    /// Recursively computes the number of entries in a container by
+    /// calling this method on each entry in `self`.
+    ///
+    /// Scalars have size 1.  Container (e.g., vector, map) size is
+    /// the sum of sizes of its elements.  If elements have constant size,
+    /// container size can be efficiently measured by multiplying the
+    /// number of elements by the size of each element.
+    fn num_entries_deep(&self) -> usize;
 
     /// Returns `Some(n)` if `Self` has constant size or `None` otherwise.
-    fn const_num_entries() -> Option<usize>;
+    const CONST_NUM_ENTRIES: Option<usize>;
 }
 
 /// Macro to implement [`NumEntries`] for a scalar type whose size is 1.
@@ -22,12 +26,17 @@ pub trait NumEntries {
 macro_rules! num_entries_scalar {
     ($type:ty) => {
         impl $crate::NumEntries for $type {
-            fn num_entries(&self) -> usize {
+            #[inline]
+            fn num_entries_shallow(&self) -> usize {
                 1
             }
-            fn const_num_entries() -> Option<usize> {
-                Some(1)
+
+            #[inline]
+            fn num_entries_deep(&self) -> usize {
+                1
             }
+
+            const CONST_NUM_ENTRIES: Option<usize> = Some(1);
         }
     };
 }
@@ -51,43 +60,43 @@ num_entries_scalar!(&'static str);
 
 #[impl_for_tuples(12)]
 impl NumEntries for Tuple {
-    fn num_entries(&self) -> usize {
+    fn num_entries_shallow(&self) -> usize {
         1
     }
-    fn const_num_entries() -> Option<usize> {
-        Some(1)
+    fn num_entries_deep(&self) -> usize {
+        1
     }
+
+    const CONST_NUM_ENTRIES: Option<usize> = Some(1);
 }
 
 impl<T> NumEntries for Vec<T>
 where
     T: NumEntries,
 {
-    fn num_entries(&self) -> usize {
-        match T::const_num_entries() {
-            None => {
-                let mut res = 0;
-                for x in self.iter() {
-                    res += x.num_entries();
-                }
-                res
-            }
+    fn num_entries_shallow(&self) -> usize {
+        self.len()
+    }
+    fn num_entries_deep(&self) -> usize {
+        match T::CONST_NUM_ENTRIES {
+            None => self.iter().map(T::num_entries_deep).sum(),
             Some(n) => n * self.len(),
         }
     }
-    fn const_num_entries() -> Option<usize> {
-        None
-    }
+
+    const CONST_NUM_ENTRIES: Option<usize> = None;
 }
 
 impl<T> NumEntries for Rc<T>
 where
     T: NumEntries,
 {
-    fn num_entries(&self) -> usize {
-        self.as_ref().num_entries()
+    fn num_entries_shallow(&self) -> usize {
+        self.as_ref().num_entries_shallow()
     }
-    fn const_num_entries() -> Option<usize> {
-        T::const_num_entries()
+    fn num_entries_deep(&self) -> usize {
+        self.as_ref().num_entries_deep()
     }
+
+    const CONST_NUM_ENTRIES: Option<usize> = T::CONST_NUM_ENTRIES;
 }
diff --git a/src/operator/adapter.rs b/src/operator/adapter.rs
index 59a8f440..bfc86165 100644
--- a/src/operator/adapter.rs
+++ b/src/operator/adapter.rs
@@ -67,6 +67,10 @@ where
     {
         self.op.register_ready_callback(cb);
     }
+
+    fn fixedpoint(&self) -> bool {
+        self.op.fixedpoint()
+    }
 }
 
 impl<RI, RO, O, Op> UnaryOperator<RI, RO> for UnaryOperatorAdapter<O, Op>
@@ -136,6 +140,10 @@ where
     {
         self.op.register_ready_callback(cb);
     }
+
+    fn fixedpoint(&self) -> bool {
+        self.op.fixedpoint()
+    }
 }
 
 impl<RI1, RI2, RO, O, Op> BinaryOperator<RI1, RI2, RO> for BinaryOperatorAdapter<O, Op>
diff --git a/src/operator/aggregate.rs b/src/operator/aggregate.rs
index 7b3de6a3..7725926b 100644
--- a/src/operator/aggregate.rs
+++ b/src/operator/aggregate.rs
@@ -1,64 +1,97 @@
 //! Aggregation operators.
 
-use std::{borrow::Cow, marker::PhantomData};
+use std::{borrow::Cow, marker::PhantomData, ops::Neg};
 
 use crate::{
-    algebra::{
-        finite_map::KeyProperties, FiniteHashMap, FiniteMap, GroupValue, MapBuilder, ZRingValue,
-    },
+    algebra::{GroupValue, HasOne, ZRingValue, ZSet},
     circuit::{
         operator_traits::{BinaryOperator, Operator, UnaryOperator},
-        Circuit, Scope, Stream,
+        Circuit, Stream,
     },
-    operator::{BinaryOperatorAdapter, UnaryOperatorAdapter},
-    NumEntries, SharedRef,
+    trace::{cursor::Cursor, BatchReader},
+    NumEntries,
 };
+use deepsize::DeepSizeOf;
 
-impl<P, SR> Stream<Circuit<P>, SR>
+impl<P, I> Stream<Circuit<P>, I>
 where
     P: Clone + 'static,
+    I: Clone + 'static,
 {
-    /// Apply [`Aggregate`] operator to `self`.
-    pub fn aggregate<K, VI, VO, W, F, O>(&self, f: F) -> Stream<Circuit<P>, O>
+    // TODO: Consider changing the signature of aggregation function to take a slice
+    // of values instead of iterator.  This is easier to understand and use, and
+    // allows computing the number of unique values in a group (an important
+    // aggregate) in `O(1)`.  Most batch implementations will allow extracting
+    // such a slice efficiently.
+    /// Aggregate each indexed Z-set in the input stream.
+    ///
+    /// Values in the input stream are [indexed
+    /// Z-sets](`crate::algebra::IndexedZSet`). The aggregation function
+    /// `agg_func` takes a single key and the set of (value, weight)
+    /// tuples associated with this key and transforms them into a single
+    /// aggregate value.  The output of the operator is a Z-set computed as
+    /// a sum of aggregates across all keys with weight `+1` each.
+    ///
+    /// # Type arguments
+    ///
+    /// * `I` - input indexed Z-set type.
+    /// * `O` - output Z-set type.
+    pub fn aggregate<F, O>(&self, f: F) -> Stream<Circuit<P>, O>
     where
-        K: KeyProperties,
-        VI: 'static,
-        SR: SharedRef + 'static,
-        <SR as SharedRef>::Target: FiniteMap<K, VI>,
-        for<'a> &'a <SR as SharedRef>::Target: IntoIterator<Item = (&'a K, &'a VI)>,
-        F: Fn(&K, &VI) -> VO + 'static,
-        VO: 'static,
-        W: ZRingValue,
-        O: Clone + MapBuilder<VO, W> + 'static,
+        I: BatchReader<R = O::R> + 'static,
+        F: Fn(&I, &mut I::Cursor) -> O::Key + 'static,
+        O: Clone + ZSet + 'static,
+        O::R: ZRingValue,
     {
-        self.circuit()
-            .add_unary_operator(<UnaryOperatorAdapter<O, _>>::new(Aggregate::new(f)), self)
+        self.circuit().add_unary_operator(Aggregate::new(f), self)
     }
 
     /// Incremental version of the [`Aggregate`] operator.
     ///
     /// This is equivalent to `self.integrate().aggregate(f).differentiate()`,
     /// but is more efficient.
-    pub fn aggregate_incremental<K, VI, VO, W, F, O>(&self, f: F) -> Stream<Circuit<P>, O>
+    pub fn aggregate_incremental<F, O>(&self, f: F) -> Stream<Circuit<P>, O>
     where
-        K: KeyProperties,
-        VI: GroupValue,
-        SR: SharedRef + 'static,
-        <SR as SharedRef>::Target: FiniteMap<K, VI>,
-        <SR as SharedRef>::Target: NumEntries + SharedRef<Target = SR::Target>,
-        for<'a> &'a <SR as SharedRef>::Target: IntoIterator<Item = (&'a K, &'a VI)>,
-        F: Fn(&K, &VI) -> VO + 'static,
-        VO: 'static,
-        W: ZRingValue,
-        O: Clone + MapBuilder<VO, W> + 'static,
+        I: BatchReader<R = O::R> + DeepSizeOf + NumEntries + GroupValue + 'static,
+        I::Key: PartialEq,
+        F: Fn(&I, &mut I::Cursor) -> O::Key + Clone + 'static,
+        O: Clone + ZSet + 'static,
+        O::R: ZRingValue,
     {
-        self.circuit().add_binary_operator(
-            BinaryOperatorAdapter::new(AggregateIncremental::new(f)),
+        let retract_old = self.circuit().add_binary_operator(
+            AggregateIncremental::new(false, f.clone()),
             self,
             &self.integrate().delay(),
-        )
+        );
+
+        let insert_new = self.circuit().add_binary_operator(
+            AggregateIncremental::new(true, f),
+            self,
+            &self.integrate(),
+        );
+
+        retract_old.plus(&insert_new)
+    }
+
+    /// Incremental nested version of the [`Aggregate`] operator.
+    ///
+    /// This is equivalent to
+    /// `self.integrate().integrate_nested().aggregate(f).differentiate_nested.
+    /// differentiate()`, but is more efficient.
+    pub fn aggregate_incremental_nested<F, O>(&self, f: F) -> Stream<Circuit<P>, O>
+    where
+        I: BatchReader<R = O::R> + DeepSizeOf + NumEntries + GroupValue + 'static,
+        I::Key: PartialEq,
+        F: Fn(&I, &mut I::Cursor) -> O::Key + Clone + 'static,
+        O: Clone + ZSet + DeepSizeOf + 'static,
+        O::R: ZRingValue,
+    {
+        self.integrate_nested()
+            .aggregate_incremental(f)
+            .differentiate_nested()
     }
 
+    /*
     /// A version of [`Self::aggregate_incremental`] optimized for linear
     /// aggregation functions.
     ///
@@ -74,46 +107,20 @@ where
     /// designed to return the key if necessar.  However,
     /// such an aggregation function can be non-linear (in fact, the plus
     /// operation may not even be defined for its output type).
-    pub fn aggregate_linear_incremental<K, VI, VO, W, F, O>(&self, f: F) -> Stream<Circuit<P>, O>
+    pub fn aggregate_linear_incremental<F, O>(&self, f: F) -> Stream<Circuit<P>, O>
     where
-        K: KeyProperties,
-        VI: GroupValue,
-        SR: SharedRef + 'static,
-        <SR as SharedRef>::Target: FiniteMap<K, VI>,
-        <SR as SharedRef>::Target: NumEntries + SharedRef<Target = SR::Target>,
-        for<'a> &'a <SR as SharedRef>::Target: IntoIterator<Item = (&'a K, &'a VI)>,
-        F: Fn(&K, &VI) -> VO + 'static,
-        VO: GroupValue + NumEntries,
-        W: ZRingValue,
-        O: Clone + MapBuilder<(K, VO), W> + 'static,
+        <SR as SharedRef>::Target: BatchReader<R=O::R> + DeepSizeOf + NumEntries + GroupValue + SharedRef<Target = SR::Target> + 'static,
+        <<SR as SharedRef>::Target as BatchReader>::Key: PartialEq + Clone,
+        F: Fn(&<<SR as SharedRef>::Target as BatchReader>::Key,
+              &<<SR as SharedRef>::Target as BatchReader>::Val) -> O::Val + 'static,
+        O: Clone + ZSet + 'static,
     {
-        let agg_delta: Stream<_, FiniteHashMap<K, VO>> = self.map_values(f);
-        agg_delta.aggregate_incremental(|key, agg_val| (key.clone(), agg_val.clone()))
-    }
-
-    /// Incremental nested version of the [`Aggregate`] operator.
-    ///
-    /// This is equivalent to
-    /// `self.integrate().integrate_nested().aggregate(f).differentiate_nested.
-    /// differentiate()`, but is more efficient.
-    pub fn aggregate_incremental_nested<K, VI, VO, W, F, O>(&self, f: F) -> Stream<Circuit<P>, O>
-    where
-        K: KeyProperties,
-        VI: GroupValue,
-        SR: SharedRef + 'static,
-        <SR as SharedRef>::Target: FiniteMap<K, VI>,
-        <SR as SharedRef>::Target: NumEntries + SharedRef<Target = SR::Target>,
-        for<'a> &'a <SR as SharedRef>::Target: IntoIterator<Item = (&'a K, &'a VI)>,
-        F: Fn(&K, &VI) -> VO + 'static,
-        VO: 'static,
-        W: ZRingValue,
-        O: NumEntries + MapBuilder<VO, W> + GroupValue,
-    {
-        self.integrate_nested()
-            .aggregate_incremental(f)
-            .differentiate_nested()
+        let agg_delta: Stream<_, OrdZSet<_, _>> = self.map_values(f);
+        agg_delta.aggregate_incremental(|zset, cursor| (zset.key().clone(), agg_val.clone()))
     }
+    */
 
+    /*
     /// A version of [`Self::aggregate_incremental_nested`] optimized for linear
     /// aggregation functions.
     ///
@@ -128,7 +135,7 @@ where
         K: KeyProperties,
         VI: GroupValue,
         SR: SharedRef + 'static,
-        <SR as SharedRef>::Target: FiniteMap<K, VI>,
+        <SR as SharedRef>::Target: ZSet<K, VI>,
         <SR as SharedRef>::Target: NumEntries + SharedRef<Target = SR::Target>,
         for<'a> &'a <SR as SharedRef>::Target: IntoIterator<Item = (&'a K, &'a VI)>,
         F: Fn(&K, &VI) -> VO + 'static,
@@ -140,31 +147,15 @@ where
             .aggregate_linear_incremental(f)
             .differentiate_nested()
     }
+    */
 }
 
-/// Aggregate each indexed Z-set in the input stream.
-///
-/// Values in the input stream are finite maps that map keys of type
-/// `K` to values of type `VI`.  The aggregation function `agg_func`
-/// maps each key-value pair into an output value of type `VO`.  The
-/// output of the operator is a Z-set of type `O` computed as:
-/// `Aggregate(i) = Sum_{(k,v) in i}(+1 x agg_func(k,v))`
-///
-/// # Type arguments
-///
-/// * `K` - key type in the input map.
-/// * `VI` - value type in the input map.  This is typically a Z-set.
-/// * `I` - input map type.
-/// * `VO` - output type of the aggregation function; value type in the output
-///   Z-set.
-/// * `W` - weight type in the output Z-set.
-/// * `O` - output Z-set type.
-pub struct Aggregate<K, VI, I, VO, W, F, O> {
+pub struct Aggregate<I, F, O> {
     agg_func: F,
-    _type: PhantomData<(K, VI, I, VO, W, O)>,
+    _type: PhantomData<(I, O)>,
 }
 
-impl<K, VI, I, VO, W, F, O> Aggregate<K, VI, I, VO, W, F, O> {
+impl<I, F, O> Aggregate<I, F, O> {
     pub fn new(agg_func: F) -> Self {
         Self {
             agg_func,
@@ -173,42 +164,36 @@ impl<K, VI, I, VO, W, F, O> Aggregate<K, VI, I, VO, W, F, O> {
     }
 }
 
-impl<K, VI, I, VO, W, F, O> Operator for Aggregate<K, VI, I, VO, W, F, O>
+impl<I, F, O> Operator for Aggregate<I, F, O>
 where
-    K: 'static,
-    VI: 'static,
     I: 'static,
-    VO: 'static,
-    W: 'static,
     F: 'static,
     O: 'static,
 {
     fn name(&self) -> Cow<'static, str> {
         Cow::from("Aggregate")
     }
-    fn clock_start(&mut self, _scope: Scope) {}
-    fn clock_end(&mut self, _scope: Scope) {}
+    fn fixedpoint(&self) -> bool {
+        true
+    }
 }
 
-impl<K, VI, I, VO, W, F, O> UnaryOperator<I, O> for Aggregate<K, VI, I, VO, W, F, O>
+impl<I, F, O> UnaryOperator<I, O> for Aggregate<I, F, O>
 where
-    K: KeyProperties,
-    VI: 'static,
-    I: FiniteMap<K, VI>,
-    for<'a> &'a I: IntoIterator<Item = (&'a K, &'a VI)>,
-    F: Fn(&K, &VI) -> VO + 'static,
-    VO: 'static,
-    W: ZRingValue,
-    O: Clone + MapBuilder<VO, W> + 'static,
+    I: BatchReader<R = O::R> + 'static,
+    F: Fn(&I, &mut I::Cursor) -> O::Key + 'static,
+    O: Clone + ZSet + 'static,
+    O::R: ZRingValue,
 {
     fn eval(&mut self, i: &I) -> O {
-        let mut result = O::with_capacity(i.support_size());
+        let mut elements = Vec::with_capacity(i.len());
+        let mut cursor = i.cursor();
 
-        for (k, v) in i.into_iter() {
-            result.increment_owned((self.agg_func)(k, v), W::one());
+        while cursor.key_valid(i) {
+            elements.push((((self.agg_func)(i, &mut cursor), ()), I::R::one()));
+            cursor.step_key(i);
         }
-
-        result
+        O::from_tuples((), elements)
     }
 }
 
@@ -218,67 +203,70 @@ where
 /// value of `A`: `z^-1(A) = a.integrate().delay()` and computes
 /// `integrate(A) - integrate(z^-1(A))` incrementally, by only considering
 /// values in the support of `a`.
-pub struct AggregateIncremental<K, VI, I, VO, W, F, O> {
+pub struct AggregateIncremental<I, F, O> {
+    polarity: bool,
     agg_func: F,
-    _type: PhantomData<(K, VI, I, VO, W, O)>,
+    _type: PhantomData<(I, O)>,
 }
 
-impl<K, VI, I, VO, W, F, O> AggregateIncremental<K, VI, I, VO, W, F, O> {
-    pub fn new(agg_func: F) -> Self {
+impl<I, F, O> AggregateIncremental<I, F, O> {
+    pub fn new(polarity: bool, agg_func: F) -> Self {
         Self {
+            polarity,
             agg_func,
             _type: PhantomData,
         }
     }
 }
 
-impl<K, VI, I, VO, W, F, O> Operator for AggregateIncremental<K, VI, I, VO, W, F, O>
+impl<I, F, O> Operator for AggregateIncremental<I, F, O>
 where
-    K: 'static,
-    VI: 'static,
     I: 'static,
-    VO: 'static,
-    W: 'static,
     F: 'static,
     O: 'static,
 {
     fn name(&self) -> Cow<'static, str> {
         Cow::from("AggregateIncremental")
     }
-    fn clock_start(&mut self, _scope: Scope) {}
-    fn clock_end(&mut self, _scope: Scope) {}
+    fn fixedpoint(&self) -> bool {
+        true
+    }
 }
 
-impl<K, VI, I, VO, W, F, O> BinaryOperator<I, I, O> for AggregateIncremental<K, VI, I, VO, W, F, O>
+impl<I, F, O> BinaryOperator<I, I, O> for AggregateIncremental<I, F, O>
 where
-    K: KeyProperties,
-    VI: GroupValue,
-    I: FiniteMap<K, VI>,
-    for<'a> &'a I: IntoIterator<Item = (&'a K, &'a VI)>,
-    F: Fn(&K, &VI) -> VO + 'static,
-    VO: 'static,
-    W: ZRingValue,
-    O: Clone + MapBuilder<VO, W> + 'static,
+    I: BatchReader<R = O::R> + 'static,
+    I::Key: PartialEq,
+    F: Fn(&I, &mut I::Cursor) -> O::Key + 'static,
+    O: Clone + ZSet + 'static,
+    O::R: ZRingValue,
 {
-    fn eval(&mut self, delta: &I, delayed_integral: &I) -> O {
-        let mut result = O::with_capacity(delta.support_size());
+    fn eval(&mut self, delta: &I, integral: &I) -> O {
+        let mut result = Vec::with_capacity(delta.len());
+
+        let mut delta_cursor = delta.cursor();
+        let mut integral_cursor = integral.cursor();
+        let weight = if self.polarity {
+            I::R::one()
+        } else {
+            I::R::one().neg()
+        };
+
+        while delta_cursor.key_valid(delta) {
+            let key = delta_cursor.key(delta);
 
-        for (k, v) in delta.into_iter() {
-            if let Some(old_val) = delayed_integral.get_in_support(k) {
+            integral_cursor.seek_key(integral, key);
+
+            if integral_cursor.key_valid(integral) && integral_cursor.key(integral) == key {
                 // Retract the old value of the aggregate.
-                result.increment_owned((self.agg_func)(k, old_val), W::one().neg());
-
-                // Insert updated aggregate.
-                let new_val = old_val.add_by_ref(v);
-                if !new_val.is_zero() {
-                    result.increment_owned((self.agg_func)(k, &old_val.add_by_ref(v)), W::one())
-                }
-            } else {
-                result.increment_owned((self.agg_func)(k, v), W::one())
+                result.push((
+                    ((self.agg_func)(integral, &mut integral_cursor), ()),
+                    weight.clone(),
+                ));
             }
+            delta_cursor.step_key(delta);
         }
-
-        result
+        O::from_tuples((), result)
     }
 }
 
@@ -287,10 +275,13 @@ mod test {
     use std::{cell::RefCell, rc::Rc};
 
     use crate::{
-        algebra::{FiniteHashMap, ZSetHashMap},
         circuit::{Root, Stream},
-        finite_map,
         operator::{Apply2, GeneratorNested},
+        trace::{
+            ord::{OrdIndexedZSet, OrdZSet},
+            BatchReader, Cursor,
+        },
+        zset,
     };
 
     #[test]
@@ -298,12 +289,12 @@ mod test {
         let root = Root::build(move |circuit| {
             let mut inputs = vec![
                 vec![
-                    finite_map! { (1, 10) => 1, (1, 20) => 1 },
-                    finite_map! { (2, 10) => 1, (1, 10) => -1, (1, 20) => 1, (3, 10) => 1 },
+                    zset! { (1, 10) => 1, (1, 20) => 1 },
+                    zset! { (2, 10) => 1, (1, 10) => -1, (1, 20) => 1, (3, 10) => 1 },
                 ],
                 vec![
-                    finite_map! { (4, 20) => 1, (2, 10) => -1 },
-                    finite_map! { (5, 10) => 1, (6, 10) => 1 },
+                    zset! { (4, 20) => 1, (2, 10) => -1 },
+                    zset! { (5, 10) => 1, (6, 10) => 1 },
                 ],
                 vec![],
             ]
@@ -314,37 +305,42 @@ mod test {
                     let counter = Rc::new(RefCell::new(0));
                     let counter_clone = counter.clone();
 
-                    let input: Stream<_, FiniteHashMap<usize, ZSetHashMap<usize, isize>>> = child
+                    let input: Stream<_, OrdIndexedZSet<usize, usize, isize>> = child
                         .add_source(GeneratorNested::new(Box::new(move || {
                             *counter_clone.borrow_mut() = 0;
                             let mut deltas = inputs.next().unwrap_or_else(Vec::new).into_iter();
-                            Box::new(move || deltas.next().unwrap_or_else(|| finite_map! {}))
+                            Box::new(move || deltas.next().unwrap_or_else(|| zset! {}))
                         })))
                         .index();
 
                     // Weighted sum aggregate.  Returns `(key, weighted_sum)`.
-                    let sum = |&key: &usize, zset: &ZSetHashMap<usize, isize>| -> (usize, isize) {
+                    let sum = |storage: &OrdIndexedZSet<usize, usize, isize>,
+                               cursor: &mut <OrdIndexedZSet<_, _, _> as BatchReader>::Cursor|
+                     -> (usize, isize) {
                         let mut result: isize = 0;
-                        for (&v, &w) in zset.into_iter() {
-                            result += (v as isize) * w;
-                        }
 
-                        (key, result)
+                        while cursor.val_valid(storage) {
+                            let v = cursor.val(storage);
+                            let w = cursor.weight(storage);
+                            result += (*v as isize) * w;
+                            cursor.step_val(storage);
+                        }
+                        (cursor.key(storage).clone(), result)
                     };
 
                     // Weighted sum aggregate that returns only the weighted sum
                     // value and is therefore linear.
-                    let sum_linear = |_key: &usize, zset: &ZSetHashMap<usize, isize>| -> isize {
+                    /*let sum_linear = |_key: &usize, zset: &OrdZSet<usize, isize>| -> isize {
                         let mut result: isize = 0;
                         for (v, w) in zset.into_iter() {
                             result += (*v as isize) * w;
                         }
 
                         result
-                    };
+                    };*/
 
                     let sum_inc = input.aggregate_incremental_nested(sum);
-                    let sum_inc_linear = input.aggregate_linear_incremental_nested(sum_linear);
+                    //let sum_inc_linear = input.aggregate_linear_incremental_nested(sum_linear);
                     let sum_noninc = input
                         .integrate_nested()
                         .integrate()
@@ -356,8 +352,8 @@ mod test {
                     child
                         .add_binary_operator(
                             Apply2::new(
-                                |d1: &FiniteHashMap<(usize, isize), isize>,
-                                 d2: &FiniteHashMap<(usize, isize), isize>| {
+                                |d1: &OrdZSet<(usize, isize), isize>,
+                                 d2: &OrdZSet<(usize, isize), isize>| {
                                     (d1.clone(), d2.clone())
                                 },
                             ),
@@ -370,31 +366,36 @@ mod test {
                             assert_eq!(d1, d2);
                         });
 
-                    child
-                        .add_binary_operator(
-                            Apply2::new(
-                                |d1: &FiniteHashMap<(usize, isize), isize>,
-                                 d2: &FiniteHashMap<(usize, isize), isize>| {
-                                    (d1.clone(), d2.clone())
-                                },
-                            ),
-                            &sum_inc,
-                            &sum_inc_linear,
-                        )
-                        .inspect(|(d1, d2)| {
-                            assert_eq!(d1, d2);
-                        });
+                    /*child
+                    .add_binary_operator(
+                        Apply2::new(
+                            |d1: &OrdZSet<(usize, isize), isize>,
+                             d2: &OrdZSet<(usize, isize), isize>| {
+                                (d1.clone(), d2.clone())
+                            },
+                        ),
+                        &sum_inc,
+                        &sum_inc_linear,
+                    )
+                    .inspect(|(d1, d2)| {
+                        assert_eq!(d1, d2);
+                    });*/
 
                     // Min aggregate (non-linear).
-                    let min = |&key: &usize, zset: &ZSetHashMap<usize, isize>| -> (usize, usize) {
-                        let mut result: usize = *zset.into_iter().next().unwrap().0;
-                        for (&v, _) in zset.into_iter() {
-                            if v < result {
-                                result = v;
+                    let min = |storage: &OrdIndexedZSet<usize, usize, isize>,
+                               cursor: &mut <OrdIndexedZSet<_, _, _> as BatchReader>::Cursor|
+                     -> (usize, usize) {
+                        let mut result = usize::MAX;
+
+                        while cursor.val_valid(storage) {
+                            let v = cursor.key(storage);
+                            if v < &result {
+                                result = v.clone();
                             }
+                            cursor.step_val(storage);
                         }
 
-                        (key, result)
+                        (cursor.key(storage).clone(), result)
                     };
 
                     let min_inc = input.aggregate_incremental_nested(min);
@@ -408,8 +409,8 @@ mod test {
                     child
                         .add_binary_operator(
                             Apply2::new(
-                                |d1: &FiniteHashMap<(usize, usize), isize>,
-                                 d2: &FiniteHashMap<(usize, usize), isize>| {
+                                |d1: &OrdZSet<(usize, usize), isize>,
+                                 d2: &OrdZSet<(usize, usize), isize>| {
                                     (d1.clone(), d2.clone())
                                 },
                             ),
diff --git a/src/operator/apply.rs b/src/operator/apply.rs
index 2807e8c9..b8302d63 100644
--- a/src/operator/apply.rs
+++ b/src/operator/apply.rs
@@ -2,7 +2,7 @@
 
 use crate::circuit::{
     operator_traits::{Operator, UnaryOperator},
-    Circuit, Scope, Stream,
+    Circuit, Stream,
 };
 
 use std::borrow::Cow;
@@ -45,8 +45,11 @@ where
         Cow::from("Apply")
     }
 
-    fn clock_start(&mut self, _scope: Scope) {}
-    fn clock_end(&mut self, _scope: Scope) {}
+    fn fixedpoint(&self) -> bool {
+        // TODO: either change `F` type to `Fn` from `FnMut` or
+        // parameterize the operator with custom fixed point check.
+        unimplemented!();
+    }
 }
 
 impl<T1, T2, F> UnaryOperator<T1, T2> for Apply<F>
diff --git a/src/operator/apply2.rs b/src/operator/apply2.rs
index bef1a60c..0e7d4f12 100644
--- a/src/operator/apply2.rs
+++ b/src/operator/apply2.rs
@@ -1,9 +1,6 @@
 //! Binary operator that applies an arbitrary binary function to its inputs.
 
-use crate::circuit::{
-    operator_traits::{BinaryOperator, Operator},
-    Scope,
-};
+use crate::circuit::operator_traits::{BinaryOperator, Operator};
 use std::borrow::Cow;
 
 /// Applies a user-provided binary function to its inputs at each timestamp.
@@ -28,8 +25,11 @@ where
         Cow::from("Apply2")
     }
 
-    fn clock_start(&mut self, _scope: Scope) {}
-    fn clock_end(&mut self, _scope: Scope) {}
+    fn fixedpoint(&self) -> bool {
+        // TODO: either change `F` type to `Fn` from `FnMut` or
+        // parameterize the operator with custom fixed point check.
+        unimplemented!();
+    }
 }
 
 impl<T1, T2, T3, F> BinaryOperator<T1, T2, T3> for Apply2<F>
diff --git a/src/operator/communication/exchange.rs b/src/operator/communication/exchange.rs
index 8d7cbec0..80005597 100644
--- a/src/operator/communication/exchange.rs
+++ b/src/operator/communication/exchange.rs
@@ -446,6 +446,11 @@ where
     fn ready(&self) -> bool {
         self.exchange.ready_to_send(self.worker_index)
     }
+
+    fn fixedpoint(&self) -> bool {
+        // TODO: Add a mechanism to communicate fixed point status among peers.
+        unimplemented!()
+    }
 }
 
 impl<D, T, L, I> SinkOperator<D> for ExchangeSender<T, L>
@@ -530,6 +535,11 @@ where
     fn ready(&self) -> bool {
         self.exchange.ready_to_receive(self.worker_index)
     }
+
+    fn fixedpoint(&self) -> bool {
+        // TODO: Add a mechanism to communicate fixed point status among peers.
+        unimplemented!()
+    }
 }
 
 impl<D, T, L> SourceOperator<D> for ExchangeReceiver<T, L>
diff --git a/src/operator/condition.rs b/src/operator/condition.rs
index 11fc97de..c4471032 100644
--- a/src/operator/condition.rs
+++ b/src/operator/condition.rs
@@ -131,14 +131,17 @@ impl<C> Condition<C> {
 #[cfg(test)]
 mod test {
     use crate::{
-        algebra::{FiniteHashMap, FiniteMap, ZSetHashMap},
         circuit::{
             schedule::{DynamicScheduler, Scheduler, StaticScheduler},
             Circuit, Root, Stream,
         },
-        finite_map,
         monitor::TraceMonitor,
         operator::{DelayedFeedback, Generator},
+        trace::{
+            ord::{OrdIndexedZSet, OrdZSet},
+            BatchReader,
+        },
+        zset,
     };
 
     #[test]
@@ -160,7 +163,7 @@ mod test {
 
             // Graph edges
             let edges = circuit.add_source(Generator::new(move || {
-                finite_map! {
+                zset! {
                     (0, 3) => 1,
                     (1, 2) => 1,
                     (2, 1) => 1,
@@ -175,9 +178,8 @@ mod test {
 
             // Two sets of initial states.  The inner circuit computes sets of nodes
             // reachable from each of these initial sets.
-            let init1 =
-                circuit.add_source(Generator::new(|| finite_map! { 1 => 1, 2 => 1, 3 => 1 }));
-            let init2 = circuit.add_source(Generator::new(|| finite_map! { 4 => 1 }));
+            let init1 = circuit.add_source(Generator::new(|| zset! { 1 => 1, 2 => 1, 3 => 1 }));
+            let init2 = circuit.add_source(Generator::new(|| zset! { 4 => 1 }));
 
             let (reachable1, reachable2) = circuit
                 .iterate_with_conditions_and_scheduler::<_, _, S>(|child| {
@@ -185,7 +187,7 @@ mod test {
                     let init1 = init1.delta0(child).integrate();
                     let init2 = init2.delta0(child).integrate();
 
-                    let edges_indexed: Stream<_, FiniteHashMap<usize, ZSetHashMap<usize, isize>>> =
+                    let edges_indexed: Stream<_, OrdIndexedZSet<usize, usize, isize>> =
                         edges.index();
 
                     // Builds a subcircuit that computes nodes reachable from `init`:
@@ -204,24 +206,19 @@ mod test {
                     //
                     // where suc computes the set of successor nodes.
                     let reachable_circuit =
-                        |init: Stream<Circuit<Circuit<()>>, ZSetHashMap<usize, isize>>| {
-                            let feedback =
-                                <DelayedFeedback<_, ZSetHashMap<usize, isize>>>::new(child);
+                        |init: Stream<Circuit<Circuit<()>>, OrdZSet<usize, isize>>| {
+                            let feedback = <DelayedFeedback<_, OrdZSet<usize, isize>>>::new(child);
 
-                            let feedback_pairs: Stream<_, ZSetHashMap<(usize, ()), isize>> =
+                            let feedback_pairs: Stream<_, OrdZSet<(usize, ()), isize>> =
                                 feedback.stream().map_keys(|&node| (node, ()));
-                            let feedback_indexed: Stream<
-                                _,
-                                FiniteHashMap<usize, ZSetHashMap<(), isize>>,
-                            > = feedback_pairs.index();
+                            let feedback_indexed: Stream<_, OrdIndexedZSet<usize, (), isize>> =
+                                feedback_pairs.index();
 
                             let suc = feedback_indexed.join(&edges_indexed, |_node, &(), &to| to);
 
                             let reachable = init.plus(&suc).distinct();
                             feedback.connect(&reachable);
-                            let condition = reachable
-                                .differentiate()
-                                .condition(|z| z.support_size() == 0);
+                            let condition = reachable.differentiate().condition(|z| z.len() == 0);
                             (condition, reachable.export())
                         };
 
@@ -233,13 +230,9 @@ mod test {
                 .unwrap();
 
             reachable1.inspect(|r| {
-                assert_eq!(
-                    r,
-                    &finite_map! { 1 => 1, 2 => 1, 3 => 1, 4 => 1, 5 => 1, 6 => 1}
-                )
+                assert_eq!(r, &zset! { 1 => 1, 2 => 1, 3 => 1, 4 => 1, 5 => 1, 6 => 1})
             });
-            reachable2
-                .inspect(|r| assert_eq!(r, &finite_map! { 1 => 1, 2 => 1, 4 => 1, 5 => 1, 6 => 1}));
+            reachable2.inspect(|r| assert_eq!(r, &zset! { 1 => 1, 2 => 1, 4 => 1, 5 => 1, 6 => 1}));
         })
         .unwrap();
 
diff --git a/src/operator/consolidate.rs b/src/operator/consolidate.rs
new file mode 100644
index 00000000..b2b38146
--- /dev/null
+++ b/src/operator/consolidate.rs
@@ -0,0 +1,94 @@
+//! Operator that consolidates a trace into a single batch.
+
+use std::{borrow::Cow, convert::TryFrom, marker::PhantomData};
+
+use crate::{
+    circuit::{
+        operator_traits::{Operator, UnaryOperator},
+        Circuit, NodeId, OwnershipPreference, Stream,
+    },
+    circuit_cache_key,
+    trace::{Batch, Trace},
+};
+
+circuit_cache_key!(ConsolidateId<C, D>(NodeId => Stream<C, D>));
+
+impl<P, T> Stream<Circuit<P>, T>
+where
+    P: Clone + 'static,
+    T: Clone + Trace<Time = ()> + 'static,
+{
+    // TODO: drop the `Time = ()` requirement?
+    /// Consolidate a trace into a single batch.
+    ///
+    /// Each element in the input streams is a trace, consisting of multiple
+    /// batches of updates.  This operator consolidates the trace into a
+    /// single batch, which uses less memory and can be handled more
+    /// efficiently by most operators than the trace.
+    ///
+    /// This operator is typically attached to the output of a nested circuit
+    /// computed as the sum of deltas across all iterations of the circuit.
+    /// Once the iteration has converged (e.g., reaching a fixed point) is a
+    /// good time to consolidate the output.
+    pub fn consolidate<B>(&self) -> Stream<Circuit<P>, B>
+    where
+        B: TryFrom<T::Batch> + Clone + 'static,
+    {
+        self.circuit()
+            .cache_get_or_insert_with(ConsolidateId::new(self.local_node_id()), || {
+                self.circuit().add_unary_operator_with_preference(
+                    Consolidate::new(),
+                    self,
+                    OwnershipPreference::STRONGLY_PREFER_OWNED,
+                )
+            })
+            .clone()
+    }
+}
+
+pub struct Consolidate<T, B> {
+    _type: PhantomData<(T, B)>,
+}
+
+impl<T, B> Consolidate<T, B> {
+    pub fn new() -> Self {
+        Self { _type: PhantomData }
+    }
+}
+
+impl<T, B> Default for Consolidate<T, B> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<T, B> Operator for Consolidate<T, B>
+where
+    T: 'static,
+    B: 'static,
+{
+    fn name(&self) -> Cow<'static, str> {
+        Cow::from("Consolidate")
+    }
+    fn fixedpoint(&self) -> bool {
+        true
+    }
+}
+
+impl<T, B> UnaryOperator<T, B> for Consolidate<T, B>
+where
+    T: Trace<Time = ()> + 'static,
+    B: TryFrom<T::Batch> + 'static,
+{
+    fn eval(&mut self, _i: &T) -> B {
+        unimplemented!()
+    }
+
+    fn eval_owned(&mut self, i: T) -> B {
+        match i.consolidate() {
+            Some(batch) => TryFrom::try_from(batch),
+            None => TryFrom::try_from(T::Batch::empty(())),
+        }
+        .unwrap_or_else(|_| panic!("Consolidate::eval_owned does not own its input"))
+    }
+}
diff --git a/src/operator/csv.rs b/src/operator/csv.rs
index a19e865f..90e45d4b 100644
--- a/src/operator/csv.rs
+++ b/src/operator/csv.rs
@@ -8,24 +8,28 @@
 // - Async implementation (wait for data to become available in the reader)
 // - Sharded implementation.
 
-use crate::circuit::{
-    operator_traits::{Data, Operator, SourceOperator},
-    Scope,
+use crate::{
+    algebra::{ZRingValue, ZSet},
+    circuit::{
+        operator_traits::{Data, Operator, SourceOperator},
+        Scope,
+    },
 };
-use csv::{Reader as CsvReader, Result as CsvResult};
+use csv::Reader as CsvReader;
 use serde::Deserialize;
 use std::{borrow::Cow, io::Read, marker::PhantomData};
 
 /// A source operator that reads records of type `T` from a CSV file.
 ///
 /// The operator reads the entire file and yields its contents
-/// in the first clock cycle.
-pub struct CsvSource<R, C, T> {
+/// in the first clock cycle as a Z-set with unit weights.
+pub struct CsvSource<R, T, W, C> {
     reader: CsvReader<R>,
-    _t: PhantomData<(C, T)>,
+    time: usize,
+    _t: PhantomData<(C, T, W)>,
 }
 
-impl<R, C, T> CsvSource<R, C, T>
+impl<R, T, W, C> CsvSource<R, T, W, C>
 where
     C: Clone,
     R: Read,
@@ -40,52 +44,72 @@ where
     pub fn from_csv_reader(reader: CsvReader<R>) -> Self {
         Self {
             reader,
+            time: 0,
             _t: PhantomData,
         }
     }
 }
 
-impl<R, C, T> Operator for CsvSource<R, C, T>
+impl<R, T, W, C> Operator for CsvSource<R, T, W, C>
 where
     C: Data,
     R: 'static,
     T: 'static,
+    W: 'static,
 {
     fn name(&self) -> Cow<'static, str> {
         Cow::from("CsvSource")
     }
-    fn clock_start(&mut self, _scope: Scope) {}
-    fn clock_end(&mut self, _scope: Scope) {}
+    fn clock_start(&mut self, _scope: Scope) {
+        self.time = 0;
+    }
+    fn fixedpoint(&self) -> bool {
+        self.time >= 2
+    }
 }
 
-impl<R, C, T> SourceOperator<C> for CsvSource<R, C, T>
+impl<R, T, W, C> SourceOperator<C> for CsvSource<R, T, W, C>
 where
     T: for<'de> Deserialize<'de> + 'static,
+    W: ZRingValue + 'static,
     R: Read + 'static,
-    C: Data + FromIterator<T>,
+    C: Data + ZSet<Key = T, R = W>,
 {
     fn eval(&mut self) -> C {
-        self.reader.deserialize().map(CsvResult::unwrap).collect()
+        let source = if self.time == 0 {
+            let data: Vec<_> = self
+                .reader
+                .deserialize()
+                .map(|x| ((x.unwrap(), ()), W::one()))
+                .collect();
+
+            C::from_tuples((), data)
+        } else {
+            C::zero()
+        };
+        self.time += 1;
+
+        source
     }
 }
 
 #[cfg(test)]
 mod test {
-    use crate::{circuit::Root, operator::CsvSource};
+    use crate::{algebra::OrdZSet, circuit::Root, finite_map, operator::CsvSource};
     use csv::ReaderBuilder;
 
     #[test]
     fn test_csv_reader() {
         let root = Root::build(move |circuit| {
-            let expected = vec![
-                (18, 3, 237641),
-                (237641, 4, 18),
-                (18, 5, 21),
-                (18, 5, 22),
-                (18, 5, 23),
-                (18, 5, 24),
-                (18, 5, 25),
-            ];
+            let expected = finite_map! {
+                (18, 3, 237641) => 1,
+                (237641, 4, 18) => 1,
+                (18, 5, 21) => 1,
+                (18, 5, 22) => 1,
+                (18, 5, 23) => 1,
+                (18, 5, 24) => 1,
+                (18, 5, 25) => 1,
+            };
             let csv_data = "\
 18,3,237641
 237641,4,18
@@ -101,7 +125,9 @@ mod test {
                 .from_reader(csv_data.as_bytes());
             circuit
                 .add_source(CsvSource::from_csv_reader(reader))
-                .inspect(move |data: &Vec<(usize, usize, usize)>| assert_eq!(data, &expected));
+                .inspect(move |data: &OrdZSet<(usize, usize, usize), isize>| {
+                    assert_eq!(data, &expected)
+                });
         })
         .unwrap();
 
diff --git a/src/operator/delta0.rs b/src/operator/delta0.rs
index 486ee111..a6cd7355 100644
--- a/src/operator/delta0.rs
+++ b/src/operator/delta0.rs
@@ -4,7 +4,7 @@ use crate::{
     algebra::HasZero,
     circuit::{
         operator_traits::{Data, ImportOperator, Operator},
-        Circuit, OwnershipPreference, Scope, Stream,
+        Circuit, OwnershipPreference, Stream,
     },
 };
 use std::borrow::Cow;
@@ -63,11 +63,15 @@ where
 /// ```
 pub struct Delta0<D> {
     val: Option<D>,
+    fixedpoint: bool,
 }
 
 impl<D> Delta0<D> {
     pub fn new() -> Self {
-        Self { val: None }
+        Self {
+            val: None,
+            fixedpoint: false,
+        }
     }
 }
 
@@ -84,8 +88,9 @@ where
     fn name(&self) -> Cow<'static, str> {
         Cow::from("delta0")
     }
-    fn clock_start(&mut self, _scope: Scope) {}
-    fn clock_end(&mut self, _scope: Scope) {}
+    fn fixedpoint(&self) -> bool {
+        self.fixedpoint
+    }
 }
 
 impl<D> ImportOperator<D, D> for Delta0<D>
@@ -94,12 +99,17 @@ where
 {
     fn import(&mut self, val: &D) {
         self.val = Some(val.clone());
+        self.fixedpoint = false;
     }
     fn import_owned(&mut self, val: D) {
         self.val = Some(val);
+        self.fixedpoint = false;
     }
 
     fn eval(&mut self) -> D {
+        if self.val.is_none() {
+            self.fixedpoint = true;
+        }
         self.val.take().unwrap_or_else(D::zero)
     }
 
diff --git a/src/operator/differentiate.rs b/src/operator/differentiate.rs
index ee591aee..db685ece 100644
--- a/src/operator/differentiate.rs
+++ b/src/operator/differentiate.rs
@@ -7,6 +7,7 @@ use crate::{
     operator::Minus,
     NumEntries,
 };
+use deepsize::DeepSizeOf;
 
 circuit_cache_key!(DifferentiateId<C, D>(NodeId => Stream<C, D>));
 circuit_cache_key!(NestedDifferentiateId<C, D>(NodeId => Stream<C, D>));
@@ -14,7 +15,7 @@ circuit_cache_key!(NestedDifferentiateId<C, D>(NodeId => Stream<C, D>));
 impl<P, D> Stream<Circuit<P>, D>
 where
     P: Clone + 'static,
-    D: NumEntries + GroupValue,
+    D: DeepSizeOf + NumEntries + GroupValue,
 {
     /// Stream differentiation.
     ///
diff --git a/src/operator/distinct.rs b/src/operator/distinct.rs
index 91c30a85..fb44fa78 100644
--- a/src/operator/distinct.rs
+++ b/src/operator/distinct.rs
@@ -1,32 +1,41 @@
 //! Distinct operator.
 
-use std::{borrow::Cow, marker::PhantomData};
+use std::{
+    borrow::Cow,
+    cmp::{max, Ordering},
+    collections::BTreeSet,
+    fmt::Write,
+    marker::PhantomData,
+    mem::take,
+    ops::Neg,
+};
 
 use crate::{
-    algebra::{finite_map::KeyProperties, ZRingValue, ZSet},
+    algebra::{AddAssignByRef, AddByRef, HasOne, HasZero, ZRingValue, ZSet},
     circuit::{
         operator_traits::{BinaryOperator, Operator, UnaryOperator},
         Circuit, NodeId, Scope, Stream,
     },
     circuit_cache_key,
     operator::{BinaryOperatorAdapter, UnaryOperatorAdapter},
-    NumEntries, SharedRef,
+    time::NestedTimestamp32,
+    trace::{ord::OrdKeySpine, BatchReader, Builder, Cursor as TraceCursor, Trace, TraceReader},
+    NumEntries, Timestamp,
 };
+use deepsize::DeepSizeOf;
 
 circuit_cache_key!(DistinctId<C, D>(NodeId => Stream<C, D>));
 circuit_cache_key!(DistinctIncrementalId<C, D>(NodeId => Stream<C, D>));
+circuit_cache_key!(DistinctTraceId<C, D>(NodeId => Stream<C, D>));
 
 impl<P, Z> Stream<Circuit<P>, Z>
 where
     P: Clone + 'static,
 {
     /// Apply [`Distinct`] operator to `self`.
-    pub fn distinct<V, W>(&self) -> Stream<Circuit<P>, <Z as SharedRef>::Target>
+    pub fn distinct(&self) -> Stream<Circuit<P>, Z>
     where
-        V: KeyProperties,
-        W: ZRingValue,
-        Z: SharedRef + 'static,
-        <Z as SharedRef>::Target: ZSet<V, W>,
+        Z: ZSet,
     {
         self.circuit()
             .cache_get_or_insert_with(DistinctId::new(self.local_node_id()), || {
@@ -40,13 +49,11 @@ where
     ///
     /// This is equivalent to `self.integrate().distinct().differentiate()`, but
     /// is more efficient.
-    pub fn distinct_incremental<V, W>(&self) -> Stream<Circuit<P>, <Z as SharedRef>::Target>
+    pub fn distinct_incremental(&self) -> Stream<Circuit<P>, Z>
     where
-        V: KeyProperties,
-        W: ZRingValue,
-        Z: SharedRef + 'static,
-        <Z as SharedRef>::Target: NumEntries + ZSet<V, W> + SharedRef<Target = Z::Target>,
-        for<'a> &'a <Z as SharedRef>::Target: IntoIterator<Item = (&'a V, &'a W)>,
+        Z: DeepSizeOf + NumEntries + ZSet,
+        Z::Key: Clone + PartialEq,
+        Z::R: ZRingValue,
     {
         self.circuit()
             .cache_get_or_insert_with(DistinctIncrementalId::new(self.local_node_id()), || {
@@ -60,13 +67,12 @@ where
     }
 
     /// Incremental nested version of the [`Distinct`] operator.
-    pub fn distinct_incremental_nested<V, W>(&self) -> Stream<Circuit<P>, <Z as SharedRef>::Target>
+    // TODO: remove this method.
+    pub fn distinct_incremental_nested(&self) -> Stream<Circuit<P>, Z>
     where
-        V: KeyProperties,
-        W: ZRingValue,
-        Z: SharedRef + 'static,
-        <Z as SharedRef>::Target: NumEntries + ZSet<V, W> + SharedRef<Target = Z::Target>,
-        for<'a> &'a <Z as SharedRef>::Target: IntoIterator<Item = (&'a V, &'a W)>,
+        Z: DeepSizeOf + NumEntries + ZSet,
+        Z::Key: Clone + PartialEq,
+        Z::R: ZRingValue,
     {
         self.integrate_nested()
             .distinct_incremental()
@@ -74,41 +80,70 @@ where
     }
 }
 
-/// Distinct operator changes all weights in the support of a Z-set to 1.
-pub struct Distinct<V, W, Z> {
-    _type: PhantomData<(V, W, Z)>,
+impl<P, Z> Stream<Circuit<P>, Z>
+where
+    P: Clone + 'static,
+{
+    // TODO: Rename this method.
+    // TODO: Document it better (we need a better framework to explain nested
+    // incremental computations).
+    /// Incremental nested version of the [`Distinct`] operator.
+    ///
+    /// This implementation integrates the input stream into a trace and should
+    /// be more CPU and memory efficient than
+    /// [`Stream::distinct_incremental_nested`].
+    pub fn distinct_trace(&self) -> Stream<Circuit<P>, Z>
+    where
+        Z: NumEntries + ZSet + DeepSizeOf,
+        Z::Key: Clone + Ord + DeepSizeOf,
+        Z::R: ZRingValue + DeepSizeOf,
+    {
+        self.circuit()
+            .cache_get_or_insert_with(DistinctTraceId::new(self.local_node_id()), || {
+                self.circuit().add_binary_operator(
+                    DistinctTrace::new(),
+                    self,
+                    &self
+                        .trace::<OrdKeySpine<Z::Key, NestedTimestamp32, Z::R>>()
+                        .delay_trace(),
+                )
+            })
+            .clone()
+    }
+}
+
+/// `Distinct` operator changes all weights in the support of a Z-set to 1.
+pub struct Distinct<Z> {
+    _type: PhantomData<Z>,
 }
 
-impl<V, W, Z> Distinct<V, W, Z> {
+impl<Z> Distinct<Z> {
     pub fn new() -> Self {
         Self { _type: PhantomData }
     }
 }
 
-impl<V, W, Z> Default for Distinct<V, W, Z> {
+impl<Z> Default for Distinct<Z> {
     fn default() -> Self {
         Self::new()
     }
 }
 
-impl<V, W, Z> Operator for Distinct<V, W, Z>
+impl<Z> Operator for Distinct<Z>
 where
-    V: 'static,
-    W: 'static,
     Z: 'static,
 {
     fn name(&self) -> Cow<'static, str> {
         Cow::from("Distinct")
     }
-    fn clock_start(&mut self, _scope: Scope) {}
-    fn clock_end(&mut self, _scope: Scope) {}
+    fn fixedpoint(&self) -> bool {
+        true
+    }
 }
 
-impl<V, W, Z> UnaryOperator<Z, Z> for Distinct<V, W, Z>
+impl<Z> UnaryOperator<Z, Z> for Distinct<Z>
 where
-    V: KeyProperties,
-    W: ZRingValue,
-    Z: ZSet<V, W> + 'static,
+    Z: ZSet,
 {
     fn eval(&mut self, i: &Z) -> Z {
         i.distinct()
@@ -125,86 +160,402 @@ where
 /// value of `A`: `z^-1(A) = a.integrate().delay()` and computes
 /// `distinct(A) - distinct(z^-1(A))` incrementally, by only considering
 /// values in the support of `a`.
-struct DistinctIncremental<V, W, Z> {
-    _type: PhantomData<(V, W, Z)>,
+struct DistinctIncremental<Z> {
+    _type: PhantomData<Z>,
 }
 
-impl<V, W, Z> DistinctIncremental<V, W, Z> {
+impl<Z> DistinctIncremental<Z> {
     pub fn new() -> Self {
         Self { _type: PhantomData }
     }
 }
 
-impl<V, W, Z> Default for DistinctIncremental<V, W, Z> {
+impl<Z> Default for DistinctIncremental<Z> {
     fn default() -> Self {
         Self::new()
     }
 }
 
-impl<V, W, Z> Operator for DistinctIncremental<V, W, Z>
+impl<Z> Operator for DistinctIncremental<Z>
 where
-    V: 'static,
-    W: 'static,
     Z: 'static,
 {
     fn name(&self) -> Cow<'static, str> {
         Cow::from("DistinctIncremental")
     }
-    fn clock_start(&mut self, _scope: Scope) {}
-    fn clock_end(&mut self, _scope: Scope) {}
+    fn fixedpoint(&self) -> bool {
+        true
+    }
 }
 
-impl<V, W, Z> BinaryOperator<Z, Z, Z> for DistinctIncremental<V, W, Z>
+impl<Z> BinaryOperator<Z, Z, Z> for DistinctIncremental<Z>
 where
-    V: KeyProperties,
-    W: ZRingValue,
-    for<'a> &'a Z: IntoIterator<Item = (&'a V, &'a W)>,
-    Z: ZSet<V, W> + 'static,
+    Z: ZSet,
+    Z::Key: Clone + PartialEq,
+    Z::R: ZRingValue,
 {
     fn eval(&mut self, delta: &Z, delayed_integral: &Z) -> Z {
-        let mut result = Z::empty();
-
-        for (v, w) in delta.into_iter() {
-            let old_weight = delayed_integral.lookup(v);
-            let new_weight = old_weight.clone() + w.clone();
+        let mut builder = Z::Builder::with_capacity((), delta.len());
+        let mut delta_cursor = delta.cursor();
+        let mut integral_cursor = delayed_integral.cursor();
+
+        while delta_cursor.key_valid(delta) {
+            let v = delta_cursor.key(delta);
+            let w = delta_cursor.weight(delta);
+            integral_cursor.seek_key(delayed_integral, v);
+            let old_weight = if integral_cursor.key_valid(delayed_integral)
+                && integral_cursor.key(delayed_integral) == v
+            {
+                integral_cursor.weight(delayed_integral).clone()
+            } else {
+                HasZero::zero()
+            };
+
+            let new_weight = old_weight.add_by_ref(w);
 
             if old_weight.le0() {
                 // Weight changes from non-positive to positive.
                 if new_weight.ge0() && !new_weight.is_zero() {
-                    result.increment(v, W::one());
+                    builder.push((v.clone(), (), HasOne::one()));
                 }
             } else if new_weight.le0() {
                 // Weight changes from positive to non-positive.
-                result.increment(v, W::one().neg());
+                builder.push((v.clone(), (), Z::R::one().neg()));
             }
+            delta_cursor.step_key(delta);
         }
 
-        result
+        builder.done()
     }
 
+    // TODO: owned implementation.
     fn eval_owned_and_ref(&mut self, delta: Z, delayed_integral: &Z) -> Z {
-        let mut result = Z::empty();
+        self.eval(&delta, delayed_integral)
+    }
+
+    fn eval_owned(&mut self, delta: Z, delayed_integral: Z) -> Z {
+        self.eval_owned_and_ref(delta, &delayed_integral)
+    }
+}
 
-        for (v, w) in delta.into_iter() {
-            let old_weight = delayed_integral.lookup(&v);
-            let new_weight = old_weight.clone() + w;
+pub struct DistinctTrace<Z, T>
+where
+    Z: ZSet,
+    T: TraceReader<Key = Z::Key, Val = (), R = Z::R> + 'static,
+{
+    // Keeps track of keys that need to be considered at future times.
+    // Specifically, `future_updates[i]` accumulates all keys observed during
+    // the current epoch whose weight can change at time `i`.
+    future_updates: Vec<BTreeSet<Z::Key>>,
+    // TODO: not needed once timekeeping is handled by the circuit.
+    time: u32,
+    empty_input: bool,
+    empty_output: bool,
+    _type: PhantomData<(Z, T)>,
+}
 
-            if old_weight.le0() {
-                // Weight changes from non-positive to positive.
-                if new_weight.ge0() && !new_weight.is_zero() {
-                    result.increment_owned(v, W::one());
+impl<Z, T> DistinctTrace<Z, T>
+where
+    Z: ZSet,
+    T: TraceReader<Key = Z::Key, Val = (), R = Z::R> + 'static,
+    T::Time: Timestamp,
+{
+    fn new() -> Self {
+        Self {
+            future_updates: Vec::new(),
+            time: HasZero::zero(),
+            empty_input: false,
+            empty_output: false,
+            _type: PhantomData,
+        }
+    }
+}
+
+impl<Z, T> DistinctTrace<Z, T>
+where
+    Z: ZSet,
+    Z::Key: Clone + Ord + PartialEq,
+    Z::R: ZRingValue,
+    T: TraceReader<Key = Z::Key, Val = (), Time = NestedTimestamp32, R = Z::R> + 'static,
+{
+    // Evaluate nested incremental distinct for a single value.
+    //
+    // In the following diagram,
+    //
+    // * `w1` - the sum of weights with which `value` appears in previous epochs at
+    //   times `t < self.time`.
+    // * `w2` - the sum of weight with which `value` appers in previous epochs at
+    //   time `self.time`.
+    // * `w3` - the sum of weights with which `value` appears in the current epoch
+    //   at times `t < self.time`.
+    // * `w4` - the weight with which `value` appears in the current epoch at times
+    //   `self.time`, i.e., in the current input `delta` being processed.
+    //
+    // ```
+    // ┌─────────────────────┬─────┐
+    // │                     │     │
+    // │                     │     │
+    // │         w1          │  w2 │
+    // │                     │     │
+    // │                     │     │
+    // ├─────────────────────┼─────┤
+    // │         w3          │  w4 │
+    // └─────────────────────┴─────┘
+    // ```
+    //
+    // Then `value` is added to the output batch with weight
+    // `w_output = delta_new - delta_old` where
+    //
+    // ```
+    // delta_old = if w1 <= 0 && w1 + w2 > 0 {
+    //      1
+    // } else if w1 > 0 && w1 + w2 <= 0 {
+    //     -1
+    // } else {
+    //      0
+    // }
+    //
+    // delta_new = if w1 + w3 <= 0 && w1 + w2 + w3 + w4 > 0 {
+    //      1
+    // } else if w1 + w3 > 0 && w1 + w2 + w3 + w4 <= 0 {
+    //      -1
+    // } else {
+    //      0
+    // }
+    // ```
+    //
+    // This is just the definition of `(↑((↑distinct)∆))∆`.
+    #[allow(clippy::type_complexity)]
+    fn eval_value(
+        &mut self,
+        trace_cursor: &mut T::Cursor,
+        trace_storage: &<T::Cursor as TraceCursor<T::Key, (), T::Time, T::R>>::Storage,
+        value: &Z::Key,
+        weight: &Z::R,
+        output: &mut Vec<((Z::Key, ()), Z::R)>,
+    ) {
+        //eprintln!("value: {:?}, weight: {:?}", value, weight);
+        trace_cursor.seek_key(trace_storage, value);
+
+        if trace_cursor.key_valid(trace_storage) && trace_cursor.key(trace_storage) == value {
+            let mut w1: Z::R = HasZero::zero();
+            let mut w2: Z::R = HasZero::zero();
+            let mut w3: Z::R = HasZero::zero();
+            let mut next_ts: Option<T::Time> = None;
+            trace_cursor.map_times(trace_storage, |t, w| {
+                if !t.epoch() {
+                    if t.inner() < self.time {
+                        w1.add_assign_by_ref(w);
+                    } else if t.inner() == self.time {
+                        w2.add_assign_by_ref(w);
+                    } else if next_ts.is_none() || t < next_ts.as_ref().unwrap() {
+                        next_ts = Some(t.clone());
+                    }
+                } else if t.inner() < self.time {
+                    w3.add_assign_by_ref(w);
                 }
-            } else if new_weight.le0() {
-                // Weight changes from positive to non-positive.
-                result.increment_owned(v, W::one().neg());
+            });
+
+            //eprintln!("w1: {:?}, w2: {:?}, w3: {:?}", w1, w2, w3);
+            // w1 + w2
+            let w12 = w1.add_by_ref(&w2);
+            // w1 + w3
+            let w13 = w1.add_by_ref(&w3);
+            // w1 + w2 + w3 + w4
+            let w1234 = w12.add_by_ref(&w3).add_by_ref(weight);
+
+            let delta_old = if w1.le0() && w12.ge0() && !w12.is_zero() {
+                HasOne::one()
+            } else if w1.ge0() && !w1.is_zero() && w12.le0() {
+                Z::R::one().neg()
+            } else {
+                HasZero::zero()
+            };
+
+            let delta_new = if w13.le0() && w1234.ge0() && !w1234.is_zero() {
+                HasOne::one()
+            } else if w13.ge0() && !w13.is_zero() && w1234.le0() {
+                Z::R::one().neg()
+            } else {
+                HasZero::zero()
+            };
+
+            // Update output.
+            if delta_old != delta_new {
+                output.push(((value.clone(), ()), delta_new + delta_old.neg()));
+            }
+
+            // Record next_ts in `self.future_updates`.
+            if let Some(next_ts) = next_ts {
+                let idx: usize = next_ts.inner() as usize;
+                self.future_updates[idx].insert(value.clone());
             }
+        } else if weight.ge0() && !weight.is_zero() {
+            output.push(((value.clone(), ()), HasOne::one()));
         }
+    }
+}
 
-        result
+impl<Z, T> Operator for DistinctTrace<Z, T>
+where
+    Z: ZSet,
+    Z::Key: DeepSizeOf + Clone + Ord + PartialEq,
+    T: TraceReader<Key = Z::Key, Val = (), Time = NestedTimestamp32, R = Z::R> + 'static,
+{
+    fn name(&self) -> Cow<'static, str> {
+        Cow::from("DistinctTrace")
+    }
+    fn clock_start(&mut self, scope: Scope) {
+        if scope == 0 {
+            self.time = 0;
+        }
+    }
+    fn clock_end(&mut self, scope: Scope) {
+        if scope == 0 {
+            self.future_updates.clear();
+            self.empty_input = false;
+            self.empty_output = false;
+        }
+    }
+    fn fixedpoint(&self) -> bool {
+        self.empty_input
+            && self.empty_output
+            && self
+                .future_updates
+                .iter()
+                .skip(self.time as usize)
+                .all(|vals| vals.is_empty())
     }
 
-    fn eval_owned(&mut self, delta: Z, delayed_integral: Z) -> Z {
-        self.eval_owned_and_ref(delta, &delayed_integral)
+    fn summary(&self, summary: &mut String) {
+        let size: usize = self.future_updates.iter().map(|vals| vals.len()).sum();
+        writeln!(summary, "size: {}", size).unwrap();
+
+        let bytes = self.future_updates.deep_size_of();
+        writeln!(summary, "bytes: {}", bytes).unwrap();
+    }
+}
+
+impl<Z, T> BinaryOperator<Z, T, Z> for DistinctTrace<Z, T>
+where
+    Z: ZSet,
+    Z::Key: Clone + Ord + PartialEq + DeepSizeOf,
+    Z::R: ZRingValue,
+    T: Trace<Key = Z::Key, Val = (), Time = NestedTimestamp32, R = Z::R> + 'static,
+{
+    // Distinct does not have nice properties like linearity that help with
+    // incremental evaluation: computing an update for each key requires inspecting
+    // the entire history of this key.  Fortunately, we do not need to look at all
+    // keys in the trace.  In particular, only those keys that appeared in input
+    // deltas during the current clock epoch can appear in the output of this
+    // operator with non-zero weights.  So, as a simple heuristic, we could track
+    // the set of keys that appeared since the start of the epoch and only consider
+    // those.
+    //
+    // But we can restrict the set of keys to consider even more by using a stronger
+    // property: only the keys `k` that satisfy one of the following conditions can
+    // appear in the output of the operator at local time `t`:
+    // * keys in the current input `delta`
+    // * keys from earlier inputs observed during the current clock epoch that
+    //   appeared in one of the previous epochs at time `t`.
+    //
+    // To efficiently compute keys that satisfy the second condition, we use the
+    // `future_updates` vector, where for each key observed in the current epoch
+    // at time `t1` we lookup the smallest time `t2 > t1` (if any) at which we saw
+    // the key during any previous epochs and record this key in
+    // `future_updates[t2]`. Then when evaluating an operatpr at time `t` we
+    // simply scan all keys in `delta` and all keys in `future_updates[t]` for
+    // candidates.
+    //
+    // TODO: Add example.
+    //
+    fn eval(&mut self, delta: &Z, trace: &T) -> Z {
+        //eprintln!("distinct_trace {}", self.time);
+
+        self.empty_input = delta.is_zero();
+
+        // Make sure we have enough room in `future_updates` to
+        // accommodate the largest timestamp in the trace, so we don't
+        // need to worry about growing `future_updates` later on.
+        let mut new_len: u32 = self.time + 1;
+        trace.map_batches(|batch| {
+            for ts in batch.upper().elements().iter() {
+                new_len = max(new_len, ts.inner() + 1);
+            }
+        });
+
+        self.future_updates
+            .resize(new_len as usize, BTreeSet::new());
+
+        let mut batch = Vec::with_capacity(delta.len());
+
+        let (mut trace_cursor, trace_storage) = trace.cursor();
+
+        // For all keys in delta, for all keys in future_updates[time].
+        let mut delta_cursor = delta.cursor();
+        let candidates = take(&mut self.future_updates[self.time as usize]);
+        let mut cand_iterator = candidates.iter();
+
+        let mut candidate = cand_iterator.next();
+
+        // Iterate over keys that appear in either `future_updates[self.time]` or
+        // `delta`.
+        while delta_cursor.key_valid(delta) && candidate.is_some() {
+            let cand_val = candidate.unwrap();
+            let k = delta_cursor.key(delta);
+            let w = delta_cursor.weight(delta);
+            match k.cmp(cand_val) {
+                // Key only appears in `delta`.
+                Ordering::Less => {
+                    self.eval_value(&mut trace_cursor, &trace_storage, k, w, &mut batch);
+                    delta_cursor.step_key(delta);
+                }
+                // Key only appears in `future_updates`.
+                Ordering::Greater => {
+                    self.eval_value(
+                        &mut trace_cursor,
+                        &trace_storage,
+                        cand_val,
+                        &HasZero::zero(),
+                        &mut batch,
+                    );
+                    candidate = cand_iterator.next();
+                }
+                // Key appears in both `delta` and `future_updates`.
+                Ordering::Equal => {
+                    self.eval_value(&mut trace_cursor, &trace_storage, k, w, &mut batch);
+                    delta_cursor.step_key(delta);
+                    candidate = cand_iterator.next();
+                }
+            }
+        }
+
+        // One of the cursors is empty; iterate over whatever remains in the other
+        // cursor.
+
+        while delta_cursor.key_valid(delta) {
+            let k = delta_cursor.key(delta);
+            let w = delta_cursor.weight(delta);
+
+            self.eval_value(&mut trace_cursor, &trace_storage, k, w, &mut batch);
+            delta_cursor.step_key(delta);
+        }
+        while candidate.is_some() {
+            self.eval_value(
+                &mut trace_cursor,
+                &trace_storage,
+                candidate.unwrap(),
+                &HasZero::zero(),
+                &mut batch,
+            );
+            candidate = cand_iterator.next();
+        }
+
+        self.time += 1;
+
+        let result = Z::from_tuples((), batch);
+        self.empty_output = result.is_zero();
+        result
     }
 }
 
@@ -213,28 +564,85 @@ mod test {
     use std::{cell::RefCell, rc::Rc};
 
     use crate::{
-        algebra::FiniteHashMap,
         circuit::Root,
-        finite_map,
         operator::{Apply2, GeneratorNested},
+        trace::ord::OrdZSet,
+        zset,
     };
 
     #[test]
     fn distinct_incremental_nested_test() {
         let root = Root::build(move |circuit| {
             let mut inputs = vec![
+                vec![zset! { 1 => 1, 2 => 1 }, zset! { 2 => -1, 3 => 2, 4 => 2 }],
+                vec![zset! { 2 => 1, 3 => 1 }, zset! { 3 => -2, 4 => -1 }],
                 vec![
-                    finite_map! { 1 => 1, 2 => 1 },
-                    finite_map! { 2 => -1, 3 => 2, 4 => 2 },
-                ],
-                vec![
-                    finite_map! { 2 => 1, 3 => 1 },
-                    finite_map! { 3 => -2, 4 => -1 },
+                    zset! { 5 => 1, 6 => 1 },
+                    zset! { 2 => -1, 7 => 1 },
+                    zset! { 2 => 1, 7 => -1, 8 => 2, 9 => 1 },
                 ],
+            ]
+            .into_iter();
+
+            circuit
+                .iterate(|child| {
+                    let counter = Rc::new(RefCell::new(0));
+                    let counter_clone = counter.clone();
+
+                    let input = child.add_source(GeneratorNested::new(Box::new(move || {
+                        *counter_clone.borrow_mut() = 0;
+                        let mut deltas = inputs.next().unwrap_or_else(Vec::new).into_iter();
+                        Box::new(move || deltas.next().unwrap_or_else(|| zset! {}))
+                    })));
+
+                    let distinct_inc = input.distinct_incremental_nested();
+                    let distinct_noninc = input
+                        // Non-incremental implementation of distinct_nested_incremental.
+                        .integrate()
+                        .integrate_nested()
+                        .distinct()
+                        .differentiate()
+                        .differentiate_nested();
+
+                    child
+                        .add_binary_operator(
+                            Apply2::new(
+                                |d1: &OrdZSet<usize, isize>, d2: &OrdZSet<usize, isize>| {
+                                    (d1.clone(), d2.clone())
+                                },
+                            ),
+                            &distinct_inc,
+                            &distinct_noninc,
+                        )
+                        .inspect(|(d1, d2)| assert_eq!(d1, d2));
+
+                    Ok((
+                        move || {
+                            *counter.borrow_mut() += 1;
+                            *counter.borrow() == 4
+                        },
+                        (),
+                    ))
+                })
+                .unwrap();
+        })
+        .unwrap();
+
+        for _ in 0..3 {
+            root.step().unwrap();
+        }
+    }
+
+    #[test]
+    fn distinct_trace_test() {
+        let root = Root::build(move |circuit| {
+            let mut inputs = vec![
+                vec![zset! { 1 => 1, 2 => 1 }, zset! { 2 => -1, 3 => 2, 4 => 2 }],
+                vec![zset! { 2 => 1, 3 => 1 }, zset! { 3 => -2, 4 => -1 }],
                 vec![
-                    finite_map! { 5 => 1, 6 => 1 },
-                    finite_map! { 2 => -1, 7 => 1 },
-                    finite_map! { 2 => 1, 7 => -1, 8 => 2, 9 => 1 },
+                    zset! { 5 => 1, 6 => 1 },
+                    zset! { 2 => -1, 7 => 1 },
+                    zset! { 2 => 1, 7 => -1, 8 => 2, 9 => 1 },
                 ],
             ]
             .into_iter();
@@ -247,10 +655,10 @@ mod test {
                     let input = child.add_source(GeneratorNested::new(Box::new(move || {
                         *counter_clone.borrow_mut() = 0;
                         let mut deltas = inputs.next().unwrap_or_else(Vec::new).into_iter();
-                        Box::new(move || deltas.next().unwrap_or_else(|| finite_map! {}))
+                        Box::new(move || deltas.next().unwrap_or_else(|| zset! {}))
                     })));
 
-                    let distinct_inc = input.distinct_incremental_nested();
+                    let distinct_inc = input.distinct_trace();
                     let distinct_noninc = input
                         // Non-incremental implementation of distinct_nested_incremental.
                         .integrate()
@@ -262,8 +670,7 @@ mod test {
                     child
                         .add_binary_operator(
                             Apply2::new(
-                                |d1: &FiniteHashMap<usize, isize>,
-                                 d2: &FiniteHashMap<usize, isize>| {
+                                |d1: &OrdZSet<usize, isize>, d2: &OrdZSet<usize, isize>| {
                                     (d1.clone(), d2.clone())
                                 },
                             ),
diff --git a/src/operator/filter.rs b/src/operator/filter.rs
index 90233e60..0acf22b7 100644
--- a/src/operator/filter.rs
+++ b/src/operator/filter.rs
@@ -1,25 +1,26 @@
 //! Filtering operators.
 
-use crate::circuit::{
-    operator_traits::{Operator, UnaryOperator},
-    Circuit, Scope, Stream,
+use crate::{
+    circuit::{
+        operator_traits::{Operator, UnaryOperator},
+        Circuit, Stream,
+    },
+    trace::{Batch, BatchReader, Builder, Cursor},
 };
 use std::{borrow::Cow, marker::PhantomData};
 
 impl<P, CI> Stream<Circuit<P>, CI>
 where
-    CI: Clone,
+    CI: BatchReader<Time = ()> + Clone + 'static,
+    CI::Key: Clone,
+    CI::Val: Clone,
     P: Clone + 'static,
 {
     /// Apply [`FilterKeys`] operator to `self`.
-    pub fn filter_keys<K, V, CO, F>(&self, func: F) -> Stream<Circuit<P>, CO>
+    pub fn filter_keys<CO, F>(&self, func: F) -> Stream<Circuit<P>, CO>
     where
-        K: Clone + 'static,
-        V: Clone + 'static,
-        CI: IntoIterator<Item = (K, V)> + 'static,
-        for<'a> &'a CI: IntoIterator<Item = (&'a K, &'a V)>,
-        CO: FromIterator<(K, V)> + Clone + 'static,
-        F: Fn(&K) -> bool + 'static,
+        CO: Batch<Key = CI::Key, Val = CI::Val, Time = (), R = CI::R> + Clone + 'static,
+        F: Fn(&CI::Key) -> bool + 'static,
     {
         self.circuit()
             .add_unary_operator(FilterKeys::new(func), self)
@@ -29,25 +30,23 @@ where
 /// Operator that filters a collection of key/value pairs based on keys.
 ///
 /// The operator applies a filtering function to each key in the input
-/// collection and builds an output collection containing only the elements
+/// batch and builds an output batch containing only the elements
 /// that satisfy the filter condition.
 ///
 /// # Type arguments
 ///
-/// * `K` - key type.
-/// * `V` - value type.
 /// * `CI` - input collection type.
 /// * `CO` - output collection type.
 /// * `F` - filtering function type.
-pub struct FilterKeys<K, V, CI, CO, F>
+pub struct FilterKeys<CI, CO, F>
 where
     F: 'static,
 {
     filter: F,
-    _type: PhantomData<(K, V, CI, CO)>,
+    _type: PhantomData<(CI, CO)>,
 }
 
-impl<K, V, CI, CO, F> FilterKeys<K, V, CI, CO, F>
+impl<CI, CO, F> FilterKeys<CI, CO, F>
 where
     F: 'static,
 {
@@ -59,10 +58,8 @@ where
     }
 }
 
-impl<K, V, CI, CO, F> Operator for FilterKeys<K, V, CI, CO, F>
+impl<CI, CO, F> Operator for FilterKeys<CI, CO, F>
 where
-    K: 'static,
-    V: 'static,
     CI: 'static,
     CO: 'static,
     F: 'static,
@@ -70,32 +67,49 @@ where
     fn name(&self) -> Cow<'static, str> {
         Cow::from("FilterKeys")
     }
-    fn clock_start(&mut self, _scope: Scope) {}
-    fn clock_end(&mut self, _scope: Scope) {}
+    fn fixedpoint(&self) -> bool {
+        true
+    }
 }
 
-impl<K, V, CI, CO, F> UnaryOperator<CI, CO> for FilterKeys<K, V, CI, CO, F>
+impl<CI, CO, F> UnaryOperator<CI, CO> for FilterKeys<CI, CO, F>
 where
-    K: Clone + 'static,
-    V: Clone + 'static,
-    CI: IntoIterator<Item = (K, V)> + 'static,
-    for<'a> &'a CI: IntoIterator<Item = (&'a K, &'a V)>,
-    CO: FromIterator<(K, V)> + 'static,
-    F: Fn(&K) -> bool + 'static,
+    CI: BatchReader<Time = ()> + 'static,
+    CI::Key: Clone,
+    CI::Val: Clone,
+    CO: Batch<Key = CI::Key, Val = CI::Val, Time = (), R = CI::R> + 'static,
+    F: Fn(&CI::Key) -> bool + 'static,
 {
     fn eval(&mut self, i: &CI) -> CO {
-        i.into_iter()
-            .filter_map(|(k, v)| {
-                if (self.filter)(k) {
-                    Some((k.clone(), v.clone()))
-                } else {
-                    None
+        let mut cursor = i.cursor();
+
+        // We can use Builder because cursor yields ordered values.  This
+        // is a nice property of the filter operation.
+
+        // This will create waste if most tuples get filtered out, since
+        // the buffers allocated here can make it all the way to the output batch.
+        // This is probably ok, because the batch will either get freed at the end
+        // of the current clock tick or get added to the trace, where it will likely
+        // get merged with other batches soon, at which point the waste is gone.
+        let mut builder = CO::Builder::with_capacity((), i.len());
+
+        while cursor.key_valid(i) {
+            let k = cursor.key(i);
+            if (self.filter)(k) {
+                while cursor.val_valid(i) {
+                    let val = cursor.val(i);
+                    let w = cursor.weight(i);
+                    builder.push((k.clone(), val.clone(), w.clone()));
+                    cursor.step_val(i);
                 }
-            })
-            .collect()
+            }
+            cursor.step_key(i);
+        }
+        builder.done()
     }
 
     fn eval_owned(&mut self, i: CI) -> CO {
-        i.into_iter().filter(|(k, _v)| (self.filter)(k)).collect()
+        // TODO: owned implementation
+        self.eval(&i)
     }
 }
diff --git a/src/operator/filter_map.rs b/src/operator/filter_map.rs
index 68d9949d..4fe4b1e4 100644
--- a/src/operator/filter_map.rs
+++ b/src/operator/filter_map.rs
@@ -3,9 +3,9 @@
 use crate::{
     circuit::{
         operator_traits::{Operator, UnaryOperator},
-        Circuit, Scope, Stream,
+        Circuit, Stream,
     },
-    RefPair,
+    trace::{Batch, BatchReader, Cursor},
 };
 use std::{borrow::Cow, marker::PhantomData};
 
@@ -17,16 +17,13 @@ where
     /// Apply [`FilterMapKeys`] operator to `self`.
     ///
     /// The `func` closure takes input keys by reference.
-    pub fn filter_map_keys<K1, K2, V, CO, F>(&self, func: F) -> Stream<Circuit<P>, CO>
+    pub fn filter_map_keys<CO, F>(&self, func: F) -> Stream<Circuit<P>, CO>
     where
-        K1: Clone + 'static,
-        K2: Clone + 'static,
-        V: Clone + 'static,
-        CI: IntoIterator<Item = (K1, V)> + 'static,
-        for<'a> &'a CI: IntoIterator,
-        for<'a> <&'a CI as IntoIterator>::Item: RefPair<'a, K1, V>,
-        CO: FromIterator<(K2, V)> + Clone + 'static,
-        F: Fn(&K1) -> Option<K2> + Clone + 'static,
+        CI: BatchReader<Time = ()> + 'static,
+        CI::Val: Clone,
+        CO: Batch<Val = CI::Val, Time = (), R = CI::R> + Clone + 'static,
+        CO::Key: Clone,
+        F: Fn(&CI::Key) -> Option<CO::Key> + Clone + 'static,
     {
         self.circuit()
             .add_unary_operator(FilterMapKeys::new(func.clone(), move |x| (func)(&x)), self)
@@ -35,66 +32,57 @@ where
     /// Apply [`FilterMapKeys`] operator to `self`.
     ///
     /// The `func` closure operates on owned keys.
-    pub fn filter_map_keys_owned<K1, K2, V, CO, F>(&self, func: F) -> Stream<Circuit<P>, CO>
+    pub fn filter_map_keys_owned<CO, F>(&self, func: F) -> Stream<Circuit<P>, CO>
     where
-        K1: Clone + 'static,
-        K2: Clone + 'static,
-        V: Clone + 'static,
-        CI: IntoIterator<Item = (K1, V)> + 'static,
-        for<'a> &'a CI: IntoIterator,
-        for<'a> <&'a CI as IntoIterator>::Item: RefPair<'a, K1, V>,
-        CO: FromIterator<(K2, V)> + Clone + 'static,
-        F: Fn(K1) -> Option<K2> + Clone + 'static,
+        CI: BatchReader<Time = ()> + 'static,
+        CI::Key: Clone,
+        CI::Val: Clone,
+        CO: Batch<Val = CI::Val, Time = (), R = CI::R> + Clone + 'static,
+        CO::Key: Clone,
+        F: Fn(CI::Key) -> Option<CO::Key> + Clone + 'static,
     {
         let func_clone = func.clone();
         self.circuit().add_unary_operator(
-            FilterMapKeys::new(move |x: &K1| (func)(x.clone()), func_clone),
+            FilterMapKeys::new(move |x: &CI::Key| (func)(x.clone()), func_clone),
             self,
         )
     }
 }
 
-/// Operator that both filters and maps keys in a collection of key/value
-/// pairs.
+/// Operator that both filters and maps keys in a batch.
 ///
 /// # Type arguments
 ///
-/// * `K1` - input key type.
-/// * `K2` - output key type.
-/// * `V` - value type.
-/// * `CI` - input collection type.
-/// * `CO` - output collection type.
+/// * `CI` - input batch type.
+/// * `CO` - output batch type.
 /// * `FB` - key mapping function type that takes a borrowed key.
 /// * `FO` - key mapping function type that takes an owned key.
-pub struct FilterMapKeys<K1, K2, V, CI, CO, FB, FO>
+pub struct FilterMapKeys<CI, CO, FB, FO>
 where
     FB: 'static,
     FO: 'static,
 {
     map_borrowed: FB,
-    map_owned: FO,
-    _type: PhantomData<(K1, K2, V, CI, CO)>,
+    _map_owned: FO,
+    _type: PhantomData<(CI, CO)>,
 }
 
-impl<K1, K2, V, CI, CO, FB, FO> FilterMapKeys<K1, K2, V, CI, CO, FB, FO>
+impl<CI, CO, FB, FO> FilterMapKeys<CI, CO, FB, FO>
 where
     FB: 'static,
     FO: 'static,
 {
-    pub fn new(map_borrowed: FB, map_owned: FO) -> Self {
+    pub fn new(map_borrowed: FB, _map_owned: FO) -> Self {
         Self {
             map_borrowed,
-            map_owned,
+            _map_owned,
             _type: PhantomData,
         }
     }
 }
 
-impl<K1, K2, V, CI, CO, FB, FO> Operator for FilterMapKeys<K1, K2, V, CI, CO, FB, FO>
+impl<CI, CO, FB, FO> Operator for FilterMapKeys<CI, CO, FB, FO>
 where
-    K1: 'static,
-    K2: 'static,
-    V: 'static,
     CI: 'static,
     CO: 'static,
     FB: 'static,
@@ -103,34 +91,41 @@ where
     fn name(&self) -> Cow<'static, str> {
         Cow::from("FilterMapKeys")
     }
-    fn clock_start(&mut self, _scope: Scope) {}
-    fn clock_end(&mut self, _scope: Scope) {}
+    fn fixedpoint(&self) -> bool {
+        true
+    }
 }
 
-impl<K1, K2, V, CI, CO, FB, FO> UnaryOperator<CI, CO> for FilterMapKeys<K1, K2, V, CI, CO, FB, FO>
+impl<CI, CO, FB, FO> UnaryOperator<CI, CO> for FilterMapKeys<CI, CO, FB, FO>
 where
-    K1: Clone + 'static,
-    K2: Clone + 'static,
-    V: Clone + 'static,
-    CI: IntoIterator<Item = (K1, V)> + 'static,
-    for<'a> &'a CI: IntoIterator,
-    for<'a> <&'a CI as IntoIterator>::Item: RefPair<'a, K1, V>,
-    CO: FromIterator<(K2, V)> + 'static,
-    FB: Fn(&K1) -> Option<K2> + 'static,
-    FO: Fn(K1) -> Option<K2> + 'static,
+    CI: BatchReader<Time = ()> + 'static,
+    CI::Val: Clone,
+    CO: Batch<Val = CI::Val, Time = (), R = CI::R> + 'static,
+    CO::Key: Clone,
+    FB: Fn(&CI::Key) -> Option<CO::Key> + 'static,
+    FO: Fn(CI::Key) -> Option<CO::Key> + 'static,
 {
     fn eval(&mut self, i: &CI) -> CO {
-        i.into_iter()
-            .filter_map(|pair| {
-                let (k, v) = pair.into_refs();
-                (self.map_borrowed)(k).map(|k| (k, v.clone()))
-            })
-            .collect()
+        let mut cursor = i.cursor();
+        let mut batch = Vec::with_capacity(i.len());
+        while cursor.key_valid(i) {
+            let k = cursor.key(i);
+            if let Some(k2) = (self.map_borrowed)(k) {
+                while cursor.val_valid(i) {
+                    let v = cursor.val(i);
+                    let w = cursor.weight(i);
+                    batch.push(((k2.clone(), v.clone()), w.clone()));
+                    cursor.step_val(i);
+                }
+            }
+            cursor.step_key(i);
+        }
+
+        CO::from_tuples((), batch)
     }
 
     fn eval_owned(&mut self, i: CI) -> CO {
-        i.into_iter()
-            .filter_map(|(k, v)| (self.map_owned)(k).map(|k| (k, v)))
-            .collect()
+        // TODO: owned implementation.
+        self.eval(&i)
     }
 }
diff --git a/src/operator/generator.rs b/src/operator/generator.rs
index 453b9c13..53ce6552 100644
--- a/src/operator/generator.rs
+++ b/src/operator/generator.rs
@@ -35,8 +35,9 @@ where
     fn name(&self) -> Cow<'static, str> {
         Cow::from("Generator")
     }
-    fn clock_start(&mut self, _scope: Scope) {}
-    fn clock_end(&mut self, _scope: Scope) {}
+    fn fixedpoint(&self) -> bool {
+        false
+    }
 }
 
 impl<T, F> SourceOperator<T> for Generator<T, F>
@@ -83,7 +84,12 @@ where
             self.generator = Some((self.reset)());
         }
     }
-    fn clock_end(&mut self, _scope: Scope) {}
+
+    fn fixedpoint(&self) -> bool {
+        // TODO: do we want a version of `GeneratorNested` that
+        // can inform the circuit that it's reached a fixedpoint?
+        false
+    }
 }
 
 impl<T> SourceOperator<T> for GeneratorNested<T>
diff --git a/src/operator/index.rs b/src/operator/index.rs
index 4cc61b37..41ec71be 100644
--- a/src/operator/index.rs
+++ b/src/operator/index.rs
@@ -1,12 +1,13 @@
 //! Index operator.
 
 use crate::{
-    algebra::{finite_map::KeyProperties, IndexedZSet, MapBuilder, ZRingValue},
+    algebra::{IndexedZSet, ZRingValue, ZSet},
     circuit::{
         operator_traits::{Operator, UnaryOperator},
-        Circuit, NodeId, Scope, Stream,
+        Circuit, NodeId, Stream,
     },
-    circuit_cache_key, RefPair, SharedRef,
+    circuit_cache_key,
+    trace::{cursor::Cursor, ord::OrdZSet, Batch, Builder},
 };
 use std::{borrow::Cow, marker::PhantomData};
 
@@ -18,15 +19,12 @@ where
     P: Clone + 'static,
 {
     /// Apply [`Index`] operator to `self`.
-    pub fn index<K, V, W, CO>(&self) -> Stream<Circuit<P>, CO>
+    pub fn index<CO>(&self) -> Stream<Circuit<P>, CO>
     where
-        K: KeyProperties,
-        V: KeyProperties,
-        W: ZRingValue,
-        CI: IntoIterator<Item = ((K, V), W)> + 'static,
-        for<'a> &'a CI: IntoIterator,
-        for<'a> <&'a CI as IntoIterator>::Item: RefPair<'a, (K, V), W>,
-        CO: IndexedZSet<K, V, W>,
+        CI: ZSet<Key = (CO::Key, CO::Val), Time = (), R = CO::R> + 'static,
+        CO: IndexedZSet<Time = ()>,
+        CO::Key: Clone,
+        CO::Val: Clone,
     {
         self.circuit()
             .cache_get_or_insert_with(IndexId::new(self.local_node_id()), || {
@@ -35,20 +33,17 @@ where
             .clone()
     }
 
-    pub fn index_with<V1, K, V2, W, CO, F>(&self, f: F) -> Stream<Circuit<P>, CO>
+    pub fn index_with<CO, F>(&self, f: F) -> Stream<Circuit<P>, CO>
     where
-        V1: KeyProperties,
-        K: KeyProperties,
-        V2: KeyProperties,
-        W: ZRingValue,
-        CI: SharedRef + 'static,
-        CI::Target: IntoIterator<Item = (V1, W)>,
-        for<'a> &'a CI::Target: IntoIterator,
-        for<'a> <&'a CI::Target as IntoIterator>::Item: RefPair<'a, V1, W>,
-        F: Fn(&V1) -> (K, V2) + Clone + 'static,
-        CO: IndexedZSet<K, V2, W>,
+        CI: ZSet<Time = (), R = CO::R> + 'static,
+        CO: IndexedZSet<Time = ()>,
+        CO::Key: Clone + Ord,
+        CO::Val: Clone + Ord,
+        CO::R: ZRingValue,
+        F: Fn(&CI::Key) -> (CO::Key, CO::Val) + Clone + 'static,
     {
-        self.map_keys::<_, _, _, Vec<_>, _>(f).index()
+        // TODO: implement UnorderedLeaf trie backed by an unsorted vector.
+        self.map_keys::<OrdZSet<_, _>, _>(f).index()
     }
 }
 
@@ -56,108 +51,100 @@ where
 ///
 /// The input of the operator is a Z-set where the value type is
 /// a key/value pair.  The output is an indexed representation of
-/// the Z-set, i.e., a finite map from keys to Z-sets of
-/// values associated with each key.
-///
-/// The input Z-set can be represented by any type that can be
-/// converted into a sequence of `((key, value), weight)` pairs.
+/// the Z-set.
 ///
 /// # Type arguments
 ///
-/// * `K` - key type.
-/// * `V` - value type.
-/// * `W` - weight type.
 /// * `CI` - input collection type.
 /// * `CO` - output collection type, a finite map from keys to a Z-set of
 ///   values.
-pub struct Index<K, V, W, CI, CO> {
-    _type: PhantomData<(K, V, W, CI, CO)>,
+pub struct Index<CI, CO> {
+    _type: PhantomData<(CI, CO)>,
 }
 
-impl<K, V, W, CI, CO> Index<K, V, W, CI, CO> {
+impl<CI, CO> Index<CI, CO> {
     pub fn new() -> Self {
         Self { _type: PhantomData }
     }
 }
 
-impl<K, V, W, CI, CO> Default for Index<K, V, W, CI, CO> {
+impl<CI, CO> Default for Index<CI, CO> {
     fn default() -> Self {
         Self::new()
     }
 }
 
-impl<K, V, W, CI, CO> Operator for Index<K, V, W, CI, CO>
+impl<CI, CO> Operator for Index<CI, CO>
 where
-    K: 'static,
-    V: 'static,
-    W: 'static,
     CI: 'static,
     CO: 'static,
 {
     fn name(&self) -> Cow<'static, str> {
         Cow::from("Index")
     }
-    fn clock_start(&mut self, _scope: Scope) {}
-    fn clock_end(&mut self, _scope: Scope) {}
+    fn fixedpoint(&self) -> bool {
+        true
+    }
 }
 
-impl<K, V, W, CI, CO> UnaryOperator<CI, CO> for Index<K, V, W, CI, CO>
+impl<CI, CO> UnaryOperator<CI, CO> for Index<CI, CO>
 where
-    K: KeyProperties,
-    V: KeyProperties,
-    W: ZRingValue,
-    CI: IntoIterator<Item = ((K, V), W)> + 'static,
-    for<'a> &'a CI: IntoIterator,
-    for<'a> <&'a CI as IntoIterator>::Item: RefPair<'a, (K, V), W>,
-    CO: IndexedZSet<K, V, W>,
+    CO: IndexedZSet<Time = ()>,
+    CI: ZSet<Key = (CO::Key, CO::Val), Time = (), R = CO::R> + 'static,
+    CO::Key: Clone,
+    CO::Val: Clone,
 {
     fn eval(&mut self, i: &CI) -> CO {
-        let mut res = CO::empty();
-        for pair in i.into_iter() {
-            let ((k, v), w) = pair.into_refs();
-            res.update(k, |val| val.increment(v, w.clone()));
+        let mut builder = <CO as Batch>::Builder::with_capacity((), i.len());
+
+        let mut cursor = i.cursor();
+        while cursor.key_valid(i) {
+            let (k, v) = cursor.key(i);
+            // TODO: pass key (and value?) by reference
+            let w = cursor.weight(i);
+            builder.push((k.clone(), v.clone(), w.clone()));
+            cursor.step_key(i);
         }
-        res
+        builder.done()
     }
 
     fn eval_owned(&mut self, i: CI) -> CO {
-        let mut res = CO::empty();
-        for ((k, v), w) in i.into_iter() {
-            res.update_owned(k, |val| val.increment_owned(v, w.clone()));
-        }
-        res
+        // TODO: owned implementation.
+        self.eval(&i)
     }
 }
 
 #[cfg(test)]
 mod test {
-    use crate::{algebra::FiniteHashMap, circuit::Root, finite_map, operator::Generator};
+    use crate::{
+        circuit::Root, indexed_zset, operator::Generator, trace::ord::OrdIndexedZSet, zset,
+    };
 
     #[test]
     fn index_sequence() {
         let root = Root::build(move |circuit| {
             let mut inputs = vec![
-                vec![ ((1, "a"), 1)
-                    , ((1, "b"), 1)
-                    , ((2, "a"), 1)
-                    , ((2, "c"), 1)
-                    , ((1, "a"), 2)
-                    , ((1, "b"), -1)
-                ],
-                vec![ ((1, "d"), 1)
-                    , ((1, "e"), 1)
-                    , ((2, "a"), -1)
-                    , ((3, "a"), 2)
-                ],
+                zset!{ (1, "a") => 1
+                     , (1, "a") => 2
+                     , (1, "b") => 1
+                     , (1, "b") => -1
+                     , (2, "a") => 1
+                     , (2, "c") => 1
+                },
+                zset!{ (1, "d") => 1
+                     , (1, "e") => 1
+                     , (2, "a") => -1
+                     , (3, "a") => 2
+                },
             ].into_iter();
             let mut outputs = vec![
-                finite_map!{ 1 => finite_map!{"a" => 3}, 2 => finite_map!{"a" => 1, "c" => 1}},
-                finite_map!{ 1 => finite_map!{"a" => 3, "d" => 1, "e" => 1}, 2 => finite_map!{"c" => 1}, 3 => finite_map!{"a" => 2}},
+                indexed_zset!{ 1 => {"a" => 3}, 2 => {"a" => 1, "c" => 1}},
+                indexed_zset!{ 1 => {"a" => 3, "d" => 1, "e" => 1}, 2 => {"c" => 1}, 3 => {"a" => 2}},
             ].into_iter();
             circuit.add_source(Generator::new(move || inputs.next().unwrap() ))
-                   .index::<_, _, _, FiniteHashMap<_, _>>()
+                   .index::<OrdIndexedZSet<_, _, _>>()
                    .integrate()
-                   .inspect(move |fm: &FiniteHashMap<_, _>| assert_eq!(fm, &outputs.next().unwrap()));
+                   .inspect(move |fm: &OrdIndexedZSet<_, _, _>| assert_eq!(fm, &outputs.next().unwrap()));
         })
         .unwrap();
 
@@ -170,29 +157,27 @@ mod test {
     fn index_zset() {
         let root = Root::build(move |circuit| {
             let mut inputs = vec![
-                finite_map!{
-                      (1, "a") => 1
-                    , (1, "b") => 1
-                    , (2, "a") => 1
-                    , (2, "c") => 1
-                    , (1, "a") => 2
-                    , (1, "b") => -1
+                zset!{ (1, "a") => 1
+                     , (1, "b") => 1
+                     , (2, "a") => 1
+                     , (2, "c") => 1
+                     , (1, "a") => 2
+                     , (1, "b") => -1
                 },
-                finite_map!{
-                      (1, "d") => 1
-                    , (1, "e") => 1
-                    , (2, "a") => -1
-                    , (3, "a") => 2
+                zset!{ (1, "d") => 1
+                     , (1, "e") => 1
+                     , (2, "a") => -1
+                     , (3, "a") => 2
                 },
             ].into_iter();
             let mut outputs = vec![
-                finite_map!{ 1 => finite_map!{"a" => 3}, 2 => finite_map!{"a" => 1, "c" => 1}},
-                finite_map!{ 1 => finite_map!{"a" => 3, "d" => 1, "e" => 1}, 2 => finite_map!{"c" => 1}, 3 => finite_map!{"a" => 2}},
+                indexed_zset!{ 1 => {"a" => 3}, 2 => {"a" => 1, "c" => 1}},
+                indexed_zset!{ 1 => {"a" => 3, "d" => 1, "e" => 1}, 2 => {"c" => 1}, 3 => {"a" => 2}},
             ].into_iter();
             circuit.add_source(Generator::new(move || inputs.next().unwrap() ))
-                   .index::<_, _, _, FiniteHashMap<_, _>>()
+                   .index::<OrdIndexedZSet<_, _, _>>()
                    .integrate()
-                   .inspect(move |fm: &FiniteHashMap<_, _>| assert_eq!(fm, &outputs.next().unwrap()));
+                   .inspect(move |fm: &OrdIndexedZSet<_, _, _>| assert_eq!(fm, &outputs.next().unwrap()));
         })
         .unwrap();
 
diff --git a/src/operator/inspect.rs b/src/operator/inspect.rs
index cdd421da..df0f658c 100644
--- a/src/operator/inspect.rs
+++ b/src/operator/inspect.rs
@@ -3,7 +3,7 @@
 
 use crate::circuit::{
     operator_traits::{Operator, SinkOperator},
-    Circuit, Scope, Stream,
+    Circuit, Stream,
 };
 use std::{borrow::Cow, marker::PhantomData};
 
@@ -71,8 +71,9 @@ where
         Cow::from("Inspect")
     }
 
-    fn clock_start(&mut self, _scope: Scope) {}
-    fn clock_end(&mut self, _scope: Scope) {}
+    fn fixedpoint(&self) -> bool {
+        true
+    }
 }
 
 impl<T, F> SinkOperator<T> for Inspect<T, F>
diff --git a/src/operator/integrate.rs b/src/operator/integrate.rs
index 036cf85e..84e8573b 100644
--- a/src/operator/integrate.rs
+++ b/src/operator/integrate.rs
@@ -6,25 +6,26 @@ use crate::{
     circuit_cache_key,
     operator::{
         z1::{DelayedFeedback, DelayedNestedFeedback},
-        BinaryOperatorAdapter, Plus,
+        Plus,
     },
-    NumEntries, SharedRef,
+    NumEntries,
 };
-use std::{ops::Add, rc::Rc};
+use deepsize::DeepSizeOf;
+use std::ops::Add;
 
 circuit_cache_key!(IntegralId<C, D>(NodeId => Stream<C, D>));
-circuit_cache_key!(NestedIntegralId<C, D>(NodeId => Stream<C, Rc<D>>));
+circuit_cache_key!(NestedIntegralId<C, D>(NodeId => Stream<C, D>));
 
 impl<P, D> Stream<Circuit<P>, D>
 where
     P: Clone + 'static,
-    D: SharedRef + 'static,
-    <D as SharedRef>::Target: Add<Output = D::Target>
+    D: Add<Output = D>
         + AddByRef
         + AddAssignByRef
         + Clone
+        + Eq
         + HasZero
-        + SharedRef<Target = D::Target>
+        + DeepSizeOf
         + NumEntries
         + 'static,
 {
@@ -62,7 +63,7 @@ where
     /// input:  1, 1, 1, 1, 1, ...
     /// output: 1, 2, 3, 4, 5, ...
     /// ```
-    pub fn integrate(&self) -> Stream<Circuit<P>, <D as SharedRef>::Target> {
+    pub fn integrate(&self) -> Stream<Circuit<P>, D> {
         self.circuit()
             .cache_get_or_insert_with(IntegralId::new(self.local_node_id()), || {
                 // Integration circuit:
@@ -87,7 +88,7 @@ where
                 self.circuit().region("integrate", || {
                     let feedback = DelayedFeedback::new(self.circuit());
                     let integral = self.circuit().add_binary_operator_with_preference(
-                        <BinaryOperatorAdapter<D::Target, _>>::new(<Plus<D::Target>>::new()),
+                        <Plus<D>>::new(),
                         feedback.stream(),
                         self,
                         OwnershipPreference::STRONGLY_PREFER_OWNED,
@@ -130,13 +131,13 @@ where
     /// 2 3 4 5 1
     /// 4 5 6 5 1
     /// ```
-    pub fn integrate_nested(&self) -> Stream<Circuit<P>, Rc<D::Target>> {
+    pub fn integrate_nested(&self) -> Stream<Circuit<P>, D> {
         self.circuit()
             .cache_get_or_insert_with(NestedIntegralId::new(self.local_node_id()), || {
                 self.circuit().region("integrate_nested", || {
                     let feedback = DelayedNestedFeedback::new(self.circuit());
                     let integral = self.circuit().add_binary_operator_with_preference(
-                        <BinaryOperatorAdapter<D::Target, _>>::new(Plus::new()),
+                        Plus::new(),
                         feedback.stream(),
                         self,
                         OwnershipPreference::STRONGLY_PREFER_OWNED,
@@ -153,10 +154,12 @@ where
 #[cfg(test)]
 mod test {
     use crate::{
-        algebra::{FiniteMap, MapBuilder, ZSetHashMap},
+        algebra::HasZero,
         circuit::Root,
         monitor::TraceMonitor,
         operator::{DelayedFeedback, Generator},
+        trace::{ord::OrdZSet, Batch},
+        zset,
     };
 
     #[test]
@@ -180,10 +183,10 @@ mod test {
     fn zset_integrate() {
         let root = Root::build(move |circuit| {
             let mut counter1 = 0;
-            let mut s = ZSetHashMap::new();
+            let mut s = <OrdZSet<usize, isize>>::zero();
             let source = circuit.add_source(Generator::new(move || {
                 let res = s.clone();
-                s.increment(&counter1, 1);
+                s = s.merge(&zset! { counter1 => 1});
                 counter1 += 1;
                 res
             }));
@@ -191,19 +194,21 @@ mod test {
             let integral = source.integrate();
             let mut counter2 = 0;
             integral.inspect(move |s| {
+                let mut batch = Vec::with_capacity(counter2);
                 for i in 0..counter2 {
-                    assert_eq!(s.lookup(&i), (counter2 - i) as isize);
+                    batch.push(((i, ()), (counter2 - i) as isize));
                 }
+                assert_eq!(s, &<OrdZSet<_, _>>::from_tuples((), batch));
                 counter2 += 1;
-                assert_eq!(s.lookup(&counter2), 0);
             });
             let mut counter3 = 0;
             integral.delay().inspect(move |s| {
+                let mut batch = Vec::with_capacity(counter2);
                 for i in 1..counter3 {
-                    assert_eq!(s.lookup(&(i - 1)), (counter3 - i) as isize);
+                    batch.push((((i - 1), ()), (counter3 - i) as isize));
                 }
+                assert_eq!(s, &<OrdZSet<_, _>>::from_tuples((), batch));
                 counter3 += 1;
-                assert_eq!(s.lookup(&(counter3 - 1)), 0);
             });
         })
         .unwrap();
@@ -252,10 +257,10 @@ mod test {
                     plus.inspect(move |n| assert_eq!(*n, expected_counters.next().unwrap()));
                     feedback.connect(&plus);
                     let integral = plus.integrate_nested();
-                    integral.inspect(move |n| assert_eq!(**n, expected_integrals.next().unwrap()));
+                    integral.inspect(move |n| assert_eq!(*n, expected_integrals.next().unwrap()));
                     Ok((
-                        integral.condition(|n| **n == 0),
-                        integral.apply(|rc| **rc).integrate().export(),
+                        integral.condition(|n| *n == 0),
+                        integral.apply(|rc| *rc).integrate().export(),
                     ))
                 })
                 .unwrap();
diff --git a/src/operator/join.rs b/src/operator/join.rs
index 6bb0ee4d..f23dc37d 100644
--- a/src/operator/join.rs
+++ b/src/operator/join.rs
@@ -1,62 +1,43 @@
 //! Relational join operator.
 
 use crate::{
-    algebra::{finite_map::KeyProperties, IndexedZSet, MapBuilder, ZRingValue, ZSet},
+    algebra::{IndexedZSet, MulByRef, ZSet},
     circuit::{
         operator_traits::{BinaryOperator, Operator},
         Circuit, Scope, Stream,
     },
-    operator::BinaryOperatorAdapter,
-    NumEntries, SharedRef,
+    time::NestedTimestamp32,
+    trace::{
+        cursor::Cursor as TraceCursor, ord::OrdValSpine, BatchReader, Batcher, Trace, TraceReader,
+    },
+};
+use deepsize::DeepSizeOf;
+use std::{
+    borrow::Cow,
+    cmp::{max, min, Ordering},
+    fmt::Write,
+    marker::PhantomData,
+    mem::swap,
 };
-use std::{borrow::Cow, marker::PhantomData};
 
-impl<P, SR1> Stream<Circuit<P>, SR1>
+impl<P, IZ1> Stream<Circuit<P>, IZ1>
 where
     P: Clone + 'static,
 {
     /// Apply [`Join`] operator to `self` and `other`.
     ///
     /// See [`Join`] operator for more info.
-    pub fn join<K, V1, V2, V, W, F, SR2, Z>(
-        &self,
-        other: &Stream<Circuit<P>, SR2>,
-        f: F,
-    ) -> Stream<Circuit<P>, Z>
+    pub fn join<F, IZ2, Z>(&self, other: &Stream<Circuit<P>, IZ2>, f: F) -> Stream<Circuit<P>, Z>
     where
-        K: KeyProperties,
-        V1: KeyProperties,
-        V2: KeyProperties,
-        W: ZRingValue,
-        SR1: SharedRef + 'static,
-        <SR1 as SharedRef>::Target: IndexedZSet<K, V1, W>,
-        for<'a> &'a <SR1 as SharedRef>::Target: IntoIterator<
-            Item = (
-                &'a K,
-                &'a <<SR1 as SharedRef>::Target as IndexedZSet<K, V1, W>>::ZSet,
-            ),
-        >,
-        for<'a> &'a <<SR1 as SharedRef>::Target as IndexedZSet<K, V1, W>>::ZSet:
-            IntoIterator<Item = (&'a V1, &'a W)>,
-        SR2: SharedRef + 'static,
-        <SR2 as SharedRef>::Target: IndexedZSet<K, V2, W>,
-        for<'a> &'a <SR2 as SharedRef>::Target: IntoIterator<
-            Item = (
-                &'a K,
-                &'a <<SR2 as SharedRef>::Target as IndexedZSet<K, V2, W>>::ZSet,
-            ),
-        >,
-        for<'a> &'a <<SR2 as SharedRef>::Target as IndexedZSet<K, V2, W>>::ZSet:
-            IntoIterator<Item = (&'a V2, &'a W)>,
-        F: Fn(&K, &V1, &V2) -> V + 'static,
-        V: 'static,
-        Z: Clone + MapBuilder<V, W> + 'static,
+        IZ1: IndexedZSet<R = Z::R>,
+        IZ2: IndexedZSet<Key = <IZ1::Target as BatchReader>::Key, R = Z::R>,
+        IZ1::Key: Ord,
+        Z: Clone + ZSet + 'static,
+        Z::R: MulByRef,
+        F: Fn(&IZ1::Key, &IZ1::Val, &IZ2::Val) -> Z::Key + 'static,
     {
-        self.circuit().add_binary_operator(
-            <BinaryOperatorAdapter<Z, _>>::new(Join::new(f)),
-            self,
-            other,
-        )
+        self.circuit()
+            .add_binary_operator(Join::new(f), self, other)
     }
 }
 
@@ -73,25 +54,19 @@ where
     /// ```text
     /// delta(A <> B) = A <> B - z^-1(A) <> z^-1(B) = a <> z^-1(B) + z^-1(A) <> b + a <> b
     /// ```
-    pub fn join_incremental<K, V1, V2, V, W, F, I2, Z>(
+    pub fn join_incremental<F, I2, Z>(
         &self,
         other: &Stream<Circuit<P>, I2>,
         join_func: F,
     ) -> Stream<Circuit<P>, Z>
     where
-        K: KeyProperties,
-        V1: KeyProperties,
-        V2: KeyProperties,
-        W: ZRingValue,
-        I1: NumEntries + IndexedZSet<K, V1, W> + SharedRef<Target = I1>,
-        for<'a> &'a I1: IntoIterator<Item = (&'a K, &'a I1::ZSet)>,
-        for<'a> &'a I1::ZSet: IntoIterator<Item = (&'a V1, &'a W)>,
-        I2: NumEntries + IndexedZSet<K, V2, W> + SharedRef<Target = I2>,
-        for<'a> &'a I2: IntoIterator<Item = (&'a K, &'a I2::ZSet)>,
-        for<'a> &'a I2::ZSet: IntoIterator<Item = (&'a V2, &'a W)>,
-        F: Clone + Fn(&K, &V1, &V2) -> V + 'static,
-        V: KeyProperties + 'static,
-        Z: ZSet<V, W>,
+        I1: IndexedZSet + DeepSizeOf,
+        I2: IndexedZSet<Key = I1::Key, R = I1::R> + DeepSizeOf,
+        I1::Key: Ord + DeepSizeOf,
+        I1::R: DeepSizeOf,
+        F: Clone + Fn(&I1::Key, &I1::Val, &I2::Val) -> Z::Key + 'static,
+        Z: ZSet<R = I1::R>,
+        Z::R: MulByRef,
     {
         self.integrate()
             .delay()
@@ -99,6 +74,7 @@ where
             .plus(&self.join(&other.integrate(), join_func))
     }
 
+    /*
     /// Incremental join of two nested streams.
     ///
     /// Given nested streams `a` and `b` of changes to relations `A` and `B`,
@@ -111,25 +87,18 @@ where
     ///     a <> I(↑I(↑z^-1(b)))     +
     ///     I(z^-1(a)) <> ↑I(↑z^-1(b)).
     /// ```
-    pub fn join_incremental_nested<K, V1, V2, V, W, F, I2, Z>(
+    pub fn join_incremental_nested<F, I2, Z>(
         &self,
         other: &Stream<Circuit<P>, I2>,
         join_func: F,
     ) -> Stream<Circuit<P>, Z>
     where
-        K: KeyProperties,
-        V1: KeyProperties,
-        V2: KeyProperties,
-        W: ZRingValue,
-        I1: NumEntries + IndexedZSet<K, V1, W> + SharedRef<Target = I1> + std::fmt::Debug,
-        for<'a> &'a I1: IntoIterator<Item = (&'a K, &'a I1::ZSet)>,
-        for<'a> &'a I1::ZSet: IntoIterator<Item = (&'a V1, &'a W)>,
-        I2: NumEntries + IndexedZSet<K, V2, W> + SharedRef<Target = I2> + std::fmt::Debug,
-        for<'a> &'a I2: IntoIterator<Item = (&'a K, &'a I2::ZSet)>,
-        for<'a> &'a I2::ZSet: IntoIterator<Item = (&'a V2, &'a W)>,
-        F: Clone + Fn(&K, &V1, &V2) -> V + 'static,
-        V: KeyProperties + 'static,
-        Z: ZSet<V, W>,
+        I1: IndexedZSet + DeepSizeOf,
+        I1::Key: Ord,
+        I2: IndexedZSet<Key = I1::Key, R = I1::R> + DeepSizeOf,
+        F: Clone + Fn(&I1::Key, &I1::Val, &I2::Val) -> Z::Key + 'static,
+        Z: ZSet<R = I1::R>,
+        Z::R: MulByRef,
     {
         let join1: Stream<_, Z> = self
             .integrate_nested()
@@ -152,7 +121,186 @@ where
         //       Rust Analyzer tries to resolve it to `Iterator::sum()`
         Stream::sum(&join1, &[join2, join3, join4])
     }
+    */
+}
+
+impl<P, I1> Stream<Circuit<P>, I1>
+where
+    P: Clone + 'static,
+    I1: IndexedZSet,
+{
+    /// Incremental join of two nested streams.
+    ///
+    /// Given nested streams `self` and `other` of changes to relations `A` and
+    /// `B`, computes `(↑((↑(self <> other))∆))∆` by first assembling traces
+    /// of both streams:
+    pub fn join_trace<I2, F, Z>(
+        &self,
+        other: &Stream<Circuit<P>, I2>,
+        join_func: F,
+    ) -> Stream<Circuit<P>, Z>
+    where
+        I1::Key: DeepSizeOf + Clone + Ord,
+        I1::Val: DeepSizeOf + Clone + Ord,
+        I1::R: DeepSizeOf,
+        I2::Val: DeepSizeOf + Clone + Ord,
+        I2: IndexedZSet<Key = I1::Key, R = I1::R>,
+        Z: ZSet<R = I1::R>,
+        Z::Batcher: DeepSizeOf,
+        Z::Key: Clone,
+        Z::R: MulByRef,
+        F: Fn(&I1::Key, &I1::Val, &I2::Val) -> Z::Key + Clone + 'static,
+    {
+        // Writing out the definition of the operator and applying distributivity,
+        // we end up with the following four terms:
+        //
+        //          self                    other
+        //
+        // ┌─────────────────┬─┐    ┌─────────────────┬─┐
+        // │                 │ │    │                 │ │
+        // │                 │ │ <> │                 │ │
+        // ├─────────────────┼─┤    ├─────────────────┼─┤
+        // │                 │x│    │                 │x│
+        // └─────────────────┴─┘    └─────────────────┴─┘
+        //                       +
+        // ┌─────────────────┬─┐    ┌─────────────────┬─┐
+        // │                 │ │    │xxxxxxxxxxxxxxxxx│x│
+        // │                 │ │ <> │xxxxxxxxxxxxxxxxx│x│
+        // ├─────────────────┼─┤    ├─────────────────┼─┤
+        // │                 │x│    │xxxxxxxxxxxxxxxxx│ │
+        // └─────────────────┴─┘    └─────────────────┴─┘
+        //                       +
+        // ┌─────────────────┬─┐    ┌─────────────────┬─┐
+        // │                 │ │    │                 │x│
+        // │                 │ │ <> │                 │x│
+        // ├─────────────────┼─┤    ├─────────────────┼─┤
+        // │xxxxxxxxxxxxxxxxx│ │    │                 │ │
+        // └─────────────────┴─┘    └─────────────────┴─┘
+        //                       +
+        // ┌─────────────────┬─┐    ┌─────────────────┬─┐
+        // │xxxxxxxxxxxxxxxxx│x│    │                 │ │
+        // │xxxxxxxxxxxxxxxxx│x│ <> │                 │ │
+        // ├─────────────────┼─┤    ├─────────────────┼─┤
+        // │xxxxxxxxxxxxxxxxx│ │    │                 │x│
+        // └─────────────────┴─┘    └─────────────────┴─┘
+        //                       +
+        // ┌─────────────────┬─┐    ┌─────────────────┬─┐
+        // │                 │x│    │                 │ │
+        // │                 │x│ <> │                 │ │
+        // ├─────────────────┼─┤    ├─────────────────┼─┤
+        // │                 │ │    │xxxxxxxxxxxxxxxxx│ │
+        // └─────────────────┴─┘    └─────────────────┴─┘
+        //
+        // Terms 2 + 3 and 4 + 5 are symmetric and are implemented by the `JoinTrace`
+        // operator. We sneak the first term into one of them, but not the other
+        // by delaying one of the traces.
+        let self_trace = self.trace::<OrdValSpine<I1::Key, I1::Val, NestedTimestamp32, I1::R>>();
+        let other_trace = other.trace::<OrdValSpine<I1::Key, I2::Val, NestedTimestamp32, I1::R>>();
+        let join_func_clone = join_func.clone();
+
+        // Terms 1+2+3:
+        //
+        //        self                        other
+        // ┌─────────────────┬─┐    ┌─────────────────┬─┐
+        // │                 │ │    │xxxxxxxxxxxxxxxxx│x│
+        // │                 │ │ <> │xxxxxxxxxxxxxxxxx│x│
+        // ├─────────────────┼─┤    ├─────────────────┼─┤
+        // │                 │x│    │xxxxxxxxxxxxxxxxx│x│
+        // └─────────────────┴─┘    └─────────────────┴─┘
+        //                       +
+        // ┌─────────────────┬─┐    ┌─────────────────┬─┐
+        // │                 │ │    │                 │x│
+        // │                 │ │ <> │                 │x│
+        // ├─────────────────┼─┤    ├─────────────────┼─┤
+        // │xxxxxxxxxxxxxxxxx│ │    │                 │ │
+        // └─────────────────┴─┘    └─────────────────┴─┘
+        let left =
+            self.circuit()
+                .add_binary_operator(JoinTrace::new(join_func), self, &other_trace);
+
+        fn flip_args<F, K, V1, V2, V>(f: F) -> F
+        where
+            F: Fn(&K, &V1, &V2) -> V,
+        {
+            f
+        }
+
+        // Terms 4+5:
+        //
+        //        self                        other
+        // ┌─────────────────┬─┐    ┌─────────────────┬─┐
+        // │xxxxxxxxxxxxxxxxx│x│    │                 │ │
+        // │xxxxxxxxxxxxxxxxx│x│ <> │                 │ │
+        // ├─────────────────┼─┤    ├─────────────────┼─┤
+        // │xxxxxxxxxxxxxxxxx│ │    │                 │x│
+        // └─────────────────┴─┘    └─────────────────┴─┘
+        //                       +
+        // ┌─────────────────┬─┐    ┌─────────────────┬─┐
+        // │                 │x│    │                 │ │
+        // │                 │x│ <> │                 │ │
+        // ├─────────────────┼─┤    ├─────────────────┼─┤
+        // │                 │ │    │xxxxxxxxxxxxxxxxx│ │
+        // └─────────────────┴─┘    └─────────────────┴─┘
+        let right = self.circuit().add_binary_operator(
+            JoinTrace::new(flip_args(move |k, v2, v1| join_func_clone(k, v1, v2))),
+            other,
+            &self_trace.delay_trace(),
+        );
+
+        left.plus(&right)
+    }
+}
+
+/*
+impl<P, I1> Stream<Circuit<P>, I1>
+where
+    P: Clone + 'static,
+    I1: IndexedZSet,
+{
+    pub fn join_incremental2<I2, T1, T2, F, Z>(
+        &self,
+        other: &Stream<Circuit<P>, I2>,
+        join_func: F,
+    ) -> Stream<Circuit<P>, Z>
+    where
+        I1::Key: DeepSizeOf,
+        I1::Value: DeepSizeOf,
+        I1::Weight: DeepSizeOf,
+        I2: IndexedZSet<Key = I1::Key, Weight = I1::Weight>,
+        I2::Value: DeepSizeOf,
+        T1::Batch: From<I1>,
+        T2::Batch: From<I2>,
+        Z: ZSet<Weight = I1::Weight>,
+        Z::TupleBuilder: DeepSizeOf,
+        F: Fn(&I1::Key, &I1::Value, &I2::Value) -> Z::Data + Clone + 'static,
+    {
+        let self_trace = self.integrate_trace::<T1>();
+        let other_trace = other.integrate_trace::<T2>();
+        let join_func_clone = join_func.clone();
+
+        let left = self.circuit().add_binary_operator(
+            JoinTrace::new(join_func),
+            self,
+            &other_trace,
+        );
+
+        fn flip_args<F, K, V1, V2, V>(f: F) -> F
+        where
+            F: Fn(&K, &V1, &V2) -> V,
+        {
+            f
+        }
+
+        let right = self.circuit().add_binary_operator(
+            JoinTrace::new(flip_args(move |k, v2, v1| join_func_clone(k, v1, v2))),
+            other,
+            &self_trace.delay_trace(),
+        );
+
+        left.plus(&right)
+    }
 }
+*/
 
 /// Join two indexed Z-sets.
 ///
@@ -166,112 +314,314 @@ where
 ///
 /// # Type arguments
 ///
-/// * `K` - key type.
-/// * `V1` - value type in the first input stream.
-/// * `V2` - value type in the second input stream.
-/// * `V` - value type in the output Z-set.
-/// * `W` - weight type used by both inputs.
 /// * `F` - join function type: maps key and a pair of values from input Z-sets
 ///   to an output value.
 /// * `I1` - indexed Z-set type in the first input stream.
-/// * `I1` - indexed Z-set type in the second input stream.
+/// * `I2` - indexed Z-set type in the second input stream.
 /// * `Z` - output Z-set type.
-pub struct Join<K, V1, V2, V, W, F, I1, I2, Z> {
+pub struct Join<F, I1, I2, Z> {
     join_func: F,
-    _val_types: PhantomData<(K, V1, V2, V, W)>,
-    _container_types: PhantomData<(I1, I2, Z)>,
+    _types: PhantomData<(I1, I2, Z)>,
 }
 
-impl<K, V1, V2, V, W, F, I1, I2, Z> Join<K, V1, V2, V, W, F, I1, I2, Z> {
+impl<F, I1, I2, Z> Join<F, I1, I2, Z> {
     pub fn new(join_func: F) -> Self {
         Self {
             join_func,
-            _val_types: PhantomData,
-            _container_types: PhantomData,
+            _types: PhantomData,
         }
     }
 }
 
-impl<K, V1, V2, V, W, F, I1, I2, Z> Operator for Join<K, V1, V2, V, W, F, I1, I2, Z>
+impl<F, I1, I2, Z> Operator for Join<F, I1, I2, Z>
 where
-    K: 'static,
-    V1: 'static,
-    V2: 'static,
-    W: 'static,
     I1: 'static,
     I2: 'static,
     F: 'static,
-    V: 'static,
     Z: 'static,
 {
     fn name(&self) -> Cow<'static, str> {
         Cow::from("Join")
     }
-    fn clock_start(&mut self, _scope: Scope) {}
-    fn clock_end(&mut self, _scope: Scope) {}
+    fn fixedpoint(&self) -> bool {
+        true
+    }
 }
 
-fn join_inner<K, V1, V2, V, W, F, I1, I2, Z>(i1: &I1, i2: &I2, join_func: &F) -> Z
+impl<F, I1, I2, Z> BinaryOperator<I1, I2, Z> for Join<F, I1, I2, Z>
 where
-    K: KeyProperties,
-    V1: KeyProperties,
-    V2: KeyProperties,
-    W: ZRingValue,
-    I1: IndexedZSet<K, V1, W>,
-    for<'a> &'a I1: IntoIterator<Item = (&'a K, &'a I1::ZSet)>,
-    for<'a> &'a I1::ZSet: IntoIterator<Item = (&'a V1, &'a W)>,
-    I2: IndexedZSet<K, V2, W>,
-    for<'a> &'a I2::ZSet: IntoIterator<Item = (&'a V2, &'a W)>,
-    F: Fn(&K, &V1, &V2) -> V,
-    Z: MapBuilder<V, W> + 'static,
+    I1: IndexedZSet<R = Z::R>,
+    I1::Key: Ord,
+    I2: IndexedZSet<Key = I1::Key, R = Z::R>,
+    F: Fn(&I1::Key, &I1::Val, &I2::Val) -> Z::Key + 'static,
+    Z: ZSet + 'static,
+    Z::R: MulByRef,
 {
-    let mut map = Z::empty();
-    for (k, vals1) in i1.into_iter() {
-        if let Some(vals2) = i2.get_in_support(k) {
-            for (v1, w1) in vals1.into_iter() {
-                for (v2, w2) in vals2.into_iter() {
-                    map.increment_owned(join_func(k, v1, v2), w1.mul_by_ref(w2));
+    fn eval(&mut self, i1: &I1, i2: &I2) -> Z {
+        let mut cursor1 = i1.cursor();
+        let mut cursor2 = i2.cursor();
+
+        // Choose capacity heuristically.
+        let mut batch = Vec::with_capacity(min(i1.len(), i2.len()));
+
+        while cursor1.key_valid(i1) && cursor2.key_valid(i2) {
+            match cursor1.key(i1).cmp(cursor2.key(i2)) {
+                Ordering::Less => cursor1.seek_key(i1, cursor2.key(i2)),
+                Ordering::Greater => cursor2.seek_key(i2, cursor1.key(i1)),
+                Ordering::Equal => {
+                    while cursor1.val_valid(i1) {
+                        let w1 = cursor1.weight(i1);
+                        let v1 = cursor1.val(i1);
+                        while cursor2.val_valid(i2) {
+                            let v2 = cursor2.val(i2);
+                            let w2 = cursor2.weight(i2);
+
+                            batch.push((
+                                ((self.join_func)(cursor1.key(i1), v1, v2), ()),
+                                w1.mul_by_ref(w2),
+                            ));
+                            cursor2.step_val(i2);
+                        }
+
+                        cursor2.rewind_vals(i2);
+                        cursor1.step_val(i1);
+                    }
+
+                    cursor1.step_key(i1);
+                    cursor2.step_key(i2);
                 }
             }
         }
+
+        Z::from_tuples((), batch)
     }
-    map
 }
 
-impl<K, V1, V2, V, W, F, I1, I2, Z> BinaryOperator<I1, I2, Z>
-    for Join<K, V1, V2, V, W, F, I1, I2, Z>
+// Computes one half of nested incremental join:
+//
+//        self                       other
+// ┌─────────────────┬─┐    ┌─────────────────┬─┐
+// │                 │ │    │xxxxxxxxxxxxxxxxx│x│
+// │                 │ │ <> │xxxxxxxxxxxxxxxxx│x│
+// ├─────────────────┼─┤    ├─────────────────┼─┤
+// │                 │x│    │xxxxxxxxxxxxxxxxx│x│
+// └─────────────────┴─┘    └─────────────────┴─┘
+//                       +
+// ┌─────────────────┬─┐    ┌─────────────────┬─┐
+// │                 │ │    │                 │x│
+// │                 │ │ <> │                 │x│
+// ├─────────────────┼─┤    ├─────────────────┼─┤
+// │xxxxxxxxxxxxxxxxx│ │    │                 │ │
+// └─────────────────┴─┘    └─────────────────┴─┘
+//       ^            ^                        ^
+//       |            |                        |
+//       t1           t2                       t2
+//
+// The first term is a standard join between a single batch
+// and a full trace.  The second term joins all updates
+// observed in the current epoch with all updates observed in
+// past epochs at the same clock cycle.  It is bit tricky to
+// compute efficiently, as the trace API does not allow
+// selecting updates for a particular time.  The trick is
+// to compute the second term ahead of time: at time t1,
+// for each key in indexed ZSet `self`, lookup matching key
+// in trace `other` scan the trace and scan associated
+// (time, weight) pairs.  We already perform this scan to
+// compute the first term above, but instead of stopping at
+// time `t1`, we continue scanning and record computed output
+// tuples for time `t2 > t1` inside the operator so that we can
+// output them at time `t2`.
+pub struct JoinTrace<F, I, T, Z>
 where
-    K: KeyProperties,
-    V1: KeyProperties,
-    V2: KeyProperties,
-    W: ZRingValue,
-    I1: IndexedZSet<K, V1, W>,
-    for<'a> &'a I1: IntoIterator<Item = (&'a K, &'a I1::ZSet)>,
-    for<'a> &'a I1::ZSet: IntoIterator<Item = (&'a V1, &'a W)>,
-    I2: IndexedZSet<K, V2, W>,
-    for<'a> &'a I2: IntoIterator<Item = (&'a K, &'a I2::ZSet)>,
-    for<'a> &'a I2::ZSet: IntoIterator<Item = (&'a V2, &'a W)>,
-    F: Fn(&K, &V1, &V2) -> V + 'static,
-    V: 'static,
-    Z: MapBuilder<V, W> + 'static,
+    T: TraceReader,
+    Z: ZSet,
 {
-    fn eval(&mut self, i1: &I1, i2: &I2) -> Z {
-        // Iterate over smaller index.
-        if i1.support_size() < i2.support_size() {
-            join_inner(i1, i2, &self.join_func)
-        } else {
-            join_inner(i2, i1, &|k, i2, i1| (self.join_func)(k, i1, i2))
+    join_func: F,
+    // TODO: not needed once timekeeping is handled by the circuit.
+    time: u32,
+    // Future update batches computed ahead of time, indexed by time
+    // when each batch should be output.
+    output_batchers: Vec<Z::Batcher>,
+    // True if empty input batch was received at the current clock cycle.
+    empty_input: bool,
+    // True if empty output was produced at the current clock cycle.
+    empty_output: bool,
+    _types: PhantomData<(I, T, Z)>,
+}
+
+impl<F, I, T, Z> JoinTrace<F, I, T, Z>
+where
+    T: TraceReader<Time = NestedTimestamp32>,
+    Z: ZSet,
+{
+    pub fn new(join_func: F) -> Self {
+        Self {
+            join_func,
+            time: 0,
+            output_batchers: Vec::new(),
+            empty_input: false,
+            empty_output: false,
+            _types: PhantomData,
         }
     }
 }
 
+impl<F, I, T, Z> Operator for JoinTrace<F, I, T, Z>
+where
+    F: 'static,
+    I: 'static,
+    T: TraceReader<Time = NestedTimestamp32> + 'static,
+    Z: ZSet,
+    Z::Batcher: DeepSizeOf,
+{
+    fn name(&self) -> Cow<'static, str> {
+        Cow::from("JoinTrace")
+    }
+    fn clock_start(&mut self, scope: Scope) {
+        if scope == 0 {
+            self.time = 0;
+            self.empty_input = false;
+            self.empty_output = false;
+        }
+    }
+    fn clock_end(&mut self, scope: Scope) {
+        if scope == 0 {
+            self.output_batchers.clear();
+        }
+    }
+
+    fn summary(&self, summary: &mut String) {
+        let num_entries: usize = self
+            .output_batchers
+            .iter()
+            .map(|batcher| batcher.tuples())
+            .sum();
+        writeln!(summary, "size: {}", num_entries).unwrap();
+
+        let bytes: usize = self
+            .output_batchers
+            .iter()
+            .map(DeepSizeOf::deep_size_of)
+            .sum();
+        writeln!(summary, "bytes: {}", bytes).unwrap();
+        //println!("zbytes:{}", bytes);
+    }
+
+    fn fixedpoint(&self) -> bool {
+        // We're in a stable state if input and output at the current clock cycle are
+        // both empty, and all future precomputed outputs are empty.
+        self.empty_input
+            && self.empty_output
+            && self
+                .output_batchers
+                .iter()
+                .skip(self.time as usize)
+                .all(|batcher| batcher.tuples() == 0)
+    }
+}
+
+impl<F, I, T, Z> BinaryOperator<I, T, Z> for JoinTrace<F, I, T, Z>
+where
+    I: IndexedZSet,
+    I::Key: Ord + Clone,
+    T: Trace<Key = I::Key, Time = NestedTimestamp32, R = I::R> + 'static,
+    F: Clone + Fn(&I::Key, &I::Val, &T::Val) -> Z::Key + 'static,
+    Z: ZSet<R = I::R>,
+    Z::Key: Clone,
+    Z::Batcher: DeepSizeOf,
+    Z::R: MulByRef,
+{
+    fn eval(&mut self, index: &I, trace: &T) -> Z {
+        /*println!("JoinTrace::eval@{}:\n  index:\n{}\n  trace:\n{}",
+        self.time,
+        textwrap::indent(&index.to_string(), "    "),
+        textwrap::indent(&trace.to_string(), "    "));*/
+
+        self.empty_input = index.is_empty();
+
+        let mut new_len: u32 = self.time + 1;
+        trace.map_batches(|batch| {
+            for ts in batch.upper().elements().iter() {
+                new_len = max(new_len, ts.inner());
+            }
+        });
+
+        //println!("new_len: {}", new_len);
+        self.output_batchers
+            .resize_with(new_len as usize, || Z::Batcher::new(()));
+        // TODO: keep output batches in `self` for allocation reuse across iterations
+        // (but potentially using more memory)..
+        let mut output_batches = Vec::new();
+        output_batches.resize_with((new_len - self.time) as usize, Vec::new);
+
+        let mut index_cursor = index.cursor();
+        let (mut trace_cursor, trace_storage) = trace.cursor();
+
+        while index_cursor.key_valid(index) && trace_cursor.key_valid(&trace_storage) {
+            match index_cursor
+                .key(index)
+                .cmp(trace_cursor.key(&trace_storage))
+            {
+                Ordering::Less => {
+                    index_cursor.seek_key(index, trace_cursor.key(&trace_storage));
+                }
+                Ordering::Greater => {
+                    trace_cursor.seek_key(&trace_storage, index_cursor.key(index));
+                }
+                Ordering::Equal => {
+                    //println!("key: {}", index_cursor.key(index));
+
+                    while index_cursor.val_valid(index) {
+                        let v1 = index_cursor.val(index);
+                        let w1 = index_cursor.weight(index);
+                        //println!("v1: {}, w1: {}", v1, w1);
+
+                        while trace_cursor.val_valid(&trace_storage) {
+                            let output = (self.join_func)(
+                                index_cursor.key(index),
+                                v1,
+                                trace_cursor.val(&trace_storage),
+                            );
+                            trace_cursor.map_times(&trace_storage, |ts, w2| {
+                                let off = (max(ts.inner(), self.time) - self.time) as usize;
+                                //println!("  tuple@{}: ({:?}, {})", off, output, w1.clone() *
+                                // w2.clone());
+                                output_batches[off].push(((output.clone(), ()), w1.mul_by_ref(w2)));
+                            });
+                            trace_cursor.step_val(&trace_storage);
+                        }
+                        trace_cursor.rewind_vals(&trace_storage);
+                        index_cursor.step_val(index);
+                    }
+
+                    index_cursor.step_key(index);
+                    trace_cursor.step_key(&trace_storage);
+                }
+            }
+        }
+
+        for (i, batch) in output_batches.iter_mut().enumerate() {
+            if !batch.is_empty() {
+                self.output_batchers[i + self.time as usize].push_batch(batch);
+            }
+        }
+
+        let mut batcher = Z::Batcher::new(());
+        swap(&mut self.output_batchers[self.time as usize], &mut batcher);
+        self.time += 1;
+        let result = batcher.seal();
+        self.empty_output = result.is_empty();
+        result
+    }
+}
+
 #[cfg(test)]
 mod test {
     use crate::{
-        algebra::{FiniteHashMap, HasZero},
         circuit::{Root, Stream},
-        finite_map,
         operator::{DelayedFeedback, Generator},
+        trace::ord::{OrdIndexedZSet, OrdZSet, OrdZSetSpine},
+        zset,
     };
     use std::vec;
 
@@ -279,37 +629,37 @@ mod test {
     fn join_test() {
         let root = Root::build(move |circuit| {
             let mut input1 = vec![
-                vec![
-                    ((1, "a"), 1),
-                    ((1, "b"), 2),
-                    ((2, "c"), 3),
-                    ((2, "d"), 4),
-                    ((3, "e"), 5),
-                    ((3, "f"), -2),
-                ],
-                vec![((1, "a"), 1)],
-                vec![((1, "a"), 1)],
-                vec![((4, "n"), 2)],
-                vec![((1, "a"), 0)],
+                zset! {
+                    (1, "a") => 1,
+                    (1, "b") => 2,
+                    (2, "c") => 3,
+                    (2, "d") => 4,
+                    (3, "e") => 5,
+                    (3, "f") => -2,
+                },
+                zset! {(1, "a") => 1},
+                zset! {(1, "a") => 1},
+                zset! {(4, "n") => 2},
+                zset! {(1, "a") => 0},
             ]
             .into_iter();
             let mut input2 = vec![
-                vec![
-                    ((2, "g"), 3),
-                    ((2, "h"), 4),
-                    ((3, "i"), 5),
-                    ((3, "j"), -2),
-                    ((4, "k"), 5),
-                    ((4, "l"), -2),
-                ],
-                vec![((1, "b"), 1)],
-                vec![((4, "m"), 1)],
-                vec![],
-                vec![],
+                zset! {
+                    (2, "g") => 3,
+                    (2, "h") => 4,
+                    (3, "i") => 5,
+                    (3, "j") => -2,
+                    (4, "k") => 5,
+                    (4, "l") => -2,
+                },
+                zset! {(1, "b") => 1},
+                zset! {(4, "m") => 1},
+                zset! {},
+                zset! {},
             ]
             .into_iter();
             let mut outputs = vec![
-                finite_map! {
+                zset! {
                     (2, "c g".to_string()) => 9,
                     (2, "c h".to_string()) => 12,
                     (2, "d g".to_string()) => 12,
@@ -319,16 +669,16 @@ mod test {
                     (3, "f i".to_string()) => -10,
                     (3, "f j".to_string()) => 4
                 },
-                finite_map! {
+                zset! {
                     (1, "a b".to_string()) => 1,
                 },
-                finite_map! {},
-                finite_map! {},
-                finite_map! {},
+                zset! {},
+                zset! {},
+                zset! {},
             ]
             .into_iter();
             let mut inc_outputs = vec![
-                finite_map! {
+                zset! {
                     (2, "c g".to_string()) => 9,
                     (2, "c h".to_string()) => 12,
                     (2, "d g".to_string()) => 12,
@@ -338,38 +688,36 @@ mod test {
                     (3, "f i".to_string()) => -10,
                     (3, "f j".to_string()) => 4
                 },
-                finite_map! {
+                zset! {
                     (1, "a b".to_string()) => 2,
                     (1, "b b".to_string()) => 2,
                 },
-                finite_map! {
+                zset! {
                     (1, "a b".to_string()) => 1,
                 },
-                finite_map! {
+                zset! {
                     (4, "n k".to_string()) => 10,
                     (4, "n l".to_string()) => -4,
                     (4, "n m".to_string()) => 2,
                 },
-                finite_map! {},
+                zset! {},
             ]
             .into_iter();
 
-            let index1: Stream<_, FiniteHashMap<usize, FiniteHashMap<&'static str, isize>>> =
-                circuit
-                    .add_source(Generator::new(move || input1.next().unwrap()))
-                    .index();
-            let index2: Stream<_, FiniteHashMap<usize, FiniteHashMap<&'static str, isize>>> =
-                circuit
-                    .add_source(Generator::new(move || input2.next().unwrap()))
-                    .index();
+            let index1: Stream<_, OrdIndexedZSet<usize, &'static str, isize>> = circuit
+                .add_source(Generator::new(move || input1.next().unwrap()))
+                .index();
+            let index2: Stream<_, OrdIndexedZSet<usize, &'static str, isize>> = circuit
+                .add_source(Generator::new(move || input2.next().unwrap()))
+                .index();
             index1
                 .join(&index2, |&k: &usize, s1, s2| (k, format!("{} {}", s1, s2)))
-                .inspect(move |fm: &FiniteHashMap<(usize, String), _>| {
+                .inspect(move |fm: &OrdZSet<(usize, String), _>| {
                     assert_eq!(fm, &outputs.next().unwrap())
                 });
             index1
                 .join_incremental(&index2, |&k: &usize, s1, s2| (k, format!("{} {}", s1, s2)))
-                .inspect(move |fm: &FiniteHashMap<(usize, String), _>| {
+                .inspect(move |fm: &OrdZSet<(usize, String), _>| {
                     assert_eq!(fm, &inc_outputs.next().unwrap())
                 });
         })
@@ -380,33 +728,34 @@ mod test {
         }
     }
 
+    /*
     // Nested incremental reachability algorithm.
     #[test]
     fn join_incremental_nested_test() {
         let root = Root::build(move |circuit| {
             // Changes to the edges relation.
-            let mut edges: vec::IntoIter<FiniteHashMap<(usize, usize), isize>> = vec![
-                finite_map! { (1, 2) => 1 },
-                finite_map! { (2, 3) => 1},
-                finite_map! { (1, 3) => 1},
-                finite_map! { (3, 1) => 1},
-                finite_map! { (3, 1) => -1},
-                finite_map! { (1, 2) => -1},
-                finite_map! { (2, 4) => 1, (4, 1) => 1 },
-                finite_map! { (2, 3) => -1, (3, 2) => 1 },
+            let mut edges: vec::IntoIter<OrdZSet<(usize, usize), isize>> = vec![
+                zset! { (1, 2) => 1 },
+                zset! { (2, 3) => 1},
+                zset! { (1, 3) => 1},
+                zset! { (3, 1) => 1},
+                zset! { (3, 1) => -1},
+                zset! { (1, 2) => -1},
+                zset! { (2, 4) => 1, (4, 1) => 1 },
+                zset! { (2, 3) => -1, (3, 2) => 1 },
             ]
             .into_iter();
 
             // Expected content of the reachability relation.
-            let mut outputs: vec::IntoIter<FiniteHashMap<(usize, usize), isize>> = vec![
-                finite_map! { (1, 2) => 1 },
-                finite_map! { (1, 2) => 1, (2, 3) => 1, (1, 3) => 1 },
-                finite_map! { (1, 2) => 1, (2, 3) => 1, (1, 3) => 1 },
-                finite_map! { (1, 1) => 1, (2, 2) => 1, (3, 3) => 1, (1, 2) => 1, (1, 3) => 1, (2, 3) => 1, (2, 1) => 1, (3, 1) => 1, (3, 2) => 1},
-                finite_map! { (1, 2) => 1, (2, 3) => 1, (1, 3) => 1 },
-                finite_map! { (2, 3) => 1, (1, 3) => 1 },
-                finite_map! { (1, 3) => 1, (2, 3) => 1, (2, 4) => 1, (2, 1) => 1, (4, 1) => 1, (4, 3) => 1 },
-                finite_map! { (1, 1) => 1, (2, 2) => 1, (3, 3) => 1, (4, 4) => 1,
+            let mut outputs: vec::IntoIter<OrdZSet<(usize, usize), isize>> = vec![
+                zset! { (1, 2) => 1 },
+                zset! { (1, 2) => 1, (2, 3) => 1, (1, 3) => 1 },
+                zset! { (1, 2) => 1, (2, 3) => 1, (1, 3) => 1 },
+                zset! { (1, 1) => 1, (2, 2) => 1, (3, 3) => 1, (1, 2) => 1, (1, 3) => 1, (2, 3) => 1, (2, 1) => 1, (3, 1) => 1, (3, 2) => 1},
+                zset! { (1, 2) => 1, (2, 3) => 1, (1, 3) => 1 },
+                zset! { (2, 3) => 1, (1, 3) => 1 },
+                zset! { (1, 3) => 1, (2, 3) => 1, (2, 4) => 1, (2, 1) => 1, (4, 1) => 1, (4, 3) => 1 },
+                zset! { (1, 1) => 1, (2, 2) => 1, (3, 3) => 1, (4, 4) => 1,
                               (1, 2) => 1, (1, 3) => 1, (1, 4) => 1,
                               (2, 1) => 1, (2, 3) => 1, (2, 4) => 1,
                               (3, 1) => 1, (3, 2) => 1, (3, 4) => 1,
@@ -414,7 +763,7 @@ mod test {
             ]
             .into_iter();
 
-            let edges: Stream<_, FiniteHashMap<(usize, usize), isize>> =
+            let edges: Stream<_, OrdZSet<(usize, usize), isize>> =
                 circuit
                     .add_source(Generator::new(move || edges.next().unwrap()));
 
@@ -436,14 +785,14 @@ mod test {
                 //      join_incremental_nested
                 // ```
                 let edges = edges.delta0(child);
-                let paths_delayed = <DelayedFeedback<_, FiniteHashMap<_, _>>>::new(child);
+                let paths_delayed = <DelayedFeedback<_, OrdZSet<_, _>>>::new(child);
 
-                let paths_inverted: Stream<_, FiniteHashMap<(usize, usize), isize>> = paths_delayed
+                let paths_inverted: Stream<_, OrdZSet<(usize, usize), isize>> = paths_delayed
                     .stream()
                     .map_keys(|&(x, y)| (y, x));
 
-                let paths_inverted_indexed: Stream<_, FiniteHashMap<usize, FiniteHashMap<usize, isize>>> = paths_inverted.index();
-                let edges_indexed: Stream<_, FiniteHashMap<usize, FiniteHashMap<usize, isize>>> = edges.index();
+                let paths_inverted_indexed: Stream<_, OrdIndexedZSet<usize, usize, isize>> = paths_inverted.index();
+                let edges_indexed: Stream<_, OrdIndexedZSet<usize, usize, isize>> = edges.index();
 
                 let paths = edges.plus(&paths_inverted_indexed.join_incremental_nested(&edges_indexed, |_via, from, to| (*from, *to)))
                     .distinct_incremental_nested();
@@ -469,4 +818,89 @@ mod test {
             root.step().unwrap();
         }
     }
+    */
+
+    #[test]
+    fn join_trace_test() {
+        let root = Root::build(move |circuit| {
+            // Changes to the edges relation.
+            let mut edges: vec::IntoIter<OrdZSet<(usize, usize), isize>> = vec![
+                zset! { (1, 2) => 1 },
+                zset! { (2, 3) => 1},
+                zset! { (1, 3) => 1},
+                zset! { (3, 1) => 1},
+                zset! { (3, 1) => -1},
+                zset! { (1, 2) => -1},
+                zset! { (2, 4) => 1, (4, 1) => 1 },
+                zset! { (2, 3) => -1, (3, 2) => 1 },
+            ]
+            .into_iter();
+
+            // Expected content of the reachability relation.
+            let mut outputs: vec::IntoIter<OrdZSet<(usize, usize), isize>> = vec![
+                zset! { (1, 2) => 1 },
+                zset! { (1, 2) => 1, (2, 3) => 1, (1, 3) => 1 },
+                zset! { (1, 2) => 1, (2, 3) => 1, (1, 3) => 1 },
+                zset! { (1, 1) => 1, (2, 2) => 1, (3, 3) => 1, (1, 2) => 1, (1, 3) => 1, (2, 3) => 1, (2, 1) => 1, (3, 1) => 1, (3, 2) => 1},
+                zset! { (1, 2) => 1, (2, 3) => 1, (1, 3) => 1 },
+                zset! { (2, 3) => 1, (1, 3) => 1 },
+                zset! { (1, 3) => 1, (2, 3) => 1, (2, 4) => 1, (2, 1) => 1, (4, 1) => 1, (4, 3) => 1 },
+                zset! { (1, 1) => 1, (2, 2) => 1, (3, 3) => 1, (4, 4) => 1,
+                              (1, 2) => 1, (1, 3) => 1, (1, 4) => 1,
+                              (2, 1) => 1, (2, 3) => 1, (2, 4) => 1,
+                              (3, 1) => 1, (3, 2) => 1, (3, 4) => 1,
+                              (4, 1) => 1, (4, 2) => 1, (4, 3) => 1 },
+            ]
+            .into_iter();
+
+            let edges: Stream<_, OrdZSet<(usize, usize), isize>> =
+                circuit
+                    .add_source(Generator::new(move || edges.next().unwrap()));
+
+            let paths = circuit.fixedpoint(|child| {
+                // ```text
+                //                      distinct_incremental_nested
+                //               ┌───┐          ┌───┐
+                // edges         │   │          │   │  paths
+                // ────┬────────►│ + ├──────────┤   ├────────┬───►
+                //     │         │   │          │   │        │
+                //     │         └───┘          └───┘        │
+                //     │           ▲                         │
+                //     │           │                         │
+                //     │         ┌─┴─┐                       │
+                //     │         │   │                       │
+                //     └────────►│ X │ ◄─────────────────────┘
+                //               │   │
+                //               └───┘
+                //      join_incremental_nested
+                // ```
+                let edges = edges.delta0(child);
+                let paths_delayed = <DelayedFeedback<_, OrdZSet<_, _>>>::new(child);
+
+                let paths_inverted: Stream<_, OrdZSet<(usize, usize), isize>> = paths_delayed
+                    .stream()
+                    .map_keys(|&(x, y)| (y, x));
+
+                let paths_inverted_indexed: Stream<_, OrdIndexedZSet<usize, usize, isize>> = paths_inverted.index();
+                let edges_indexed: Stream<_, OrdIndexedZSet<usize, usize, isize>> = edges.index();
+
+                let paths = edges.plus(&paths_inverted_indexed.join_trace(&edges_indexed, |_via, from, to| (*from, *to)))
+                    .distinct_trace();
+                paths_delayed.connect(&paths);
+                let output = paths.integrate_trace::<OrdZSetSpine<_, _>>();
+                Ok(output.export())
+            })
+            .unwrap();
+
+            paths.consolidate::<OrdZSet<_, _>>().integrate().distinct().inspect(move |ps| {
+                assert_eq!(*ps, outputs.next().unwrap());
+            })
+        })
+        .unwrap();
+
+        for _ in 0..8 {
+            //eprintln!("{}", i);
+            root.step().unwrap();
+        }
+    }
 }
diff --git a/src/operator/map.rs b/src/operator/map.rs
index 32422090..3a629b07 100644
--- a/src/operator/map.rs
+++ b/src/operator/map.rs
@@ -3,76 +3,58 @@
 use crate::{
     circuit::{
         operator_traits::{Operator, UnaryOperator},
-        Circuit, Scope, Stream,
+        Circuit, Stream,
     },
-    operator::UnaryOperatorAdapter,
-    RefPair, SharedRef,
+    trace::{cursor::Cursor, Batch, BatchReader},
 };
 use std::{borrow::Cow, marker::PhantomData};
 
-impl<P, SR> Stream<Circuit<P>, SR>
+impl<P, B> Stream<Circuit<P>, B>
 where
-    SR: Clone,
+    B: Clone,
     P: Clone + 'static,
 {
     /// Apply [`MapKeys`] operator to `self`.
     ///
     /// The `map` closure takes input keys by reference.
-    pub fn map_keys<K1, K2, V, CO, F>(&self, map: F) -> Stream<Circuit<P>, CO>
+    pub fn map_keys<CO, F>(&self, map: F) -> Stream<Circuit<P>, CO>
     where
-        K1: Clone + 'static,
-        K2: Clone + 'static,
-        V: Clone + 'static,
-        SR: SharedRef + 'static,
-        SR::Target: IntoIterator<Item = (K1, V)> + 'static,
-        for<'a> &'a SR::Target: IntoIterator,
-        for<'a> <&'a SR::Target as IntoIterator>::Item: RefPair<'a, K1, V>,
-        CO: FromIterator<(K2, V)> + Clone + 'static,
-        F: Fn(&K1) -> K2 + Clone + 'static,
+        B: BatchReader<Time = ()> + 'static,
+        CO: Batch<Val = B::Val, Time = (), R = B::R> + Clone + 'static,
+        CO::Val: Clone,
+        F: Fn(&B::Key) -> CO::Key + Clone + 'static,
     {
-        self.circuit().add_unary_operator(
-            UnaryOperatorAdapter::new(MapKeys::new(map.clone(), move |x| (map)(&x))),
-            self,
-        )
+        self.circuit()
+            .add_unary_operator(MapKeys::new(map.clone(), move |x| (map)(&x)), self)
     }
 
     /// Apply [`MapKeys`] operator to `self`.
     ///
     /// The `map` closure operates on owned keys.
-    pub fn map_keys_owned<K1, K2, V, CO, F>(&self, map: F) -> Stream<Circuit<P>, CO>
+    pub fn map_keys_owned<CO, F>(&self, map: F) -> Stream<Circuit<P>, CO>
     where
-        K1: Clone + 'static,
-        K2: Clone + 'static,
-        V: Clone + 'static,
-        SR: SharedRef + 'static,
-        SR::Target: IntoIterator<Item = (K1, V)> + 'static,
-        for<'a> &'a SR::Target: IntoIterator,
-        for<'a> <&'a SR::Target as IntoIterator>::Item: RefPair<'a, K1, V>,
-        CO: FromIterator<(K2, V)> + Clone + 'static,
-        F: Fn(K1) -> K2 + Clone + 'static,
+        B: BatchReader<Time = ()> + 'static,
+        B::Key: Clone,
+        CO: Batch<Val = B::Val, Time = (), R = B::R> + Clone + 'static,
+        CO::Val: Clone,
+        F: Fn(B::Key) -> CO::Key + Clone + 'static,
     {
         let func_clone = map.clone();
         self.circuit().add_unary_operator(
-            UnaryOperatorAdapter::new(MapKeys::new(move |x: &K1| (map)(x.clone()), func_clone)),
+            MapKeys::new(move |x: &B::Key| (map)(x.clone()), func_clone),
             self,
         )
     }
 
     /// Apply [`MapValues`] operator to `self`.
-    pub fn map_values<K, V1, V2, CO, F>(&self, map: F) -> Stream<Circuit<P>, CO>
+    pub fn map_values<CO, F>(&self, map: F) -> Stream<Circuit<P>, CO>
     where
-        K: Clone + 'static,
-        V1: Clone + 'static,
-        V2: Clone + 'static,
-        SR: SharedRef + 'static,
-        SR::Target: IntoIterator<Item = (K, V1)> + 'static,
-        for<'a> &'a SR::Target: IntoIterator,
-        for<'a> <&'a SR::Target as IntoIterator>::Item: RefPair<'a, K, V1>,
-        CO: FromIterator<(K, V2)> + Clone + 'static,
-        F: Fn(&K, &V1) -> V2 + 'static,
+        B: BatchReader<Time = (), Key = CO::Key, R = CO::R> + 'static,
+        CO: Batch<Time = ()> + Clone + 'static,
+        CO::Key: Clone,
+        F: Fn(&B::Key, &B::Val) -> CO::Val + 'static,
     {
-        self.circuit()
-            .add_unary_operator(UnaryOperatorAdapter::new(MapValues::new(map)), self)
+        self.circuit().add_unary_operator(MapValues::new(map), self)
     }
 }
 
@@ -88,35 +70,32 @@ where
 /// * `CO` - output collection type.
 /// * `FB` - key mapping function type that takes a borrowed key.
 /// * `FO` - key mapping function type that takes an owned key.
-pub struct MapKeys<K1, K2, V, CI, CO, FB, FO>
+pub struct MapKeys<CI, CO, FB, FO>
 where
     FB: 'static,
     FO: 'static,
 {
     map_borrowed: FB,
-    map_owned: FO,
-    _type: PhantomData<(K1, K2, V, CI, CO)>,
+    _map_owned: FO,
+    _type: PhantomData<(CI, CO)>,
 }
 
-impl<K1, K2, V, CI, CO, FB, FO> MapKeys<K1, K2, V, CI, CO, FB, FO>
+impl<CI, CO, FB, FO> MapKeys<CI, CO, FB, FO>
 where
     FB: 'static,
     FO: 'static,
 {
-    pub fn new(map_borrowed: FB, map_owned: FO) -> Self {
+    pub fn new(map_borrowed: FB, _map_owned: FO) -> Self {
         Self {
             map_borrowed,
-            map_owned,
+            _map_owned,
             _type: PhantomData,
         }
     }
 }
 
-impl<K1, K2, V, CI, CO, FB, FO> Operator for MapKeys<K1, K2, V, CI, CO, FB, FO>
+impl<CI, CO, FB, FO> Operator for MapKeys<CI, CO, FB, FO>
 where
-    K1: 'static,
-    K2: 'static,
-    V: 'static,
     CI: 'static,
     CO: 'static,
     FB: 'static,
@@ -125,35 +104,39 @@ where
     fn name(&self) -> Cow<'static, str> {
         Cow::from("MapKeys")
     }
-    fn clock_start(&mut self, _scope: Scope) {}
-    fn clock_end(&mut self, _scope: Scope) {}
+    fn fixedpoint(&self) -> bool {
+        true
+    }
 }
 
-impl<K1, K2, V, CI, CO, FB, FO> UnaryOperator<CI, CO> for MapKeys<K1, K2, V, CI, CO, FB, FO>
+impl<CI, CO, FB, FO> UnaryOperator<CI, CO> for MapKeys<CI, CO, FB, FO>
 where
-    K1: Clone + 'static,
-    K2: Clone + 'static,
-    V: Clone + 'static,
-    CI: IntoIterator<Item = (K1, V)> + 'static,
-    for<'a> &'a CI: IntoIterator,
-    for<'a> <&'a CI as IntoIterator>::Item: RefPair<'a, K1, V>,
-    CO: FromIterator<(K2, V)> + 'static,
-    FB: Fn(&K1) -> K2 + 'static,
-    FO: Fn(K1) -> K2 + 'static,
+    CI: BatchReader<Time = ()> + 'static,
+    CI::Val: Clone,
+    CO: Batch<Val = CI::Val, Time = (), R = CI::R> + 'static,
+    FB: Fn(&CI::Key) -> CO::Key + 'static,
+    FO: Fn(CI::Key) -> CO::Key + 'static,
 {
     fn eval(&mut self, i: &CI) -> CO {
-        i.into_iter()
-            .map(|pair| {
-                let (k, v) = pair.into_refs();
-                ((self.map_borrowed)(k), v.clone())
-            })
-            .collect()
+        let mut batch = Vec::with_capacity(i.len());
+
+        let mut cursor = i.cursor();
+        while cursor.key_valid(i) {
+            let k = cursor.key(i);
+            while cursor.val_valid(i) {
+                let v = cursor.val(i);
+                let w = cursor.weight(i);
+                batch.push((((self.map_borrowed)(k), v.clone()), w.clone()));
+                cursor.step_val(i);
+            }
+            cursor.step_key(i);
+        }
+        CO::from_tuples((), batch)
     }
 
     fn eval_owned(&mut self, i: CI) -> CO {
-        i.into_iter()
-            .map(|(k, v)| ((self.map_owned)(k), v))
-            .collect()
+        // TODO: owned implementation.
+        self.eval(&i)
     }
 }
 
@@ -169,15 +152,15 @@ where
 /// * `CI` - input collection type.
 /// * `CO` - output collection type.
 /// * `F` - function that maps input key-value pairs into output values.
-pub struct MapValues<K, V1, V2, CI, CO, F>
+pub struct MapValues<CI, CO, F>
 where
     F: 'static,
 {
     map: F,
-    _type: PhantomData<(K, V1, V2, CI, CO)>,
+    _type: PhantomData<(CI, CO)>,
 }
 
-impl<K, V1, V2, CI, CO, F> MapValues<K, V1, V2, CI, CO, F>
+impl<CI, CO, F> MapValues<CI, CO, F>
 where
     F: 'static,
 {
@@ -189,11 +172,8 @@ where
     }
 }
 
-impl<K, V1, V2, CI, CO, F> Operator for MapValues<K, V1, V2, CI, CO, F>
+impl<CI, CO, F> Operator for MapValues<CI, CO, F>
 where
-    K: 'static,
-    V1: 'static,
-    V2: 'static,
     CI: 'static,
     CO: 'static,
     F: 'static,
@@ -201,90 +181,90 @@ where
     fn name(&self) -> Cow<'static, str> {
         Cow::from("MapValues")
     }
-    fn clock_start(&mut self, _scope: Scope) {}
-    fn clock_end(&mut self, _scope: Scope) {}
+    fn fixedpoint(&self) -> bool {
+        true
+    }
 }
 
-impl<K, V1, V2, CI, CO, F> UnaryOperator<CI, CO> for MapValues<K, V1, V2, CI, CO, F>
+impl<CI, CO, F> UnaryOperator<CI, CO> for MapValues<CI, CO, F>
 where
-    K: Clone + 'static,
-    V1: Clone + 'static,
-    V2: Clone + 'static,
-    CI: IntoIterator<Item = (K, V1)> + 'static,
-    for<'a> &'a CI: IntoIterator,
-    for<'a> <&'a CI as IntoIterator>::Item: RefPair<'a, K, V1>,
-    CO: FromIterator<(K, V2)> + 'static,
-    F: Fn(&K, &V1) -> V2 + 'static,
+    CI: BatchReader<Time = ()> + 'static,
+    CI::Key: Clone,
+    CO: Batch<Key = CI::Key, Time = (), R = CI::R> + 'static,
+    F: Fn(&CI::Key, &CI::Val) -> CO::Val + 'static,
 {
     fn eval(&mut self, i: &CI) -> CO {
-        i.into_iter()
-            .map(|pair| {
-                let (k, v) = pair.into_refs();
-                (k.clone(), (self.map)(k, v))
-            })
-            .collect()
+        let mut batch = Vec::with_capacity(i.len());
+
+        let mut cursor = i.cursor();
+        while cursor.key_valid(i) {
+            let k = cursor.key(i);
+            while cursor.val_valid(i) {
+                let v = cursor.val(i);
+                let w = cursor.weight(i);
+                batch.push(((k.clone(), (self.map)(k, v)), w.clone()));
+                cursor.step_val(i);
+            }
+            cursor.step_key(i);
+        }
+        CO::from_tuples((), batch)
     }
 
     fn eval_owned(&mut self, i: CI) -> CO {
-        i.into_iter()
-            .map(|(k, v)| {
-                let output_v = (self.map)(&k, &v);
-                (k, output_v)
-            })
-            .collect()
+        self.eval(&i)
     }
 }
 
 #[cfg(test)]
 mod test {
     use crate::{
-        algebra::FiniteHashMap,
         circuit::{Root, Stream},
-        finite_map,
         operator::Generator,
+        trace::ord::OrdZSet,
+        zset,
     };
     use std::vec;
 
     #[test]
     fn map_keys_test() {
         let root = Root::build(move |circuit| {
-            let mut input_map: vec::IntoIter<FiniteHashMap<isize, isize>> =
-                vec![finite_map! { 1 => 1, -1 => 1, 5 => 1 }].into_iter();
-            let mut times2_output: vec::IntoIter<FiniteHashMap<isize, isize>> =
-                vec![finite_map! { 2 => 1, -2 => 1, 10 => 1 }].into_iter();
-            let mut times2_pos_output: vec::IntoIter<FiniteHashMap<isize, isize>> =
-                vec![finite_map! { 2 => 1, 10 => 1 }].into_iter();
-            let mut neg_output: vec::IntoIter<FiniteHashMap<isize, isize>> =
-                vec![finite_map! { -1 => 1, 1 => 1, -5 => 1}].into_iter();
-            let mut neg_pos_output: vec::IntoIter<FiniteHashMap<isize, isize>> =
-                vec![finite_map! { -1 => 1, -5 => 1}].into_iter();
+            let mut input_map: vec::IntoIter<OrdZSet<isize, isize>> =
+                vec![zset! { 1 => 1, -1 => 1, 5 => 1 }].into_iter();
+            let mut times2_output: vec::IntoIter<OrdZSet<isize, isize>> =
+                vec![zset! { 2 => 1, -2 => 1, 10 => 1 }].into_iter();
+            let mut times2_pos_output: vec::IntoIter<OrdZSet<isize, isize>> =
+                vec![zset! { 2 => 1, 10 => 1 }].into_iter();
+            let mut neg_output: vec::IntoIter<OrdZSet<isize, isize>> =
+                vec![zset! { -1 => 1, 1 => 1, -5 => 1}].into_iter();
+            let mut neg_pos_output: vec::IntoIter<OrdZSet<isize, isize>> =
+                vec![zset! { -1 => 1, -5 => 1}].into_iter();
 
-            let mut input_vec: vec::IntoIter<Vec<(isize, isize)>> =
-                vec![vec![(1, 1), (-1, 1)]].into_iter();
-            let mut abs_output: vec::IntoIter<FiniteHashMap<isize, isize>> =
-                vec![finite_map! { 1 => 2 }].into_iter();
-            let mut abs_pos_output: vec::IntoIter<FiniteHashMap<isize, isize>> =
-                vec![finite_map! { 1 => 1 }].into_iter();
-            let mut sqr_output: vec::IntoIter<FiniteHashMap<isize, isize>> =
-                vec![finite_map! { 1 => 2, }].into_iter();
-            let mut sqr_pos_output: vec::IntoIter<FiniteHashMap<isize, isize>> =
-                vec![finite_map! { 1 => 1, }].into_iter();
+            let mut input_vec: vec::IntoIter<OrdZSet<isize, isize>> =
+                vec![zset! { 1 => 1, -1 => 1}].into_iter();
+            let mut abs_output: vec::IntoIter<OrdZSet<isize, isize>> =
+                vec![zset! { 1 => 2 }].into_iter();
+            let mut abs_pos_output: vec::IntoIter<OrdZSet<isize, isize>> =
+                vec![zset! { 1 => 1 }].into_iter();
+            let mut sqr_output: vec::IntoIter<OrdZSet<isize, isize>> =
+                vec![zset! { 1 => 2, }].into_iter();
+            let mut sqr_pos_output: vec::IntoIter<OrdZSet<isize, isize>> =
+                vec![zset! { 1 => 1, }].into_iter();
 
             let input_map_stream =
                 circuit.add_source(Generator::new(move || input_map.next().unwrap()));
             let input_vec_stream =
                 circuit.add_source(Generator::new(move || input_vec.next().unwrap()));
-            let times2: Stream<_, FiniteHashMap<_, _>> = input_map_stream.map_keys(|n| n * 2);
-            let times2_pos: Stream<_, FiniteHashMap<_, _>> =
+            let times2: Stream<_, OrdZSet<_, _>> = input_map_stream.map_keys(|n| n * 2);
+            let times2_pos: Stream<_, OrdZSet<_, _>> =
                 input_map_stream.filter_map_keys(|n| if *n > 0 { Some(n * 2) } else { None });
-            let neg: Stream<_, FiniteHashMap<_, _>> = input_map_stream.map_keys_owned(|n| -n);
-            let neg_pos: Stream<_, FiniteHashMap<_, _>> =
+            let neg: Stream<_, OrdZSet<_, _>> = input_map_stream.map_keys_owned(|n| -n);
+            let neg_pos: Stream<_, OrdZSet<_, _>> =
                 input_map_stream.filter_map_keys_owned(|n| if n > 0 { Some(-n) } else { None });
-            let abs: Stream<_, FiniteHashMap<_, _>> = input_vec_stream.map_keys(|n| n.abs());
-            let abs_pos: Stream<_, FiniteHashMap<_, _>> =
+            let abs: Stream<_, OrdZSet<_, _>> = input_vec_stream.map_keys(|n| n.abs());
+            let abs_pos: Stream<_, OrdZSet<_, _>> =
                 input_vec_stream.filter_map_keys(|n| if *n > 0 { Some(n.abs()) } else { None });
-            let sqr: Stream<_, FiniteHashMap<_, _>> = input_vec_stream.map_keys_owned(|n| n * n);
-            let sqr_pos: Stream<_, FiniteHashMap<_, _>> =
+            let sqr: Stream<_, OrdZSet<_, _>> = input_vec_stream.map_keys_owned(|n| n * n);
+            let sqr_pos: Stream<_, OrdZSet<_, _>> =
                 input_vec_stream.filter_map_keys_owned(|n| if n > 0 { Some(n * n) } else { None });
             times2.inspect(move |n| {
                 assert_eq!(*n, times2_output.next().unwrap());
diff --git a/src/operator/mod.rs b/src/operator/mod.rs
index fddb3dc0..b88aee51 100644
--- a/src/operator/mod.rs
+++ b/src/operator/mod.rs
@@ -21,7 +21,9 @@ pub use z1::{DelayedFeedback, DelayedNestedFeedback, Z1Nested, Z1};
 mod generator;
 pub use generator::{Generator, GeneratorNested};
 
+mod consolidate;
 mod integrate;
+mod trace;
 
 pub mod communication;
 
diff --git a/src/operator/plus.rs b/src/operator/plus.rs
index 6af73ec6..67dfa58e 100644
--- a/src/operator/plus.rs
+++ b/src/operator/plus.rs
@@ -4,7 +4,7 @@ use crate::{
     algebra::{AddAssignByRef, AddByRef, NegByRef},
     circuit::{
         operator_traits::{BinaryOperator, Operator},
-        Circuit, OwnershipPreference, Scope, Stream,
+        Circuit, OwnershipPreference, Stream,
     },
 };
 use std::{
@@ -16,7 +16,7 @@ use std::{
 impl<P, D> Stream<Circuit<P>, D>
 where
     P: Clone + 'static,
-    D: Add<Output = D> + AddByRef + AddAssignByRef + Neg<Output = D> + NegByRef + Clone + 'static,
+    D: Add<Output = D> + AddByRef + AddAssignByRef + Clone + 'static,
 {
     /// Apply the [`Plus`] operator to `self` and `other`.
     ///
@@ -54,7 +54,13 @@ where
     pub fn plus(&self, other: &Stream<Circuit<P>, D>) -> Stream<Circuit<P>, D> {
         self.circuit().add_binary_operator(Plus::new(), self, other)
     }
+}
 
+impl<P, D> Stream<Circuit<P>, D>
+where
+    P: Clone + 'static,
+    D: Add<Output = D> + AddByRef + AddAssignByRef + Neg<Output = D> + NegByRef + Clone + 'static,
+{
     /// Apply the [`Minus`] operator to `self` and `other`.
     pub fn minus(&self, other: &Stream<Circuit<P>, D>) -> Stream<Circuit<P>, D> {
         self.circuit()
@@ -84,8 +90,9 @@ where
         Cow::from("Plus")
     }
 
-    fn clock_start(&mut self, _scope: Scope) {}
-    fn clock_end(&mut self, _scope: Scope) {}
+    fn fixedpoint(&self) -> bool {
+        true
+    }
 }
 
 impl<D> BinaryOperator<D, D, D> for Plus<D>
@@ -140,8 +147,9 @@ where
         Cow::from("Minus")
     }
 
-    fn clock_start(&mut self, _scope: Scope) {}
-    fn clock_end(&mut self, _scope: Scope) {}
+    fn fixedpoint(&self) -> bool {
+        true
+    }
 }
 
 // TODO: Add `subtract` operation to `GroupValue`, which
@@ -179,9 +187,11 @@ where
 #[cfg(test)]
 mod test {
     use crate::{
-        algebra::{MapBuilder, ZSetHashMap},
+        algebra::HasZero,
         circuit::{Circuit, OwnershipPreference, Root},
         operator::{Generator, Inspect},
+        trace::{ord::OrdZSet, Batch},
+        zset,
     };
 
     #[test]
@@ -211,40 +221,40 @@ mod test {
     #[test]
     fn zset_plus() {
         let build_plus_circuit = |circuit: &Circuit<()>| {
-            let mut s = ZSetHashMap::new();
+            let mut s = <OrdZSet<_, _>>::zero();
+            let delta = zset! { 5 => 1};
             let source1 = circuit.add_source(Generator::new(move || {
-                let res = s.clone();
-                s.increment(&5, 1);
-                res
+                s = s.merge(&delta);
+                s.clone()
             }));
-            let mut s = ZSetHashMap::new();
+            let mut s = <OrdZSet<_, _>>::zero();
+            let delta = zset! { 5 => -1};
             let source2 = circuit.add_source(Generator::new(move || {
-                let res = s.clone();
-                s.increment(&5, -1);
-                res
+                s = s.merge(&delta);
+                s.clone()
             }));
             source1
                 .plus(&source2)
-                .inspect(|s| assert_eq!(s, &ZSetHashMap::new()));
+                .inspect(|s| assert_eq!(s, &<OrdZSet<usize, isize>>::zero()));
             (source1, source2)
         };
 
         let build_minus_circuit = |circuit: &Circuit<()>| {
-            let mut s = ZSetHashMap::new();
+            let mut s = <OrdZSet<_, _>>::zero();
+            let delta = zset! { 5 => 1};
             let source1 = circuit.add_source(Generator::new(move || {
-                let res = s.clone();
-                s.increment(&5, 1);
-                res
+                s = s.merge(&delta);
+                s.clone()
             }));
-            let mut s = ZSetHashMap::new();
+            let mut s = <OrdZSet<_, _>>::zero();
+            let delta = zset! { 5 => 1};
             let source2 = circuit.add_source(Generator::new(move || {
-                let res = s.clone();
-                s.increment(&5, 1);
-                res
+                s = s.merge(&delta);
+                s.clone()
             }));
             source1
                 .minus(&source2)
-                .inspect(|s| assert_eq!(s, &ZSetHashMap::new()));
+                .inspect(|s| assert_eq!(s, &<OrdZSet<_, _>>::zero()));
             (source1, source2)
         };
         // Allow `Plus` to consume both streams by value.
diff --git a/src/operator/sum.rs b/src/operator/sum.rs
index 4cb66b80..bd49b4f6 100644
--- a/src/operator/sum.rs
+++ b/src/operator/sum.rs
@@ -1,11 +1,12 @@
 //! N-ary plus operator.
 
 use crate::{
-    algebra::{AddAssignByRef, AddByRef, HasZero, WithNumEntries},
+    algebra::{AddAssignByRef, AddByRef, HasZero},
     circuit::{
         operator_traits::{NaryOperator, Operator},
-        Circuit, OwnershipPreference, Scope, Stream,
+        Circuit, OwnershipPreference, Stream,
     },
+    NumEntries,
 };
 use std::{
     borrow::Cow,
@@ -18,7 +19,7 @@ use std::{
 impl<P, D> Stream<Circuit<P>, D>
 where
     P: Clone + 'static,
-    D: Add<Output = D> + AddByRef + AddAssignByRef + Clone + HasZero + WithNumEntries + 'static,
+    D: Add<Output = D> + AddByRef + AddAssignByRef + Clone + HasZero + NumEntries + 'static,
 {
     /// Apply the [`Sum`] operator to `self` and all streams in `streams`.
     pub fn sum<'a, I>(&'a self, streams: I) -> Stream<Circuit<P>, D>
@@ -67,13 +68,14 @@ where
         Cow::from("Sum")
     }
 
-    fn clock_start(&mut self, _scope: Scope) {}
-    fn clock_end(&mut self, _scope: Scope) {}
+    fn fixedpoint(&self) -> bool {
+        true
+    }
 }
 
 impl<D> NaryOperator<D, D> for Sum<D>
 where
-    D: Add<Output = D> + AddAssignByRef + Clone + HasZero + WithNumEntries + 'static,
+    D: Add<Output = D> + AddAssignByRef + Clone + HasZero + NumEntries + 'static,
 {
     fn eval<'a, Iter>(&mut self, inputs: Iter) -> D
     where
@@ -91,7 +93,7 @@ where
             input_vec.push(input);
         }
 
-        input_vec.sort_by_key(|x| Reverse(x.num_entries()));
+        input_vec.sort_by_key(|x| Reverse(x.num_entries_shallow()));
 
         let mut res = D::zero();
         for input in input_vec.drain(..) {
@@ -126,38 +128,39 @@ where
 #[cfg(test)]
 mod test {
     use crate::{
-        algebra::{MapBuilder, ZSetHashMap},
+        algebra::HasZero,
         circuit::{Circuit, OwnershipPreference, Root},
         operator::{Generator, Inspect},
+        trace::{ord::OrdZSet, Batch},
+        zset,
     };
 
     #[test]
     fn zset_sum() {
         let build_circuit = |circuit: &Circuit<()>| {
-            let mut s = ZSetHashMap::new();
+            let mut s = <OrdZSet<_, _> as HasZero>::zero();
             let source1 = circuit.add_source(Generator::new(move || {
                 let res = s.clone();
-                s.increment(&5, 1);
-                s.increment(&6, 2);
+                s = s.merge(&zset! { 5 => 1, 6 => 2 });
                 res
             }));
-            let mut s = ZSetHashMap::new();
+            let mut s = <OrdZSet<_, _> as HasZero>::zero();
             let source2 = circuit.add_source(Generator::new(move || {
                 let res = s.clone();
-                s.increment(&5, -1);
+                s = s.merge(&zset! { 5 => -1 });
                 res
             }));
-            let mut s = ZSetHashMap::new();
+            let mut s = <OrdZSet<_, _> as HasZero>::zero();
             let source3 = circuit.add_source(Generator::new(move || {
                 let res = s.clone();
-                s.increment(&6, -1);
+                s = s.merge(&zset! { 6 => -1 });
                 res
             }));
 
             // Supply `source3` twice to test the handling of aliases.
             source3
                 .sum(&[source2.clone(), source1.clone(), source3.clone()])
-                .inspect(|s| assert_eq!(s, &ZSetHashMap::new()));
+                .inspect(|s| assert_eq!(s, &<OrdZSet<_, _> as HasZero>::zero()));
             (source1, source2, source3)
         };
 
diff --git a/src/operator/trace.rs b/src/operator/trace.rs
new file mode 100644
index 00000000..591b90c9
--- /dev/null
+++ b/src/operator/trace.rs
@@ -0,0 +1,424 @@
+use crate::{
+    circuit::{
+        operator_traits::{BinaryOperator, Operator, StrictOperator, StrictUnaryOperator},
+        Circuit, ExportId, ExportStream, NodeId, OwnershipPreference, Scope, Stream,
+    },
+    circuit_cache_key,
+    time::NestedTimestamp32,
+    trace::{cursor::Cursor, Batch, BatchReader, Builder, Trace, TraceReader},
+    NumEntries, Timestamp,
+};
+use deepsize::DeepSizeOf;
+use std::{borrow::Cow, fmt::Write, marker::PhantomData, rc::Rc};
+
+circuit_cache_key!(TraceId<B, D>(NodeId => Stream<B, D>));
+circuit_cache_key!(DelayedTraceId<B, D>(NodeId => Stream<B, D>));
+circuit_cache_key!(IntegrateTraceId<B, D>(NodeId => Stream<B, D>));
+circuit_cache_key!(DelayedIntegrateTraceId<B, D>(NodeId => Stream<B, D>));
+
+// TODO: add infrastructure to compact the trace during slack time.
+
+/// Add `timestamp` to all tuples in the input batch.
+///
+/// Given an input batch without timing information (`BatchReader::Time = ()`),
+/// generate an output batch by adding the same time `timestamp` to
+/// each tuple.
+///
+/// Most DBSP operators output untimed batches.  When such a batch is
+/// added to a trace, the current timestamp must be added to it.
+// TODO: this can be implemented more efficiently by having a special batch type
+// where all updates have the same timestamp, as this is the only kind of
+// batch that we ever create directly in DBSP; batches with multiple timestamps
+// are only created as a result of merging.  The main complication is that
+// we will need to extend the trace implementation to work with batches of
+// multiple types.  This shouldn't be too hard and is on the todo list.
+fn batch_add_time<BI, TS, BO>(batch: &BI, timestamp: &TS) -> BO
+where
+    TS: Timestamp,
+    BI: BatchReader<Time = ()>,
+    BI::Key: Clone,
+    BI::Val: Clone,
+    BO: Batch<Key = BI::Key, Val = BI::Val, Time = TS, R = BI::R>,
+{
+    let mut builder = BO::Builder::with_capacity(timestamp.clone(), batch.len());
+    let mut cursor = batch.cursor();
+    while cursor.key_valid(batch) {
+        let key = cursor.key(batch);
+        while cursor.val_valid(batch) {
+            let val = cursor.val(batch);
+            let w = cursor.weight(batch);
+            builder.push((key.clone(), val.clone(), w.clone()));
+            cursor.step_val(batch);
+        }
+        cursor.step_key(batch);
+    }
+    builder.done()
+}
+
+impl<P, B> Stream<Circuit<P>, B>
+where
+    P: Clone + 'static,
+    B: Clone + 'static,
+{
+    // TODO: derive timestamp type from the parent circuit.
+
+    /// Record batches in `self` in a trace.
+    ///
+    /// This operator labels each untimed batch in the stream with the current
+    /// timestamp and adds it to a trace.  
+    pub fn trace<T>(&self) -> Stream<Circuit<P>, T>
+    where
+        B: BatchReader<Time = ()>,
+        B::Key: Clone,
+        B::Val: Clone,
+        T: NumEntries
+            + DeepSizeOf
+            + Trace<Key = B::Key, Val = B::Val, Time = NestedTimestamp32, R = B::R>
+            + Clone
+            + 'static,
+    {
+        self.circuit()
+            .cache_get_or_insert_with(TraceId::new(self.local_node_id()), || {
+                self.circuit().region("trace", || {
+                    let (ExportStream { local, export }, z1feedback) =
+                        self.circuit().add_feedback_with_export(Z1Trace::new(false));
+                    let trace = self.circuit().add_binary_operator_with_preference(
+                        <TraceAppend<T, B>>::new(),
+                        &local,
+                        self,
+                        OwnershipPreference::STRONGLY_PREFER_OWNED,
+                        OwnershipPreference::PREFER_OWNED,
+                    );
+                    z1feedback.connect_with_preference(
+                        &trace,
+                        OwnershipPreference::STRONGLY_PREFER_OWNED,
+                    );
+                    self.circuit()
+                        .cache_insert(DelayedTraceId::new(trace.local_node_id()), local);
+                    self.circuit()
+                        .cache_insert(ExportId::new(trace.local_node_id()), export);
+                    trace
+                })
+            })
+            .clone()
+    }
+
+    // TODO: this method should replace `Stream::integrate()`.
+    pub fn integrate_trace<T>(&self) -> Stream<Circuit<P>, T>
+    where
+        B: Batch,
+        T: NumEntries + DeepSizeOf + Trace<Batch = Rc<B>> + Clone + 'static,
+        T::Time: Timestamp,
+    {
+        self.circuit()
+            .cache_get_or_insert_with(IntegrateTraceId::new(self.local_node_id()), || {
+                self.circuit().region("integrate_trace", || {
+                    let (ExportStream { local, export }, z1feedback) =
+                        self.circuit().add_feedback_with_export(Z1Trace::new(true));
+                    let trace = self.circuit().add_binary_operator_with_preference(
+                        <UntimedTraceAppend<T, B>>::new(),
+                        &local,
+                        self,
+                        OwnershipPreference::STRONGLY_PREFER_OWNED,
+                        OwnershipPreference::PREFER_OWNED,
+                    );
+                    z1feedback.connect_with_preference(
+                        &trace,
+                        OwnershipPreference::STRONGLY_PREFER_OWNED,
+                    );
+                    self.circuit()
+                        .cache_insert(DelayedIntegrateTraceId::new(trace.local_node_id()), local);
+                    self.circuit()
+                        .cache_insert(ExportId::new(trace.local_node_id()), export);
+                    trace
+                })
+            })
+            .clone()
+    }
+}
+
+impl<P, T> Stream<Circuit<P>, T>
+where
+    P: Clone + 'static,
+    T: TraceReader + 'static,
+{
+    pub fn delay_trace(&self) -> Stream<Circuit<P>, T> {
+        self.circuit()
+            .cache_get_or_insert_with(
+                DelayedTraceId::new(self.local_node_id()),
+                || unimplemented!(),
+            )
+            .clone()
+    }
+}
+
+pub struct UntimedTraceAppend<T, B>
+where
+    T: TraceReader,
+{
+    _phantom: PhantomData<(T, B)>,
+}
+
+impl<T, B> UntimedTraceAppend<T, B>
+where
+    T: TraceReader,
+{
+    pub fn new() -> Self {
+        Self {
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<T, B> Default for UntimedTraceAppend<T, B>
+where
+    T: TraceReader,
+{
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<T, B> Operator for UntimedTraceAppend<T, B>
+where
+    T: TraceReader + 'static,
+    B: 'static,
+{
+    fn name(&self) -> Cow<'static, str> {
+        Cow::from("UntimedTraceAppend")
+    }
+    fn fixedpoint(&self) -> bool {
+        true
+    }
+}
+
+impl<T, B> BinaryOperator<T, B, T> for UntimedTraceAppend<T, B>
+where
+    B: Batch + Clone + 'static,
+    T: Trace<Batch = Rc<B>> + 'static,
+{
+    fn eval(&mut self, _trace: &T, _batch: &B) -> T {
+        // Refuse to accept trace by reference.  This should not happen in a correctly
+        // constructed circuit.
+        unimplemented!()
+    }
+
+    fn eval_owned_and_ref(&mut self, mut trace: T, batch: &B) -> T {
+        trace.insert(From::from(batch.clone()));
+        trace
+    }
+
+    fn eval_ref_and_owned(&mut self, _trace: &T, _batch: B) -> T {
+        // Refuse to accept trace by reference.  This should not happen in a correctly
+        // constructed circuit.
+        unimplemented!()
+    }
+
+    fn eval_owned(&mut self, mut trace: T, batch: B) -> T {
+        trace.insert(Rc::new(batch));
+        trace
+    }
+
+    fn input_preference(&self) -> (OwnershipPreference, OwnershipPreference) {
+        (
+            OwnershipPreference::PREFER_OWNED,
+            OwnershipPreference::PREFER_OWNED,
+        )
+    }
+}
+
+pub struct TraceAppend<T, B>
+where
+    T: TraceReader,
+{
+    time: T::Time,
+    _phantom: PhantomData<B>,
+}
+
+impl<T, B> TraceAppend<T, B>
+where
+    T: TraceReader,
+{
+    pub fn new() -> Self {
+        Self {
+            time: T::Time::minimum(),
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<T, B> Default for TraceAppend<T, B>
+where
+    T: TraceReader,
+{
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<T, B> Operator for TraceAppend<T, B>
+where
+    T: TraceReader + 'static,
+    B: 'static,
+{
+    fn name(&self) -> Cow<'static, str> {
+        Cow::from("TraceAppend")
+    }
+    fn clock_start(&mut self, scope: Scope) {
+        self.time = self.time.advance(scope + 1);
+    }
+    fn fixedpoint(&self) -> bool {
+        true
+    }
+}
+
+impl<T, B> BinaryOperator<T, B, T> for TraceAppend<T, B>
+where
+    B: BatchReader<Time = ()> + 'static,
+    B::Key: Clone,
+    B::Val: Clone,
+    T: Trace<Key = B::Key, Val = B::Val, R = B::R> + 'static,
+{
+    fn eval(&mut self, _trace: &T, _batch: &B) -> T {
+        // Refuse to accept trace by reference.  This should not happen in a correctly
+        // constructed circuit.
+        unimplemented!()
+    }
+
+    fn eval_owned_and_ref(&mut self, mut trace: T, batch: &B) -> T {
+        // TODO: extend `trace` type to feed untimed batches directly
+        // (adding fixed timestamp on the fly).
+        trace.insert(batch_add_time(batch, &self.time));
+        self.time = self.time.advance(0);
+        trace
+    }
+
+    fn eval_ref_and_owned(&mut self, _trace: &T, _batch: B) -> T {
+        // Refuse to accept trace by reference.  This should not happen in a correctly
+        // constructed circuit.
+        unimplemented!()
+    }
+
+    fn eval_owned(&mut self, mut trace: T, batch: B) -> T {
+        trace.insert(batch_add_time(&batch, &self.time));
+        self.time = self.time.advance(0);
+        trace
+    }
+
+    fn input_preference(&self) -> (OwnershipPreference, OwnershipPreference) {
+        (
+            OwnershipPreference::PREFER_OWNED,
+            OwnershipPreference::PREFER_OWNED,
+        )
+    }
+}
+
+pub struct Z1Trace<T: TraceReader> {
+    time: T::Time,
+    trace: Option<T>,
+    reset_on_clock_start: bool,
+}
+
+impl<T> Z1Trace<T>
+where
+    T: Trace,
+{
+    pub fn new(reset_on_clock_start: bool) -> Self {
+        Self {
+            time: T::Time::minimum(),
+            trace: None,
+            reset_on_clock_start,
+        }
+    }
+}
+
+impl<T> Operator for Z1Trace<T>
+where
+    T: Trace + DeepSizeOf + NumEntries + 'static,
+    T::Time: Timestamp,
+{
+    fn name(&self) -> Cow<'static, str> {
+        Cow::from("Z1 (trace)")
+    }
+
+    fn clock_start(&mut self, scope: Scope) {
+        self.time.advance(scope + 1);
+        if scope == 0 && self.trace.is_none() {
+            // TODO: use T::with_effort with configurable effort?
+            self.trace = Some(T::new(None));
+        }
+    }
+    fn clock_end(&mut self, scope: Scope) {
+        if scope == 0 {
+            if let Some(tr) = self.trace.as_mut() {
+                tr.recede_to(&self.time.recede(1));
+            }
+        }
+    }
+
+    fn summary(&self, summary: &mut String) {
+        writeln!(
+            summary,
+            "size: {}",
+            self.trace
+                .as_ref()
+                .map(|trace| trace.num_entries_deep())
+                .unwrap_or(0)
+        )
+        .unwrap();
+
+        let bytes = self
+            .trace
+            .as_ref()
+            .map(|trace| trace.deep_size_of())
+            .unwrap_or(0);
+        writeln!(summary, "bytes: {}", bytes).unwrap();
+        //println!("zbytes:{}", bytes);
+    }
+
+    fn fixedpoint(&self) -> bool {
+        match &self.trace {
+            None => false,
+            Some(trace) => !trace.dirty(),
+        }
+    }
+}
+
+impl<T> StrictOperator<T> for Z1Trace<T>
+where
+    T: DeepSizeOf + NumEntries + Trace + 'static,
+    T::Time: Timestamp,
+{
+    fn get_output(&mut self) -> T {
+        let mut result = self.trace.take().unwrap();
+        result.clear_dirty_flag();
+        result
+    }
+
+    fn get_final_output(&mut self) -> T {
+        if self.reset_on_clock_start {
+            self.get_output()
+        } else {
+            T::new(None)
+        }
+    }
+}
+
+impl<T> StrictUnaryOperator<T, T> for Z1Trace<T>
+where
+    T: DeepSizeOf + NumEntries + Trace + 'static,
+    T::Time: Timestamp,
+{
+    fn eval_strict(&mut self, _i: &T) {
+        unimplemented!()
+    }
+
+    fn eval_strict_owned(&mut self, i: T) {
+        self.time = self.time.advance(0);
+        self.trace = Some(i);
+    }
+
+    fn input_preference(&self) -> OwnershipPreference {
+        OwnershipPreference::PREFER_OWNED
+    }
+}
diff --git a/src/operator/z1.rs b/src/operator/z1.rs
index 24b0ff61..523d9f6b 100644
--- a/src/operator/z1.rs
+++ b/src/operator/z1.rs
@@ -9,6 +9,7 @@ use crate::{
     },
     circuit_cache_key, NumEntries,
 };
+use deepsize::DeepSizeOf;
 use std::{borrow::Cow, fmt::Write, mem::replace};
 
 circuit_cache_key!(DelayedId<C, D>(NodeId => Stream<C, D>));
@@ -28,7 +29,7 @@ pub struct DelayedFeedback<P, D> {
 impl<P, D> DelayedFeedback<P, D>
 where
     P: Clone + 'static,
-    D: NumEntries + Clone + HasZero + 'static,
+    D: Eq + DeepSizeOf + NumEntries + Clone + HasZero + 'static,
 {
     /// Create a feedback loop with `Z1` operator.  Use [`Self::connect`] to
     /// close the loop.
@@ -77,7 +78,7 @@ pub struct DelayedNestedFeedback<P, D> {
 impl<P, D> DelayedNestedFeedback<P, D>
 where
     P: Clone + 'static,
-    D: NumEntries + Clone + 'static,
+    D: Eq + DeepSizeOf + NumEntries + Clone + 'static,
 {
     /// Create a feedback loop with `Z1` operator.  Use [`Self::connect`] to
     /// close the loop.
@@ -109,7 +110,7 @@ impl<P, D> Stream<Circuit<P>, D> {
     pub fn delay(&self) -> Stream<Circuit<P>, D>
     where
         P: Clone + 'static,
-        D: NumEntries + Clone + HasZero + 'static,
+        D: Eq + DeepSizeOf + NumEntries + Clone + HasZero + 'static,
     {
         self.circuit()
             .cache_get_or_insert_with(DelayedId::new(self.local_node_id()), || {
@@ -122,7 +123,7 @@ impl<P, D> Stream<Circuit<P>, D> {
     pub fn delay_nested(&self) -> Stream<Circuit<P>, D>
     where
         P: Clone + 'static,
-        D: Clone + HasZero + NumEntries + 'static,
+        D: Eq + Clone + HasZero + DeepSizeOf + NumEntries + 'static,
     {
         self.circuit()
             .cache_get_or_insert_with(NestedDelayedId::new(self.local_node_id()), || {
@@ -156,6 +157,7 @@ impl<P, D> Stream<Circuit<P>, D> {
 /// ```
 pub struct Z1<T> {
     zero: T,
+    empty_output: bool,
     val: T,
 }
 
@@ -166,18 +168,15 @@ where
     pub fn new(zero: T) -> Self {
         Self {
             zero: zero.clone(),
+            empty_output: false,
             val: zero,
         }
     }
-
-    fn reset(&mut self) {
-        self.val = self.zero.clone();
-    }
 }
 
 impl<T> Operator for Z1<T>
 where
-    T: NumEntries + Clone + 'static,
+    T: Eq + DeepSizeOf + NumEntries + Clone + 'static,
 {
     fn name(&self) -> Cow<'static, str> {
         Cow::from("Z^-1")
@@ -185,18 +184,29 @@ where
 
     fn clock_start(&mut self, _scope: Scope) {}
     fn clock_end(&mut self, _scope: Scope) {
-        self.reset();
+        self.empty_output = false;
+        self.val = self.zero.clone();
     }
 
     fn summary(&self, summary: &mut String) {
-        summary.clear();
-        writeln!(summary, "size: {}", self.val.num_entries()).unwrap();
+        writeln!(summary, "size: {}", self.val.num_entries_deep()).unwrap();
+
+        let bytes = self.val.deep_size_of();
+        writeln!(summary, "bytes: {}", bytes).unwrap();
+        //println!("zbytes:{}", bytes);
+    }
+
+    fn fixedpoint(&self) -> bool {
+        (self.val.num_entries_shallow() == 0) && self.empty_output
+        /*if res == false {
+            eprintln!("num_entries_shallow: {}", self.val.num_entries_shallow());
+        }*/
     }
 }
 
 impl<T> UnaryOperator<T, T> for Z1<T>
 where
-    T: NumEntries + Clone + 'static,
+    T: Eq + DeepSizeOf + NumEntries + Clone + 'static,
 {
     fn eval(&mut self, i: &T) -> T {
         replace(&mut self.val, i.clone())
@@ -213,16 +223,21 @@ where
 
 impl<T> StrictOperator<T> for Z1<T>
 where
-    T: NumEntries + Clone + 'static,
+    T: Eq + DeepSizeOf + NumEntries + Clone + 'static,
 {
     fn get_output(&mut self) -> T {
+        self.empty_output = self.val.num_entries_shallow() == 0;
         replace(&mut self.val, self.zero.clone())
     }
+
+    fn get_final_output(&mut self) -> T {
+        self.get_output()
+    }
 }
 
 impl<T> StrictUnaryOperator<T, T> for Z1<T>
 where
-    T: NumEntries + Clone + 'static,
+    T: Eq + DeepSizeOf + NumEntries + Clone + 'static,
 {
     fn eval_strict(&mut self, i: &T) {
         self.val = i.clone();
@@ -241,7 +256,7 @@ where
 ///
 /// The operator stores a complete nested stream consumed at the last iteration
 /// of the parent clock and outputs it at the next parent clock cycle.
-/// It outputs a stream of zeros value in the first parent clock tick.
+/// It outputs a stream of zeros in the first parent clock tick.
 ///
 /// One important subtlety is that mathematically speaking nested streams are
 /// infinite, but we can only compute and store finite prefixes of such
@@ -294,7 +309,7 @@ impl<T> Z1Nested<T> {
 
 impl<T> Operator for Z1Nested<T>
 where
-    T: NumEntries + Clone + 'static,
+    T: Eq + DeepSizeOf + NumEntries + Clone + 'static,
 {
     fn name(&self) -> Cow<'static, str> {
         Cow::from("Z^-1 (nested)")
@@ -314,11 +329,10 @@ where
     }
 
     fn summary(&self, summary: &mut String) {
-        summary.clear();
         let mut total = 0;
         write!(summary, "sizes: [").unwrap();
         for (i, v) in self.val.iter().enumerate() {
-            let nentries = v.num_entries();
+            let nentries = v.num_entries_deep();
             total += nentries;
             if i == self.val.len() - 1 {
                 write!(summary, "{}", nentries).unwrap();
@@ -328,12 +342,34 @@ where
         }
         writeln!(summary, "]").unwrap();
         writeln!(summary, "total: {}", total).unwrap();
+
+        let mut total_bytes = 0;
+        write!(summary, "byte sizes: [").unwrap();
+        for (i, v) in self.val.iter().enumerate() {
+            let bytes = v.deep_size_of();
+            total_bytes += bytes;
+            if i == self.val.len() - 1 {
+                write!(summary, "{}", bytes).unwrap();
+            } else {
+                write!(summary, "{},", bytes).unwrap();
+            }
+        }
+        writeln!(summary, "]").unwrap();
+        writeln!(summary, "total bytes: {}", total_bytes).unwrap();
+        //println!("bytes: {}", total_bytes);
+    }
+
+    fn fixedpoint(&self) -> bool {
+        self.val
+            .iter()
+            .skip(self.timestamp - 1)
+            .all(|v| *v == self.zero)
     }
 }
 
 impl<T> UnaryOperator<T, T> for Z1Nested<T>
 where
-    T: NumEntries + Clone + 'static,
+    T: Eq + DeepSizeOf + NumEntries + Clone + 'static,
 {
     fn eval(&mut self, i: &T) -> T {
         debug_assert!(self.timestamp <= self.val.len());
@@ -372,7 +408,7 @@ where
 
 impl<T> StrictOperator<T> for Z1Nested<T>
 where
-    T: NumEntries + Clone + 'static,
+    T: Eq + DeepSizeOf + NumEntries + Clone + 'static,
 {
     fn get_output(&mut self) -> T {
         if self.timestamp >= self.val.len() {
@@ -388,11 +424,15 @@ where
             self.zero.clone(),
         )
     }
+
+    fn get_final_output(&mut self) -> T {
+        self.get_output()
+    }
 }
 
 impl<T> StrictUnaryOperator<T, T> for Z1Nested<T>
 where
-    T: NumEntries + Clone + 'static,
+    T: Eq + DeepSizeOf + NumEntries + Clone + 'static,
 {
     fn eval_strict(&mut self, i: &T) {
         debug_assert!(self.timestamp < self.val.len());
diff --git a/src/test/mod.rs b/src/test/mod.rs
deleted file mode 100644
index 0b7ab748..00000000
--- a/src/test/mod.rs
+++ /dev/null
@@ -1,107 +0,0 @@
-#![cfg(test)]
-
-use crate::{
-    algebra::{AddByRef, MapBuilder, ZSetHashMap},
-    circuit::{operator_traits::SourceOperator, Root},
-    finite_map,
-    operator::Generator,
-};
-use std::{cell::RefCell, ops::Deref, rc::Rc};
-
-fn make_generator() -> impl SourceOperator<ZSetHashMap<i64, i64>> {
-    let mut z = ZSetHashMap::new();
-    let mut count = 0i64;
-
-    Generator::new(move || {
-        count += 1;
-        let result = z.clone();
-        z.increment(&count, 1i64);
-        result
-    })
-}
-
-// Apply functions to a stream
-#[test]
-fn map() {
-    let actual_data = Rc::new(RefCell::new(Vec::new()));
-    let actual_data_clone = actual_data.clone();
-    let root = Root::build(|circuit| {
-        circuit
-            .add_source(make_generator())
-            .apply(|map| map.add_by_ref(map))
-            .inspect(move |map| actual_data.borrow_mut().push(map.clone()));
-    })
-    .unwrap();
-
-    for _ in 0..3 {
-        root.step().unwrap()
-    }
-
-    let expected = vec![
-        finite_map! {},
-        finite_map! { 1 => 2 },
-        finite_map! { 1 => 2, 2 => 2 },
-    ];
-    assert_eq!(&expected, actual_data_clone.borrow().deref());
-}
-
-fn make_tuple_generator() -> impl SourceOperator<ZSetHashMap<(i64, i64), i64>> {
-    let mut z = ZSetHashMap::new();
-    let mut count = 0;
-
-    Generator::new(move || {
-        count += 1;
-        let result = z.clone();
-        z.increment(&(count, count + 1), 1i64);
-        result
-    })
-}
-
-// Test a map on a relation containing tuples
-#[test]
-fn tuple_relation_test() {
-    let actual_data = Rc::new(RefCell::new(Vec::new()));
-    let actual_data_clone = actual_data.clone();
-    let root = Root::build(|circuit| {
-        circuit
-            .add_source(make_tuple_generator())
-            .apply(|map| map.add_by_ref(map))
-            .inspect(move |map| actual_data.borrow_mut().push(map.clone()));
-    })
-    .unwrap();
-
-    for _ in 0..3 {
-        root.step().unwrap()
-    }
-
-    let expected = vec![
-        finite_map! {},
-        finite_map! { (1, 2) => 2 },
-        finite_map! {
-            (1, 2) => 2,
-            (2, 3) => 2,
-        },
-    ];
-    assert_eq!(&expected, actual_data_clone.borrow().deref());
-}
-
-// Test a filter on a relation containing tuples
-#[test]
-fn tuple_filter_test() {
-    let actual_data = Rc::new(RefCell::new(Vec::new()));
-    let actual_data_clone = actual_data.clone();
-    let root = Root::build(|circuit| {
-        circuit
-            .add_source(make_tuple_generator())
-            .filter_keys::<_, _, ZSetHashMap<_, _>, _>(|(left, _)| left % 2 == 0)
-            .inspect(move |map| actual_data.borrow_mut().push(map.clone()));
-    })
-    .unwrap();
-
-    for _ in 0..3 {
-        root.step().unwrap()
-    }
-
-    let expected = vec![finite_map! {}, finite_map! {}, finite_map! { (2, 3) => 1 }];
-    assert_eq!(&expected, actual_data_clone.borrow().deref());
-}
diff --git a/src/time.rs b/src/time.rs
new file mode 100644
index 00000000..41f3f194
--- /dev/null
+++ b/src/time.rs
@@ -0,0 +1,225 @@
+use crate::{circuit::Scope, lattice::Lattice};
+use deepsize_derive::DeepSizeOf;
+use timely::{progress::PathSummary, PartialOrder};
+
+/// Logical timestamp.
+///
+/// A DBSP circuit runs on a discrete logical clock that starts at 0
+/// on the `clock_start` event and increments by 1 at each clock tick.
+/// A nested circuit has a two-dimensional clock that consists of the
+/// parent clock `c1 `and its local clock `c2`: `(c1, c2)`.  A second-level
+/// nested circuit has a three-dimensional clock: `((c1, c2), c3)`, etc.
+///
+/// Every value produced by an operator is logically labelled by the
+/// time when it was produced.  Depending on what we do with the data,
+/// this time may or may not be stored explicitly.  In the former case,
+/// it is often beneficial to use a lossy representation that stores just
+/// enough timing information required by operators that compute on the
+/// data.
+///
+/// Thus, while we can represent any DBSP timestamp as an array of
+/// integers whose length is equal to the nesting depth of the circuit
+/// and whose `i`th element is the local time of the circuit at the `i`th
+/// nesting level, in practice we use several more compact "lossy"
+/// representations.  For example, we use unit type `()` for untimed data,
+/// where we only track values and not the time when each value was generated.
+///
+/// As another example, the [`NestedTimestamp32`] type represents nested
+/// timestamp `(c1, c2)`, but only uses 1 bit for `c1` to distinguish data
+/// generated in the latest clock epoch from all earlier epochs (which is
+/// sufficient for all existing DBSP operators).
+///
+/// The `Timestamp` trait captures common functionality of any (lossy or
+/// lossless) time representation.
+///
+/// # Example: Untimed data
+///
+/// The [`integrate_trace`](`crate::circuit::Stream::integrate_trace`) operator
+/// computes the union of all Z-sets in its input stream generated during the
+/// current clock epoch, i.e., since the last
+/// [`clock_start`](`crate::circuit::operator_traits::Operator::clock_start`)
+/// invocation.  Its consumers only need to know the current value of the
+/// sum and not when each update was produced.  It therefore stores its output
+/// in an untimed [`Trace`]([`crate::trace::Trace`]), i.e., a trace whose
+/// timestamp type is `()`.
+///
+/// # Example: `NestedTimestamp32`.
+///
+/// [`join_trace`](`crate::circuit::Stream::join_trace`) and
+/// [`distinct_trace`](`crate::circuit::Stream::distinct_trace`) methods compute
+/// incremental versions
+/// of `join` and `distinct` operators within nested scopes.  They need to know
+/// the exact local time in the child circuit when each key-value tuple was
+/// generated; however they do not require the exact parent clock value as long
+/// as they can distinguish between values generated during the current epoch
+/// (i.e., the current parent clock cycle) from older values.  They therefore
+/// take advantage of the lossy timestamp representation implemented by the
+/// `NestedTimestamp32` type.
+// TODO: Eliminate timely dependency.
+// TODO: Conversion to/from the most general time representation (`[usize]`).
+// TODO: Model overflow by having `advance` return Option<Self>.
+pub trait Timestamp: PartialOrder + Clone + Ord + PartialEq + Eq + 'static {
+    fn minimum() -> Self;
+
+    /// Advance the timestamp by one clock tick.
+    ///
+    /// Advance `self` by one clock tick by incrementing the clock at the
+    /// specified nesting level by one, while resetting all clocks at deeper
+    /// nesting levels to `0`. `scope` identifies the nesting level of the
+    /// circuit whoce clock is ticking.  `0` refers to the innermost
+    /// circuit.  `1` is its parent circuit, etc. Returns the most accurate
+    /// approximation of the new timestamp value supported by this time
+    /// representation.
+    ///
+    /// # Example
+    ///
+    /// Assume a two-dimensional time modeled as (parent time, child time)
+    /// tuple.
+    ///
+    /// ```ignore
+    /// assert_eq!((2, 3).advance(0), (2, 4));
+    /// assert_eq!((2, 3).advance(1), (3, 0));
+    /// ```
+    fn advance(&self, scope: Scope) -> Self;
+
+    /// Push the timestamp back by one clock tick.
+    ///
+    /// Push `self` back by one clock cycle by decrementing the clock at the
+    /// specified nesting level by one.  `scope` identifies the nesting
+    /// level of the circuit whoce clock is ticking. `0` refers to the
+    /// innermost circuit.  `1` is its parent circuit, etc.
+    ///
+    /// While time does not normally flow backward in DBSP, it is sometimes
+    /// useful to push values back in time in order to "forget" the
+    /// distinction between multiple older timestamps. See
+    /// [`Trace::recede_to`](`crate::trace::Trace::recede_to`) for more details.
+    ///
+    /// # Example
+    ///
+    /// Assume a two-dimensional time modeled as (parent time, child time)
+    /// tuple.
+    ///
+    /// ```ignore
+    /// assert_eq!((2, 3).recede(0), (2, 2));
+    /// assert_eq!((2, 3).recede(1), (1, 3));
+    /// ```
+    fn recede(&self, scope: Scope) -> Self;
+}
+
+fn bool_followed_by(this: bool, other: bool) -> Option<bool> {
+    if this && other {
+        None
+    } else {
+        Some(this || other)
+    }
+}
+
+/// Nested timestamp that allocates one bit for the parent clock and the
+/// remaining 31 bits for the child clock.
+///
+/// This representation precisely captures the nested clock value, but only
+/// distinguishes the latest parent clock cycle, or "epoch", (higher-order bit
+/// set to `1`) from all previous epochs (higher order bit is `0`).
+#[derive(Clone, DeepSizeOf, Default, Eq, PartialEq, Debug, Hash, PartialOrd, Ord)]
+pub struct NestedTimestamp32(u32);
+
+impl NestedTimestamp32 {
+    #[inline]
+    pub fn new(epoch: bool, inner: u32) -> Self {
+        debug_assert_eq!(inner >> 31, 0);
+
+        let epoch = if epoch { 0x80000000 } else { 0 };
+        Self(epoch | inner)
+    }
+
+    #[inline]
+    pub fn epoch(&self) -> bool {
+        self.0 >> 31 == 1
+    }
+
+    #[inline]
+    pub fn inner(&self) -> u32 {
+        self.0 & 0x7fffffff
+    }
+}
+
+impl PartialOrder for NestedTimestamp32 {
+    #[inline]
+    fn less_equal(&self, other: &Self) -> bool {
+        self.epoch().le(&other.epoch()) && self.inner().less_equal(&other.inner())
+    }
+}
+
+// TODO: We probably don't need this trait in DBSP.  Drop is as we eliminate
+// the timely dataflow dependency.
+impl PathSummary<NestedTimestamp32> for NestedTimestamp32 {
+    #[inline]
+    fn results_in(&self, src: &Self) -> Option<Self> {
+        bool_followed_by(self.epoch(), src.epoch()).and_then(|epoch| {
+            self.inner()
+                .results_in(&src.inner())
+                .map(|inner| Self::new(epoch, inner))
+        })
+    }
+    #[inline]
+    fn followed_by(&self, other: &Self) -> Option<Self> {
+        bool_followed_by(self.epoch(), other.epoch()).and_then(|epoch| {
+            self.inner()
+                .followed_by(&other.inner())
+                .map(|inner| Self::new(epoch, inner))
+        })
+    }
+}
+
+impl Timestamp for NestedTimestamp32 {
+    fn minimum() -> Self {
+        Self::new(false, 0)
+    }
+
+    fn advance(&self, scope: Scope) -> Self {
+        if scope == 0 {
+            if self.0 & 0x7fffffff == 0x7fffffff {
+                panic!("NestedTimestamp32::advance timestamp overflow");
+            }
+            Self(self.0 + 1)
+        } else {
+            Self::new(true, 0)
+        }
+    }
+
+    fn recede(&self, scope: Scope) -> Self {
+        if scope == 0 {
+            if self.0 & 0x7fffffff == 0 {
+                panic!("NestedTimestamp32::recede timestamp underflow");
+            }
+            Self(self.0 - 1)
+        } else if scope == 1 {
+            Self(self.0 & 0x7fffffff)
+        } else {
+            self.clone()
+        }
+    }
+}
+
+impl Lattice for NestedTimestamp32 {
+    #[inline]
+    fn join(&self, other: &NestedTimestamp32) -> NestedTimestamp32 {
+        Self::new(
+            self.epoch() || other.epoch(),
+            self.inner().join(&other.inner()),
+        )
+    }
+    #[inline]
+    fn meet(&self, other: &NestedTimestamp32) -> NestedTimestamp32 {
+        Self::new(
+            self.epoch() && other.epoch(),
+            self.inner().meet(&other.inner()),
+        )
+    }
+}
+
+impl Timestamp for () {
+    fn minimum() -> Self {}
+    fn advance(&self, _scope: Scope) -> Self {}
+    fn recede(&self, _scope: Scope) -> Self {}
+}
diff --git a/src/trace/LICENSE b/src/trace/LICENSE
new file mode 100644
index 00000000..9d81fe56
--- /dev/null
+++ b/src/trace/LICENSE
@@ -0,0 +1,27 @@
+This module was borowed with modifications from the Differential Dataflow
+project (https://github.com/TimelyDataflow/differential-dataflow/)
+under the following license:
+
+-----------------------------
+
+The MIT License (MIT)
+
+Copyright (c) 2015-2022 Frank McSherry
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/src/trace/consolidation.rs b/src/trace/consolidation.rs
new file mode 100644
index 00000000..30a808c5
--- /dev/null
+++ b/src/trace/consolidation.rs
@@ -0,0 +1,173 @@
+//! Common logic for the consolidation of vectors of MonoidValues.
+//!
+//! Often we find ourselves with collections of records with associated weights
+//! (often integers) where we want to reduce the collection to the point that
+//! each record occurs at most once, with the accumulated weights. These methods
+//! supply that functionality.
+
+use crate::algebra::{AddAssignByRef, HasZero, MonoidValue};
+
+/// Sorts and consolidates `vec`.
+///
+/// This method will sort `vec` and then consolidate runs of more than one entry
+/// with identical first elements by accumulating the second elements of the
+/// pairs. Should the final accumulation be zero, the element is discarded.
+pub fn consolidate<T: Ord, R: MonoidValue>(vec: &mut Vec<(T, R)>) {
+    consolidate_from(vec, 0);
+}
+
+/// Sorts and consolidate `vec[offset..]`.
+///
+/// This method will sort `vec[offset..]` and then consolidate runs of more than
+/// one entry with identical first elements by accumulating the second elements
+/// of the pairs. Should the final accumulation be zero, the element is
+/// discarded.
+pub fn consolidate_from<T: Ord, R: MonoidValue>(vec: &mut Vec<(T, R)>, offset: usize) {
+    let length = consolidate_slice(&mut vec[offset..]);
+    vec.truncate(offset + length);
+}
+
+/// Sorts and consolidates a slice, returning the valid prefix length.
+pub fn consolidate_slice<T: Ord, R: AddAssignByRef + HasZero>(slice: &mut [(T, R)]) -> usize {
+    // We could do an insertion-sort like initial scan which builds up sorted,
+    // consolidated runs. In a world where there are not many results, we may
+    // never even need to call in to merge sort.
+    slice.sort_by(|x, y| x.0.cmp(&y.0));
+
+    // Counts the number of distinct known-non-zero accumulations. Indexes the write
+    // location.
+    let mut offset = 0;
+    for index in 1..slice.len() {
+        // The following unsafe block elides various bounds checks, using the reasoning
+        // that `offset` is always strictly less than `index` at the beginning
+        // of each iteration. This is initially true, and in each iteration
+        // `offset` can increase by at most one (whereas `index` always
+        // increases by one). As `index` is always in bounds, and `offset` starts at
+        // zero, it too is always in bounds.
+        //
+        // LLVM appears to struggle to optimize out Rust's split_at_mut, which would
+        // prove disjointness using run-time tests.
+        unsafe {
+            assert!(offset < index);
+
+            // LOOP INVARIANT: offset < index
+            let ptr1 = slice.as_mut_ptr().add(offset);
+            let ptr2 = slice.as_mut_ptr().add(index);
+
+            if (*ptr1).0 == (*ptr2).0 {
+                (*ptr1).1.add_assign_by_ref(&(*ptr2).1);
+            } else {
+                if !(*ptr1).1.is_zero() {
+                    offset += 1;
+                }
+                let ptr1 = slice.as_mut_ptr().add(offset);
+                std::ptr::swap(ptr1, ptr2);
+            }
+        }
+    }
+    if offset < slice.len() && !slice[offset].1.is_zero() {
+        offset += 1;
+    }
+
+    offset
+}
+
+/// Sorts and consolidates `vec`.
+///
+/// This method will sort `vec` and then consolidate runs of more than one entry
+/// with identical first two elements by accumulating the third elements of the
+/// triples. Should the final accumulation be zero, the element is discarded.
+pub fn consolidate_updates<D: Ord, R: MonoidValue>(vec: &mut Vec<(D, R)>) {
+    consolidate_updates_from(vec, 0);
+}
+
+/// Sorts and consolidates `vec[offset..]`.
+///
+/// This method will sort `vec[offset..]` and then consolidate runs of more than
+/// one entry with identical first two elements by accumulating the third
+/// elements of the triples. Should the final accumulation be zero, the element
+/// is discarded.
+pub fn consolidate_updates_from<D: Ord, R: MonoidValue>(vec: &mut Vec<(D, R)>, offset: usize) {
+    let length = consolidate_updates_slice(&mut vec[offset..]);
+    vec.truncate(offset + length);
+}
+
+/// Sorts and consolidates a slice, returning the valid prefix length.
+pub fn consolidate_updates_slice<D: Ord, R: MonoidValue>(slice: &mut [(D, R)]) -> usize {
+    // We could do an insertion-sort like initial scan which builds up sorted,
+    // consolidated runs. In a world where there are not many results, we may
+    // never even need to call in to merge sort.
+    slice.sort_unstable_by(|x, y| (&x.0).cmp(&y.0));
+
+    // Counts the number of distinct known-non-zero accumulations. Indexes the write
+    // location.
+    let mut offset = 0;
+    for index in 1..slice.len() {
+        // The following unsafe block elides various bounds checks, using the reasoning
+        // that `offset` is always strictly less than `index` at the beginning
+        // of each iteration. This is initially true, and in each iteration
+        // `offset` can increase by at most one (whereas `index` always
+        // increases by one). As `index` is always in bounds, and `offset` starts at
+        // zero, it too is always in bounds.
+        //
+        // LLVM appears to struggle to optimize out Rust's split_at_mut, which would
+        // prove disjointness using run-time tests.
+        unsafe {
+            // LOOP INVARIANT: offset < index
+            let ptr1 = slice.as_mut_ptr().add(offset);
+            let ptr2 = slice.as_mut_ptr().add(index);
+
+            if (*ptr1).0 == (*ptr2).0 {
+                (*ptr1).1.add_assign_by_ref(&(*ptr2).1);
+            } else {
+                if !(*ptr1).1.is_zero() {
+                    offset += 1;
+                }
+                let ptr1 = slice.as_mut_ptr().add(offset);
+                std::ptr::swap(ptr1, ptr2);
+            }
+        }
+    }
+    if offset < slice.len() && !slice[offset].1.is_zero() {
+        offset += 1;
+    }
+
+    offset
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_consolidate() {
+        let test_cases = vec![
+            (vec![("a", -1), ("b", -2), ("a", 1)], vec![("b", -2)]),
+            (vec![("a", -1), ("b", 0), ("a", 1)], vec![]),
+            (vec![("a", 0)], vec![]),
+            (vec![("a", 0), ("b", 0)], vec![]),
+            (vec![("a", 1), ("b", 1)], vec![("a", 1), ("b", 1)]),
+        ];
+
+        for (mut input, output) in test_cases {
+            consolidate(&mut input);
+            assert_eq!(input, output);
+        }
+    }
+
+    #[test]
+    fn test_consolidate_updates() {
+        let test_cases = vec![
+            (vec![("a", -1), ("b", -2), ("a", 1)], vec![("b", -2)]),
+            (vec![("a", -1), ("b", 0), ("a", 1)], vec![]),
+            (vec![("a", 0)], vec![]),
+            (vec![("a", 0), ("b", 0)], vec![]),
+            (vec![("a", 1), ("b", 1)], vec![("a", 1), ("b", 1)]),
+        ];
+
+        for (mut input, output) in test_cases {
+            consolidate_updates(&mut input);
+            assert_eq!(input, output);
+        }
+    }
+}
diff --git a/src/trace/cursor/cursor_list.rs b/src/trace/cursor/cursor_list.rs
new file mode 100644
index 00000000..2a4483f3
--- /dev/null
+++ b/src/trace/cursor/cursor_list.rs
@@ -0,0 +1,190 @@
+//! A generic cursor implementation merging multiple cursors.
+
+use crate::trace::cursor::Cursor;
+use std::marker::PhantomData;
+
+/// Provides a cursor interface over a list of cursors.
+///
+/// The `CursorList` tracks the indices of cursors with the minimum key, and the
+/// the indices of cursors with the minimum key and minimum value. It performs
+/// no clever management of these sets otherwise.
+#[derive(Debug)]
+pub struct CursorList<K, V, T, R, C: Cursor<K, V, T, R>> {
+    _phantom: PhantomData<(K, V, T, R)>,
+    cursors: Vec<C>,
+    min_key: Vec<usize>,
+    min_val: Vec<usize>,
+}
+
+impl<K, V, T, R, C: Cursor<K, V, T, R>> CursorList<K, V, T, R, C>
+where
+    K: Ord,
+    V: Ord,
+{
+    /// Creates a new cursor list from pre-existing cursors.
+    pub fn new(cursors: Vec<C>, storage: &[C::Storage]) -> Self {
+        let mut result = CursorList {
+            _phantom: PhantomData,
+            cursors,
+            min_key: Vec::new(),
+            min_val: Vec::new(),
+        };
+
+        result.minimize_keys(storage);
+        result
+    }
+
+    // Initialize min_key with the indices of cursors with the minimum key.
+    //
+    // This method scans the current keys of each cursor, and tracks the indices
+    // of cursors whose key equals the minimum valid key seen so far. As it goes,
+    // if it observes an improved key it clears the current list, updates the
+    // minimum key, and continues.
+    //
+    // Once finished, it invokes `minimize_vals()` to ensure the value cursor is
+    // in a consistent state as well.
+    fn minimize_keys(&mut self, storage: &[C::Storage]) {
+        self.min_key.clear();
+
+        // Determine the index of the cursor with minimum key.
+        let mut min_key_opt: Option<&K> = None;
+        for (index, cursor) in self.cursors.iter().enumerate() {
+            let key = cursor.get_key(&storage[index]);
+            if key.is_some() {
+                if min_key_opt.is_none() || key.lt(&min_key_opt) {
+                    min_key_opt = key;
+                    self.min_key.clear();
+                }
+                if key.eq(&min_key_opt) {
+                    self.min_key.push(index);
+                }
+            }
+        }
+
+        self.minimize_vals(storage);
+    }
+
+    // Initialize min_val with the indices of minimum key cursors with the minimum
+    // value.
+    //
+    // This method scans the current values of cursor with minimum keys, and tracks
+    // the indices of cursors whose value equals the minimum valid value seen so
+    // far. As it goes, if it observes an improved value it clears the current
+    // list, updates the minimum value, and continues.
+    fn minimize_vals(&mut self, storage: &[C::Storage]) {
+        self.min_val.clear();
+
+        // Determine the index of the cursor with minimum value.
+        let mut min_val: Option<&V> = None;
+        for &index in self.min_key.iter() {
+            let val = self.cursors[index].get_val(&storage[index]);
+            if val.is_some() {
+                if min_val.is_none() || val.lt(&min_val) {
+                    min_val = val;
+                    self.min_val.clear();
+                }
+                if val.eq(&min_val) {
+                    self.min_val.push(index);
+                }
+            }
+        }
+    }
+}
+
+impl<K, V, T, R, C: Cursor<K, V, T, R>> Cursor<K, V, T, R> for CursorList<K, V, T, R, C>
+where
+    K: Ord,
+    V: Ord,
+{
+    type Storage = Vec<C::Storage>;
+
+    // validation methods
+    #[inline]
+    fn key_valid(&self, _storage: &Self::Storage) -> bool {
+        !self.min_key.is_empty()
+    }
+    #[inline]
+    fn val_valid(&self, _storage: &Self::Storage) -> bool {
+        !self.min_val.is_empty()
+    }
+
+    // accessors
+    #[inline]
+    fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K {
+        debug_assert!(self.key_valid(storage));
+        debug_assert!(self.cursors[self.min_key[0]].key_valid(&storage[self.min_key[0]]));
+        self.cursors[self.min_key[0]].key(&storage[self.min_key[0]])
+    }
+    #[inline]
+    fn val<'a>(&self, storage: &'a Self::Storage) -> &'a V {
+        debug_assert!(self.key_valid(storage));
+        debug_assert!(self.val_valid(storage));
+        debug_assert!(self.cursors[self.min_val[0]].val_valid(&storage[self.min_val[0]]));
+        self.cursors[self.min_val[0]].val(&storage[self.min_val[0]])
+    }
+    #[inline]
+    fn map_times<L: FnMut(&T, &R)>(&mut self, storage: &Self::Storage, mut logic: L) {
+        for &index in self.min_val.iter() {
+            self.cursors[index].map_times(&storage[index], |t, d| logic(t, d));
+        }
+    }
+
+    #[inline]
+    fn weight<'a>(&self, storage: &'a Self::Storage) -> &'a R
+    where
+        T: PartialEq<()>,
+    {
+        debug_assert!(self.key_valid(storage));
+        debug_assert!(self.val_valid(storage));
+        debug_assert!(self.cursors[self.min_val[0]].val_valid(&storage[self.min_val[0]]));
+        self.cursors[self.min_val[0]].weight(&storage[self.min_val[0]])
+    }
+
+    // key methods
+    #[inline]
+    fn step_key(&mut self, storage: &Self::Storage) {
+        for &index in self.min_key.iter() {
+            self.cursors[index].step_key(&storage[index]);
+        }
+        self.minimize_keys(storage);
+    }
+    #[inline]
+    fn seek_key(&mut self, storage: &Self::Storage, key: &K) {
+        for (index, cursor) in self.cursors.iter_mut().enumerate() {
+            cursor.seek_key(&storage[index], key);
+        }
+        self.minimize_keys(storage);
+    }
+
+    // value methods
+    #[inline]
+    fn step_val(&mut self, storage: &Self::Storage) {
+        for &index in self.min_val.iter() {
+            self.cursors[index].step_val(&storage[index]);
+        }
+        self.minimize_vals(storage);
+    }
+    #[inline]
+    fn seek_val(&mut self, storage: &Self::Storage, val: &V) {
+        for &index in self.min_key.iter() {
+            self.cursors[index].seek_val(&storage[index], val);
+        }
+        self.minimize_vals(storage);
+    }
+
+    // rewinding methods
+    #[inline]
+    fn rewind_keys(&mut self, storage: &Self::Storage) {
+        for (index, cursor) in self.cursors.iter_mut().enumerate() {
+            cursor.rewind_keys(&storage[index]);
+        }
+        self.minimize_keys(storage);
+    }
+    #[inline]
+    fn rewind_vals(&mut self, storage: &Self::Storage) {
+        for &index in self.min_key.iter() {
+            self.cursors[index].rewind_vals(&storage[index]);
+        }
+        self.minimize_vals(storage);
+    }
+}
diff --git a/src/trace/cursor/cursor_pair.rs b/src/trace/cursor/cursor_pair.rs
new file mode 100644
index 00000000..4f2b5b3c
--- /dev/null
+++ b/src/trace/cursor/cursor_pair.rs
@@ -0,0 +1,189 @@
+//! A generic cursor implementation merging pairs of different cursors.
+
+use std::cmp::Ordering;
+
+use super::Cursor;
+
+/// A cursor over the combined updates of two different cursors.
+///
+/// A `CursorPair` wraps two cursors over the same types of updates, and
+/// provides navigation through their merged updates.
+pub struct CursorPair<C1, C2> {
+    cursor1: C1,
+    cursor2: C2,
+    key_order: Ordering, /* Invalid keys are `Greater` than all other keys. `Equal` implies both
+                          * valid. */
+    val_order: Ordering, /* Invalid vals are `Greater` than all other vals. `Equal` implies both
+                          * valid. */
+}
+
+impl<K, V, T, R, C1, C2> Cursor<K, V, T, R> for CursorPair<C1, C2>
+where
+    K: Ord,
+    V: Ord,
+    C1: Cursor<K, V, T, R>,
+    C2: Cursor<K, V, T, R>,
+{
+    type Storage = (C1::Storage, C2::Storage);
+
+    // validation methods
+    fn key_valid(&self, storage: &Self::Storage) -> bool {
+        match self.key_order {
+            Ordering::Less => self.cursor1.key_valid(&storage.0),
+            Ordering::Equal => true,
+            Ordering::Greater => self.cursor2.key_valid(&storage.1),
+        }
+    }
+    fn val_valid(&self, storage: &Self::Storage) -> bool {
+        match (self.key_order, self.val_order) {
+            (Ordering::Less, _) => self.cursor1.val_valid(&storage.0),
+            (Ordering::Greater, _) => self.cursor2.val_valid(&storage.1),
+            (Ordering::Equal, Ordering::Less) => self.cursor1.val_valid(&storage.0),
+            (Ordering::Equal, Ordering::Greater) => self.cursor2.val_valid(&storage.1),
+            (Ordering::Equal, Ordering::Equal) => true,
+        }
+    }
+
+    // accessors
+    fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K {
+        match self.key_order {
+            Ordering::Less => self.cursor1.key(&storage.0),
+            _ => self.cursor2.key(&storage.1),
+        }
+    }
+    fn val<'a>(&self, storage: &'a Self::Storage) -> &'a V {
+        if self.key_order == Ordering::Less
+            || (self.key_order == Ordering::Equal && self.val_order != Ordering::Greater)
+        {
+            self.cursor1.val(&storage.0)
+        } else {
+            self.cursor2.val(&storage.1)
+        }
+    }
+    fn map_times<L: FnMut(&T, &R)>(&mut self, storage: &Self::Storage, mut logic: L) {
+        if self.key_order == Ordering::Less
+            || (self.key_order == Ordering::Equal && self.val_order != Ordering::Greater)
+        {
+            self.cursor1.map_times(&storage.0, |t, d| logic(t, d));
+        }
+        if self.key_order == Ordering::Greater
+            || (self.key_order == Ordering::Equal && self.val_order != Ordering::Less)
+        {
+            self.cursor2.map_times(&storage.1, |t, d| logic(t, d));
+        }
+    }
+
+    fn weight<'a>(&self, storage: &'a Self::Storage) -> &'a R
+    where
+        T: PartialEq<()>,
+    {
+        debug_assert!(self.val_valid(storage));
+        if self.key_order == Ordering::Less
+            || (self.key_order == Ordering::Equal && self.val_order != Ordering::Greater)
+        {
+            self.cursor1.weight(&storage.0)
+        } else {
+            self.cursor2.weight(&storage.1)
+        }
+    }
+
+    // key methods
+    fn step_key(&mut self, storage: &Self::Storage) {
+        if self.key_order != Ordering::Greater {
+            self.cursor1.step_key(&storage.0);
+        }
+        if self.key_order != Ordering::Less {
+            self.cursor2.step_key(&storage.1);
+        }
+
+        self.key_order = match (
+            self.cursor1.key_valid(&storage.0),
+            self.cursor2.key_valid(&storage.1),
+        ) {
+            (false, _) => Ordering::Greater,
+            (_, false) => Ordering::Less,
+            (true, true) => self
+                .cursor1
+                .key(&storage.0)
+                .cmp(self.cursor2.key(&storage.1)),
+        };
+    }
+    fn seek_key(&mut self, storage: &Self::Storage, key: &K) {
+        self.cursor1.seek_key(&storage.0, key);
+        self.cursor2.seek_key(&storage.1, key);
+
+        self.key_order = match (
+            self.cursor1.key_valid(&storage.0),
+            self.cursor2.key_valid(&storage.1),
+        ) {
+            (false, _) => Ordering::Greater,
+            (_, false) => Ordering::Less,
+            (true, true) => self
+                .cursor1
+                .key(&storage.0)
+                .cmp(self.cursor2.key(&storage.1)),
+        };
+    }
+
+    // value methods
+    fn step_val(&mut self, storage: &Self::Storage) {
+        match self.key_order {
+            Ordering::Less => self.cursor1.step_val(&storage.0),
+            Ordering::Equal => {
+                if self.val_order != Ordering::Greater {
+                    self.cursor1.step_val(&storage.0);
+                }
+                if self.val_order != Ordering::Less {
+                    self.cursor2.step_val(&storage.1);
+                }
+                self.val_order = match (
+                    self.cursor1.val_valid(&storage.0),
+                    self.cursor2.val_valid(&storage.1),
+                ) {
+                    (false, _) => Ordering::Greater,
+                    (_, false) => Ordering::Less,
+                    (true, true) => self
+                        .cursor1
+                        .val(&storage.0)
+                        .cmp(self.cursor2.val(&storage.1)),
+                };
+            }
+            Ordering::Greater => self.cursor2.step_val(&storage.1),
+        }
+    }
+    fn seek_val(&mut self, storage: &Self::Storage, val: &V) {
+        match self.key_order {
+            Ordering::Less => self.cursor1.seek_val(&storage.0, val),
+            Ordering::Equal => {
+                self.cursor1.seek_val(&storage.0, val);
+                self.cursor2.seek_val(&storage.1, val);
+                self.val_order = match (
+                    self.cursor1.val_valid(&storage.0),
+                    self.cursor2.val_valid(&storage.1),
+                ) {
+                    (false, _) => Ordering::Greater,
+                    (_, false) => Ordering::Less,
+                    (true, true) => self
+                        .cursor1
+                        .val(&storage.0)
+                        .cmp(self.cursor2.val(&storage.1)),
+                };
+            }
+            Ordering::Greater => self.cursor2.seek_val(&storage.1, val),
+        }
+    }
+
+    // rewinding methods
+    fn rewind_keys(&mut self, storage: &Self::Storage) {
+        self.cursor1.rewind_keys(&storage.0);
+        self.cursor2.rewind_keys(&storage.1);
+    }
+    fn rewind_vals(&mut self, storage: &Self::Storage) {
+        if self.key_order != Ordering::Greater {
+            self.cursor1.rewind_vals(&storage.0);
+        }
+        if self.key_order != Ordering::Less {
+            self.cursor2.rewind_vals(&storage.1);
+        }
+    }
+}
diff --git a/src/trace/cursor/mod.rs b/src/trace/cursor/mod.rs
new file mode 100644
index 00000000..9ff66e5f
--- /dev/null
+++ b/src/trace/cursor/mod.rs
@@ -0,0 +1,114 @@
+//! Traits and types for navigating order sequences of update tuples.
+//!
+//! The `Cursor` trait contains several methods for efficiently navigating
+//! ordered collections of tuples of the form `(key, val, time, diff)`. The
+//! cursor is different from an iterator both because it allows navigation on
+//! multiple levels (key and val), but also because it supports efficient
+//! seeking (via the `seek_key` and `seek_val` methods).
+
+pub mod cursor_list;
+pub mod cursor_pair;
+
+pub use self::cursor_list::CursorList;
+
+/// A cursor for navigating ordered `(key, val, time, diff)` updates.
+pub trait Cursor<K, V, T, R> {
+    /// Type the cursor addresses data in.
+    type Storage;
+
+    /// Indicates if the current key is valid.
+    ///
+    /// A value of `false` indicates that the cursor has exhausted all keys.
+    fn key_valid(&self, storage: &Self::Storage) -> bool;
+    /// Indicates if the current value is valid.
+    ///
+    /// A value of `false` indicates that the cursor has exhausted all values
+    /// for this key.
+    fn val_valid(&self, storage: &Self::Storage) -> bool;
+
+    /// A reference to the current key. Asserts if invalid.
+    fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K;
+    /// A reference to the current value. Asserts if invalid.
+    fn val<'a>(&self, storage: &'a Self::Storage) -> &'a V;
+
+    /// Returns a reference to the current key, if valid.
+    fn get_key<'a>(&self, storage: &'a Self::Storage) -> Option<&'a K> {
+        if self.key_valid(storage) {
+            Some(self.key(storage))
+        } else {
+            None
+        }
+    }
+    /// Returns a reference to the current value, if valid.
+    fn get_val<'a>(&self, storage: &'a Self::Storage) -> Option<&'a V> {
+        if self.val_valid(storage) {
+            Some(self.val(storage))
+        } else {
+            None
+        }
+    }
+
+    /// Applies `logic` to each pair of time and difference. Intended for
+    /// mutation of the closure's scope.
+    fn map_times<L: FnMut(&T, &R)>(&mut self, storage: &Self::Storage, logic: L);
+
+    /// Returns the weight associated with the current key/value pair.
+    ///
+    /// This method is only defined for cursors with unit timestamp type
+    /// (`T=()`), which contain exactly one weight per key/value pair.  It
+    /// is more convenient (and potentially more efficient) than using
+    /// [`Self::map_times`] to iterate over a single value.
+    ///
+    /// # Panics
+    ///
+    /// Panics if not `self.key_valid() && self.val_valid()`.
+    fn weight<'a>(&self, storage: &'a Self::Storage) -> &'a R
+    where
+        T: PartialEq<()>;
+
+    /// Advances the cursor to the next key.
+    fn step_key(&mut self, storage: &Self::Storage);
+    /// Advances the cursor to the specified key.
+    fn seek_key(&mut self, storage: &Self::Storage, key: &K);
+
+    /// Advances the cursor to the next value.
+    fn step_val(&mut self, storage: &Self::Storage);
+    /// Advances the cursor to the specified value.
+    fn seek_val(&mut self, storage: &Self::Storage, val: &V);
+
+    /// Rewinds the cursor to the first key.
+    fn rewind_keys(&mut self, storage: &Self::Storage);
+    /// Rewinds the cursor to the first value for current key.
+    fn rewind_vals(&mut self, storage: &Self::Storage);
+}
+
+/// Debugging and testing utilities for Cursor.
+pub trait CursorDebug<K: Clone, V: Clone, T: Clone, R: Clone>: Cursor<K, V, T, R> {
+    /// Rewinds the cursor and outputs its contents to a Vec
+    #[allow(clippy::type_complexity)]
+    fn to_vec(&mut self, storage: &Self::Storage) -> Vec<((K, V), Vec<(T, R)>)> {
+        let mut out = Vec::new();
+        self.rewind_keys(storage);
+        self.rewind_vals(storage);
+        while self.key_valid(storage) {
+            while self.val_valid(storage) {
+                let mut kv_out = Vec::new();
+                self.map_times(storage, |ts, r| {
+                    kv_out.push((ts.clone(), r.clone()));
+                });
+                out.push((
+                    (self.key(storage).clone(), self.val(storage).clone()),
+                    kv_out,
+                ));
+                self.step_val(storage);
+            }
+            self.step_key(storage);
+        }
+        out
+    }
+}
+
+impl<C, K: Clone, V: Clone, T: Clone, R: Clone> CursorDebug<K, V, T, R> for C where
+    C: Cursor<K, V, T, R>
+{
+}
diff --git a/src/trace/description.rs b/src/trace/description.rs
new file mode 100644
index 00000000..825b43df
--- /dev/null
+++ b/src/trace/description.rs
@@ -0,0 +1,45 @@
+//! Descriptions of intervals of partially ordered times.
+//!
+//! A description provides a characterization of a batch of updates in terms of
+//! upper and lower bounds on timestamps in the update: all updates in the batch
+//! are greater or equal to some element of `lower` but not greater or equal to
+//! any element of `upper`.
+
+use timely::{progress::Antichain, PartialOrder};
+
+/// Describes an interval of partially ordered times.
+#[derive(Clone, Debug)]
+pub struct Description<Time> {
+    /// Lower frontier of contained updates.
+    lower: Antichain<Time>,
+    /// Upper frontier of contained updates.
+    upper: Antichain<Time>,
+}
+
+impl<Time: PartialOrder + Clone> Description<Time> {
+    /// Returns a new description from its component parts.
+    pub fn new(lower: Antichain<Time>, upper: Antichain<Time>) -> Self {
+        assert!(!lower.elements().is_empty()); // this should always be true.
+                                               // assert!(upper.len() > 0);           // this may not always be true.
+        Description { lower, upper }
+    }
+}
+
+impl<Time> Description<Time> {
+    /// The lower envelope for times in the interval.
+    pub fn lower(&self) -> &Antichain<Time> {
+        &self.lower
+    }
+    /// The upper envelope for times in the interval.
+    pub fn upper(&self) -> &Antichain<Time> {
+        &self.upper
+    }
+}
+
+impl<Time: PartialEq> PartialEq for Description<Time> {
+    fn eq(&self, other: &Self) -> bool {
+        self.lower.eq(other.lower()) && self.upper.eq(other.upper())
+    }
+}
+
+impl<Time: Eq> Eq for Description<Time> {}
diff --git a/src/trace/implementations/mod.rs b/src/trace/implementations/mod.rs
new file mode 100644
index 00000000..0415c9f4
--- /dev/null
+++ b/src/trace/implementations/mod.rs
@@ -0,0 +1,63 @@
+//! Implementations of `Trace` and associated traits.
+
+// The following is a historical comment by @frankmcsherry.  It no longer describes
+// the contents of this model, but it discusses some interesting implementation
+// options.
+
+/*
+//!
+//! The `Trace` trait provides access to an ordered collection of `(key, val,
+//! time, diff)` tuples, but there is substantial flexibility in implementations
+//! of this trait. Depending on characteristics of the data, we may wish to
+//! represent the data in different ways. This module contains several of these
+//! implementations, and combiners for merging the results of different traces.
+//!
+//! As examples of implementations,
+//!
+//! * The `trie` module is meant to represent general update tuples, with no
+//!   particular assumptions made about their contents. It organizes the data
+//!   first by key, then by val, and then leaves the rest in an unordered pile.
+//!
+//! * The `keys` module is meant for collections whose value type is `()`, which
+//!   is to say there is no (key, val) structure on the records; all of them are
+//!   just viewed as "keys".
+//!
+//! * The `time` module is meant for collections with a single time value. This
+//!   can remove repetition from the representation, at the cost of requiring
+//!   more instances and run-time merging.
+//!
+//! * The `base` module is meant for collections with a single time value
+//!   equivalent to the least time. These collections must always accumulate to
+//!   non-negative collections, and as such we can indicate the frequency of an
+//!   element by its multiplicity. This removes both the time and weight from
+//!   the representation, but is only appropriate for a subset (often
+//!   substantial) of the data.
+//!
+//! Each of these representations is best suited for different data, but they
+//! can be combined to get the benefits of each, as appropriate. There are
+//! several `Cursor` combiners, `CursorList` and `CursorPair`, for homogenous
+//! and inhomogenous cursors, respectively.
+//!
+//! #Musings
+//!
+//! What is less clear is how to transfer updates between the representations at
+//! merge time in a tasteful way. Perhaps we could put an ordering on the
+//! representations, each pair with a dominant representation, and part of
+//! merging the latter filters updates into the former. Although back and forth
+//! might be appealing, more thinking is required to negotiate all of these
+//! policies.
+//!
+//! One option would be to require the layer builder to handle these smarts.
+//! Merging is currently done by the layer as part of custom code, but we could
+//! make it simply be "iterate through cursor, push results into 'ordered
+//! builder'". Then the builder would be bright enough to emit a "batch" for the
+//! composite trace, rather than just a batch of the type merged.
+*/
+
+pub mod spine_fueled;
+
+mod merge_batcher;
+
+pub use self::merge_batcher::MergeBatcher as Batcher;
+
+pub mod ord;
diff --git a/src/trace/layers/mod.rs b/src/trace/layers/mod.rs
new file mode 100644
index 00000000..84423625
--- /dev/null
+++ b/src/trace/layers/mod.rs
@@ -0,0 +1,257 @@
+//! Traits and types for building trie-based indices.
+//!
+//! The trie structure has each each element of each layer indicate a range of
+//! elements in the next layer. Similarly, ranges of elements in the layer
+//! itself may correspond to single elements in the layer above.
+
+use crate::algebra::HasZero;
+
+pub mod ordered;
+pub mod ordered_leaf;
+// pub mod hashed;
+// pub mod weighted;
+// pub mod unordered;
+
+/// A collection of tuples, and types for building and enumerating them.
+///
+/// There are some implicit assumptions about the elements in trie-structured
+/// data, mostly that the items have some `(key, val)` structure. Perhaps we
+/// will nail these down better in the future and get a better name for the
+/// trait.
+pub trait Trie: Sized {
+    /// The type of item from which the type is constructed.
+    type Item;
+    /// The type of cursor used to navigate the type.
+    type Cursor: Cursor<Self>;
+    /// The type used to merge instances of the type together.
+    type MergeBuilder: MergeBuilder<Trie = Self>;
+    /// The type used to assemble instances of the type from its `Item`s.
+    type TupleBuilder: TupleBuilder<Trie = Self, Item = Self::Item>;
+
+    /// The number of distinct keys, as distinct from the total number of
+    /// tuples.
+    fn keys(&self) -> usize;
+
+    /// True if `self.keys()` is zero.
+    fn is_empty(&self) -> bool {
+        self.keys() == 0
+    }
+
+    /// The total number of tuples in the collection.
+    fn tuples(&self) -> usize;
+    /// Returns a cursor capable of navigating the collection.
+    fn cursor(&self) -> Self::Cursor {
+        self.cursor_from(0, self.keys())
+    }
+    /// Returns a cursor over a range of data, commonly used by others to
+    /// restrict navigation to sub-collections.
+    fn cursor_from(&self, lower: usize, upper: usize) -> Self::Cursor;
+
+    /// Merges two collections into a third.
+    ///
+    /// Collections are allowed their own semantics for merging. For example,
+    /// unordered collections simply collect values, whereas weighted
+    /// collections accumulate weights and discard elements whose weights
+    /// are zero.
+    fn merge(&self, other: &Self) -> Self {
+        let mut merger = Self::MergeBuilder::with_capacity(self, other);
+        // println!("{:?} and {:?}", self.keys(), other.keys());
+        merger.push_merge((self, self.cursor()), (other, other.cursor()));
+        merger.done()
+    }
+}
+
+pub struct TrieSlice<'a, T: Trie>(&'a T, T::Cursor);
+
+impl<T: Trie> HasZero for T {
+    fn is_zero(&self) -> bool {
+        self.keys() == 0
+    }
+    fn zero() -> Self {
+        <Self as Trie>::TupleBuilder::new().done()
+    }
+}
+
+/// A type used to assemble collections.
+pub trait Builder {
+    /// The type of collection produced.
+    type Trie: Trie;
+    /// Requests a commitment to the offset of the current-most sub-collection.
+    ///
+    /// This is most often used by parent collections to indicate that some set
+    /// of values are now logically distinct from the next set of values,
+    /// and that the builder should acknowledge this and report the limit
+    /// (to store as an offset in the parent collection).
+    fn boundary(&mut self) -> usize;
+    /// Finalizes the building process and returns the collection.
+    fn done(self) -> Self::Trie;
+}
+
+/// A type used to assemble collections by merging other instances.
+pub trait MergeBuilder: Builder {
+    /// Allocates an instance of the builder with sufficient capacity to contain
+    /// the merged data.
+    fn with_capacity(other1: &Self::Trie, other2: &Self::Trie) -> Self;
+    fn with_key_capacity(cap: usize) -> Self;
+    /// Copies sub-collections of `other` into this collection.
+    fn copy_range(&mut self, other: &Self::Trie, lower: usize, upper: usize);
+    /// Merges two sub-collections into one sub-collection.
+    fn push_merge(
+        &mut self,
+        other1: (&Self::Trie, <Self::Trie as Trie>::Cursor),
+        other2: (&Self::Trie, <Self::Trie as Trie>::Cursor),
+    ) -> usize;
+}
+
+/// A type used to assemble collections from ordered sequences of tuples.
+pub trait TupleBuilder: Builder {
+    /// The type of item accepted for construction.
+    type Item;
+    /// Allocates a new builder.
+    fn new() -> Self;
+    /// Allocates a new builder with capacity for at least `cap` tuples.
+    fn with_capacity(cap: usize) -> Self; // <-- unclear how to set child capacities...
+    /// Inserts a new into the collection.
+    fn push_tuple(&mut self, tuple: Self::Item);
+    fn tuples(&self) -> usize;
+}
+
+/// A type supporting navigation.
+///
+/// The precise meaning of this navigation is not defined by the trait. It is
+/// likely that having navigated around, the cursor will be different in some
+/// other way, but the `Cursor` trait does not explain how this is so.
+pub trait Cursor<Storage> {
+    /// The type revealed by the cursor.
+    type Key;
+    type ValueStorage: Trie;
+
+    fn keys(&self) -> usize;
+    /// Reveals the current key.
+    fn key<'a>(&self, storage: &'a Storage) -> &'a Self::Key;
+    fn values<'a>(
+        &self,
+        storage: &'a Storage,
+    ) -> (&'a Self::ValueStorage, <Self::ValueStorage as Trie>::Cursor);
+    /// Advances the cursor by one element.
+    fn step(&mut self, storage: &Storage);
+    /// Advances the cursor until the location where `key` would be expected.
+    fn seek(&mut self, storage: &Storage, key: &Self::Key);
+    /// Returns `true` if the cursor points at valid data. Returns `false` if
+    /// the cursor is exhausted.
+    fn valid(&self, storage: &Storage) -> bool;
+    /// Rewinds the cursor to its initial state.
+    fn rewind(&mut self, storage: &Storage);
+    /// Repositions the cursor to a different range of values.
+    fn reposition(&mut self, storage: &Storage, lower: usize, upper: usize);
+}
+
+/// Reports the number of elements satisfing the predicate.
+///
+/// This methods *relies strongly* on the assumption that the predicate
+/// stays false once it becomes false, a joint property of the predicate
+/// and the slice. This allows `advance` to use exponential search to
+/// count the number of elements in time logarithmic in the result.
+pub fn advance<T, F: Fn(&T) -> bool>(slice: &[T], function: F) -> usize {
+    let small_limit = 8;
+
+    // Exponential seach if the answer isn't within `small_limit`.
+    if slice.len() > small_limit && function(&slice[small_limit]) {
+        // start with no advance
+        let mut index = small_limit + 1;
+        if index < slice.len() && function(&slice[index]) {
+            // advance in exponentially growing steps.
+            let mut step = 1;
+            while index + step < slice.len() && function(&slice[index + step]) {
+                index += step;
+                step <<= step;
+            }
+
+            // advance in exponentially shrinking steps.
+            step >>= 1;
+            while step > 0 {
+                if index + step < slice.len() && function(&slice[index + step]) {
+                    index += step;
+                }
+                step >>= 1;
+            }
+
+            index += 1;
+        }
+
+        index
+    } else {
+        let limit = std::cmp::min(slice.len(), small_limit);
+        slice[..limit].iter().filter(|x| function(*x)).count()
+    }
+}
+
+impl Trie for () {
+    type Item = ();
+    type Cursor = ();
+    type MergeBuilder = ();
+    type TupleBuilder = ();
+
+    fn keys(&self) -> usize {
+        0
+    }
+    fn tuples(&self) -> usize {
+        0
+    }
+    fn cursor_from(&self, _lower: usize, _upper: usize) -> Self::Cursor {}
+}
+
+impl Builder for () {
+    type Trie = ();
+
+    fn boundary(&mut self) -> usize {
+        0
+    }
+    fn done(self) -> Self::Trie {}
+}
+
+impl MergeBuilder for () {
+    fn with_capacity(_other1: &(), _other2: &()) -> Self {}
+    fn with_key_capacity(_cap: usize) -> Self {}
+    fn copy_range(&mut self, _other: &Self::Trie, _lower: usize, _upper: usize) {}
+    fn push_merge(
+        &mut self,
+        _other1: (&Self::Trie, <Self::Trie as Trie>::Cursor),
+        _other2: (&Self::Trie, <Self::Trie as Trie>::Cursor),
+    ) -> usize {
+        0
+    }
+}
+
+impl TupleBuilder for () {
+    type Item = ();
+
+    fn new() -> Self {}
+    fn with_capacity(_cap: usize) -> Self {}
+    fn push_tuple(&mut self, _tuple: Self::Item) {}
+    fn tuples(&self) -> usize {
+        0
+    }
+}
+
+impl Cursor<()> for () {
+    type Key = ();
+    type ValueStorage = ();
+
+    fn keys(&self) -> usize {
+        0
+    }
+    fn key<'a>(&self, _storage: &'a ()) -> &'a Self::Key {
+        &()
+    }
+    fn values<'a>(&self, _storage: &'a ()) -> (&'a (), ()) {
+        (&(), ())
+    }
+    fn step(&mut self, _storage: &()) {}
+    fn seek(&mut self, _storage: &(), _key: &Self::Key) {}
+    fn valid(&self, _storage: &()) -> bool {
+        false
+    }
+    fn rewind(&mut self, _storage: &()) {}
+    fn reposition(&mut self, _storage: &(), _lower: usize, _upper: usize) {}
+}
diff --git a/src/trace/layers/ordered.rs b/src/trace/layers/ordered.rs
new file mode 100644
index 00000000..0fe7ea6c
--- /dev/null
+++ b/src/trace/layers/ordered.rs
@@ -0,0 +1,674 @@
+//! Implementation using ordered keys and exponential search.
+
+use crate::{
+    algebra::{AddAssignByRef, AddByRef, NegByRef},
+    trace::layers::{advance, Builder, Cursor, MergeBuilder, Trie, TrieSlice, TupleBuilder},
+    NumEntries, SharedRef,
+};
+use deepsize::DeepSizeOf;
+use std::{
+    cmp::{min, Ordering},
+    convert::{TryFrom, TryInto},
+    fmt::{Debug, Display, Formatter},
+    marker::PhantomData,
+    ops::{Add, AddAssign, Neg, Sub},
+};
+use textwrap::indent;
+
+/// Trait for types used as offsets into an ordered layer.
+/// This is usually `usize`, but `u32` can also be used in applications
+/// where huge batches do not occur to reduce metadata size.
+pub trait OrdOffset:
+    Copy + PartialEq + Add<Output = Self> + Sub<Output = Self> + TryFrom<usize> + TryInto<usize>
+{
+}
+
+impl<O> OrdOffset for O where
+    O: Copy + PartialEq + Add<Output = Self> + Sub<Output = Self> + TryFrom<usize> + TryInto<usize>
+{
+}
+
+/// A level of the trie, with keys and offsets into a lower layer.
+///
+/// In this representation, the values for `keys[i]` are found at `vals[offs[i]
+/// .. offs[i+1]]`.
+#[derive(Debug, DeepSizeOf, Eq, PartialEq, Clone)]
+pub struct OrderedLayer<K, L, O = usize>
+where
+    K: Ord,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    /// The keys of the layer.
+    pub keys: Vec<K>,
+    /// The offsets associate with each key.
+    ///
+    /// The bounds for `keys[i]` are `(offs[i], offs[i+1]`). The offset array is
+    /// guaranteed to be one element longer than the keys array, ensuring
+    /// that these accesses do not panic.
+    pub offs: Vec<O>,
+    /// The ranges of values associated with the keys.
+    pub vals: L,
+}
+
+impl<K, L, O> Display for OrderedLayer<K, L, O>
+where
+    K: Ord + Clone + Display,
+    L: Trie,
+    <Self as Trie>::Cursor: Clone,
+    L::Cursor: Clone,
+    for<'a> TrieSlice<'a, L>: Display,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+        TrieSlice(self, self.cursor()).fmt(f)
+    }
+}
+
+impl<'a, K, L, O> Display for TrieSlice<'a, OrderedLayer<K, L, O>>
+where
+    K: Ord + Clone + Display,
+    L: Trie,
+    <OrderedLayer<K, L, O> as Trie>::Cursor: Clone,
+    L::Cursor: Clone,
+    for<'b> TrieSlice<'b, L>: Display,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+        let TrieSlice(storage, cursor) = self;
+        let mut cursor: OrderedCursor<L> = cursor.clone();
+
+        while cursor.valid(storage) {
+            let key = cursor.key(storage);
+            writeln!(f, "{}:", key)?;
+            let (val_storage, val_cursor) = cursor.values(storage);
+
+            f.write_str(&indent(
+                &TrieSlice(val_storage, val_cursor).to_string(),
+                "    ",
+            ))?;
+            cursor.step(storage);
+        }
+
+        Ok(())
+    }
+}
+
+impl<K, L, O> SharedRef for OrderedLayer<K, L, O>
+where
+    K: Ord + Clone,
+    L: Clone,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    type Target = Self;
+
+    fn try_into_owned(self) -> Result<Self::Target, Self> {
+        Ok(self)
+    }
+}
+
+impl<K, L, O> NumEntries for OrderedLayer<K, L, O>
+where
+    K: Ord + Clone,
+    L: Trie,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn num_entries_shallow(&self) -> usize {
+        self.keys()
+    }
+
+    fn num_entries_deep(&self) -> usize {
+        self.tuples()
+    }
+
+    const CONST_NUM_ENTRIES: Option<usize> = None;
+}
+
+impl<K, L, O> NegByRef for OrderedLayer<K, L, O>
+where
+    K: Ord + Clone,
+    L: Trie + NegByRef,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn neg_by_ref(&self) -> Self {
+        Self {
+            keys: self.keys.clone(),
+            offs: self.offs.clone(),
+            // We assume that offsets in `vals` don't change after negation;
+            // otherwise `self.offs` will be invalid.
+            vals: self.vals.neg_by_ref(),
+        }
+    }
+}
+
+impl<K, L, O> Neg for OrderedLayer<K, L, O>
+where
+    K: Ord + Clone,
+    L: Trie + Neg<Output = L>,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    type Output = Self;
+
+    fn neg(self) -> Self {
+        Self {
+            keys: self.keys,
+            offs: self.offs,
+            // We assume that offsets in `vals` don't change after negation;
+            // otherwise `self.offs` will be invalid.
+            vals: self.vals.neg(),
+        }
+    }
+}
+
+// TODO: by-value merge
+impl<K, L, O> Add<Self> for OrderedLayer<K, L, O>
+where
+    K: Ord + Clone,
+    L: Trie,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        if self.is_empty() {
+            rhs
+        } else if rhs.is_empty() {
+            self
+        } else {
+            self.merge(&rhs)
+        }
+    }
+}
+
+impl<K, L, O> AddAssign<Self> for OrderedLayer<K, L, O>
+where
+    K: Ord + Clone,
+    L: Trie,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn add_assign(&mut self, rhs: Self) {
+        if self.is_empty() {
+            *self = rhs;
+        } else if !rhs.is_empty() {
+            *self = self.merge(&rhs);
+        }
+    }
+}
+
+impl<K, L, O> AddAssignByRef for OrderedLayer<K, L, O>
+where
+    K: Ord + Clone,
+    L: Trie,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn add_assign_by_ref(&mut self, other: &Self) {
+        if !other.is_empty() {
+            *self = self.merge(other);
+        }
+    }
+}
+
+impl<K, L, O> AddByRef for OrderedLayer<K, L, O>
+where
+    K: Ord + Clone,
+    L: Trie,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn add_by_ref(&self, rhs: &Self) -> Self {
+        self.merge(rhs)
+    }
+}
+
+impl<K, L, O> Trie for OrderedLayer<K, L, O>
+where
+    K: Ord + Clone,
+    L: Trie,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    type Item = (K, L::Item);
+    type Cursor = OrderedCursor<L>;
+    type MergeBuilder = OrderedBuilder<K, L::MergeBuilder, O>;
+    type TupleBuilder = UnorderedBuilder<K, L::TupleBuilder, O>;
+
+    fn keys(&self) -> usize {
+        self.keys.len()
+    }
+    fn tuples(&self) -> usize {
+        self.vals.tuples()
+    }
+    fn cursor_from(&self, lower: usize, upper: usize) -> Self::Cursor {
+        if lower < upper {
+            let child_lower = self.offs[lower];
+            let child_upper = self.offs[lower + 1];
+            OrderedCursor {
+                bounds: (lower, upper),
+                child: self.vals.cursor_from(
+                    child_lower.try_into().unwrap(),
+                    child_upper.try_into().unwrap(),
+                ),
+                pos: lower,
+            }
+        } else {
+            OrderedCursor {
+                bounds: (0, 0),
+                child: self.vals.cursor_from(0, 0),
+                pos: 0,
+            }
+        }
+    }
+}
+
+/// Assembles a layer of this
+pub struct OrderedBuilder<K, L, O = usize>
+where
+    K: Ord,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    /// Keys
+    pub keys: Vec<K>,
+    /// Offsets
+    pub offs: Vec<O>,
+    /// The next layer down
+    pub vals: L,
+}
+
+impl<K, L, O> Builder for OrderedBuilder<K, L, O>
+where
+    K: Ord + Clone,
+    L: Builder,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    type Trie = OrderedLayer<K, L::Trie, O>;
+    fn boundary(&mut self) -> usize {
+        self.offs[self.keys.len()] = O::try_from(self.vals.boundary()).unwrap();
+        self.keys.len()
+    }
+    fn done(mut self) -> Self::Trie {
+        if !self.keys.is_empty() && self.offs[self.keys.len()].try_into().unwrap() == 0 {
+            self.offs[self.keys.len()] = O::try_from(self.vals.boundary()).unwrap();
+        }
+        OrderedLayer {
+            keys: self.keys,
+            offs: self.offs,
+            vals: self.vals.done(),
+        }
+    }
+}
+
+impl<K, L, O> MergeBuilder for OrderedBuilder<K, L, O>
+where
+    K: Ord + Clone,
+    L: MergeBuilder,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn with_capacity(other1: &Self::Trie, other2: &Self::Trie) -> Self {
+        let mut offs = Vec::with_capacity(other1.keys() + other2.keys() + 1);
+        offs.push(O::try_from(0_usize).unwrap());
+        OrderedBuilder {
+            keys: Vec::with_capacity(other1.keys() + other2.keys()),
+            offs,
+            vals: L::with_capacity(&other1.vals, &other2.vals),
+        }
+    }
+    fn with_key_capacity(cap: usize) -> Self {
+        let mut offs = Vec::with_capacity(cap + 1);
+        offs.push(O::try_from(0_usize).unwrap());
+        OrderedBuilder {
+            keys: Vec::with_capacity(cap),
+            offs,
+            vals: L::with_key_capacity(cap),
+        }
+    }
+
+    #[inline]
+    fn copy_range(&mut self, other: &Self::Trie, lower: usize, upper: usize) {
+        debug_assert!(lower < upper);
+        let other_basis = other.offs[lower];
+        let self_basis = self
+            .offs
+            .last()
+            .copied()
+            .unwrap_or_else(|| O::try_from(0).unwrap());
+
+        self.keys.extend_from_slice(&other.keys[lower..upper]);
+        for index in lower..upper {
+            self.offs
+                .push((other.offs[index + 1] + self_basis) - other_basis);
+        }
+        self.vals.copy_range(
+            &other.vals,
+            other_basis.try_into().unwrap(),
+            other.offs[upper].try_into().unwrap(),
+        );
+    }
+
+    fn push_merge(
+        &mut self,
+        other1: (&Self::Trie, <Self::Trie as Trie>::Cursor),
+        other2: (&Self::Trie, <Self::Trie as Trie>::Cursor),
+    ) -> usize {
+        let (trie1, cursor1) = other1;
+        let (trie2, cursor2) = other2;
+        let mut lower1 = cursor1.bounds.0;
+        let upper1 = cursor1.bounds.1;
+        let mut lower2 = cursor2.bounds.0;
+        let upper2 = cursor2.bounds.1;
+
+        self.keys.reserve((upper1 - lower1) + (upper2 - lower2));
+
+        // while both mergees are still active
+        while lower1 < upper1 && lower2 < upper2 {
+            self.merge_step((trie1, &mut lower1, upper1), (trie2, &mut lower2, upper2));
+        }
+
+        if lower1 < upper1 {
+            self.copy_range(trie1, lower1, upper1);
+        }
+        if lower2 < upper2 {
+            self.copy_range(trie2, lower2, upper2);
+        }
+
+        self.keys.len()
+    }
+}
+
+impl<K, L, O> OrderedBuilder<K, L, O>
+where
+    K: Ord + Clone,
+    L: MergeBuilder,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    /// Performs one step of merging.
+    #[inline]
+    pub fn merge_step(
+        &mut self,
+        other1: (&<Self as Builder>::Trie, &mut usize, usize),
+        other2: (&<Self as Builder>::Trie, &mut usize, usize),
+    ) {
+        let (trie1, lower1, upper1) = other1;
+        let (trie2, lower2, upper2) = other2;
+
+        match trie1.keys[*lower1].cmp(&trie2.keys[*lower2]) {
+            Ordering::Less => {
+                // determine how far we can advance lower1 until we reach/pass lower2
+                let step = 1 + advance(&trie1.keys[(1 + *lower1)..upper1], |x| {
+                    x < &trie2.keys[*lower2]
+                });
+                let step = min(step, 1_000);
+                self.copy_range(trie1, *lower1, *lower1 + step);
+                *lower1 += step;
+            }
+            Ordering::Equal => {
+                let lower = self.vals.boundary();
+                // record vals_length so we can tell if anything was pushed.
+                let upper = self.vals.push_merge(
+                    (
+                        &trie1.vals,
+                        trie1.vals.cursor_from(
+                            trie1.offs[*lower1].try_into().unwrap(),
+                            trie1.offs[*lower1 + 1].try_into().unwrap(),
+                        ),
+                    ),
+                    (
+                        &trie2.vals,
+                        trie2.vals.cursor_from(
+                            trie2.offs[*lower2].try_into().unwrap(),
+                            trie2.offs[*lower2 + 1].try_into().unwrap(),
+                        ),
+                    ),
+                );
+                if upper > lower {
+                    self.keys.push(trie1.keys[*lower1].clone());
+                    self.offs.push(O::try_from(upper).unwrap());
+                }
+
+                *lower1 += 1;
+                *lower2 += 1;
+            }
+            Ordering::Greater => {
+                // determine how far we can advance lower2 until we reach/pass lower1
+                let step = 1 + advance(&trie2.keys[(1 + *lower2)..upper2], |x| {
+                    x < &trie1.keys[*lower1]
+                });
+                let step = min(step, 1_000);
+                self.copy_range(trie2, *lower2, *lower2 + step);
+                *lower2 += step;
+            }
+        }
+    }
+}
+
+impl<K, L, O> TupleBuilder for OrderedBuilder<K, L, O>
+where
+    K: Ord + Clone,
+    L: TupleBuilder,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    type Item = (K, L::Item);
+    fn new() -> Self {
+        OrderedBuilder {
+            keys: Vec::new(),
+            offs: vec![O::try_from(0).unwrap()],
+            vals: L::new(),
+        }
+    }
+    fn with_capacity(cap: usize) -> Self {
+        let mut offs = Vec::with_capacity(cap + 1);
+        offs.push(O::try_from(0).unwrap());
+        OrderedBuilder {
+            keys: Vec::with_capacity(cap),
+            offs,
+            vals: L::with_capacity(cap),
+        }
+    }
+    #[inline]
+    fn push_tuple(&mut self, (key, val): (K, L::Item)) {
+        // if first element, prior element finish, or different element, need to push
+        // and maybe punctuate.
+        if self.keys.is_empty()
+            || self.offs[self.keys.len()].try_into().unwrap() != 0
+            || self.keys[self.keys.len() - 1] != key
+        {
+            if !self.keys.is_empty() && self.offs[self.keys.len()].try_into().unwrap() == 0 {
+                self.offs[self.keys.len()] = O::try_from(self.vals.boundary()).unwrap();
+            }
+            self.keys.push(key);
+            self.offs.push(O::try_from(0).unwrap()); // <-- indicates
+                                                     // "unfinished".
+        }
+        self.vals.push_tuple(val);
+    }
+
+    fn tuples(&self) -> usize {
+        self.vals.tuples()
+    }
+}
+
+pub struct UnorderedBuilder<K, L, O = usize>
+where
+    K: Ord,
+    L: TupleBuilder,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    pub vals: Vec<(K, L::Item)>,
+    _phantom: PhantomData<O>,
+}
+
+impl<K, L, O> Builder for UnorderedBuilder<K, L, O>
+where
+    K: Ord + Clone,
+    L: TupleBuilder,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    type Trie = OrderedLayer<K, L::Trie, O>;
+    fn boundary(&mut self) -> usize {
+        self.vals.len()
+    }
+    fn done(mut self) -> Self::Trie {
+        // Don't use `sort_unstable_by_key` to avoid cloning the key.
+        self.vals
+            .sort_unstable_by(|(k1, _), (k2, _)| K::cmp(k1, k2));
+        let mut builder = <OrderedBuilder<K, L, O> as TupleBuilder>::with_capacity(self.vals.len());
+
+        for (k, v) in self.vals.into_iter() {
+            builder.push_tuple((k, v))
+        }
+        builder.done()
+    }
+}
+
+impl<K, L, O> TupleBuilder for UnorderedBuilder<K, L, O>
+where
+    K: Ord + Clone,
+    L: TupleBuilder,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    type Item = (K, L::Item);
+    fn new() -> Self {
+        UnorderedBuilder {
+            vals: Vec::new(),
+            _phantom: PhantomData,
+        }
+    }
+    fn with_capacity(cap: usize) -> Self {
+        UnorderedBuilder {
+            vals: Vec::with_capacity(cap),
+            _phantom: PhantomData,
+        }
+    }
+    #[inline]
+    fn push_tuple(&mut self, kv: Self::Item) {
+        self.vals.push(kv);
+    }
+
+    fn tuples(&self) -> usize {
+        self.vals.len()
+    }
+}
+
+/// A cursor with a child cursor that is updated as we move.
+#[derive(Debug, Clone)]
+pub struct OrderedCursor<L: Trie> {
+    // keys: OwningRef<Rc<Erased>, [K]>,
+    // offs: OwningRef<Rc<Erased>, [usize]>,
+    pos: usize,
+    bounds: (usize, usize),
+    /// The cursor for the trie layer below this one.
+    pub child: L::Cursor,
+}
+
+impl<K, L, O> Cursor<OrderedLayer<K, L, O>> for OrderedCursor<L>
+where
+    K: Ord,
+    L: Trie,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    type Key = K;
+    type ValueStorage = L;
+
+    fn keys(&self) -> usize {
+        self.bounds.1 - self.bounds.0
+    }
+    fn key<'a>(&self, storage: &'a OrderedLayer<K, L, O>) -> &'a Self::Key {
+        &storage.keys[self.pos]
+    }
+    fn values<'a>(&self, storage: &'a OrderedLayer<K, L, O>) -> (&'a L, L::Cursor) {
+        let child_cursor = if self.valid(storage) {
+            storage.vals.cursor_from(
+                storage.offs[self.pos].try_into().unwrap(),
+                storage.offs[self.pos + 1].try_into().unwrap(),
+            )
+        } else {
+            storage.vals.cursor_from(0, 0)
+        };
+        (&storage.vals, child_cursor)
+    }
+    fn step(&mut self, storage: &OrderedLayer<K, L, O>) {
+        self.pos += 1;
+        if self.valid(storage) {
+            self.child.reposition(
+                &storage.vals,
+                storage.offs[self.pos].try_into().unwrap(),
+                storage.offs[self.pos + 1].try_into().unwrap(),
+            );
+        } else {
+            self.pos = self.bounds.1;
+        }
+    }
+    fn seek(&mut self, storage: &OrderedLayer<K, L, O>, key: &Self::Key) {
+        self.pos += advance(&storage.keys[self.pos..self.bounds.1], |k| k.lt(key));
+        if self.valid(storage) {
+            self.child.reposition(
+                &storage.vals,
+                storage.offs[self.pos].try_into().unwrap(),
+                storage.offs[self.pos + 1].try_into().unwrap(),
+            );
+        }
+    }
+    // fn size(&self) -> usize { self.bounds.1 - self.bounds.0 }
+    fn valid(&self, _storage: &OrderedLayer<K, L, O>) -> bool {
+        self.pos < self.bounds.1
+    }
+    fn rewind(&mut self, storage: &OrderedLayer<K, L, O>) {
+        self.pos = self.bounds.0;
+        if self.valid(storage) {
+            self.child.reposition(
+                &storage.vals,
+                storage.offs[self.pos].try_into().unwrap(),
+                storage.offs[self.pos + 1].try_into().unwrap(),
+            );
+        }
+    }
+    fn reposition(&mut self, storage: &OrderedLayer<K, L, O>, lower: usize, upper: usize) {
+        self.pos = lower;
+        self.bounds = (lower, upper);
+        if self.valid(storage) {
+            self.child.reposition(
+                &storage.vals,
+                storage.offs[self.pos].try_into().unwrap(),
+                storage.offs[self.pos + 1].try_into().unwrap(),
+            );
+        }
+    }
+}
diff --git a/src/trace/layers/ordered_leaf.rs b/src/trace/layers/ordered_leaf.rs
new file mode 100644
index 00000000..f2093efa
--- /dev/null
+++ b/src/trace/layers/ordered_leaf.rs
@@ -0,0 +1,414 @@
+//! Implementation using ordered keys and exponential search.
+
+use crate::{
+    algebra::{AddAssignByRef, AddByRef, HasZero, NegByRef},
+    trace::{
+        consolidation::consolidate_slice,
+        layers::{advance, Builder, Cursor, MergeBuilder, Trie, TrieSlice, TupleBuilder},
+    },
+    NumEntries, SharedRef,
+};
+use deepsize::DeepSizeOf;
+use std::{
+    cmp::{min, Ordering},
+    fmt::{Display, Formatter},
+    ops::{Add, AddAssign, Neg},
+};
+
+/// A layer of unordered values.
+#[derive(Debug, DeepSizeOf, Eq, PartialEq, Clone)]
+pub struct OrderedLeaf<K, R> {
+    /// Unordered values.
+    pub vals: Vec<(K, R)>,
+}
+
+impl<K: Ord + Clone, R: Eq + HasZero + AddAssignByRef + Clone> Trie for OrderedLeaf<K, R> {
+    type Item = (K, R);
+    type Cursor = OrderedLeafCursor;
+    type MergeBuilder = OrderedLeafBuilder<K, R>;
+    type TupleBuilder = UnorderedLeafBuilder<K, R>;
+    fn keys(&self) -> usize {
+        self.vals.len()
+    }
+    fn tuples(&self) -> usize {
+        <OrderedLeaf<K, R> as Trie>::keys(self)
+    }
+    fn cursor_from(&self, lower: usize, upper: usize) -> Self::Cursor {
+        OrderedLeafCursor {
+            bounds: (lower, upper),
+            pos: lower,
+        }
+    }
+}
+
+impl<K, R> Display for OrderedLeaf<K, R>
+where
+    K: Ord + Clone + Display,
+    R: Eq + HasZero + AddAssignByRef + Clone + Display,
+{
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+        TrieSlice(self, self.cursor()).fmt(f)
+    }
+}
+
+impl<'a, K, R> Display for TrieSlice<'a, OrderedLeaf<K, R>>
+where
+    K: Ord + Clone + Display,
+    R: Eq + HasZero + AddAssignByRef + Clone + Display,
+{
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+        let TrieSlice(storage, cursor) = self;
+        let mut cursor: OrderedLeafCursor = cursor.clone();
+
+        while cursor.valid(storage) {
+            let (key, val) = cursor.key(storage);
+            writeln!(f, "{} -> {}", key, val)?;
+            cursor.step(storage);
+        }
+
+        Ok(())
+    }
+}
+
+// TODO: by-value merge
+impl<K, R> Add<Self> for OrderedLeaf<K, R>
+where
+    K: Ord + Clone,
+    R: Eq + HasZero + AddAssignByRef + Clone,
+{
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        if self.is_empty() {
+            rhs
+        } else if rhs.is_empty() {
+            self
+        } else {
+            self.merge(&rhs)
+        }
+    }
+}
+
+impl<K, R> AddAssign<Self> for OrderedLeaf<K, R>
+where
+    K: Ord + Clone,
+    R: Eq + HasZero + AddAssignByRef + Clone,
+{
+    fn add_assign(&mut self, rhs: Self) {
+        if !rhs.is_empty() {
+            *self = self.merge(&rhs);
+        }
+    }
+}
+
+impl<K, R> AddAssignByRef for OrderedLeaf<K, R>
+where
+    K: Ord + Clone,
+    R: Eq + HasZero + AddAssignByRef + Clone,
+{
+    fn add_assign_by_ref(&mut self, other: &Self) {
+        if !other.is_empty() {
+            *self = self.merge(other);
+        }
+    }
+}
+
+impl<K, R> AddByRef for OrderedLeaf<K, R>
+where
+    K: Ord + Clone,
+    R: Eq + HasZero + AddAssignByRef + Clone,
+{
+    fn add_by_ref(&self, rhs: &Self) -> Self {
+        self.merge(rhs)
+    }
+}
+
+impl<K, R> NegByRef for OrderedLeaf<K, R>
+where
+    K: Ord + Clone,
+    R: NegByRef,
+{
+    fn neg_by_ref(&self) -> Self {
+        Self {
+            vals: self
+                .vals
+                .iter()
+                .map(|(k, v)| (k.clone(), v.neg_by_ref()))
+                .collect(),
+        }
+    }
+}
+
+impl<K, R> Neg for OrderedLeaf<K, R>
+where
+    K: Ord + Clone,
+    R: Neg<Output = R>,
+{
+    type Output = Self;
+
+    fn neg(self) -> Self {
+        Self {
+            vals: self.vals.into_iter().map(|(k, v)| (k, v.neg())).collect(),
+        }
+    }
+}
+
+impl<K, R> NumEntries for OrderedLeaf<K, R>
+where
+    K: Ord + Clone,
+    R: Eq + HasZero + AddAssignByRef + Clone,
+{
+    fn num_entries_shallow(&self) -> usize {
+        self.keys()
+    }
+
+    fn num_entries_deep(&self) -> usize {
+        self.keys()
+    }
+
+    const CONST_NUM_ENTRIES: Option<usize> = None;
+}
+
+impl<K, R> SharedRef for OrderedLeaf<K, R>
+where
+    K: Clone,
+    R: Clone,
+{
+    type Target = Self;
+
+    fn try_into_owned(self) -> Result<Self::Target, Self> {
+        Ok(self)
+    }
+}
+
+/// A builder for unordered values.
+pub struct OrderedLeafBuilder<K, R> {
+    /// Unordered values.
+    pub vals: Vec<(K, R)>,
+}
+
+impl<K: Ord + Clone, R: Eq + HasZero + AddAssignByRef + Clone> Builder
+    for OrderedLeafBuilder<K, R>
+{
+    type Trie = OrderedLeaf<K, R>;
+    fn boundary(&mut self) -> usize {
+        self.vals.len()
+    }
+    fn done(self) -> Self::Trie {
+        OrderedLeaf { vals: self.vals }
+    }
+}
+
+impl<K: Ord + Clone, R: Eq + HasZero + AddAssignByRef + Clone> MergeBuilder
+    for OrderedLeafBuilder<K, R>
+{
+    fn with_capacity(other1: &Self::Trie, other2: &Self::Trie) -> Self {
+        OrderedLeafBuilder {
+            vals: Vec::with_capacity(
+                <OrderedLeaf<K, R> as Trie>::keys(other1)
+                    + <OrderedLeaf<K, R> as Trie>::keys(other2),
+            ),
+        }
+    }
+    fn with_key_capacity(cap: usize) -> Self {
+        OrderedLeafBuilder {
+            vals: Vec::with_capacity(cap),
+        }
+    }
+    #[inline]
+    fn copy_range(&mut self, other: &Self::Trie, lower: usize, upper: usize) {
+        self.vals.extend_from_slice(&other.vals[lower..upper]);
+    }
+    fn push_merge(
+        &mut self,
+        other1: (&Self::Trie, <Self::Trie as Trie>::Cursor),
+        other2: (&Self::Trie, <Self::Trie as Trie>::Cursor),
+    ) -> usize {
+        let (trie1, cursor1) = other1;
+        let (trie2, cursor2) = other2;
+        let mut lower1 = cursor1.bounds.0;
+        let upper1 = cursor1.bounds.1;
+        let mut lower2 = cursor2.bounds.0;
+        let upper2 = cursor2.bounds.1;
+
+        self.vals.reserve((upper1 - lower1) + (upper2 - lower2));
+
+        // while both mergees are still active
+        while lower1 < upper1 && lower2 < upper2 {
+            match trie1.vals[lower1].0.cmp(&trie2.vals[lower2].0) {
+                Ordering::Less => {
+                    // determine how far we can advance lower1 until we reach/pass lower2
+                    let step = 1 + advance(&trie1.vals[(1 + lower1)..upper1], |x| {
+                        x.0 < trie2.vals[lower2].0
+                    });
+                    let step = min(step, 1000);
+                    <OrderedLeafBuilder<K, R> as MergeBuilder>::copy_range(
+                        self,
+                        trie1,
+                        lower1,
+                        lower1 + step,
+                    );
+                    lower1 += step;
+                }
+                Ordering::Equal => {
+                    let mut sum = trie1.vals[lower1].1.clone();
+                    sum.add_assign_by_ref(&trie2.vals[lower2].1);
+                    if !sum.is_zero() {
+                        self.vals.push((trie1.vals[lower1].0.clone(), sum));
+                    }
+
+                    lower1 += 1;
+                    lower2 += 1;
+                }
+                Ordering::Greater => {
+                    // determine how far we can advance lower2 until we reach/pass lower1
+                    let step = 1 + advance(&trie2.vals[(1 + lower2)..upper2], |x| {
+                        x.0 < trie1.vals[lower1].0
+                    });
+                    let step = min(step, 1000);
+                    <OrderedLeafBuilder<K, R> as MergeBuilder>::copy_range(
+                        self,
+                        trie2,
+                        lower2,
+                        lower2 + step,
+                    );
+                    lower2 += step;
+                }
+            }
+        }
+
+        if lower1 < upper1 {
+            <OrderedLeafBuilder<K, R> as MergeBuilder>::copy_range(self, trie1, lower1, upper1);
+        }
+        if lower2 < upper2 {
+            <OrderedLeafBuilder<K, R> as MergeBuilder>::copy_range(self, trie2, lower2, upper2);
+        }
+
+        self.vals.len()
+    }
+}
+
+impl<K: Ord + Clone, R: Eq + HasZero + AddAssignByRef + Clone> TupleBuilder
+    for OrderedLeafBuilder<K, R>
+{
+    type Item = (K, R);
+    fn new() -> Self {
+        OrderedLeafBuilder { vals: Vec::new() }
+    }
+    fn with_capacity(cap: usize) -> Self {
+        OrderedLeafBuilder {
+            vals: Vec::with_capacity(cap),
+        }
+    }
+    #[inline]
+    fn push_tuple(&mut self, tuple: (K, R)) {
+        self.vals.push(tuple)
+    }
+
+    fn tuples(&self) -> usize {
+        self.vals.len()
+    }
+}
+
+#[derive(DeepSizeOf)]
+pub struct UnorderedLeafBuilder<K, R> {
+    pub vals: Vec<(K, R)>,
+    boundary: usize,
+}
+
+impl<K: Ord + Clone, R: Eq + HasZero + AddAssignByRef + Clone> Builder
+    for UnorderedLeafBuilder<K, R>
+{
+    type Trie = OrderedLeaf<K, R>;
+
+    fn boundary(&mut self) -> usize {
+        let consolidated_len = consolidate_slice(&mut self.vals[self.boundary..]);
+        self.boundary += consolidated_len;
+        self.vals.truncate(self.boundary);
+        self.boundary
+    }
+    fn done(mut self) -> Self::Trie {
+        self.boundary();
+        OrderedLeaf { vals: self.vals }
+    }
+}
+
+impl<K: Ord + Clone, R: Eq + HasZero + AddAssignByRef + Clone> TupleBuilder
+    for UnorderedLeafBuilder<K, R>
+{
+    type Item = (K, R);
+    fn new() -> Self {
+        UnorderedLeafBuilder {
+            vals: Vec::new(),
+            boundary: 0,
+        }
+    }
+    fn with_capacity(cap: usize) -> Self {
+        UnorderedLeafBuilder {
+            vals: Vec::with_capacity(cap),
+            boundary: 0,
+        }
+    }
+    #[inline]
+    fn push_tuple(&mut self, tuple: (K, R)) {
+        self.vals.push(tuple)
+    }
+
+    fn tuples(&self) -> usize {
+        self.vals.len()
+    }
+}
+
+/// A cursor for walking through an unordered sequence of values.
+///
+/// This cursor does not support `seek`, though I'm not certain how to expose
+/// this.
+#[derive(Clone, Debug)]
+pub struct OrderedLeafCursor {
+    pos: usize,
+    bounds: (usize, usize),
+}
+
+impl OrderedLeafCursor {
+    pub fn seek_key<K: Eq + Ord + Clone, R: Clone>(
+        &mut self,
+        storage: &OrderedLeaf<K, R>,
+        key: &K,
+    ) {
+        self.pos += advance(&storage.vals[self.pos..self.bounds.1], |(k, _)| k.lt(key));
+    }
+}
+
+impl<K: Eq + Ord + Clone, R: Clone> Cursor<OrderedLeaf<K, R>> for OrderedLeafCursor {
+    type Key = (K, R);
+    type ValueStorage = ();
+
+    fn keys(&self) -> usize {
+        self.bounds.1 - self.bounds.0
+    }
+    fn key<'a>(&self, storage: &'a OrderedLeaf<K, R>) -> &'a Self::Key {
+        &storage.vals[self.pos]
+    }
+    fn values<'a>(&self, _storage: &'a OrderedLeaf<K, R>) -> (&'a (), ()) {
+        (&(), ())
+    }
+    fn step(&mut self, storage: &OrderedLeaf<K, R>) {
+        self.pos += 1;
+        if !self.valid(storage) {
+            self.pos = self.bounds.1;
+        }
+    }
+    fn seek(&mut self, storage: &OrderedLeaf<K, R>, key: &Self::Key) {
+        self.seek_key(storage, &key.0);
+    }
+    fn valid(&self, _storage: &OrderedLeaf<K, R>) -> bool {
+        self.pos < self.bounds.1
+    }
+    fn rewind(&mut self, _storage: &OrderedLeaf<K, R>) {
+        self.pos = self.bounds.0;
+    }
+    fn reposition(&mut self, _storage: &OrderedLeaf<K, R>, lower: usize, upper: usize) {
+        self.pos = lower;
+        self.bounds = (lower, upper);
+    }
+}
diff --git a/src/trace/mod.rs b/src/trace/mod.rs
new file mode 100644
index 00000000..ef37ee74
--- /dev/null
+++ b/src/trace/mod.rs
@@ -0,0 +1,476 @@
+//! Traits and datastructures representing a collection trace.
+//!
+//! A collection trace is a set of updates of the form `(key, val, time, diff)`,
+//! which determine the contents of a collection at given times by accumulating
+//! updates whose time field is less or equal to the target field.
+//!
+//! The `Trace` trait describes those types and methods that a data structure
+//! must implement to be viewed as a collection trace. This trait allows
+//! operator implementations to be generic with respect to the type of trace,
+//! and allows various data structures to be interpretable as multiple different
+//! types of trace.
+
+pub mod consolidation;
+pub mod cursor;
+pub mod description;
+pub mod layers;
+pub mod ord;
+pub mod spine_fueled;
+
+use crate::{algebra::MonoidValue, lattice::Lattice, time::Timestamp};
+use timely::progress::Antichain;
+
+pub use cursor::Cursor;
+pub use description::Description;
+
+/// A trace whose contents may be read.
+///
+/// This is a restricted interface to the more general `Trace` trait, which
+/// extends this trait with further methods to update the contents of the trace.
+/// These methods are used to examine the contents, and to update the reader's
+/// capabilities (which may release restrictions on the mutations to the
+/// underlying trace and cause work to happen).
+pub trait TraceReader {
+    /// Key by which updates are indexed.
+    type Key;
+    /// Values associated with keys.
+    type Val;
+    /// Timestamps associated with updates
+    type Time: Timestamp + Lattice;
+    /// Associated update.
+    type R;
+
+    /// The type of an immutable collection of updates.
+    type Batch: Batch<Key = Self::Key, Val = Self::Val, Time = Self::Time, R = Self::R>
+        + Clone
+        + 'static;
+
+    /// The type used to enumerate the collections contents.
+    type Cursor: Cursor<Self::Key, Self::Val, Self::Time, Self::R>;
+
+    /// Provides a cursor over updates contained in the trace.
+    #[allow(clippy::type_complexity)]
+    fn cursor(
+        &self,
+    ) -> (
+        Self::Cursor,
+        <Self::Cursor as Cursor<Self::Key, Self::Val, Self::Time, Self::R>>::Storage,
+    );
+
+    // TODO: Do we want a version of `cursor` with an upper bound on time?  E.g., it
+    // could help in `distinct` to avoid iterating into the future (and then
+    // drop future timestamps anyway).
+    /*
+    /// Acquires a cursor to the restriction of the collection's contents to updates at times not greater or
+    /// equal to an element of `upper`.
+    ///
+    /// This method is expected to work if called with an `upper` that (i) was an observed bound in batches from
+    /// the trace, and (ii) the trace has not been advanced beyond `upper`. Practically, the implementation should
+    /// be expected to look for a "clean cut" using `upper`, and if it finds such a cut can return a cursor. This
+    /// should allow `upper` such as `&[]` as used by `self.cursor()`, though it is difficult to imagine other uses.
+    fn cursor_through(&self, upper: AntichainRef<Self::Time>) -> Option<(Self::Cursor, <Self::Cursor as Cursor<Self::Key, Self::Val, Self::Time, Self::R>>::Storage)>;
+    */
+
+    /// Maps logic across the non-empty sequence of batches in the trace.
+    fn map_batches<F: FnMut(&Self::Batch)>(&self, f: F);
+}
+
+/// An append-only collection of `(key, val, time, diff)` tuples.
+///
+/// The trace must be constructable from, and navigable by the `Key`, `Val`,
+/// `Time` types, but does not need to return them.
+pub trait Trace: TraceReader {
+    /// Allocates a new empty trace.
+    fn new(activator: Option<timely::scheduling::activate::Activator>) -> Self;
+
+    /// Push all timestamps in the trace back to `frontier`.
+    ///
+    /// Modifies all timestamps `t` that are not less than or equal to
+    /// `frontier` to `t.meet(frontier)`.  As a result, the trace can no
+    /// longer distinguish between timestamps that map to the same value,
+    /// but it will contain fewer different timestamps, thus reducing its
+    /// memory footprint.
+    ///
+    /// This also enables us to use fewer bits to represent timestamps.
+    /// In DBSP, computations inside a nested circuit only need to distinguish
+    /// between updates added during the current run of the nested circuit
+    /// vs all previous runs.  Thus, we only need a single bit for the outer
+    /// time stamp.  When the nested clock epoch completes, all tuples with
+    /// outer timestamp `1` are demoted to `0`, so they appear as old
+    /// updates during the next run of the circuit.
+    ///
+    /// The downside of the 1-bit clock is that it requires rewriting timestamps
+    /// and rearranging batches in the trace at the end of every clock epoch.
+    /// Unlike merging of batches, which can be done in the backgound, this work
+    /// must be completed synchronously before the start of the next epoch.
+    /// This cost should be roughly proportional to the number of updates
+    /// added to the trace during the last epoch.
+    ///
+    /// See [`NestedTimestamp32`](`crate::time::NestedTimestamp32`) for an
+    /// example of a timestamp type that takes advantage of the 1-bit
+    /// timestamp representation.
+    fn recede_to(&mut self, frontier: &Self::Time);
+
+    /// Exert merge effort, even without updates.
+    fn exert(&mut self, effort: &mut isize);
+
+    /// Merge all updates in a trace into a single batch.
+    fn consolidate(self) -> Option<Self::Batch>;
+
+    /// Introduces a batch of updates to the trace.
+    ///
+    /// Batches describe the time intervals they contain, and they should be
+    /// added to the trace in contiguous intervals. If a batch arrives with
+    /// a lower bound that does not equal the upper bound of the most recent
+    /// addition, the trace will add an empty batch. It is an error to then try
+    /// to populate that region of time.
+    ///
+    /// This restriction could be relaxed, especially if we discover ways in
+    /// which batch interval order could commute. For now, the trace should
+    /// complain, to the extent that it cares about contiguous intervals.
+    fn insert(&mut self, batch: Self::Batch);
+
+    /// Clears the value of the "dirty" flag to `false`.
+    ///
+    /// The "dirty" flag is used to efficiently track changes to the trace,
+    /// e.g., as part of checking whether a circuit has reached a fixed point.
+    /// Pushing a non-empty batch to the trace sets the flag to `true`. The
+    /// [`Self::dirty`] method returns true iff the trace has changed since the
+    /// last call to `clear_dirty_flag`.
+    fn clear_dirty_flag(&mut self);
+
+    /// Returns the value of the dirty flag.
+    fn dirty(&self) -> bool;
+}
+
+/// A batch of updates whose contents may be read.
+///
+/// This is a restricted interface to batches of updates, which support the
+/// reading of the batch's contents, but do not expose ways to construct the
+/// batches. This trait is appropriate for views of the batch, and is especially
+/// useful for views derived from other sources in ways that prevent the
+/// construction of batches from the type of data in the view (for example,
+/// filtered views, or views with extended time coordinates).
+pub trait BatchReader
+where
+    Self: Sized,
+{
+    type Key;
+    type Val;
+    type Time: Timestamp + Lattice;
+    type R: MonoidValue;
+
+    /// The type used to enumerate the batch's contents.
+    type Cursor: Cursor<Self::Key, Self::Val, Self::Time, Self::R, Storage = Self>;
+    /// Acquires a cursor to the batch's contents.
+    fn cursor(&self) -> Self::Cursor;
+    /// The number of updates in the batch.
+    fn len(&self) -> usize;
+    /// True if the batch is empty.
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+    /// Describes the times of the updates in the batch.
+    fn description(&self) -> &Description<Self::Time>;
+
+    /// All times in the batch are greater or equal to an element of `lower`.
+    fn lower(&self) -> &Antichain<Self::Time> {
+        self.description().lower()
+    }
+    /// All times in the batch are not greater or equal to any element of
+    /// `upper`.
+    fn upper(&self) -> &Antichain<Self::Time> {
+        self.description().upper()
+    }
+}
+
+/// An immutable collection of updates.
+pub trait Batch: BatchReader
+where
+    Self: Sized,
+{
+    /// A type used to assemble batches from disordered updates.
+    type Batcher: Batcher<Self::Key, Self::Val, Self::Time, Self::R, Self>;
+
+    /// A type used to assemble batches from ordered update sequences.
+    type Builder: Builder<Self::Key, Self::Val, Self::Time, Self::R, Self>;
+
+    /// A type used to progressively merge batches.
+    type Merger: Merger<Self::Key, Self::Val, Self::Time, Self::R, Self>;
+
+    #[allow(clippy::type_complexity)]
+    fn from_tuples(time: Self::Time, mut tuples: Vec<((Self::Key, Self::Val), Self::R)>) -> Self {
+        let mut batcher = Self::Batcher::new(time);
+        batcher.push_batch(&mut tuples);
+        batcher.seal()
+    }
+
+    /// Initiates the merging of consecutive batches.
+    ///
+    /// The result of this method can be exercised to eventually produce the
+    /// same result that a call to `self.merge(other)` would produce, but it
+    /// can be done in a measured fashion. This can help to avoid latency
+    /// spikes where a large merge needs to happen.
+    fn begin_merge(&self, other: &Self) -> Self::Merger {
+        Self::Merger::new(self, other)
+    }
+
+    /// Merges `self` with `other` by running merger to completion.
+    fn merge(&self, other: &Self) -> Self {
+        let mut fuel = isize::max_value();
+        let mut merger = Self::Merger::new(self, other);
+        merger.work(self, other, &mut fuel);
+        merger.done()
+    }
+
+    /// Creates an empty batch with timestamp `time`.
+    fn empty(time: Self::Time) -> Self {
+        <Self::Builder>::new(time).done()
+    }
+
+    /// Push all timestamps in the batch back to `frontier`.
+    ///
+    /// Modifies all timestamps `t` that are not less than or equal to
+    /// `frontier` to `t.meet(frontier)`.  See [`Trace::recede_to`].
+    fn recede_to(&mut self, frontier: &Self::Time);
+}
+
+/// Functionality for collecting and batching updates.
+pub trait Batcher<K, V, T, R, Output: Batch<Key = K, Val = V, Time = T, R = R>> {
+    /// Allocates a new empty batcher.  All tuples in the batcher (and its
+    /// output batch) will have timestamp `time`.
+    fn new(time: T) -> Self;
+    /// Adds an unordered batch of elements to the batcher.
+    fn push_batch(&mut self, batch: &mut Vec<((K, V), R)>);
+    /// Returns the number of tuples in the batcher.
+    fn tuples(&self) -> usize;
+    /// Returns all updates not greater or equal to an element of `upper`.
+    fn seal(self) -> Output;
+}
+
+/// Functionality for building batches from ordered update sequences.
+pub trait Builder<K, V, T, R, Output: Batch<Key = K, Val = V, Time = T, R = R>> {
+    /// Allocates an empty builder.  All tuples in the builder (and its output
+    /// batch) will have timestamp `time`.
+    fn new(time: T) -> Self;
+    /// Allocates an empty builder with some capacity.  All tuples in the
+    /// builder (and its output batch) will have timestamp `time`.
+    fn with_capacity(time: T, cap: usize) -> Self;
+    /// Adds an element to the batch.
+    fn push(&mut self, element: (K, V, R));
+    /// Adds an ordered sequence of elements to the batch.
+    fn extend<I: Iterator<Item = (K, V, R)>>(&mut self, iter: I) {
+        for item in iter {
+            self.push(item);
+        }
+    }
+    /// Completes building and returns the batch.
+    fn done(self) -> Output;
+}
+
+/// Represents a merge in progress.
+pub trait Merger<K, V, T, R, Output: Batch<Key = K, Val = V, Time = T, R = R>> {
+    /// Creates a new merger to merge the supplied batches, optionally
+    /// compacting up to the supplied frontier.
+    fn new(source1: &Output, source2: &Output) -> Self;
+    /// Perform some amount of work, decrementing `fuel`.
+    ///
+    /// If `fuel` is non-zero after the call, the merging is complete and
+    /// one should call `done` to extract the merged results.
+    fn work(&mut self, source1: &Output, source2: &Output, fuel: &mut isize);
+    /// Extracts merged results.
+    ///
+    /// This method should only be called after `work` has been called and
+    /// has not brought `fuel` to zero. Otherwise, the merge is still in
+    /// progress.
+    fn done(self) -> Output;
+}
+
+/// Blanket implementations for reference counted batches.
+pub mod rc_blanket_impls {
+
+    use std::{marker::PhantomData, rc::Rc};
+
+    use super::{Batch, BatchReader, Batcher, Builder, Cursor, Description, Merger};
+
+    impl<B: BatchReader> BatchReader for Rc<B> {
+        type Key = B::Key;
+        type Val = B::Val;
+        type Time = B::Time;
+        type R = B::R;
+
+        /// The type used to enumerate the batch's contents.
+        type Cursor = RcBatchCursor<B>;
+        /// Acquires a cursor to the batch's contents.
+        fn cursor(&self) -> Self::Cursor {
+            RcBatchCursor::new((&**self).cursor())
+        }
+
+        /// The number of updates in the batch.
+        fn len(&self) -> usize {
+            (&**self).len()
+        }
+        /// Describes the times of the updates in the batch.
+        fn description(&self) -> &Description<B::Time> {
+            (&**self).description()
+        }
+    }
+
+    /// Wrapper to provide cursor to nested scope.
+    pub struct RcBatchCursor<B: BatchReader> {
+        phantom: PhantomData<B>,
+        cursor: B::Cursor,
+    }
+
+    impl<B: BatchReader> RcBatchCursor<B> {
+        fn new(cursor: B::Cursor) -> Self {
+            RcBatchCursor {
+                cursor,
+                phantom: PhantomData,
+            }
+        }
+    }
+
+    impl<B: BatchReader> Cursor<B::Key, B::Val, B::Time, B::R> for RcBatchCursor<B> {
+        type Storage = Rc<B>;
+
+        #[inline]
+        fn key_valid(&self, storage: &Self::Storage) -> bool {
+            self.cursor.key_valid(storage)
+        }
+        #[inline]
+        fn val_valid(&self, storage: &Self::Storage) -> bool {
+            self.cursor.val_valid(storage)
+        }
+
+        #[inline]
+        fn key<'a>(&self, storage: &'a Self::Storage) -> &'a B::Key {
+            self.cursor.key(storage)
+        }
+        #[inline]
+        fn val<'a>(&self, storage: &'a Self::Storage) -> &'a B::Val {
+            self.cursor.val(storage)
+        }
+
+        #[inline]
+        fn map_times<L: FnMut(&B::Time, &B::R)>(&mut self, storage: &Self::Storage, logic: L) {
+            self.cursor.map_times(storage, logic)
+        }
+
+        #[inline]
+        fn weight<'a>(&self, storage: &'a Self::Storage) -> &'a B::R
+        where
+            B::Time: PartialEq<()>,
+        {
+            self.cursor.weight(storage)
+        }
+
+        #[inline]
+        fn step_key(&mut self, storage: &Self::Storage) {
+            self.cursor.step_key(storage)
+        }
+        #[inline]
+        fn seek_key(&mut self, storage: &Self::Storage, key: &B::Key) {
+            self.cursor.seek_key(storage, key)
+        }
+
+        #[inline]
+        fn step_val(&mut self, storage: &Self::Storage) {
+            self.cursor.step_val(storage)
+        }
+        #[inline]
+        fn seek_val(&mut self, storage: &Self::Storage, val: &B::Val) {
+            self.cursor.seek_val(storage, val)
+        }
+
+        #[inline]
+        fn rewind_keys(&mut self, storage: &Self::Storage) {
+            self.cursor.rewind_keys(storage)
+        }
+        #[inline]
+        fn rewind_vals(&mut self, storage: &Self::Storage) {
+            self.cursor.rewind_vals(storage)
+        }
+    }
+
+    /// An immutable collection of updates.
+    impl<B: Batch> Batch for Rc<B> {
+        type Batcher = RcBatcher<B>;
+        type Builder = RcBuilder<B>;
+        type Merger = RcMerger<B>;
+
+        fn recede_to(&mut self, frontier: &B::Time) {
+            Rc::get_mut(self).unwrap().recede_to(frontier);
+        }
+    }
+
+    /// Wrapper type for batching reference counted batches.
+    pub struct RcBatcher<B: Batch> {
+        batcher: B::Batcher,
+    }
+
+    /// Functionality for collecting and batching updates.
+    impl<B: Batch> Batcher<B::Key, B::Val, B::Time, B::R, Rc<B>> for RcBatcher<B> {
+        fn new(time: B::Time) -> Self {
+            RcBatcher {
+                batcher: <B::Batcher as Batcher<B::Key, B::Val, B::Time, B::R, B>>::new(time),
+            }
+        }
+        fn push_batch(&mut self, batch: &mut Vec<((B::Key, B::Val), B::R)>) {
+            self.batcher.push_batch(batch)
+        }
+        fn tuples(&self) -> usize {
+            self.batcher.tuples()
+        }
+        fn seal(self) -> Rc<B> {
+            Rc::new(self.batcher.seal())
+        }
+    }
+
+    /// Wrapper type for building reference counted batches.
+    pub struct RcBuilder<B: Batch> {
+        builder: B::Builder,
+    }
+
+    /// Functionality for building batches from ordered update sequences.
+    impl<B: Batch> Builder<B::Key, B::Val, B::Time, B::R, Rc<B>> for RcBuilder<B> {
+        fn new(time: B::Time) -> Self {
+            RcBuilder {
+                builder: <B::Builder as Builder<B::Key, B::Val, B::Time, B::R, B>>::new(time),
+            }
+        }
+        fn with_capacity(time: B::Time, cap: usize) -> Self {
+            RcBuilder {
+                builder: <B::Builder as Builder<B::Key, B::Val, B::Time, B::R, B>>::with_capacity(
+                    time, cap,
+                ),
+            }
+        }
+        fn push(&mut self, element: (B::Key, B::Val, B::R)) {
+            self.builder.push(element)
+        }
+        fn done(self) -> Rc<B> {
+            Rc::new(self.builder.done())
+        }
+    }
+
+    /// Wrapper type for merging reference counted batches.
+    pub struct RcMerger<B: Batch> {
+        merger: B::Merger,
+    }
+
+    /// Represents a merge in progress.
+    impl<B: Batch> Merger<B::Key, B::Val, B::Time, B::R, Rc<B>> for RcMerger<B> {
+        fn new(source1: &Rc<B>, source2: &Rc<B>) -> Self {
+            RcMerger {
+                merger: B::begin_merge(source1, source2),
+            }
+        }
+        fn work(&mut self, source1: &Rc<B>, source2: &Rc<B>, fuel: &mut isize) {
+            self.merger.work(source1, source2, fuel)
+        }
+        fn done(self) -> Rc<B> {
+            Rc::new(self.merger.done())
+        }
+    }
+}
diff --git a/src/trace/ord/indexed_zset_batch.rs b/src/trace/ord/indexed_zset_batch.rs
new file mode 100644
index 00000000..5310e460
--- /dev/null
+++ b/src/trace/ord/indexed_zset_batch.rs
@@ -0,0 +1,490 @@
+use std::{
+    cmp::max,
+    convert::{TryFrom, TryInto},
+    fmt::Debug,
+    marker::PhantomData,
+    ops::{Add, AddAssign, Neg},
+    rc::Rc,
+};
+
+use timely::progress::Antichain;
+
+use crate::{
+    algebra::{AddAssignByRef, AddByRef, HasZero, MonoidValue, NegByRef},
+    lattice::Lattice,
+    trace::{
+        description::Description,
+        layers::{
+            ordered::{OrdOffset, OrderedBuilder, OrderedCursor, OrderedLayer},
+            ordered_leaf::{OrderedLeaf, OrderedLeafBuilder},
+            Builder as TrieBuilder, Cursor as TrieCursor, MergeBuilder, Trie, TupleBuilder,
+        },
+        ord::merge_batcher::MergeBatcher,
+        Batch, BatchReader, Builder, Cursor, Merger,
+    },
+    NumEntries, SharedRef,
+};
+
+use deepsize::DeepSizeOf;
+
+/// An immutable collection of update tuples.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct OrdIndexedZSet<K, V, R, O = usize>
+where
+    K: Ord,
+    V: Ord,
+    R: Clone,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    /// Where all the dataz is.
+    pub layer: OrderedLayer<K, OrderedLeaf<V, R>, O>,
+    pub desc: Description<()>,
+}
+
+impl<K, V, R, O> HasZero for OrdIndexedZSet<K, V, R, O>
+where
+    K: Ord + Clone + 'static,
+    V: Ord + Clone,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn zero() -> Self {
+        Self::empty(())
+    }
+
+    fn is_zero(&self) -> bool {
+        self.is_empty()
+    }
+}
+
+impl<K, V, R, O> SharedRef for OrdIndexedZSet<K, V, R, O>
+where
+    K: Ord + Clone,
+    V: Ord + Clone,
+    R: Clone,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    type Target = Self;
+
+    fn try_into_owned(self) -> Result<Self::Target, Self> {
+        Ok(self)
+    }
+}
+
+impl<K, V, R, O> From<OrderedLayer<K, OrderedLeaf<V, R>, O>> for OrdIndexedZSet<K, V, R, O>
+where
+    K: Ord,
+    V: Ord,
+    R: Clone,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn from(layer: OrderedLayer<K, OrderedLeaf<V, R>, O>) -> Self {
+        Self {
+            layer,
+            desc: Description::new(Antichain::from_elem(()), Antichain::new()),
+        }
+    }
+}
+
+impl<K, V, R, O> From<OrderedLayer<K, OrderedLeaf<V, R>, O>> for Rc<OrdIndexedZSet<K, V, R, O>>
+where
+    K: Ord,
+    V: Ord,
+    R: Clone,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn from(layer: OrderedLayer<K, OrderedLeaf<V, R>, O>) -> Self {
+        Rc::new(From::from(layer))
+    }
+}
+
+impl<K, V, R, O> TryFrom<Rc<OrdIndexedZSet<K, V, R, O>>> for OrdIndexedZSet<K, V, R, O>
+where
+    K: Ord,
+    V: Ord,
+    R: Clone,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    type Error = Rc<OrdIndexedZSet<K, V, R, O>>;
+
+    fn try_from(batch: Rc<OrdIndexedZSet<K, V, R, O>>) -> Result<Self, Self::Error> {
+        Rc::try_unwrap(batch)
+    }
+}
+
+impl<K, V, R, O> DeepSizeOf for OrdIndexedZSet<K, V, R, O>
+where
+    K: DeepSizeOf + Ord,
+    V: DeepSizeOf + Ord,
+    R: DeepSizeOf + Clone,
+    O: DeepSizeOf + OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn deep_size_of_children(&self, _context: &mut deepsize::Context) -> usize {
+        self.layer.deep_size_of()
+    }
+}
+
+impl<K, V, R, O> NumEntries for OrdIndexedZSet<K, V, R, O>
+where
+    K: Clone + Ord,
+    V: Clone + Ord,
+    R: Eq + HasZero + AddAssignByRef + Clone,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn num_entries_shallow(&self) -> usize {
+        self.layer.num_entries_shallow()
+    }
+
+    fn num_entries_deep(&self) -> usize {
+        self.layer.num_entries_deep()
+    }
+
+    const CONST_NUM_ENTRIES: Option<usize> =
+        <OrderedLayer<K, OrderedLeaf<V, R>, O>>::CONST_NUM_ENTRIES;
+}
+
+impl<K, V, R, O> NegByRef for OrdIndexedZSet<K, V, R, O>
+where
+    K: Ord + Clone,
+    V: Ord + Clone,
+    R: MonoidValue + NegByRef,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn neg_by_ref(&self) -> Self {
+        Self {
+            layer: self.layer.neg_by_ref(),
+            desc: self.desc.clone(),
+        }
+    }
+}
+
+impl<K, V, R, O> Neg for OrdIndexedZSet<K, V, R, O>
+where
+    K: Ord + Clone,
+    V: Ord + Clone,
+    R: MonoidValue + Neg<Output = R>,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    type Output = Self;
+
+    fn neg(self) -> Self {
+        Self {
+            layer: self.layer.neg(),
+            desc: self.desc,
+        }
+    }
+}
+
+// TODO: by-value merge
+impl<K, V, R, O> Add<Self> for OrdIndexedZSet<K, V, R, O>
+where
+    K: Ord + Clone + 'static,
+    V: Ord + Clone,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        let desc = Description::new(
+            self.lower().meet(rhs.lower()),
+            self.upper().join(rhs.upper()),
+        );
+
+        Self {
+            layer: self.layer.add(rhs.layer),
+            desc,
+        }
+    }
+}
+
+impl<K, V, R, O> AddAssign<Self> for OrdIndexedZSet<K, V, R, O>
+where
+    K: Ord + Clone + 'static,
+    V: Ord + Clone,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn add_assign(&mut self, rhs: Self) {
+        self.desc = Description::new(
+            self.lower().meet(rhs.lower()),
+            self.upper().join(rhs.upper()),
+        );
+        self.layer.add_assign(rhs.layer);
+    }
+}
+
+impl<K, V, R, O> AddAssignByRef for OrdIndexedZSet<K, V, R, O>
+where
+    K: Ord + Clone + 'static,
+    V: Ord + Clone,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn add_assign_by_ref(&mut self, rhs: &Self) {
+        self.layer.add_assign_by_ref(&rhs.layer);
+        self.desc = Description::new(
+            self.lower().meet(rhs.lower()),
+            self.upper().join(rhs.upper()),
+        );
+    }
+}
+
+impl<K, V, R, O> AddByRef for OrdIndexedZSet<K, V, R, O>
+where
+    K: Ord + Clone + 'static,
+    V: Ord + Clone,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn add_by_ref(&self, rhs: &Self) -> Self {
+        Self {
+            layer: self.layer.add_by_ref(&rhs.layer),
+            desc: Description::new(
+                self.lower().meet(rhs.lower()),
+                self.upper().join(rhs.upper()),
+            ),
+        }
+    }
+}
+
+impl<K, V, R, O> BatchReader for OrdIndexedZSet<K, V, R, O>
+where
+    K: Ord + Clone + 'static,
+    V: Ord + Clone,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    type Key = K;
+    type Val = V;
+    type Time = ();
+    type R = R;
+    type Cursor = OrdIndexedZSetCursor<K, V, R, O>;
+
+    fn cursor(&self) -> Self::Cursor {
+        OrdIndexedZSetCursor {
+            cursor: self.layer.cursor(),
+            _phantom: PhantomData,
+        }
+    }
+    fn len(&self) -> usize {
+        <OrderedLayer<K, OrderedLeaf<V, R>, O> as Trie>::tuples(&self.layer)
+    }
+    fn description(&self) -> &Description<()> {
+        &self.desc
+    }
+}
+
+impl<K, V, R, O> Batch for OrdIndexedZSet<K, V, R, O>
+where
+    K: Ord + Clone + 'static,
+    V: Ord + Clone,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    type Batcher = MergeBatcher<K, V, (), R, Self>;
+    type Builder = OrdIndexedZSetBuilder<K, V, R, O>;
+    type Merger = OrdIndexedZSetMerger<K, V, R, O>;
+
+    fn begin_merge(&self, other: &Self) -> Self::Merger {
+        OrdIndexedZSetMerger::new(self, other)
+    }
+
+    fn recede_to(&mut self, _frontier: &()) {}
+}
+
+/// State for an in-progress merge.
+pub struct OrdIndexedZSetMerger<K, V, R, O>
+where
+    K: Ord + Clone + 'static,
+    V: Ord + Clone,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    // result that we are currently assembling.
+    result: <OrderedLayer<K, OrderedLeaf<V, R>, O> as Trie>::MergeBuilder,
+}
+
+impl<K, V, R, O> Merger<K, V, (), R, OrdIndexedZSet<K, V, R, O>>
+    for OrdIndexedZSetMerger<K, V, R, O>
+where
+    K: Ord + Clone + 'static,
+    V: Ord + Clone,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn new(batch1: &OrdIndexedZSet<K, V, R, O>, batch2: &OrdIndexedZSet<K, V, R, O>) -> Self {
+        OrdIndexedZSetMerger {
+            result: <<OrderedLayer<K, OrderedLeaf<V, R>, O> as Trie>::MergeBuilder as MergeBuilder>::with_capacity(&batch1.layer, &batch2.layer),
+        }
+    }
+    fn done(self) -> OrdIndexedZSet<K, V, R, O> {
+        OrdIndexedZSet {
+            layer: self.result.done(),
+            desc: Description::new(Antichain::from_elem(()), Antichain::new()),
+        }
+    }
+    fn work(
+        &mut self,
+        source1: &OrdIndexedZSet<K, V, R, O>,
+        source2: &OrdIndexedZSet<K, V, R, O>,
+        fuel: &mut isize,
+    ) {
+        *fuel -= self.result.push_merge(
+            (&source1.layer, source1.layer.cursor()),
+            (&source2.layer, source2.layer.cursor()),
+        ) as isize;
+        *fuel = max(*fuel, 1);
+    }
+}
+
+/// A cursor for navigating a single layer.
+#[derive(Debug)]
+pub struct OrdIndexedZSetCursor<K, V, R, O>
+where
+    K: Ord + Clone,
+    V: Ord + Clone,
+    R: MonoidValue,
+{
+    cursor: OrderedCursor<OrderedLeaf<V, R>>,
+    _phantom: PhantomData<(K, O)>,
+}
+
+impl<K, V, R, O> Cursor<K, V, (), R> for OrdIndexedZSetCursor<K, V, R, O>
+where
+    K: Ord + Clone,
+    V: Ord + Clone,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    type Storage = OrdIndexedZSet<K, V, R, O>;
+
+    fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K {
+        self.cursor.key(&storage.layer)
+    }
+    fn val<'a>(&self, storage: &'a Self::Storage) -> &'a V {
+        &self.cursor.child.key(&storage.layer.vals).0
+    }
+    fn map_times<L: FnMut(&(), &R)>(&mut self, storage: &Self::Storage, mut logic: L) {
+        if self.cursor.child.valid(&storage.layer.vals) {
+            logic(&(), &self.cursor.child.key(&storage.layer.vals).1);
+        }
+    }
+    fn weight<'a>(&self, storage: &'a Self::Storage) -> &'a R {
+        debug_assert!(self.cursor.child.valid(&storage.layer.vals));
+        &self.cursor.child.key(&storage.layer.vals).1
+    }
+
+    fn key_valid(&self, storage: &Self::Storage) -> bool {
+        self.cursor.valid(&storage.layer)
+    }
+    fn val_valid(&self, storage: &Self::Storage) -> bool {
+        self.cursor.child.valid(&storage.layer.vals)
+    }
+    fn step_key(&mut self, storage: &Self::Storage) {
+        self.cursor.step(&storage.layer);
+    }
+    fn seek_key(&mut self, storage: &Self::Storage, key: &K) {
+        self.cursor.seek(&storage.layer, key);
+    }
+    fn step_val(&mut self, storage: &Self::Storage) {
+        self.cursor.child.step(&storage.layer.vals);
+    }
+    fn seek_val(&mut self, storage: &Self::Storage, val: &V) {
+        self.cursor.child.seek_key(&storage.layer.vals, val);
+    }
+    fn rewind_keys(&mut self, storage: &Self::Storage) {
+        self.cursor.rewind(&storage.layer);
+    }
+    fn rewind_vals(&mut self, storage: &Self::Storage) {
+        self.cursor.child.rewind(&storage.layer.vals);
+    }
+}
+
+/// A builder for creating layers from unsorted update tuples.
+pub struct OrdIndexedZSetBuilder<K, V, R, O>
+where
+    K: Ord,
+    V: Ord,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    builder: OrderedBuilder<K, OrderedLeafBuilder<V, R>, O>,
+}
+
+impl<K, V, R, O> Builder<K, V, (), R, OrdIndexedZSet<K, V, R, O>>
+    for OrdIndexedZSetBuilder<K, V, R, O>
+where
+    K: Ord + Clone + 'static,
+    V: Ord + Clone,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn new(_time: ()) -> Self {
+        OrdIndexedZSetBuilder {
+            builder: <OrderedBuilder<K, OrderedLeafBuilder<V, R>, O>>::new(),
+        }
+    }
+
+    fn with_capacity(_time: (), cap: usize) -> Self {
+        OrdIndexedZSetBuilder {
+            builder:
+                <OrderedBuilder<K, OrderedLeafBuilder<V, R>, O> as TupleBuilder>::with_capacity(cap),
+        }
+    }
+
+    #[inline]
+    fn push(&mut self, (key, val, diff): (K, V, R)) {
+        self.builder.push_tuple((key, (val, diff)));
+    }
+
+    #[inline(never)]
+    fn done(self) -> OrdIndexedZSet<K, V, R, O> {
+        OrdIndexedZSet {
+            layer: self.builder.done(),
+            desc: Description::new(Antichain::from_elem(()), Antichain::new()),
+        }
+    }
+}
diff --git a/src/trace/ord/key_batch.rs b/src/trace/ord/key_batch.rs
new file mode 100644
index 00000000..7bf5da9f
--- /dev/null
+++ b/src/trace/ord/key_batch.rs
@@ -0,0 +1,430 @@
+use std::{
+    convert::{TryFrom, TryInto},
+    fmt::Debug,
+    marker::PhantomData,
+};
+
+use timely::progress::Antichain;
+
+use crate::{
+    algebra::MonoidValue,
+    lattice::Lattice,
+    trace::{
+        description::Description,
+        layers::{
+            ordered::{OrdOffset, OrderedBuilder, OrderedCursor, OrderedLayer},
+            ordered_leaf::{OrderedLeaf, OrderedLeafBuilder},
+            Builder as TrieBuilder, Cursor as TrieCursor, MergeBuilder, Trie, TupleBuilder,
+        },
+        ord::merge_batcher::MergeBatcher,
+        Batch, BatchReader, Builder, Cursor, Merger,
+    },
+    Timestamp,
+};
+
+use deepsize::DeepSizeOf;
+
+/// An immutable collection of update tuples, from a contiguous interval of
+/// logical times.
+#[derive(Debug)]
+pub struct OrdKeyBatch<K, T, R, O = usize>
+where
+    K: Ord,
+    T: Lattice,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    /// Where all the dataz is.
+    pub layer: OrderedLayer<K, OrderedLeaf<T, R>, O>,
+    /// Description of the update times this layer represents.
+    pub desc: Description<T>,
+}
+
+impl<K, T, R, O> DeepSizeOf for OrdKeyBatch<K, T, R, O>
+where
+    K: DeepSizeOf + Ord,
+    T: DeepSizeOf + Lattice,
+    R: DeepSizeOf,
+    O: DeepSizeOf + OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn deep_size_of_children(&self, _context: &mut deepsize::Context) -> usize {
+        self.layer.deep_size_of()
+    }
+}
+
+impl<K, T, R, O> BatchReader for OrdKeyBatch<K, T, R, O>
+where
+    K: Ord + Clone + 'static,
+    T: Timestamp + Lattice,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    type Key = K;
+    type Val = ();
+    type Time = T;
+    type R = R;
+    type Cursor = OrdKeyCursor<T, R, O>;
+
+    fn cursor(&self) -> Self::Cursor {
+        OrdKeyCursor {
+            valid: true,
+            cursor: self.layer.cursor(),
+            phantom: PhantomData,
+        }
+    }
+    fn len(&self) -> usize {
+        <OrderedLayer<K, OrderedLeaf<T, R>, O> as Trie>::tuples(&self.layer)
+    }
+    fn description(&self) -> &Description<T> {
+        &self.desc
+    }
+}
+
+impl<K, T, R, O> Batch for OrdKeyBatch<K, T, R, O>
+where
+    K: Ord + Clone + 'static,
+    T: Lattice + Timestamp + Ord + Clone + 'static,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    type Batcher = MergeBatcher<K, (), T, R, Self>;
+    type Builder = OrdKeyBuilder<K, T, R, O>;
+    type Merger = OrdKeyMerger<K, T, R, O>;
+
+    fn begin_merge(&self, other: &Self) -> Self::Merger {
+        OrdKeyMerger::new(self, other)
+    }
+
+    fn recede_to(&mut self, frontier: &T) {
+        // Nothing to do if the batch is entirely before the frontier.
+        if !self.upper().less_equal(frontier) {
+            // TODO: Optimize case where self.upper()==self.lower().
+            self.do_recede_to(frontier);
+        }
+    }
+}
+
+impl<K, T, R, O> OrdKeyBatch<K, T, R, O>
+where
+    K: Ord + Clone + 'static,
+    T: Lattice + Ord + Clone + 'static,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn do_recede_to(&mut self, frontier: &T) {
+        // We will zip through the time leaves, calling advance on each,
+        //    then zip through the value layer, sorting and collapsing each,
+        //    then zip through the key layer, collapsing each .. ?
+
+        // 1. For each (time, diff) pair, advance the time.
+        for i in 0..self.layer.vals.vals.len() {
+            self.layer.vals.vals[i].0.meet_assign(frontier);
+        }
+        // for time_diff in self.layer.vals.vals.iter_mut() {
+        //     time_diff.0 = time_diff.0.advance_by(frontier);
+        // }
+
+        // 2. For each `(val, off)` pair, sort the range, compact, and rewrite `off`.
+        //    This may leave `val` with an empty range; filtering happens in step 3.
+        let mut write_position = 0;
+        for i in 0..self.layer.keys.len() {
+            // NB: batch.layer.vals.offs[i+1] will be used next iteration, and should not be
+            // changed.     we will change batch.layer.vals.offs[i] in this
+            // iteration, from `write_position`'s     initial value.
+
+            let lower: usize = self.layer.offs[i].try_into().unwrap();
+            let upper: usize = self.layer.offs[i + 1].try_into().unwrap();
+
+            self.layer.offs[i] = O::try_from(write_position).unwrap();
+
+            let updates = &mut self.layer.vals.vals[..];
+
+            // sort the range by the times (ignore the diffs; they will collapse).
+            let count = crate::trace::consolidation::consolidate_slice(&mut updates[lower..upper]);
+
+            for index in lower..(lower + count) {
+                updates.swap(write_position, index);
+                write_position += 1;
+            }
+        }
+        self.layer.vals.vals.truncate(write_position);
+        self.layer.offs[self.layer.keys.len()] = O::try_from(write_position).unwrap();
+
+        // 4. Remove empty keys.
+        let mut write_position = 0;
+        for i in 0..self.layer.keys.len() {
+            let lower: usize = self.layer.offs[i].try_into().unwrap();
+            let upper: usize = self.layer.offs[i + 1].try_into().unwrap();
+
+            if lower < upper {
+                self.layer.keys.swap(write_position, i);
+                // batch.layer.offs updated via `dedup` below; keeps me sane.
+                write_position += 1;
+            }
+        }
+        self.layer.offs.dedup();
+        self.layer.keys.truncate(write_position);
+        self.layer.offs.truncate(write_position + 1);
+    }
+}
+
+/// State for an in-progress merge.
+pub struct OrdKeyMerger<K, T, R, O = usize>
+where
+    K: Ord + Clone + 'static,
+    T: Lattice + Ord + Clone + 'static,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    // first batch, and position therein.
+    lower1: usize,
+    upper1: usize,
+    // second batch, and position therein.
+    lower2: usize,
+    upper2: usize,
+    // result that we are currently assembling.
+    result: <OrderedLayer<K, OrderedLeaf<T, R>, O> as Trie>::MergeBuilder,
+    description: Description<T>,
+}
+
+impl<K, T, R, O> Merger<K, (), T, R, OrdKeyBatch<K, T, R, O>> for OrdKeyMerger<K, T, R, O>
+where
+    K: Ord + Clone + 'static,
+    T: Lattice + Timestamp + Ord + Clone + 'static,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn new(batch1: &OrdKeyBatch<K, T, R, O>, batch2: &OrdKeyBatch<K, T, R, O>) -> Self {
+        // Leonid: we do not require batch bounds to grow monotonically.
+        //assert!(batch1.upper() == batch2.lower());
+
+        // Leonid: we do not require batch bounds to grow monotonically.
+        let description = Description::new(
+            batch1.lower().meet(batch2.lower()),
+            batch2.upper().join(batch2.upper()),
+        );
+
+        OrdKeyMerger {
+            lower1: 0,
+            upper1: batch1.layer.keys(),
+            lower2: 0,
+            upper2: batch2.layer.keys(),
+            result: <<OrderedLayer<K, OrderedLeaf<T, R>, O> as Trie>::MergeBuilder as MergeBuilder>::with_capacity(&batch1.layer, &batch2.layer),
+            description,
+        }
+    }
+    fn done(self) -> OrdKeyBatch<K, T, R, O> {
+        assert!(self.lower1 == self.upper1);
+        assert!(self.lower2 == self.upper2);
+
+        OrdKeyBatch {
+            layer: self.result.done(),
+            desc: self.description,
+        }
+    }
+    fn work(
+        &mut self,
+        source1: &OrdKeyBatch<K, T, R, O>,
+        source2: &OrdKeyBatch<K, T, R, O>,
+        fuel: &mut isize,
+    ) {
+        let starting_updates = self.result.vals.vals.len();
+        let mut effort = 0isize;
+
+        // while both mergees are still active
+        while self.lower1 < self.upper1 && self.lower2 < self.upper2 && effort < *fuel {
+            self.result.merge_step(
+                (&source1.layer, &mut self.lower1, self.upper1),
+                (&source2.layer, &mut self.lower2, self.upper2),
+            );
+            effort = (self.result.vals.vals.len() - starting_updates) as isize;
+        }
+
+        // if self.lower1 == self.upper1 || self.lower2 == self.upper2 {
+        //     // these are just copies, so let's bite the bullet and just do them.
+        //     if self.lower1 < self.upper1 { self.result.copy_range(&source1.layer,
+        // self.lower1, self.upper1); self.lower1 = self.upper1; }     if self.
+        // lower2 < self.upper2 { self.result.copy_range(&source2.layer, self.lower2,
+        // self.upper2); self.lower2 = self.upper2; } }
+        // Merging is complete; only copying remains. Copying is probably faster than
+        // merging, so could take some liberties here.
+        if self.lower1 == self.upper1 || self.lower2 == self.upper2 {
+            // Limit merging by remaining fuel.
+            let remaining_fuel = *fuel - effort;
+            if remaining_fuel > 0 {
+                if self.lower1 < self.upper1 {
+                    let mut to_copy = remaining_fuel as usize;
+                    if to_copy < 1_000 {
+                        to_copy = 1_000;
+                    }
+                    if to_copy > (self.upper1 - self.lower1) {
+                        to_copy = self.upper1 - self.lower1;
+                    }
+                    self.result
+                        .copy_range(&source1.layer, self.lower1, self.lower1 + to_copy);
+                    self.lower1 += to_copy;
+                }
+                if self.lower2 < self.upper2 {
+                    let mut to_copy = remaining_fuel as usize;
+                    if to_copy < 1_000 {
+                        to_copy = 1_000;
+                    }
+                    if to_copy > (self.upper2 - self.lower2) {
+                        to_copy = self.upper2 - self.lower2;
+                    }
+                    self.result
+                        .copy_range(&source2.layer, self.lower2, self.lower2 + to_copy);
+                    self.lower2 += to_copy;
+                }
+            }
+        }
+
+        effort = (self.result.vals.vals.len() - starting_updates) as isize;
+
+        *fuel -= effort;
+
+        // if *fuel < -1_000_000 {
+        //     eprintln!("Massive deficit OrdKey::work: {}", fuel);
+        // }
+    }
+}
+
+/// A cursor for navigating a single layer.
+#[derive(Debug)]
+pub struct OrdKeyCursor<T: Lattice + Ord + Clone, R: MonoidValue, O = usize> {
+    valid: bool,
+    cursor: OrderedCursor<OrderedLeaf<T, R>>,
+    phantom: PhantomData<O>,
+}
+
+impl<K, T, R, O> Cursor<K, (), T, R> for OrdKeyCursor<T, R, O>
+where
+    K: Ord + Clone,
+    T: Lattice + Ord + Clone,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    type Storage = OrdKeyBatch<K, T, R, O>;
+
+    fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K {
+        self.cursor.key(&storage.layer)
+    }
+    fn val<'a>(&self, _storage: &'a Self::Storage) -> &'a () {
+        &()
+    }
+    fn map_times<L: FnMut(&T, &R)>(&mut self, storage: &Self::Storage, mut logic: L) {
+        self.cursor.child.rewind(&storage.layer.vals);
+        while self.cursor.child.valid(&storage.layer.vals) {
+            logic(
+                &self.cursor.child.key(&storage.layer.vals).0,
+                &self.cursor.child.key(&storage.layer.vals).1,
+            );
+            self.cursor.child.step(&storage.layer.vals);
+        }
+    }
+    fn weight<'a>(&self, storage: &'a Self::Storage) -> &'a R
+    where
+        T: PartialEq<()>,
+    {
+        debug_assert!(self.cursor.child.valid(&storage.layer.vals));
+        &self.cursor.child.key(&storage.layer.vals).1
+    }
+    fn key_valid(&self, storage: &Self::Storage) -> bool {
+        self.cursor.valid(&storage.layer)
+    }
+    fn val_valid(&self, _storage: &Self::Storage) -> bool {
+        self.valid
+    }
+    fn step_key(&mut self, storage: &Self::Storage) {
+        self.cursor.step(&storage.layer);
+        self.valid = true;
+    }
+    fn seek_key(&mut self, storage: &Self::Storage, key: &K) {
+        self.cursor.seek(&storage.layer, key);
+        self.valid = true;
+    }
+    fn step_val(&mut self, _storage: &Self::Storage) {
+        self.valid = false;
+    }
+    fn seek_val(&mut self, _storage: &Self::Storage, _val: &()) {}
+    fn rewind_keys(&mut self, storage: &Self::Storage) {
+        self.cursor.rewind(&storage.layer);
+        self.valid = true;
+    }
+    fn rewind_vals(&mut self, _storage: &Self::Storage) {
+        self.valid = true;
+    }
+}
+
+/// A builder for creating layers from unsorted update tuples.
+pub struct OrdKeyBuilder<K, T, R, O = usize>
+where
+    K: Ord,
+    T: Ord + Lattice,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    time: T,
+    builder: OrderedBuilder<K, OrderedLeafBuilder<T, R>, O>,
+}
+
+impl<K, T, R, O> Builder<K, (), T, R, OrdKeyBatch<K, T, R, O>> for OrdKeyBuilder<K, T, R, O>
+where
+    K: Ord + Clone + 'static,
+    T: Lattice + Timestamp + Ord + Clone + 'static,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn new(time: T) -> Self {
+        OrdKeyBuilder {
+            time,
+            builder: OrderedBuilder::<K, OrderedLeafBuilder<T, R>, O>::new(),
+        }
+    }
+
+    fn with_capacity(time: T, cap: usize) -> Self {
+        OrdKeyBuilder {
+            time,
+            builder:
+                <OrderedBuilder<K, OrderedLeafBuilder<T, R>, O> as TupleBuilder>::with_capacity(cap),
+        }
+    }
+
+    #[inline]
+    fn push(&mut self, (key, _, diff): (K, (), R)) {
+        self.builder.push_tuple((key, (self.time.clone(), diff)));
+    }
+
+    #[inline(never)]
+    fn done(self) -> OrdKeyBatch<K, T, R, O> {
+        let time_next = self.time.advance(0);
+        let upper = if time_next <= self.time {
+            Antichain::new()
+        } else {
+            Antichain::from_elem(time_next)
+        };
+        OrdKeyBatch {
+            layer: self.builder.done(),
+            desc: Description::new(Antichain::from_elem(self.time), upper),
+        }
+    }
+}
diff --git a/src/trace/ord/merge_batcher.rs b/src/trace/ord/merge_batcher.rs
new file mode 100644
index 00000000..5e48052a
--- /dev/null
+++ b/src/trace/ord/merge_batcher.rs
@@ -0,0 +1,408 @@
+//! A general purpose `Batcher` implementation based on radix sort.
+
+use crate::{
+    algebra::MonoidValue,
+    lattice::Lattice,
+    trace::{Batch, Batcher, Builder},
+    Timestamp,
+};
+use deepsize::DeepSizeOf;
+use std::{
+    marker::PhantomData,
+    mem::{replace, size_of, swap, take},
+    slice::from_raw_parts,
+};
+
+/// Creates batches from unordered tuples.
+pub struct MergeBatcher<
+    K: Ord,
+    V: Ord,
+    T: Ord,
+    R: MonoidValue,
+    B: Batch<Key = K, Val = V, Time = T, R = R>,
+> {
+    sorter: MergeSorter<(K, V), R>,
+    time: T,
+    phantom: PhantomData<B>,
+}
+
+impl<K, V, T, R, B> DeepSizeOf for MergeBatcher<K, V, T, R, B>
+where
+    K: DeepSizeOf + Ord,
+    V: DeepSizeOf + Ord,
+    T: Ord,
+    R: DeepSizeOf + MonoidValue,
+    B: Batch<Key = K, Val = V, Time = T, R = R>,
+{
+    fn deep_size_of_children(&self, _context: &mut deepsize::Context) -> usize {
+        self.sorter.deep_size_of()
+    }
+}
+
+impl<K, V, T, R, B> Batcher<K, V, T, R, B> for MergeBatcher<K, V, T, R, B>
+where
+    K: Ord + Clone,
+    V: Ord + Clone,
+    T: Lattice + Timestamp + Ord + Clone,
+    R: MonoidValue,
+    B: Batch<Key = K, Val = V, Time = T, R = R>,
+{
+    fn new(time: T) -> Self {
+        MergeBatcher {
+            sorter: MergeSorter::new(),
+            time,
+            phantom: PhantomData,
+        }
+    }
+
+    #[inline(never)]
+    fn push_batch(&mut self, batch: &mut Vec<((K, V), R)>) {
+        self.sorter.push(batch);
+    }
+
+    fn tuples(&self) -> usize {
+        self.sorter.tuples()
+    }
+
+    // Sealing a batch means finding those updates with times not greater or equal
+    // to any time in `upper`. All updates must have time greater or equal to
+    // the previously used `upper`, which we call `lower`, by assumption that
+    // after sealing a batcher we receive no more updates with times not greater
+    // or equal to `upper`.
+    #[inline(never)]
+    fn seal(mut self) -> B {
+        let mut builder = B::Builder::new(self.time.clone());
+
+        let mut merged = Vec::new();
+        self.sorter.finish_into(&mut merged);
+
+        // TODO: Re-use buffer, rather than dropping.
+        for mut buffer in merged.drain(..) {
+            for ((key, val), diff) in buffer.drain(..) {
+                builder.push((key, val, diff));
+            }
+        }
+
+        builder.done()
+    }
+}
+
+pub struct VecQueue<T> {
+    list: Vec<T>,
+    head: usize,
+    tail: usize,
+}
+
+impl<T> VecQueue<T> {
+    #[inline]
+    pub fn new() -> Self {
+        VecQueue::from(Vec::new())
+    }
+    #[inline]
+    pub fn pop(&mut self) -> T {
+        debug_assert!(self.head < self.tail);
+        self.head += 1;
+        unsafe { ::std::ptr::read(self.list.as_mut_ptr().offset((self.head as isize) - 1)) }
+    }
+    #[inline]
+    pub fn peek(&self) -> &T {
+        debug_assert!(self.head < self.tail);
+        unsafe { self.list.get_unchecked(self.head) }
+    }
+    #[inline]
+    pub fn _peek_tail(&self) -> &T {
+        debug_assert!(self.head < self.tail);
+        unsafe { self.list.get_unchecked(self.tail - 1) }
+    }
+    #[inline]
+    pub fn _slice(&self) -> &[T] {
+        debug_assert!(self.head < self.tail);
+        unsafe { from_raw_parts(self.list.get_unchecked(self.head), self.tail - self.head) }
+    }
+    #[inline]
+    pub fn from(mut list: Vec<T>) -> Self {
+        let tail = list.len();
+        unsafe {
+            list.set_len(0);
+        }
+        VecQueue {
+            list,
+            head: 0,
+            tail,
+        }
+    }
+    // could leak, if self.head != self.tail.
+    #[inline]
+    pub fn done(self) -> Vec<T> {
+        debug_assert!(self.head == self.tail);
+        self.list
+    }
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.tail - self.head
+    }
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.head == self.tail
+    }
+}
+
+#[inline]
+unsafe fn push_unchecked<T>(vec: &mut Vec<T>, element: T) {
+    debug_assert!(vec.len() < vec.capacity());
+    let len = vec.len();
+    vec.spare_capacity_mut().get_unchecked_mut(0).write(element);
+    vec.set_len(len + 1);
+}
+
+pub struct MergeSorter<D: Ord, R: MonoidValue> {
+    queue: Vec<Vec<Vec<(D, R)>>>, // each power-of-two length list of allocations.
+    stash: Vec<Vec<(D, R)>>,
+}
+
+impl<D, R> DeepSizeOf for MergeSorter<D, R>
+where
+    D: DeepSizeOf + Ord,
+    R: DeepSizeOf + MonoidValue,
+{
+    fn deep_size_of_children(&self, _context: &mut deepsize::Context) -> usize {
+        self.queue.deep_size_of() + self.stash.deep_size_of()
+    }
+}
+
+impl<D: Ord, R: MonoidValue> MergeSorter<D, R> {
+    const BUFFER_SIZE_BYTES: usize = 1 << 13;
+
+    fn buffer_size() -> usize {
+        let size = size_of::<(D, R)>();
+        if size == 0 {
+            Self::BUFFER_SIZE_BYTES
+        } else if size <= Self::BUFFER_SIZE_BYTES {
+            Self::BUFFER_SIZE_BYTES / size
+        } else {
+            1
+        }
+    }
+
+    #[inline]
+    pub fn new() -> Self {
+        MergeSorter {
+            queue: Vec::new(),
+            stash: Vec::new(),
+        }
+    }
+
+    #[inline]
+    pub fn empty(&mut self) -> Vec<(D, R)> {
+        self.stash
+            .pop()
+            .unwrap_or_else(|| Vec::with_capacity(Self::buffer_size()))
+    }
+
+    #[inline(never)]
+    pub fn _sort(&mut self, list: &mut Vec<Vec<(D, R)>>) {
+        for mut batch in list.drain(..) {
+            self.push(&mut batch);
+        }
+        self.finish_into(list);
+    }
+
+    #[inline]
+    pub fn push(&mut self, batch: &mut Vec<(D, R)>) {
+        // TODO: Reason about possible unbounded stash growth. How to / should we return
+        // them? TODO: Reason about mis-sized vectors, from deserialized data;
+        // should probably drop.
+        let mut batch = if self.stash.len() > 2 {
+            replace(batch, self.stash.pop().unwrap())
+        } else {
+            take(batch)
+        };
+
+        if !batch.is_empty() {
+            crate::trace::consolidation::consolidate_updates(&mut batch);
+            self.queue.push(vec![batch]);
+            while self.queue.len() > 1
+                && (self.queue[self.queue.len() - 1].len()
+                    >= self.queue[self.queue.len() - 2].len() / 2)
+            {
+                let list1 = self.queue.pop().unwrap();
+                let list2 = self.queue.pop().unwrap();
+                let merged = self.merge_by(list1, list2);
+                self.queue.push(merged);
+            }
+        }
+    }
+
+    #[inline(never)]
+    pub fn finish_into(&mut self, target: &mut Vec<Vec<(D, R)>>) {
+        while self.queue.len() > 1 {
+            let list1 = self.queue.pop().unwrap();
+            let list2 = self.queue.pop().unwrap();
+            let merged = self.merge_by(list1, list2);
+            self.queue.push(merged);
+        }
+
+        if let Some(mut last) = self.queue.pop() {
+            swap(&mut last, target);
+        }
+    }
+
+    // merges two sorted input lists into one sorted output list.
+    #[inline(never)]
+    fn merge_by(&mut self, list1: Vec<Vec<(D, R)>>, list2: Vec<Vec<(D, R)>>) -> Vec<Vec<(D, R)>> {
+        use std::cmp::Ordering;
+
+        // TODO: `list1` and `list2` get dropped; would be better to reuse?
+        let mut output = Vec::with_capacity(list1.len() + list2.len());
+        let mut result = self.empty();
+
+        let mut list1 = VecQueue::from(list1);
+        let mut list2 = VecQueue::from(list2);
+
+        let mut head1 = if !list1.is_empty() {
+            VecQueue::from(list1.pop())
+        } else {
+            VecQueue::new()
+        };
+        let mut head2 = if !list2.is_empty() {
+            VecQueue::from(list2.pop())
+        } else {
+            VecQueue::new()
+        };
+
+        // while we have valid data in each input, merge.
+        while !head1.is_empty() && !head2.is_empty() {
+            while (result.capacity() - result.len()) > 0 && !head1.is_empty() && !head2.is_empty() {
+                let cmp = {
+                    let x = head1.peek();
+                    let y = head2.peek();
+                    (&x.0).cmp(&y.0)
+                };
+                match cmp {
+                    Ordering::Less => unsafe {
+                        push_unchecked(&mut result, head1.pop());
+                    },
+                    Ordering::Greater => unsafe {
+                        push_unchecked(&mut result, head2.pop());
+                    },
+                    Ordering::Equal => {
+                        let (data1, mut diff1) = head1.pop();
+                        let (_data2, diff2) = head2.pop();
+                        diff1.add_assign_by_ref(&diff2);
+                        if !diff1.is_zero() {
+                            unsafe {
+                                push_unchecked(&mut result, (data1, diff1));
+                            }
+                        }
+                    }
+                }
+            }
+
+            if result.capacity() == result.len() {
+                output.push(result);
+                result = self.empty();
+            }
+
+            if head1.is_empty() {
+                let done1 = head1.done();
+                if done1.capacity() == Self::buffer_size() {
+                    self.stash.push(done1);
+                }
+                head1 = if !list1.is_empty() {
+                    VecQueue::from(list1.pop())
+                } else {
+                    VecQueue::new()
+                };
+            }
+            if head2.is_empty() {
+                let done2 = head2.done();
+                if done2.capacity() == Self::buffer_size() {
+                    self.stash.push(done2);
+                }
+                head2 = if !list2.is_empty() {
+                    VecQueue::from(list2.pop())
+                } else {
+                    VecQueue::new()
+                };
+            }
+        }
+
+        if !result.is_empty() {
+            output.push(result);
+        } else if result.capacity() > 0 {
+            self.stash.push(result);
+        }
+
+        if !head1.is_empty() {
+            let mut result = self.empty();
+            for _ in 0..head1.len() {
+                result.push(head1.pop());
+            }
+            output.push(result);
+        }
+        while !list1.is_empty() {
+            output.push(list1.pop());
+        }
+
+        if !head2.is_empty() {
+            let mut result = self.empty();
+            for _ in 0..head2.len() {
+                result.push(head2.pop());
+            }
+            output.push(result);
+        }
+        while !list2.is_empty() {
+            output.push(list2.pop());
+        }
+
+        output
+    }
+
+    fn tuples(&self) -> usize {
+        let mut result = 0;
+
+        for alloc in self.queue.iter() {
+            for v in alloc.iter() {
+                result += v.len();
+            }
+        }
+        for v in self.stash.iter() {
+            result += v.len();
+        }
+
+        result
+    }
+}
+
+/// Reports the number of elements satisfing the predicate.
+///
+/// This methods *relies strongly* on the assumption that the predicate
+/// stays false once it becomes false, a joint property of the predicate
+/// and the slice. This allows `advance` to use exponential search to
+/// count the number of elements in time logarithmic in the result.
+#[inline]
+pub fn _advance<T, F: Fn(&T) -> bool>(slice: &[T], function: F) -> usize {
+    // start with no advance
+    let mut index = 0;
+    if index < slice.len() && function(&slice[index]) {
+        // advance in exponentially growing steps.
+        let mut step = 1;
+        while index + step < slice.len() && function(&slice[index + step]) {
+            index += step;
+            step <<= 1;
+        }
+
+        // advance in exponentially shrinking steps.
+        step >>= 1;
+        while step > 0 {
+            if index + step < slice.len() && function(&slice[index + step]) {
+                index += step;
+            }
+            step >>= 1;
+        }
+
+        index += 1;
+    }
+
+    index
+}
diff --git a/src/trace/ord/mod.rs b/src/trace/ord/mod.rs
new file mode 100644
index 00000000..bcf850df
--- /dev/null
+++ b/src/trace/ord/mod.rs
@@ -0,0 +1,51 @@
+//! Trace and batch implementations based on sorted ranges.
+//!
+//! The types and type aliases in this module start with one of:
+//!
+//! * `OrdVal`: Collections whose data have the form `(key, val)` where `key`
+//!   and `val` are ordered.
+//! * `OrdKey`: Collections whose data have the form `key` where `key` is
+//!   ordered.
+//! * `OrdIndexedZSet`:  Collections whose data have the form `(key, val)` where
+//!   `key` and `val` are ordered and whose timestamp type is `()`.
+//!   Semantically, such collections store `(key, val, weight)` tuples without
+//!   timing information, and implement the indexed ZSet abstraction of DBSP.
+//! * `OrdZSet`:  Collections whose data have the form `key` where `key` is
+//!   ordered and whose timestamp type is `()`.  Semantically, such collections
+//!   store `(key, weight)` tuples without timing information, and implement the
+//!   ZSet abstraction of DBSP.
+//!
+//! Although `OrdVal` is more general than `OrdKey`, the latter has a simpler
+//! representation and should consume fewer resources (computation and memory)
+//! when it applies.
+//!
+//! Likewise, `OrdIndexedZSet` and `OrdZSet` are less general than `OrdVal` and
+//! `OrdKey` respectively, but are more light-weight.
+
+use crate::trace::spine_fueled::Spine;
+use std::rc::Rc;
+
+mod merge_batcher;
+
+pub mod val_batch;
+pub use val_batch::OrdValBatch;
+
+/// A trace implementation using a spine of ordered lists.
+pub type OrdValSpine<K, V, T, R, O = usize> = Spine<Rc<OrdValBatch<K, V, T, R, O>>>;
+
+pub mod key_batch;
+pub use key_batch::OrdKeyBatch;
+
+/// A trace implementation for empty values using a spine of ordered lists.
+pub type OrdKeySpine<K, T, R, O = usize> = Spine<Rc<OrdKeyBatch<K, T, R, O>>>;
+
+pub mod zset_batch;
+pub use zset_batch::OrdZSet;
+
+/// A trace implementation using a [`Spine`] of [`OrdZSet`].
+pub type OrdZSetSpine<K, R> = Spine<Rc<OrdZSet<K, R>>>;
+
+pub mod indexed_zset_batch;
+pub use indexed_zset_batch::OrdIndexedZSet;
+
+pub type OrdIndexedZSetSpine<K, V, R, O = usize> = Spine<Rc<OrdIndexedZSet<K, V, R, O>>>;
diff --git a/src/trace/ord/val_batch.rs b/src/trace/ord/val_batch.rs
new file mode 100644
index 00000000..9c43771d
--- /dev/null
+++ b/src/trace/ord/val_batch.rs
@@ -0,0 +1,487 @@
+use std::{
+    convert::{TryFrom, TryInto},
+    fmt::{Debug, Display, Formatter},
+};
+
+use timely::progress::Antichain;
+
+use crate::{
+    algebra::{AddAssignByRef, HasZero, MonoidValue},
+    lattice::Lattice,
+    trace::{
+        description::Description,
+        layers::{
+            ordered::{OrdOffset, OrderedBuilder, OrderedCursor, OrderedLayer},
+            ordered_leaf::{OrderedLeaf, OrderedLeafBuilder},
+            Builder as TrieBuilder, Cursor as TrieCursor, MergeBuilder, Trie, TupleBuilder,
+        },
+        ord::merge_batcher::MergeBatcher,
+        Batch, BatchReader, Builder, Cursor, Merger,
+    },
+    Timestamp,
+};
+
+use deepsize::DeepSizeOf;
+
+/// An immutable collection of update tuples, from a contiguous interval of
+/// logical times.
+#[derive(Debug)]
+pub struct OrdValBatch<K, V, T, R, O = usize>
+where
+    K: Ord,
+    V: Ord,
+    T: Lattice,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    /// Where all the dataz is.
+    pub layer: OrdValBatchLayer<K, V, T, R, O>,
+    /// Description of the update times this layer represents.
+    pub desc: Description<T>,
+}
+
+pub type OrdValBatchLayer<K, V, T, R, O> =
+    OrderedLayer<K, OrderedLayer<V, OrderedLeaf<T, R>, O>, O>;
+
+impl<K, V, T, R, O> Display for OrdValBatch<K, V, T, R, O>
+where
+    K: Ord + Clone + Display,
+    V: Ord + Clone + Display,
+    T: Lattice + Clone + Ord + Display + Debug,
+    R: Eq + HasZero + AddAssignByRef + Clone + Display,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+        writeln!(
+            f,
+            "description: {:?}\nlayer:\n{}",
+            self.desc,
+            textwrap::indent(&self.layer.to_string(), "    ")
+        )
+    }
+}
+
+impl<K, V, T, R, O> DeepSizeOf for OrdValBatch<K, V, T, R, O>
+where
+    K: DeepSizeOf + Ord,
+    V: DeepSizeOf + Ord,
+    T: DeepSizeOf + Lattice,
+    R: DeepSizeOf,
+    O: DeepSizeOf + OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn deep_size_of_children(&self, _context: &mut deepsize::Context) -> usize {
+        self.layer.deep_size_of()
+    }
+}
+
+impl<K, V, T, R, O> BatchReader for OrdValBatch<K, V, T, R, O>
+where
+    K: Ord + Clone + 'static,
+    V: Ord + Clone + 'static,
+    T: Timestamp + Lattice,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    type Key = K;
+    type Val = V;
+    type Time = T;
+    type R = R;
+
+    type Cursor = OrdValCursor<V, T, R, O>;
+    fn cursor(&self) -> Self::Cursor {
+        OrdValCursor {
+            cursor: self.layer.cursor(),
+        }
+    }
+    fn len(&self) -> usize {
+        <OrdValBatchLayer<K, V, T, R, O> as Trie>::tuples(&self.layer)
+    }
+    fn description(&self) -> &Description<T> {
+        &self.desc
+    }
+}
+
+impl<K, V, T, R, O> Batch for OrdValBatch<K, V, T, R, O>
+where
+    K: Ord + Clone + 'static,
+    V: Ord + Clone + 'static,
+    T: Lattice + Timestamp + Ord + Clone + ::std::fmt::Debug + 'static,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    type Batcher = MergeBatcher<K, V, T, R, Self>;
+    type Builder = OrdValBuilder<K, V, T, R, O>;
+    type Merger = OrdValMerger<K, V, T, R, O>;
+
+    fn begin_merge(&self, other: &Self) -> Self::Merger {
+        OrdValMerger::new(self, other)
+    }
+
+    fn recede_to(&mut self, frontier: &T) {
+        // Nothing to do if the batch is entirely before the frontier.
+        if !self.upper().less_equal(frontier) {
+            self.do_recede_to(frontier);
+        }
+    }
+}
+
+impl<K, V, T, R, O> OrdValBatch<K, V, T, R, O>
+where
+    K: Ord + Clone + 'static,
+    V: Ord + Clone + 'static,
+    T: Lattice + Ord + Clone + ::std::fmt::Debug + 'static,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn do_recede_to(&mut self, frontier: &T) {
+        // We have unique ownership of the batch, and can advance times in place.
+        // We must still sort, collapse, and remove empty updates.
+
+        // We will zip throught the time leaves, calling advance on each,
+        //    then zip through the value layer, sorting and collapsing each,
+        //    then zip through the key layer, collapsing each .. ?
+
+        // 1. For each (time, diff) pair, advance the time.
+        for i in 0..self.layer.vals.vals.vals.len() {
+            self.layer.vals.vals.vals[i].0.meet_assign(frontier);
+        }
+
+        // 2. For each `(val, off)` pair, sort the range, compact, and rewrite `off`.
+        //    This may leave `val` with an empty range; filtering happens in step 3.
+        let mut write_position = 0;
+        for i in 0..self.layer.vals.keys.len() {
+            // NB: batch.layer.vals.offs[i+1] will be used next iteration, and should not be
+            // changed.     we will change batch.layer.vals.offs[i] in this
+            // iteration, from `write_position`'s     initial value.
+
+            let lower: usize = self.layer.vals.offs[i].try_into().unwrap();
+            let upper: usize = self.layer.vals.offs[i + 1].try_into().unwrap();
+
+            self.layer.vals.offs[i] = O::try_from(write_position).unwrap();
+
+            let updates = &mut self.layer.vals.vals.vals[..];
+
+            // sort the range by the times (ignore the diffs; they will collapse).
+            let count = crate::trace::consolidation::consolidate_slice(&mut updates[lower..upper]);
+
+            for index in lower..(lower + count) {
+                updates.swap(write_position, index);
+                write_position += 1;
+            }
+        }
+        self.layer.vals.vals.vals.truncate(write_position);
+        self.layer.vals.offs[self.layer.vals.keys.len()] = O::try_from(write_position).unwrap();
+
+        // 3. For each `(key, off)` pair, (values already sorted), filter vals, and
+        // rewrite `off`.    This may leave `key` with an empty range. Filtering
+        // happens in step 4.
+        let mut write_position = 0;
+        for i in 0..self.layer.keys.len() {
+            // NB: batch.layer.offs[i+1] must remain as is for the next iteration.
+            //     instead, we update batch.layer.offs[i]
+
+            let lower: usize = self.layer.offs[i].try_into().unwrap();
+            let upper: usize = self.layer.offs[i + 1].try_into().unwrap();
+
+            self.layer.offs[i] = O::try_from(write_position).unwrap();
+
+            // values should already be sorted, but some might now be empty.
+            for index in lower..upper {
+                let val_lower: usize = self.layer.vals.offs[index].try_into().unwrap();
+                let val_upper: usize = self.layer.vals.offs[index + 1].try_into().unwrap();
+                if val_lower < val_upper {
+                    self.layer.vals.keys.swap(write_position, index);
+                    self.layer.vals.offs[write_position + 1] = self.layer.vals.offs[index + 1];
+                    write_position += 1;
+                }
+            }
+            // batch.layer.offs[i+1] = write_position;
+        }
+        self.layer.vals.keys.truncate(write_position);
+        self.layer.vals.offs.truncate(write_position + 1);
+        self.layer.offs[self.layer.keys.len()] = O::try_from(write_position).unwrap();
+
+        // 4. Remove empty keys.
+        let mut write_position = 0;
+        for i in 0..self.layer.keys.len() {
+            let lower: usize = self.layer.offs[i].try_into().unwrap();
+            let upper: usize = self.layer.offs[i + 1].try_into().unwrap();
+
+            if lower < upper {
+                self.layer.keys.swap(write_position, i);
+                // batch.layer.offs updated via `dedup` below; keeps me sane.
+                write_position += 1;
+            }
+        }
+        self.layer.offs.dedup();
+        self.layer.keys.truncate(write_position);
+        self.layer.offs.truncate(write_position + 1);
+    }
+}
+
+/// State for an in-progress merge.
+pub struct OrdValMerger<K, V, T, R, O = usize>
+where
+    K: Ord + Clone + 'static,
+    V: Ord + Clone + 'static,
+    T: Lattice + Ord + Clone + ::std::fmt::Debug + 'static,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    // first batch, and position therein.
+    lower1: usize,
+    upper1: usize,
+    // second batch, and position therein.
+    lower2: usize,
+    upper2: usize,
+    // result that we are currently assembling.
+    result: <OrdValBatchLayer<K, V, T, R, O> as Trie>::MergeBuilder,
+    description: Description<T>,
+}
+
+impl<K, V, T, R, O> Merger<K, V, T, R, OrdValBatch<K, V, T, R, O>> for OrdValMerger<K, V, T, R, O>
+where
+    K: Ord + Clone + 'static,
+    V: Ord + Clone + 'static,
+    T: Lattice + Timestamp + Ord + Clone + ::std::fmt::Debug + 'static,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn new(batch1: &OrdValBatch<K, V, T, R, O>, batch2: &OrdValBatch<K, V, T, R, O>) -> Self {
+        // Leonid: we do not require batch bounds to grow monotonically.
+        // assert!(batch1.upper() == batch2.lower());
+
+        // Leonid: we do not require batch bounds to grow monotonically.
+        let description = Description::new(
+            batch1.lower().meet(batch2.lower()),
+            batch1.upper().join(batch2.upper()),
+        );
+
+        OrdValMerger {
+            lower1: 0,
+            upper1: batch1.layer.keys(),
+            lower2: 0,
+            upper2: batch2.layer.keys(),
+            result: <<OrdValBatchLayer<K, V, T, R, O> as Trie>::MergeBuilder as MergeBuilder>::with_capacity(&batch1.layer, &batch2.layer),
+            description,
+        }
+    }
+    fn done(self) -> OrdValBatch<K, V, T, R, O> {
+        assert!(self.lower1 == self.upper1);
+        assert!(self.lower2 == self.upper2);
+
+        OrdValBatch {
+            layer: self.result.done(),
+            desc: self.description,
+        }
+    }
+    fn work(
+        &mut self,
+        source1: &OrdValBatch<K, V, T, R, O>,
+        source2: &OrdValBatch<K, V, T, R, O>,
+        fuel: &mut isize,
+    ) {
+        let starting_updates = self.result.vals.vals.vals.len();
+        let mut effort = 0isize;
+
+        // while both mergees are still active
+        while self.lower1 < self.upper1 && self.lower2 < self.upper2 && effort < *fuel {
+            self.result.merge_step(
+                (&source1.layer, &mut self.lower1, self.upper1),
+                (&source2.layer, &mut self.lower2, self.upper2),
+            );
+            effort = (self.result.vals.vals.vals.len() - starting_updates) as isize;
+        }
+
+        // Merging is complete; only copying remains. Copying is probably faster than
+        // merging, so could take some liberties here.
+        if self.lower1 == self.upper1 || self.lower2 == self.upper2 {
+            // Limit merging by remaining fuel.
+            let remaining_fuel = *fuel - effort;
+            if remaining_fuel > 0 {
+                if self.lower1 < self.upper1 {
+                    let mut to_copy = remaining_fuel as usize;
+                    if to_copy < 1_000 {
+                        to_copy = 1_000;
+                    }
+                    if to_copy > (self.upper1 - self.lower1) {
+                        to_copy = self.upper1 - self.lower1;
+                    }
+                    self.result
+                        .copy_range(&source1.layer, self.lower1, self.lower1 + to_copy);
+                    self.lower1 += to_copy;
+                }
+                if self.lower2 < self.upper2 {
+                    let mut to_copy = remaining_fuel as usize;
+                    if to_copy < 1_000 {
+                        to_copy = 1_000;
+                    }
+                    if to_copy > (self.upper2 - self.lower2) {
+                        to_copy = self.upper2 - self.lower2;
+                    }
+                    self.result
+                        .copy_range(&source2.layer, self.lower2, self.lower2 + to_copy);
+                    self.lower2 += to_copy;
+                }
+            }
+        }
+
+        effort = (self.result.vals.vals.vals.len() - starting_updates) as isize;
+
+        *fuel -= effort;
+
+        // if *fuel < -1_000_000 {
+        //     eprintln!("Massive deficit OrdVal::work: {}", fuel);
+        // }
+    }
+}
+
+/// A cursor for navigating a single layer.
+#[derive(Debug)]
+pub struct OrdValCursor<V, T, R, O = usize>
+where
+    V: Ord + Clone,
+    T: Lattice + Ord + Clone,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    cursor: OrderedCursor<OrderedLayer<V, OrderedLeaf<T, R>, O>>,
+}
+
+impl<K, V, T, R, O> Cursor<K, V, T, R> for OrdValCursor<V, T, R, O>
+where
+    K: Ord + Clone,
+    V: Ord + Clone,
+    T: Lattice + Ord + Clone,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    type Storage = OrdValBatch<K, V, T, R, O>;
+
+    fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K {
+        self.cursor.key(&storage.layer)
+    }
+    fn val<'a>(&self, storage: &'a Self::Storage) -> &'a V {
+        self.cursor.child.key(&storage.layer.vals)
+    }
+    fn map_times<L: FnMut(&T, &R)>(&mut self, storage: &Self::Storage, mut logic: L) {
+        self.cursor.child.child.rewind(&storage.layer.vals.vals);
+        while self.cursor.child.child.valid(&storage.layer.vals.vals) {
+            logic(
+                &self.cursor.child.child.key(&storage.layer.vals.vals).0,
+                &self.cursor.child.child.key(&storage.layer.vals.vals).1,
+            );
+            self.cursor.child.child.step(&storage.layer.vals.vals);
+        }
+    }
+    fn weight<'a>(&self, storage: &'a Self::Storage) -> &'a R
+    where
+        T: PartialEq<()>,
+    {
+        debug_assert!(self.cursor.child.child.valid(&storage.layer.vals.vals));
+        &self.cursor.child.child.key(&storage.layer.vals.vals).1
+    }
+
+    fn key_valid(&self, storage: &Self::Storage) -> bool {
+        self.cursor.valid(&storage.layer)
+    }
+    fn val_valid(&self, storage: &Self::Storage) -> bool {
+        self.cursor.child.valid(&storage.layer.vals)
+    }
+    fn step_key(&mut self, storage: &Self::Storage) {
+        self.cursor.step(&storage.layer);
+    }
+    fn seek_key(&mut self, storage: &Self::Storage, key: &K) {
+        self.cursor.seek(&storage.layer, key);
+    }
+    fn step_val(&mut self, storage: &Self::Storage) {
+        self.cursor.child.step(&storage.layer.vals);
+    }
+    fn seek_val(&mut self, storage: &Self::Storage, val: &V) {
+        self.cursor.child.seek(&storage.layer.vals, val);
+    }
+    fn rewind_keys(&mut self, storage: &Self::Storage) {
+        self.cursor.rewind(&storage.layer);
+    }
+    fn rewind_vals(&mut self, storage: &Self::Storage) {
+        self.cursor.child.rewind(&storage.layer.vals);
+    }
+}
+
+/// A builder for creating layers from unsorted update tuples.
+pub struct OrdValBuilder<K, V, T, R, O = usize>
+where
+    K: Ord,
+    V: Ord,
+    T: Ord + Lattice,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    time: T,
+    builder: OrderedBuilder<K, OrderedBuilder<V, OrderedLeafBuilder<T, R>, O>, O>,
+}
+
+impl<K, V, T, R, O> Builder<K, V, T, R, OrdValBatch<K, V, T, R, O>> for OrdValBuilder<K, V, T, R, O>
+where
+    K: Ord + Clone + 'static,
+    V: Ord + Clone + 'static,
+    T: Lattice + Timestamp + Ord + Clone + ::std::fmt::Debug + 'static,
+    R: MonoidValue,
+    O: OrdOffset,
+    <O as TryFrom<usize>>::Error: Debug,
+    <O as TryInto<usize>>::Error: Debug,
+{
+    fn new(time: T) -> Self {
+        OrdValBuilder {
+            time,
+            builder: OrderedBuilder::<K, OrderedBuilder<V, OrderedLeafBuilder<T, R>, O>, O>::new(),
+        }
+    }
+    fn with_capacity(time: T, cap: usize) -> Self {
+        OrdValBuilder {
+            time,
+            builder: <OrderedBuilder<K, OrderedBuilder<V, OrderedLeafBuilder<T, R>, O>, O> as TupleBuilder>::with_capacity(cap)
+        }
+    }
+
+    #[inline]
+    fn push(&mut self, (key, val, diff): (K, V, R)) {
+        self.builder
+            .push_tuple((key, (val, (self.time.clone(), diff))));
+    }
+
+    #[inline(never)]
+    fn done(self) -> OrdValBatch<K, V, T, R, O> {
+        let time_next = self.time.advance(0);
+        let upper = if time_next <= self.time {
+            Antichain::new()
+        } else {
+            Antichain::from_elem(time_next)
+        };
+        OrdValBatch {
+            layer: self.builder.done(),
+            desc: Description::new(Antichain::from_elem(self.time), upper),
+        }
+    }
+}
diff --git a/src/trace/ord/zset_batch.rs b/src/trace/ord/zset_batch.rs
new file mode 100644
index 00000000..b5306f9b
--- /dev/null
+++ b/src/trace/ord/zset_batch.rs
@@ -0,0 +1,391 @@
+use std::{
+    cmp::max,
+    convert::TryFrom,
+    fmt::Debug,
+    ops::{Add, AddAssign, Neg},
+    rc::Rc,
+};
+
+use timely::progress::Antichain;
+
+use crate::{
+    algebra::{AddAssignByRef, AddByRef, HasZero, MonoidValue, NegByRef},
+    lattice::Lattice,
+    trace::{
+        description::Description,
+        layers::{
+            ordered_leaf::{OrderedLeaf, OrderedLeafBuilder, OrderedLeafCursor},
+            Builder as TrieBuilder, Cursor as TrieCursor, MergeBuilder, Trie, TupleBuilder,
+        },
+        ord::merge_batcher::MergeBatcher,
+        Batch, BatchReader, Builder, Cursor, Merger,
+    },
+    NumEntries, SharedRef,
+};
+
+use deepsize::DeepSizeOf;
+
+/// An immutable collection of `(key, weight)` pairs without timing information.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct OrdZSet<K, R>
+where
+    K: Ord,
+{
+    /// Where all the dataz is.
+    pub layer: OrderedLeaf<K, R>,
+    pub desc: Description<()>,
+}
+
+impl<K, R> From<OrderedLeaf<K, R>> for OrdZSet<K, R>
+where
+    K: Ord,
+{
+    fn from(layer: OrderedLeaf<K, R>) -> Self {
+        Self {
+            layer,
+            desc: Description::new(Antichain::from_elem(()), Antichain::new()),
+        }
+    }
+}
+
+impl<K, R> From<OrderedLeaf<K, R>> for Rc<OrdZSet<K, R>>
+where
+    K: Ord,
+{
+    fn from(layer: OrderedLeaf<K, R>) -> Self {
+        Rc::new(From::from(layer))
+    }
+}
+
+impl<K, R> TryFrom<Rc<OrdZSet<K, R>>> for OrdZSet<K, R>
+where
+    K: Ord,
+{
+    type Error = Rc<OrdZSet<K, R>>;
+
+    fn try_from(batch: Rc<OrdZSet<K, R>>) -> Result<Self, Self::Error> {
+        Rc::try_unwrap(batch)
+    }
+}
+
+impl<K, R> DeepSizeOf for OrdZSet<K, R>
+where
+    K: DeepSizeOf + Ord,
+    R: DeepSizeOf,
+{
+    fn deep_size_of_children(&self, _context: &mut deepsize::Context) -> usize {
+        self.layer.deep_size_of()
+    }
+}
+
+impl<K, R> NumEntries for OrdZSet<K, R>
+where
+    K: Ord + Clone,
+    R: Eq + HasZero + AddAssignByRef + Clone,
+{
+    fn num_entries_shallow(&self) -> usize {
+        self.layer.num_entries_shallow()
+    }
+
+    fn num_entries_deep(&self) -> usize {
+        self.layer.num_entries_deep()
+    }
+
+    const CONST_NUM_ENTRIES: Option<usize> = <OrderedLeaf<K, R>>::CONST_NUM_ENTRIES;
+}
+
+impl<K, R> HasZero for OrdZSet<K, R>
+where
+    K: Ord + Clone + 'static,
+    R: MonoidValue,
+{
+    fn zero() -> Self {
+        Self::empty(())
+    }
+
+    fn is_zero(&self) -> bool {
+        self.is_empty()
+    }
+}
+
+impl<K, R> SharedRef for OrdZSet<K, R>
+where
+    K: Ord + Clone,
+    R: Clone,
+{
+    type Target = Self;
+
+    fn try_into_owned(self) -> Result<Self::Target, Self> {
+        Ok(self)
+    }
+}
+
+impl<K, R> NegByRef for OrdZSet<K, R>
+where
+    K: Ord + Clone,
+    R: MonoidValue + NegByRef,
+{
+    fn neg_by_ref(&self) -> Self {
+        Self {
+            layer: self.layer.neg_by_ref(),
+            desc: self.desc.clone(),
+        }
+    }
+}
+
+impl<K, R> Neg for OrdZSet<K, R>
+where
+    K: Ord + Clone,
+    R: MonoidValue + Neg<Output = R>,
+{
+    type Output = Self;
+
+    fn neg(self) -> Self {
+        Self {
+            layer: self.layer.neg(),
+            desc: self.desc,
+        }
+    }
+}
+
+// TODO: by-value merge
+impl<K, R> Add<Self> for OrdZSet<K, R>
+where
+    K: Ord + Clone + 'static,
+    R: MonoidValue,
+{
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        let desc = Description::new(
+            self.lower().meet(rhs.lower()),
+            self.upper().join(rhs.upper()),
+        );
+
+        Self {
+            layer: self.layer.add(rhs.layer),
+            desc,
+        }
+    }
+}
+
+impl<K, R> AddAssign<Self> for OrdZSet<K, R>
+where
+    K: Ord + Clone + 'static,
+    R: MonoidValue,
+{
+    fn add_assign(&mut self, rhs: Self) {
+        self.desc = Description::new(
+            self.lower().meet(rhs.lower()),
+            self.upper().join(rhs.upper()),
+        );
+        self.layer.add_assign(rhs.layer);
+    }
+}
+
+impl<K, R> AddAssignByRef for OrdZSet<K, R>
+where
+    K: Ord + Clone + 'static,
+    R: MonoidValue,
+{
+    fn add_assign_by_ref(&mut self, rhs: &Self) {
+        self.layer.add_assign_by_ref(&rhs.layer);
+        self.desc = Description::new(
+            self.lower().meet(rhs.lower()),
+            self.upper().join(rhs.upper()),
+        );
+    }
+}
+
+impl<K, R> AddByRef for OrdZSet<K, R>
+where
+    K: Ord + Clone + 'static,
+    R: MonoidValue,
+{
+    fn add_by_ref(&self, rhs: &Self) -> Self {
+        Self {
+            layer: self.layer.add_by_ref(&rhs.layer),
+            desc: Description::new(
+                self.lower().meet(rhs.lower()),
+                self.upper().join(rhs.upper()),
+            ),
+        }
+    }
+}
+
+impl<K, R> BatchReader for OrdZSet<K, R>
+where
+    K: Ord + Clone + 'static,
+    R: MonoidValue,
+{
+    type Key = K;
+    type Val = ();
+    type Time = ();
+    type R = R;
+    type Cursor = OrdZSetCursor;
+
+    fn cursor(&self) -> Self::Cursor {
+        OrdZSetCursor {
+            empty: (),
+            valid: true,
+            cursor: self.layer.cursor(),
+        }
+    }
+    fn len(&self) -> usize {
+        <OrderedLeaf<K, R> as Trie>::tuples(&self.layer)
+    }
+    fn description(&self) -> &Description<()> {
+        &self.desc
+    }
+}
+
+impl<K, R> Batch for OrdZSet<K, R>
+where
+    K: Ord + Clone + 'static,
+    R: MonoidValue,
+{
+    type Batcher = MergeBatcher<K, (), (), R, Self>;
+    type Builder = OrdZSetBuilder<K, R>;
+    type Merger = OrdZSetMerger<K, R>;
+
+    fn begin_merge(&self, other: &Self) -> Self::Merger {
+        OrdZSetMerger::new(self, other)
+    }
+
+    fn recede_to(&mut self, _frontier: &()) {}
+}
+
+/// State for an in-progress merge.
+pub struct OrdZSetMerger<K, R>
+where
+    K: Ord + Clone + 'static,
+    R: MonoidValue,
+{
+    // result that we are currently assembling.
+    result: <OrderedLeaf<K, R> as Trie>::MergeBuilder,
+}
+
+impl<K, R> Merger<K, (), (), R, OrdZSet<K, R>> for OrdZSetMerger<K, R>
+where
+    K: Ord + Clone + 'static,
+    R: MonoidValue,
+{
+    fn new(batch1: &OrdZSet<K, R>, batch2: &OrdZSet<K, R>) -> Self {
+        OrdZSetMerger {
+            result: <<OrderedLeaf<K, R> as Trie>::MergeBuilder as MergeBuilder>::with_capacity(
+                &batch1.layer,
+                &batch2.layer,
+            ),
+        }
+    }
+    fn done(self) -> OrdZSet<K, R> {
+        OrdZSet {
+            layer: self.result.done(),
+            desc: Description::new(Antichain::from_elem(()), Antichain::new()),
+        }
+    }
+    fn work(&mut self, source1: &OrdZSet<K, R>, source2: &OrdZSet<K, R>, fuel: &mut isize) {
+        *fuel -= self.result.push_merge(
+            (&source1.layer, source1.layer.cursor()),
+            (&source2.layer, source2.layer.cursor()),
+        ) as isize;
+        *fuel = max(*fuel, 1);
+    }
+}
+
+/// A cursor for navigating a single layer.
+#[derive(Debug)]
+pub struct OrdZSetCursor {
+    valid: bool,
+    empty: (),
+    cursor: OrderedLeafCursor,
+}
+
+impl<K, R> Cursor<K, (), (), R> for OrdZSetCursor
+where
+    K: Ord + Clone,
+    R: MonoidValue,
+{
+    type Storage = OrdZSet<K, R>;
+
+    fn key<'a>(&self, storage: &'a Self::Storage) -> &'a K {
+        &self.cursor.key(&storage.layer).0
+    }
+    fn val<'a>(&self, _storage: &'a Self::Storage) -> &'a () {
+        unsafe { ::std::mem::transmute(&self.empty) }
+    }
+    fn map_times<L: FnMut(&(), &R)>(&mut self, storage: &Self::Storage, mut logic: L) {
+        if self.cursor.valid(&storage.layer) {
+            logic(&(), &self.cursor.key(&storage.layer).1);
+        }
+    }
+    fn weight<'a>(&self, storage: &'a Self::Storage) -> &'a R {
+        debug_assert!(&self.cursor.valid(&storage.layer));
+        &self.cursor.key(&storage.layer).1
+    }
+    fn key_valid(&self, storage: &Self::Storage) -> bool {
+        self.cursor.valid(&storage.layer)
+    }
+    fn val_valid(&self, _storage: &Self::Storage) -> bool {
+        self.valid
+    }
+    fn step_key(&mut self, storage: &Self::Storage) {
+        self.cursor.step(&storage.layer);
+        self.valid = true;
+    }
+    fn seek_key(&mut self, storage: &Self::Storage, key: &K) {
+        self.cursor.seek_key(&storage.layer, key);
+        self.valid = true;
+    }
+    fn step_val(&mut self, _storage: &Self::Storage) {
+        self.valid = false;
+    }
+    fn seek_val(&mut self, _storage: &Self::Storage, _val: &()) {}
+    fn rewind_keys(&mut self, storage: &Self::Storage) {
+        self.cursor.rewind(&storage.layer);
+        self.valid = true;
+    }
+    fn rewind_vals(&mut self, _storage: &Self::Storage) {
+        self.valid = true;
+    }
+}
+
+/// A builder for creating layers from unsorted update tuples.
+pub struct OrdZSetBuilder<K, R>
+where
+    K: Ord,
+    R: MonoidValue,
+{
+    builder: OrderedLeafBuilder<K, R>,
+}
+
+impl<K, R> Builder<K, (), (), R, OrdZSet<K, R>> for OrdZSetBuilder<K, R>
+where
+    K: Ord + Clone + 'static,
+    R: MonoidValue,
+{
+    fn new(_time: ()) -> Self {
+        OrdZSetBuilder {
+            builder: <OrderedLeafBuilder<K, R>>::new(),
+        }
+    }
+
+    fn with_capacity(_time: (), cap: usize) -> Self {
+        OrdZSetBuilder {
+            builder: <OrderedLeafBuilder<K, R> as TupleBuilder>::with_capacity(cap),
+        }
+    }
+
+    #[inline]
+    fn push(&mut self, (key, (), diff): (K, (), R)) {
+        self.builder.push_tuple((key, diff));
+    }
+
+    #[inline(never)]
+    fn done(self) -> OrdZSet<K, R> {
+        OrdZSet {
+            layer: self.builder.done(),
+            desc: Description::new(Antichain::from_elem(()), Antichain::new()),
+        }
+    }
+}
diff --git a/src/trace/spine_fueled.rs b/src/trace/spine_fueled.rs
new file mode 100644
index 00000000..bb8d9ca8
--- /dev/null
+++ b/src/trace/spine_fueled.rs
@@ -0,0 +1,841 @@
+//! An append-only collection of update batches.
+//!
+//! The `Spine` is a general-purpose trace implementation based on collection
+//! and merging immutable batches of updates. It is generic with respect to the
+//! batch type, and can be instantiated for any implementor of `trace::Batch`.
+//!
+//! ## Design
+//!
+//! This spine is represented as a list of layers, where each element in the
+//! list is either
+//!
+//!   1. MergeState::Vacant  empty
+//!   2. MergeState::Single  a single batch
+//!   3. MergeState::Double  a pair of batches
+//!
+//! Each "batch" has the option to be `None`, indicating a non-batch that
+//! nonetheless acts as a number of updates proportionate to the level at which
+//! it exists (for bookkeeping).
+//!
+//! Each of the batches at layer i contains at most 2^i elements.
+//!
+//! Each batch at layer i is treated as if it contains exactly 2^i elements,
+//! even though it may actually contain fewer elements. This allows us to
+//! decouple the physical representation from logical amounts of effort invested
+//! in each batch. It allows us to begin compaction and to reduce the number of
+//! updates, without compromising our ability to continue to move updates along
+//! the spine. We are explicitly making the trade-off that while some batches
+//! might compact at lower levels, we want to treat them as if they contained
+//! their full set of updates for accounting reasons (to apply work to higher
+//! levels).
+//!
+//! We maintain the invariant that for any in-progress merge at level k there
+//! should be fewer than 2^k records at levels lower than k. That is, even if we
+//! were to apply an unbounded amount of effort to those records, we would not
+//! have enough records to prompt a merge into the in-progress merge. Ideally,
+//! we maintain the extended invariant that for any in-progress merge at level
+//! k, the remaining effort required (number of records minus applied effort) is
+//! less than the number of records that would need to be added to reach 2^k
+//! records in layers below.
+//!
+//! ## Mathematics
+//!
+//! When a merge is initiated, there should be a non-negative *deficit* of
+//! updates before the layers below could plausibly produce a new batch for the
+//! currently merging layer. We must determine a factor of proportionality, so
+//! that newly arrived updates provide at least that amount of "fuel"
+//! towards the merging layer, so that the merge completes before lower levels
+//! invade.
+//!
+//! ### Deficit:
+//!
+//! A new merge is initiated only in response to the completion of a prior
+//! merge, or the introduction of new records from outside. The latter case is
+//! special, and will maintain our invariant trivially, so we will focus on the
+//! former case.
+//!
+//! When a merge at level k completes, assuming we have maintained our invariant
+//! then there should be fewer than 2^k records at lower levels. The newly
+//! created merge at level k+1 will require up to 2^k+2 units of work, and
+//! should not expect a new batch until strictly more than 2^k records are
+//! added. This means that a factor of proportionality of four should be
+//! sufficient to ensure that the merge completes before a new merge is
+//! initiated.
+//!
+//! When new records get introduced, we will need to roll up any batches at
+//! lower levels, which we treat as the introduction of records. Each of these
+//! virtual records introduced should either be accounted for the fuel it should
+//! contribute, as it results in the promotion of batches closer to in-progress
+//! merges.
+//!
+//! ### Fuel sharing
+//!
+//! We like the idea of applying fuel preferentially to merges at *lower*
+//! levels, under the idea that they are easier to complete, and we benefit from
+//! fewer total merges in progress. This does delay the completion of merges at
+//! higher levels, and may not obviously be a total win. If we choose to
+//! do this, we should make sure that we correctly account for completed merges
+//! at low layers: they should still extract fuel from new updates even though
+//! they have completed, at least until they have paid back any "debt" to higher
+//! layers by continuing to provide fuel as updates arrive.
+
+use std::{
+    fmt::{Display, Formatter},
+    mem::replace,
+};
+
+use crate::trace::cursor::{Cursor, CursorList};
+use crate::trace::Merger;
+use crate::trace::{Batch, Trace, TraceReader};
+use crate::NumEntries;
+use deepsize::DeepSizeOf;
+use textwrap::indent;
+
+/// An append-only collection of update tuples.
+///
+/// A spine maintains a small number of immutable collections of update tuples,
+/// merging the collections when two have similar sizes. In this way, it allows
+/// the addition of more tuples, which may then be merged with other immutable
+/// collections.
+pub struct Spine<B>
+where
+    B: Batch,
+{
+    merging: Vec<MergeState<B>>,
+    effort: usize,
+    activator: Option<timely::scheduling::activate::Activator>,
+    dirty: bool,
+}
+
+impl<B> Display for Spine<B>
+where
+    B: Batch + Display + Clone + 'static,
+    B::Key: Ord,
+    B::Val: Ord,
+{
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+        let mut res = Vec::new();
+        self.map_batches(|batch| {
+            res.push(writeln!(
+                f,
+                "batch:\n{}",
+                indent(&batch.to_string(), "    ")
+            ))
+        });
+        res.into_iter().collect()
+    }
+}
+
+// TODO.
+impl<B> Clone for Spine<B>
+where
+    B: Batch,
+{
+    fn clone(&self) -> Self {
+        unimplemented!()
+    }
+}
+
+impl<B> DeepSizeOf for Spine<B>
+where
+    B: Batch + DeepSizeOf + Clone + 'static,
+    B::Key: Ord,
+    B::Val: Ord,
+{
+    fn deep_size_of_children(&self, _context: &mut deepsize::Context) -> usize {
+        let mut result = 0;
+        self.map_batches(|batch| result += batch.deep_size_of());
+        result
+    }
+}
+
+impl<B> NumEntries for Spine<B>
+where
+    B: Batch + DeepSizeOf + Clone + 'static,
+    B::Key: Ord,
+    B::Val: Ord,
+{
+    fn num_entries_shallow(&self) -> usize {
+        let mut total = 0;
+        self.map_batches(|batch| total += batch.len());
+        total
+    }
+
+    fn num_entries_deep(&self) -> usize {
+        self.num_entries_shallow()
+    }
+
+    const CONST_NUM_ENTRIES: Option<usize> = None;
+}
+
+impl<B> TraceReader for Spine<B>
+where
+    B: Batch + Clone + 'static,
+    B::Key: Ord,
+    B::Val: Ord,
+{
+    type Key = B::Key;
+    type Val = B::Val;
+    type Time = B::Time;
+    type R = B::R;
+
+    type Batch = B;
+    type Cursor = CursorList<B::Key, B::Val, B::Time, B::R, B::Cursor>;
+
+    fn cursor(
+        &self,
+    ) -> (
+        Self::Cursor,
+        <Self::Cursor as Cursor<B::Key, B::Val, B::Time, B::R>>::Storage,
+    ) {
+        let mut cursors = Vec::new();
+        let mut storage = Vec::new();
+
+        for merge_state in self.merging.iter().rev() {
+            match merge_state {
+                MergeState::Double(variant) => match variant {
+                    MergeVariant::InProgress(batch1, batch2, _) => {
+                        if !batch1.is_empty() {
+                            cursors.push(batch1.cursor());
+                            storage.push(batch1.clone());
+                        }
+                        if !batch2.is_empty() {
+                            cursors.push(batch2.cursor());
+                            storage.push(batch2.clone());
+                        }
+                    }
+                    MergeVariant::Complete(Some(batch)) => {
+                        if !batch.is_empty() {
+                            cursors.push(batch.cursor());
+                            storage.push(batch.clone());
+                        }
+                    }
+                    MergeVariant::Complete(None) => {}
+                },
+                MergeState::Single(Some(batch)) => {
+                    if !batch.is_empty() {
+                        cursors.push(batch.cursor());
+                        storage.push(batch.clone());
+                    }
+                }
+                MergeState::Single(None) => {}
+                MergeState::Vacant => {}
+            }
+        }
+
+        (CursorList::new(cursors, &storage), storage)
+    }
+
+    fn map_batches<F: FnMut(&Self::Batch)>(&self, mut f: F) {
+        for batch in self.merging.iter().rev() {
+            match batch {
+                MergeState::Double(MergeVariant::InProgress(batch1, batch2, _)) => {
+                    f(batch1);
+                    f(batch2);
+                }
+                MergeState::Double(MergeVariant::Complete(Some(batch))) => f(batch),
+                MergeState::Single(Some(batch)) => f(batch),
+                _ => {}
+            }
+        }
+    }
+}
+
+impl<B> Trace for Spine<B>
+where
+    B: Batch + Clone + 'static,
+    B::Key: Ord,
+    B::Val: Ord,
+{
+    fn new(activator: Option<timely::scheduling::activate::Activator>) -> Self {
+        Self::with_effort(1, activator)
+    }
+
+    fn recede_to(&mut self, frontier: &B::Time) {
+        // Complete all in-progress merges, as we don't have an easy way to update
+        // timestamps in an ongoing merge.
+        self.complete_merges();
+
+        self.map_batches_mut(|b| b.recede_to(frontier));
+    }
+
+    /// Apply some amount of effort to trace maintenance.
+    ///
+    /// The units of effort are updates, and the method should be
+    /// thought of as analogous to inserting as many empty updates,
+    /// where the trace is permitted to perform proportionate work.
+    fn exert(&mut self, effort: &mut isize) {
+        // If there is work to be done, ...
+        self.tidy_layers();
+        if !self.reduced() {
+            // If any merges exist, we can directly call `apply_fuel`.
+            if self.merging.iter().any(|b| b.is_double()) {
+                self.apply_fuel(effort);
+            }
+            // Otherwise, we'll need to introduce fake updates to move merges along.
+            else {
+                // Introduce an empty batch with roughly *effort number of virtual updates.
+                let level = (*effort as usize).next_power_of_two().trailing_zeros() as usize;
+                self.introduce_batch(None, level);
+            }
+            // We were not in reduced form, so let's check again in the future.
+            if let Some(activator) = &self.activator {
+                activator.activate();
+            }
+        }
+    }
+
+    fn consolidate(mut self) -> Option<Self::Batch> {
+        // Merge batches until there is nothing left to merge.
+        let mut fuel = isize::max_value();
+        while !self.reduced() {
+            self.exert(&mut fuel);
+        }
+        // Return the sole remaining batch (if one exists).
+        for merging in self.merging.into_iter() {
+            if let MergeState::Single(Some(batch)) = merging {
+                if !batch.is_empty() {
+                    return Some(batch);
+                }
+            }
+        }
+
+        // Consolidated trace is empty.
+        None
+    }
+
+    // Ideally, this method acts as insertion of `batch`, even if we are not yet
+    // able to begin merging the batch. This means it is a good time to perform
+    // amortized work proportional to the size of batch.
+    fn insert(&mut self, batch: Self::Batch) {
+        assert!(batch.lower() != batch.upper());
+
+        // Ignore empty batches.
+        // Note: we may want to use empty batches to artificially force compaction.
+        if batch.is_empty() {
+            return;
+        }
+
+        self.dirty = true;
+
+        // Leonid: we do not require batch bounds to grow monotonically.
+        //assert_eq!(batch.lower(), &self.upper);
+
+        let index = batch.len().next_power_of_two();
+        self.introduce_batch(Some(batch), index.trailing_zeros() as usize);
+
+        // If more than one batch remains reschedule ourself.
+        if !self.reduced() {
+            if let Some(activator) = &self.activator {
+                activator.activate();
+            }
+        }
+    }
+
+    fn clear_dirty_flag(&mut self) {
+        self.dirty = false;
+    }
+
+    fn dirty(&self) -> bool {
+        self.dirty
+    }
+}
+
+impl<B> Spine<B>
+where
+    B: Batch + Clone + 'static,
+    B::Key: Ord,
+    B::Val: Ord,
+{
+    /// True iff there is at most one non-empty batch in `self.merging`.
+    ///
+    /// When true, there is no maintenance work to perform in the trace, other
+    /// than compaction. We do not yet have logic in place to determine if
+    /// compaction would improve a trace, so for now we are ignoring that.
+    fn reduced(&self) -> bool {
+        let mut non_empty = 0;
+        for index in 0..self.merging.len() {
+            if self.merging[index].is_double() {
+                return false;
+            }
+            if self.merging[index].len() > 0 {
+                non_empty += 1;
+            }
+            if non_empty > 1 {
+                return false;
+            }
+        }
+        true
+    }
+
+    /// Describes the merge progress of layers in the trace.
+    ///
+    /// Intended for diagnostics rather than public consumption.
+    #[allow(dead_code)]
+    fn describe(&self) -> Vec<(usize, usize)> {
+        self.merging
+            .iter()
+            .map(|b| match b {
+                MergeState::Vacant => (0, 0),
+                x @ MergeState::Single(_) => (1, x.len()),
+                x @ MergeState::Double(_) => (2, x.len()),
+            })
+            .collect()
+    }
+
+    /// Allocates a fueled `Spine` with a specified effort multiplier.
+    ///
+    /// This trace will merge batches progressively, with each inserted batch
+    /// applying a multiple of the batch's length in effort to each merge.
+    /// The `effort` parameter is that multiplier. This value should be at
+    /// least one for the merging to happen; a value of zero is not helpful.
+    pub fn with_effort(
+        mut effort: usize,
+        activator: Option<timely::scheduling::activate::Activator>,
+    ) -> Self {
+        // Zero effort is .. not smart.
+        if effort == 0 {
+            effort = 1;
+        }
+
+        Spine {
+            merging: Vec::new(),
+            effort,
+            activator,
+            dirty: false,
+        }
+    }
+
+    /// Introduces a batch at an indicated level.
+    ///
+    /// The level indication is often related to the size of the batch, but
+    /// it can also be used to artificially fuel the computation by supplying
+    /// empty batches at non-trivial indices, to move merges along.
+    pub fn introduce_batch(&mut self, batch: Option<B>, batch_index: usize) {
+        // Step 0.  Determine an amount of fuel to use for the computation.
+        //
+        //          Fuel is used to drive maintenance of the data structure,
+        //          and in particular are used to make progress through merges
+        //          that are in progress. The amount of fuel to use should be
+        //          proportional to the number of records introduced, so that
+        //          we are guaranteed to complete all merges before they are
+        //          required as arguments to merges again.
+        //
+        //          The fuel use policy is negotiable, in that we might aim
+        //          to use relatively less when we can, so that we return
+        //          control promptly, or we might account more work to larger
+        //          batches. Not clear to me which are best, of if there
+        //          should be a configuration knob controlling this.
+
+        // The amount of fuel to use is proportional to 2^batch_index, scaled
+        // by a factor of self.effort which determines how eager we are in
+        // performing maintenance work. We need to ensure that each merge in
+        // progress receives fuel for each introduced batch, and so multiply
+        // by that as well.
+        // Leonid: We deliberately hit this path in `consolidate`.
+        /*
+        if batch_index > 32 {
+            println!("Large batch index: {}", batch_index);
+        }
+        */
+
+        // We believe that eight units of fuel is sufficient for each introduced
+        // record, accounted as four for each record, and a potential four more
+        // for each virtual record associated with promoting existing smaller
+        // batches. We could try and make this be less, or be scaled to merges
+        // based on their deficit at time of instantiation. For now, we remain
+        // conservative.
+        let mut fuel = 8 << batch_index;
+        // Scale up by the effort parameter, which is calibrated to one as the
+        // minimum amount of effort.
+        fuel *= self.effort;
+        // Convert to an `isize` so we can observe any fuel shortfall.
+        let mut fuel = fuel as isize;
+
+        // Step 1.  Apply fuel to each in-progress merge.
+        //
+        //          Before we can introduce new updates, we must apply any
+        //          fuel to in-progress merges, as this fuel is what ensures
+        //          that the merges will be complete by the time we insert
+        //          the updates.
+        self.apply_fuel(&mut fuel);
+
+        // Step 2.  We must ensure the invariant that adjacent layers do not
+        //          contain two batches will be satisfied when we insert the
+        //          batch. We forcibly completing all merges at layers lower
+        //          than and including `batch_index`, so that the new batch
+        //          is inserted into an empty layer.
+        //
+        //          We could relax this to "strictly less than `batch_index`"
+        //          if the layer above has only a single batch in it, which
+        //          seems not implausible if it has been the focus of effort.
+        //
+        //          This should be interpreted as the introduction of some
+        //          volume of fake updates, and we will need to fuel merges
+        //          by a proportional amount to ensure that they are not
+        //          surprised later on. The number of fake updates should
+        //          correspond to the deficit for the layer, which perhaps
+        //          we should track explicitly.
+        self.roll_up(batch_index);
+
+        // Step 3. This insertion should be into an empty layer. It is a
+        //         logical error otherwise, as we may be violating our
+        //         invariant, from which all wonderment derives.
+        self.insert_at(batch, batch_index);
+
+        // Step 4. Tidy the largest layers.
+        //
+        //         It is important that we not tidy only smaller layers,
+        //         as their ascension is what ensures the merging and
+        //         eventual compaction of the largest layers.
+        self.tidy_layers();
+    }
+
+    /// Ensures that an insertion at layer `index` will succeed.
+    ///
+    /// This method is subject to the constraint that all existing batches
+    /// should occur at higher levels, which requires it to "roll up" batches
+    /// present at lower levels before the method is called. In doing this,
+    /// we should not introduce more virtual records than 2^index, as that
+    /// is the amount of excess fuel we have budgeted for completing merges.
+    fn roll_up(&mut self, index: usize) {
+        // Ensure entries sufficient for `index`.
+        while self.merging.len() <= index {
+            self.merging.push(MergeState::Vacant);
+        }
+
+        // We only need to roll up if there are non-vacant layers.
+        if self.merging[..index].iter().any(|m| !m.is_vacant()) {
+            // Collect and merge all batches at layers up to but not including `index`.
+            let mut merged = None;
+            for i in 0..index {
+                self.insert_at(merged, i);
+                merged = self.complete_at(i);
+            }
+
+            // The merged results should be introduced at level `index`, which should
+            // be ready to absorb them (possibly creating a new merge at the time).
+            self.insert_at(merged, index);
+
+            // If the insertion results in a merge, we should complete it to ensure
+            // the upcoming insertion at `index` does not panic.
+            if self.merging[index].is_double() {
+                let merged = self.complete_at(index);
+                self.insert_at(merged, index + 1);
+            }
+        }
+    }
+
+    /// Applies an amount of fuel to merges in progress.
+    ///
+    /// The supplied `fuel` is for each in progress merge, and if we want to
+    /// spend the fuel non-uniformly (e.g. prioritizing merges at low
+    /// layers) we could do so in order to maintain fewer batches on average
+    /// (at the risk of completing merges of large batches later, but tbh
+    /// probably not much later).
+    pub fn apply_fuel(&mut self, fuel: &mut isize) {
+        // For the moment our strategy is to apply fuel independently to each merge
+        // in progress, rather than prioritizing small merges. This sounds like a
+        // great idea, but we need better accounting in place to ensure that merges
+        // that borrow against later layers but then complete still "acquire" fuel
+        // to pay back their debts.
+        for index in 0..self.merging.len() {
+            // Give each level independent fuel, for now.
+            let mut fuel = *fuel;
+            // Pass along various logging stuffs, in case we need to report success.
+            self.merging[index].work(&mut fuel);
+            // `fuel` could have a deficit at this point, meaning we over-spent when
+            // we took a merge step. We could ignore this, or maintain the deficit
+            // and account future fuel against it before spending again. It isn't
+            // clear why that would be especially helpful to do; we might want to
+            // avoid overspends at multiple layers in the same invocation (to limit
+            // latencies), but there is probably a rich policy space here.
+
+            // If a merge completes, we can immediately merge it in to the next
+            // level, which is "guaranteed" to be complete at this point, by our
+            // fueling discipline.
+            if self.merging[index].is_complete() {
+                let complete = self.complete_at(index);
+                self.insert_at(complete, index + 1);
+            }
+        }
+    }
+
+    /// Inserts a batch at a specific location.
+    ///
+    /// This is a non-public internal method that can panic if we try and insert
+    /// into a layer which already contains two batches (and is still in the
+    /// process of merging).
+    fn insert_at(&mut self, batch: Option<B>, index: usize) {
+        // Ensure the spine is large enough.
+        while self.merging.len() <= index {
+            self.merging.push(MergeState::Vacant);
+        }
+
+        // Insert the batch at the location.
+        match self.merging[index].take() {
+            MergeState::Vacant => {
+                self.merging[index] = MergeState::Single(batch);
+            }
+            MergeState::Single(old) => {
+                self.merging[index] = MergeState::begin_merge(old, batch);
+            }
+            MergeState::Double(_) => {
+                panic!("Attempted to insert batch into incomplete merge!")
+            }
+        };
+    }
+
+    /// Completes and extracts what ever is at layer `index`.
+    fn complete_at(&mut self, index: usize) -> Option<B> {
+        self.merging[index].complete()
+    }
+
+    /// Attempts to draw down large layers to size appropriate layers.
+    fn tidy_layers(&mut self) {
+        // If the largest layer is complete (not merging), we can attempt
+        // to draw it down to the next layer. This is permitted if we can
+        // maintain our invariant that below each merge there are at most
+        // half the records that would be required to invade the merge.
+        if !self.merging.is_empty() {
+            let mut length = self.merging.len();
+            if self.merging[length - 1].is_single() {
+                // To move a batch down, we require that it contain few
+                // enough records that the lower level is appropriate,
+                // and that moving the batch would not create a merge
+                // violating our invariant.
+
+                let appropriate_level = self.merging[length - 1]
+                    .len()
+                    .next_power_of_two()
+                    .trailing_zeros() as usize;
+
+                // Continue only as far as is appropriate
+                while appropriate_level < length - 1 {
+                    match self.merging[length - 2].take() {
+                        // Vacant or structurally empty batches can be absorbed.
+                        MergeState::Vacant | MergeState::Single(None) => {
+                            self.merging.remove(length - 2);
+                            length = self.merging.len();
+                        }
+                        // Single batches may initiate a merge, if sizes are
+                        // within bounds, but terminate the loop either way.
+                        MergeState::Single(Some(batch)) => {
+                            // Determine the number of records that might lead
+                            // to a merge. Importantly, this is not the number
+                            // of actual records, but the sum of upper bounds
+                            // based on indices.
+                            let mut smaller = 0;
+                            for (index, batch) in self.merging[..(length - 2)].iter().enumerate() {
+                                match batch {
+                                    MergeState::Vacant => {}
+                                    MergeState::Single(_) => {
+                                        smaller += 1 << index;
+                                    }
+                                    MergeState::Double(_) => {
+                                        smaller += 2 << index;
+                                    }
+                                }
+                            }
+
+                            if smaller <= (1 << length) / 8 {
+                                self.merging.remove(length - 2);
+                                self.insert_at(Some(batch), length - 2);
+                            } else {
+                                self.merging[length - 2] = MergeState::Single(Some(batch));
+                            }
+                            return;
+                        }
+                        // If a merge is in progress there is nothing to do.
+                        MergeState::Double(state) => {
+                            self.merging[length - 2] = MergeState::Double(state);
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /// Complete all in-progress merges (without starting any new ones).
+    fn complete_merges(&mut self) {
+        for merge_state in self.merging.iter_mut() {
+            if merge_state.is_inprogress() {
+                let mut fuel = isize::max_value();
+                merge_state.work(&mut fuel);
+            }
+        }
+        assert!(self.merging.iter().all(|m| !m.is_inprogress()));
+    }
+
+    /// Mutate all batches.  Can only be invoked when there are no in-progress
+    /// matches in the trait.
+    fn map_batches_mut<F: FnMut(&mut <Self as TraceReader>::Batch)>(&mut self, mut f: F) {
+        for batch in self.merging.iter_mut().rev() {
+            match batch {
+                MergeState::Double(MergeVariant::InProgress(_batch1, _batch2, _)) => {
+                    panic!("map_batches_mut called on an in-progress batch")
+                }
+                MergeState::Double(MergeVariant::Complete(Some(batch))) => f(batch),
+                MergeState::Single(Some(batch)) => f(batch),
+                _ => {}
+            }
+        }
+    }
+}
+
+/// Describes the state of a layer.
+///
+/// A layer can be empty, contain a single batch, or contain a pair of batches
+/// that are in the process of merging into a batch for the next layer.
+enum MergeState<B: Batch> {
+    /// An empty layer, containing no updates.
+    Vacant,
+    /// A layer containing a single batch.
+    ///
+    /// The `None` variant is used to represent a structurally empty batch
+    /// present to ensure the progress of maintenance work.
+    Single(Option<B>),
+    /// A layer containing two batches, in the process of merging.
+    Double(MergeVariant<B>),
+}
+
+impl<B: Batch> MergeState<B> {
+    /// The number of actual updates contained in the level.
+    fn len(&self) -> usize {
+        match self {
+            MergeState::Single(Some(b)) => b.len(),
+            MergeState::Double(MergeVariant::InProgress(b1, b2, _)) => b1.len() + b2.len(),
+            MergeState::Double(MergeVariant::Complete(Some(b))) => b.len(),
+            _ => 0,
+        }
+    }
+
+    /// True only for the MergeState::Vacant variant.
+    fn is_vacant(&self) -> bool {
+        matches!(self, MergeState::Vacant)
+    }
+
+    /// True only for the MergeState::Single variant.
+    fn is_single(&self) -> bool {
+        matches!(self, MergeState::Single(_))
+    }
+
+    /// True only for the MergeState::Double variant.
+    fn is_double(&self) -> bool {
+        matches!(self, MergeState::Double(_))
+    }
+
+    /// Immediately complete any merge.
+    ///
+    /// The result is either a batch, if there is a non-trivial batch to return
+    /// or `None` if there is no meaningful batch to return. This does not
+    /// distinguish between Vacant entries and structurally empty batches,
+    /// which should be done with the `is_complete()` method.
+    ///
+    /// There is the addional option of input batches.
+    fn complete(&mut self) -> Option<B> {
+        match replace(self, MergeState::Vacant) {
+            MergeState::Vacant => None,
+            MergeState::Single(batch) => batch,
+            MergeState::Double(variant) => variant.complete(),
+        }
+    }
+
+    /// True iff the layer is a complete merge, ready for extraction.
+    fn is_complete(&self) -> bool {
+        matches!(self, MergeState::Double(MergeVariant::Complete(_)))
+    }
+
+    /// True iff the layer is an in-progress merge.
+    fn is_inprogress(&self) -> bool {
+        matches!(self, MergeState::Double(MergeVariant::InProgress(..)))
+    }
+
+    /// Performs a bounded amount of work towards a merge.
+    ///
+    /// If the merge completes, the resulting batch is returned.
+    /// If a batch is returned, it is the obligation of the caller
+    /// to correctly install the result.
+    fn work(&mut self, fuel: &mut isize) {
+        // We only perform work for merges in progress.
+        if let MergeState::Double(layer) = self {
+            layer.work(fuel)
+        }
+    }
+
+    /// Extract the merge state, typically temporarily.
+    fn take(&mut self) -> Self {
+        replace(self, MergeState::Vacant)
+    }
+
+    /// Initiates the merge of an "old" batch with a "new" batch.
+    ///
+    /// The upper frontier of the old batch should match the lower
+    /// frontier of the new batch, with the resulting batch describing
+    /// their composed interval, from the lower frontier of the old
+    /// batch to the upper frontier of the new batch.
+    ///
+    /// Either batch may be `None` which corresponds to a structurally
+    /// empty batch whose upper and lower froniers are equal. This
+    /// option exists purely for bookkeeping purposes, and no computation
+    /// is performed to merge the two batches.
+    fn begin_merge(batch1: Option<B>, batch2: Option<B>) -> MergeState<B> {
+        let variant = match (batch1, batch2) {
+            (Some(batch1), Some(batch2)) => {
+                // Leonid: we do not require batch bounds to grow monotonically.
+                //assert!(batch1.upper() == batch2.lower());
+
+                let begin_merge = <B as Batch>::begin_merge(&batch1, &batch2);
+                MergeVariant::InProgress(batch1, batch2, begin_merge)
+            }
+            (None, Some(x)) => MergeVariant::Complete(Some(x)),
+            (Some(x), None) => MergeVariant::Complete(Some(x)),
+            (None, None) => MergeVariant::Complete(None),
+        };
+
+        MergeState::Double(variant)
+    }
+}
+
+enum MergeVariant<B: Batch> {
+    /// Describes an actual in-progress merge between two non-trivial batches.
+    InProgress(B, B, <B as Batch>::Merger),
+    /// A merge that requires no further work. May or may not represent a
+    /// non-trivial batch.
+    Complete(Option<B>),
+}
+
+impl<B: Batch> MergeVariant<B> {
+    /// Completes and extracts the batch, unless structurally empty.
+    ///
+    /// The result is either `None`, for structurally empty batches,
+    /// or a batch and optionally input batches from which it derived.
+    fn complete(mut self) -> Option<B> {
+        let mut fuel = isize::max_value();
+        self.work(&mut fuel);
+        if let MergeVariant::Complete(batch) = self {
+            batch
+        } else {
+            panic!("Failed to complete a merge!");
+        }
+    }
+
+    /// Applies some amount of work, potentially completing the merge.
+    ///
+    /// In case the work completes, the source batches are returned.
+    /// This allows the caller to manage the released resources.
+    fn work(&mut self, fuel: &mut isize) {
+        let variant = replace(self, MergeVariant::Complete(None));
+        if let MergeVariant::InProgress(b1, b2, mut merge) = variant {
+            merge.work(&b1, &b2, fuel);
+            if *fuel > 0 {
+                *self = MergeVariant::Complete(Some(merge.done()));
+            } else {
+                *self = MergeVariant::InProgress(b1, b2, merge);
+            }
+        } else {
+            *self = variant;
+        }
+    }
+}
diff --git a/tools/pre-push b/tools/pre-push
index ef4eceba..51408613 100755
--- a/tools/pre-push
+++ b/tools/pre-push
@@ -7,10 +7,7 @@ echo "Checking Rust rules prior to push.  To run this check by hand invoke 'tool
 
 set -ex
 
-if [ $# -gt 0 ]; then
-    cargo fmt -- --config imports_granularity=Crate
-else
-    cargo fmt -- --check --config format_code_in_doc_comments=true --config wrap_comments=true
-    cargo clippy -- -D warnings
-fi
+cargo fmt -- --check --config format_code_in_doc_comments=true --config wrap_comments=true
+cargo clippy -- -D warnings
+
 RUSTDOCFLAGS="-Dwarnings" cargo doc