diff --git a/dogsdogsdogs/src/operators/count.rs b/dogsdogsdogs/src/operators/count.rs
index 1cc193d66..8382d631c 100644
--- a/dogsdogsdogs/src/operators/count.rs
+++ b/dogsdogsdogs/src/operators/count.rs
@@ -19,9 +19,8 @@ pub fn count<G, Tr, R, F, P>(
     index: usize,
 ) -> Collection<G, (P, usize, usize), R>
 where
-    G: Scope,
-    G::Timestamp: Lattice,
-    Tr: TraceReader<ValOwned=(), Time=G::Timestamp, Diff=isize>+Clone+'static,
+    G: Scope<Timestamp=Tr::Time>,
+    Tr: TraceReader<ValOwned=(), Diff=isize>+Clone+'static,
     Tr::KeyOwned: Hashable + Default,
     R: Monoid+Multiply<Output = R>+ExchangeData,
     F: Fn(&P)->Tr::KeyOwned+Clone+'static,
diff --git a/dogsdogsdogs/src/operators/half_join.rs b/dogsdogsdogs/src/operators/half_join.rs
index 0f5b90509..9d1f6114f 100644
--- a/dogsdogsdogs/src/operators/half_join.rs
+++ b/dogsdogsdogs/src/operators/half_join.rs
@@ -76,13 +76,11 @@ pub fn half_join<G, V, R, Tr, FF, CF, DOut, S>(
     mut output_func: S,
 ) -> Collection<G, (DOut, G::Timestamp), <R as Mul<Tr::Diff>>::Output>
 where
-    G: Scope,
-    G::Timestamp: Lattice,
-    Tr::KeyOwned: Ord + Hashable + ExchangeData,
+    G: Scope<Timestamp = Tr::Time>,
+    Tr::KeyOwned: Hashable + ExchangeData,
     V: ExchangeData,
     R: ExchangeData + Monoid,
-    Tr: TraceReader<Time=G::Timestamp>+Clone+'static,
-    Tr::Diff: Semigroup,
+    Tr: TraceReader+Clone+'static,
     R: Mul<Tr::Diff>,
     <R as Mul<Tr::Diff>>::Output: Semigroup,
     FF: Fn(&G::Timestamp) -> G::Timestamp + 'static,
@@ -131,13 +129,11 @@ pub fn half_join_internal_unsafe<G, V, R, Tr, FF, CF, DOut, ROut, Y, I, S>(
     mut output_func: S,
 ) -> Collection<G, DOut, ROut>
 where
-    G: Scope,
-    G::Timestamp: Lattice,
-    Tr::KeyOwned: Ord + Hashable + ExchangeData,
+    G: Scope<Timestamp = Tr::Time>,
+    Tr::KeyOwned: Hashable + ExchangeData,
     V: ExchangeData,
     R: ExchangeData + Monoid,
-    Tr: TraceReader<Time=G::Timestamp>+Clone+'static,
-    Tr::Diff: Semigroup,
+    Tr: TraceReader+Clone+'static,
     FF: Fn(&G::Timestamp) -> G::Timestamp + 'static,
     CF: Fn(&G::Timestamp, &G::Timestamp) -> bool + 'static,
     DOut: Clone+'static,
diff --git a/dogsdogsdogs/src/operators/lookup_map.rs b/dogsdogsdogs/src/operators/lookup_map.rs
index 0704fecb1..a069c9d23 100644
--- a/dogsdogsdogs/src/operators/lookup_map.rs
+++ b/dogsdogsdogs/src/operators/lookup_map.rs
@@ -27,9 +27,8 @@ pub fn lookup_map<G, D, R, Tr, F, DOut, ROut, S>(
     supplied_key2: Tr::KeyOwned,
 ) -> Collection<G, DOut, ROut>
 where
-    G: Scope,
-    G::Timestamp: Lattice,
-    Tr: TraceReader<Time=G::Timestamp>+Clone+'static,
+    G: Scope<Timestamp=Tr::Time>,
+    Tr: TraceReader+Clone+'static,
     Tr::KeyOwned: Hashable,
     Tr::Diff: Monoid+ExchangeData,
     F: FnMut(&D, &mut Tr::KeyOwned)+Clone+'static,
diff --git a/dogsdogsdogs/src/operators/propose.rs b/dogsdogsdogs/src/operators/propose.rs
index 1434963f1..cca4ee975 100644
--- a/dogsdogsdogs/src/operators/propose.rs
+++ b/dogsdogsdogs/src/operators/propose.rs
@@ -21,9 +21,8 @@ pub fn propose<G, Tr, F, P>(
     key_selector: F,
 ) -> Collection<G, (P, Tr::ValOwned), Tr::Diff>
 where
-    G: Scope,
-    G::Timestamp: Lattice,
-    Tr: TraceReader<Time=G::Timestamp>+Clone+'static,
+    G: Scope<Timestamp=Tr::Time>,
+    Tr: TraceReader+Clone+'static,
     Tr::KeyOwned: Hashable + Default,
     Tr::Diff: Monoid+Multiply<Output = Tr::Diff>+ExchangeData,
     F: Fn(&P)->Tr::KeyOwned+Clone+'static,
@@ -51,9 +50,8 @@ pub fn propose_distinct<G, Tr, F, P>(
     key_selector: F,
 ) -> Collection<G, (P, Tr::ValOwned), Tr::Diff>
 where
-    G: Scope,
-    G::Timestamp: Lattice,
-    Tr: TraceReader<Time=G::Timestamp>+Clone+'static,
+    G: Scope<Timestamp=Tr::Time>,
+    Tr: TraceReader+Clone+'static,
     Tr::KeyOwned: Hashable + Default,
     Tr::Diff: Monoid+Multiply<Output = Tr::Diff>+ExchangeData,
     F: Fn(&P)->Tr::KeyOwned+Clone+'static,
diff --git a/dogsdogsdogs/src/operators/validate.rs b/dogsdogsdogs/src/operators/validate.rs
index 2d1e8f371..ec347b386 100644
--- a/dogsdogsdogs/src/operators/validate.rs
+++ b/dogsdogsdogs/src/operators/validate.rs
@@ -19,9 +19,8 @@ pub fn validate<G, K, V, Tr, F, P>(
     key_selector: F,
 ) -> Collection<G, (P, V), Tr::Diff>
 where
-    G: Scope,
-    G::Timestamp: Lattice,
-    Tr: TraceReader<KeyOwned=(K,V), ValOwned=(), Time=G::Timestamp>+Clone+'static,
+    G: Scope<Timestamp=Tr::Time>,
+    Tr: TraceReader<KeyOwned=(K,V), ValOwned=()>+Clone+'static,
     K: Ord+Hash+Clone+Default,
     V: ExchangeData+Hash+Default,
     Tr::Diff: Monoid+Multiply<Output = Tr::Diff>+ExchangeData,
diff --git a/examples/cursors.rs b/examples/cursors.rs
index 120c6a55d..a9632570c 100644
--- a/examples/cursors.rs
+++ b/examples/cursors.rs
@@ -132,10 +132,10 @@ fn main() {
 fn dump_cursor<Tr>(round: u32, index: usize, trace: &mut Tr)
 where
     Tr: TraceReader,
-    Tr::KeyOwned: Debug + Clone,
-    Tr::ValOwned: Debug + Clone,
-    Tr::Time: Debug + Clone,
-    Tr::Diff: Debug + Clone,
+    Tr::KeyOwned: Debug,
+    Tr::ValOwned: Debug,
+    Tr::Time: Debug,
+    Tr::Diff: Debug,
 {
     let (mut cursor, storage) = trace.cursor();
     for ((k, v), diffs) in cursor.to_vec(&storage).iter() {
diff --git a/src/algorithms/graphs/bfs.rs b/src/algorithms/graphs/bfs.rs
index 31fa6978a..2211a5276 100644
--- a/src/algorithms/graphs/bfs.rs
+++ b/src/algorithms/graphs/bfs.rs
@@ -26,10 +26,9 @@ use crate::operators::arrange::Arranged;
 /// Returns pairs (node, dist) indicating distance of each node from a root.
 pub fn bfs_arranged<G, N, Tr>(edges: &Arranged<G, Tr>, roots: &Collection<G, N>) -> Collection<G, (N, u32)>
 where
-    G: Scope,
-    G::Timestamp: Lattice+Ord,
+    G: Scope<Timestamp=Tr::Time>,
     N: ExchangeData+Hash,
-    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Time=G::Timestamp, Diff=isize>+Clone+'static,
+    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Diff=isize>+Clone+'static,
 {
     // initialize roots as reaching themselves at distance 0
     let nodes = roots.map(|x| (x, 0));
diff --git a/src/algorithms/graphs/bijkstra.rs b/src/algorithms/graphs/bijkstra.rs
index 3c16595dd..7dc11c1d9 100644
--- a/src/algorithms/graphs/bijkstra.rs
+++ b/src/algorithms/graphs/bijkstra.rs
@@ -42,10 +42,9 @@ pub fn bidijkstra_arranged<G, N, Tr>(
     goals: &Collection<G, (N,N)>
 ) -> Collection<G, ((N,N), u32)>
 where
-    G: Scope,
-    G::Timestamp: Lattice+Ord,
+    G: Scope<Timestamp=Tr::Time>,
     N: ExchangeData+Hash,
-    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Time=G::Timestamp, Diff=isize>+Clone+'static,
+    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Diff=isize>+Clone+'static,
 {
     forward
         .stream
diff --git a/src/algorithms/graphs/propagate.rs b/src/algorithms/graphs/propagate.rs
index 4b8f1a9e1..9aef8e08b 100644
--- a/src/algorithms/graphs/propagate.rs
+++ b/src/algorithms/graphs/propagate.rs
@@ -56,14 +56,13 @@ use crate::operators::arrange::arrangement::Arranged;
 /// of `logic should be a number in the interval [0,64],
 pub fn propagate_core<G, N, L, Tr, F, R>(edges: &Arranged<G,Tr>, nodes: &Collection<G,(N,L),R>, logic: F) -> Collection<G,(N,L),R>
 where
-    G: Scope,
-    G::Timestamp: Lattice+Ord,
+    G: Scope<Timestamp=Tr::Time>,
     N: ExchangeData+Hash,
     R: ExchangeData+Abelian,
     R: Multiply<R, Output=R>,
     R: From<i8>,
     L: ExchangeData,
-    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Time=G::Timestamp, Diff=R>+Clone+'static,
+    Tr: for<'a> TraceReader<Key<'a>=&'a N, Val<'a>=&'a N, Diff=R>+Clone+'static,
     F: Fn(&L)->u64+Clone+'static,
 {
     // Morally the code performs the following iterative computation. However, in the interest of a simplified
diff --git a/src/operators/arrange/agent.rs b/src/operators/arrange/agent.rs
index d1bac4fc5..c18b7e30e 100644
--- a/src/operators/arrange/agent.rs
+++ b/src/operators/arrange/agent.rs
@@ -10,7 +10,6 @@ use timely::progress::Timestamp;
 use timely::progress::{Antichain, frontier::AntichainRef};
 use timely::dataflow::operators::CapabilitySet;
 
-use crate::lattice::Lattice;
 use crate::trace::{Trace, TraceReader, Batch, BatchReader};
 use crate::trace::wrappers::rc::TraceBox;
 
@@ -29,7 +28,6 @@ use crate::trace::wrappers::frontier::{TraceFrontier, BatchFrontier};
 pub struct TraceAgent<Tr>
 where
     Tr: TraceReader,
-    Tr::Time: Lattice+Ord+Clone+'static,
 {
     trace: Rc<RefCell<TraceBox<Tr>>>,
     queues: Weak<RefCell<Vec<TraceAgentQueueWriter<Tr>>>>,
@@ -44,7 +42,6 @@ where
 impl<Tr> TraceReader for TraceAgent<Tr>
 where
     Tr: TraceReader,
-    Tr::Time: Lattice+Ord+Clone+'static,
 {
     type Key<'a> = Tr::Key<'a>;
     type KeyOwned = Tr::KeyOwned;
@@ -85,11 +82,7 @@ where
     fn map_batches<F: FnMut(&Self::Batch)>(&self, f: F) { self.trace.borrow().trace.map_batches(f) }
 }
 
-impl<Tr> TraceAgent<Tr>
-where
-    Tr: TraceReader,
-    Tr::Time: Timestamp+Lattice,
-{
+impl<Tr: TraceReader> TraceAgent<Tr> {
     /// Creates a new agent from a trace reader.
     pub fn new(trace: Tr, operator: OperatorInfo, logging: Option<crate::logging::Logger>) -> (Self, TraceWriter<Tr>)
     where
@@ -177,7 +170,6 @@ where
 impl<Tr> TraceAgent<Tr>
 where
     Tr: TraceReader+'static,
-    Tr::Time: Lattice+Ord+Clone+'static,
 {
     /// Copies an existing collection into the supplied scope.
     ///
@@ -233,7 +225,6 @@ where
     pub fn import<G>(&mut self, scope: &G) -> Arranged<G, TraceAgent<Tr>>
     where
         G: Scope<Timestamp=Tr::Time>,
-        Tr::Time: Timestamp,
     {
         self.import_named(scope, "ArrangedSource")
     }
@@ -242,7 +233,6 @@ where
     pub fn import_named<G>(&mut self, scope: &G, name: &str) -> Arranged<G, TraceAgent<Tr>>
     where
         G: Scope<Timestamp=Tr::Time>,
-        Tr::Time: Timestamp,
     {
         // Drop ShutdownButton and return only the arrangement.
         self.import_core(scope, name).0
@@ -300,7 +290,6 @@ where
     pub fn import_core<G>(&mut self, scope: &G, name: &str) -> (Arranged<G, TraceAgent<Tr>>, ShutdownButton<CapabilitySet<Tr::Time>>)
     where
         G: Scope<Timestamp=Tr::Time>,
-        Tr::Time: Timestamp,
     {
         let trace = self.clone();
 
@@ -418,7 +407,6 @@ where
     pub fn import_frontier<G>(&mut self, scope: &G, name: &str) -> (Arranged<G, TraceFrontier<TraceAgent<Tr>>>, ShutdownButton<CapabilitySet<Tr::Time>>)
     where
         G: Scope<Timestamp=Tr::Time>,
-        Tr::Time: Timestamp+ Lattice+Ord+Clone+'static,
         Tr: TraceReader,
     {
         // This frontier describes our only guarantee on the compaction frontier.
@@ -437,7 +425,6 @@ where
     pub fn import_frontier_core<G>(&mut self, scope: &G, name: &str, since: Antichain<Tr::Time>, until: Antichain<Tr::Time>) -> (Arranged<G, TraceFrontier<TraceAgent<Tr>>>, ShutdownButton<CapabilitySet<Tr::Time>>)
     where
         G: Scope<Timestamp=Tr::Time>,
-        Tr::Time: Timestamp+ Lattice+Ord+Clone+'static,
         Tr: TraceReader,
     {
         let trace = self.clone();
@@ -541,7 +528,6 @@ impl<T> Drop for ShutdownDeadmans<T> {
 impl<Tr> Clone for TraceAgent<Tr>
 where
     Tr: TraceReader,
-    Tr::Time: Lattice+Ord+Clone+'static,
 {
     fn clone(&self) -> Self {
 
@@ -571,7 +557,6 @@ where
 impl<Tr> Drop for TraceAgent<Tr>
 where
     Tr: TraceReader,
-    Tr::Time: Lattice+Ord+Clone+'static,
 {
     fn drop(&mut self) {
 
diff --git a/src/operators/arrange/arrangement.rs b/src/operators/arrange/arrangement.rs
index 6f640074b..788a8405c 100644
--- a/src/operators/arrange/arrangement.rs
+++ b/src/operators/arrange/arrangement.rs
@@ -18,7 +18,7 @@
 //! commit only completed data to the trace).
 
 use timely::dataflow::operators::{Enter, Map};
-use timely::order::{PartialOrder, TotalOrder};
+use timely::order::PartialOrder;
 use timely::dataflow::{Scope, Stream};
 use timely::dataflow::operators::generic::Operator;
 use timely::dataflow::channels::pact::{ParallelizationContract, Pipeline, Exchange};
@@ -62,10 +62,10 @@ where
     // returns when invoked, so as to not duplicate work with multiple calls to `as_collection`.
 }
 
-impl<G: Scope, Tr> Clone for Arranged<G, Tr>
+impl<G, Tr> Clone for Arranged<G, Tr>
 where
-    G::Timestamp: Lattice+Ord,
-    Tr: TraceReader<Time=G::Timestamp> + Clone,
+    G: Scope<Timestamp=Tr::Time>,
+    Tr: TraceReader + Clone,
 {
     fn clone(&self) -> Self {
         Arranged {
@@ -78,10 +78,10 @@ where
 use ::timely::dataflow::scopes::Child;
 use ::timely::progress::timestamp::Refines;
 
-impl<G: Scope, Tr> Arranged<G, Tr>
+impl<G, Tr> Arranged<G, Tr>
 where
-    G::Timestamp: Lattice+Ord,
-    Tr: TraceReader<Time=G::Timestamp> + Clone,
+    G: Scope<Timestamp=Tr::Time>,
+    Tr: TraceReader + Clone,
 {
     /// Brings an arranged collection into a nested scope.
     ///
@@ -91,9 +91,7 @@ where
     pub fn enter<'a, TInner>(&self, child: &Child<'a, G, TInner>)
         -> Arranged<Child<'a, G, TInner>, TraceEnter<Tr, TInner>>
         where
-            Tr::Diff: 'static,
-            G::Timestamp: Clone+'static,
-            TInner: Refines<G::Timestamp>+Lattice+Timestamp+Clone+'static,
+            TInner: Refines<G::Timestamp>+Lattice+Timestamp+Clone,
     {
         Arranged {
             stream: self.stream.enter(child).map(|bw| BatchEnter::make_from(bw)),
@@ -106,11 +104,7 @@ where
     /// This method only applies to *regions*, which are subscopes with the same timestamp
     /// as their containing scope. In this case, the trace type does not need to change.
     pub fn enter_region<'a>(&self, child: &Child<'a, G, G::Timestamp>)
-        -> Arranged<Child<'a, G, G::Timestamp>, Tr>
-        where
-            Tr::Diff: 'static,
-            G::Timestamp: Clone+'static,
-    {
+        -> Arranged<Child<'a, G, G::Timestamp>, Tr> {
         Arranged {
             stream: self.stream.enter(child),
             trace: self.trace.clone(),
@@ -125,8 +119,6 @@ where
     pub fn enter_at<'a, TInner, F, P>(&self, child: &Child<'a, G, TInner>, logic: F, prior: P)
         -> Arranged<Child<'a, G, TInner>, TraceEnterAt<Tr, TInner, F, P>>
         where
-            Tr::Diff: 'static,
-            G::Timestamp: Clone+'static,
             TInner: Refines<G::Timestamp>+Lattice+Timestamp+Clone+'static,
             F: FnMut(Tr::Key<'_>, Tr::Val<'_>, &G::Timestamp)->TInner+Clone+'static,
             P: FnMut(&TInner)->Tr::Time+Clone+'static,
@@ -168,8 +160,6 @@ where
     pub fn filter<F>(&self, logic: F)
         -> Arranged<G, TraceFilter<Tr, F>>
         where
-            Tr::Diff: 'static,
-            G::Timestamp: Clone+'static,
             F: FnMut(Tr::Key<'_>, Tr::Val<'_>)->bool+Clone+'static,
     {
         let logic1 = logic.clone();
@@ -186,7 +176,6 @@ where
     /// supplied as arguments to an operator using the same key-value structure.
     pub fn as_collection<D: Data, L>(&self, mut logic: L) -> Collection<G, D, Tr::Diff>
         where
-            Tr::Diff: Semigroup,
             L: FnMut(Tr::Key<'_>, Tr::Val<'_>) -> D+'static,
     {
         self.flat_map_ref(move |key, val| Some(logic(key,val)))
@@ -198,7 +187,6 @@ where
     /// filtering or flat mapping as part of the extraction.
     pub fn flat_map_ref<I, L>(&self, logic: L) -> Collection<G, I::Item, Tr::Diff>
         where
-            Tr::Diff: Semigroup,
             I: IntoIterator,
             I::Item: Data,
             L: FnMut(Tr::Key<'_>, Tr::Val<'_>) -> I+'static,
@@ -215,7 +203,6 @@ where
     /// If you have the arrangement, its `flat_map_ref` method is equivalent to this.
     pub fn flat_map_batches<I, L>(stream: &Stream<G, Tr::Batch>, mut logic: L) -> Collection<G, I::Item, Tr::Diff>
     where
-        Tr::Diff: Semigroup,
         I: IntoIterator,
         I::Item: Data,
         L: FnMut(Tr::Key<'_>, Tr::Val<'_>) -> I+'static,
@@ -249,10 +236,9 @@ where
     /// (key, value, time, diff) accumulations in the `self` trace.
     pub fn lookup(&self, queries: &Stream<G, (Tr::KeyOwned, G::Timestamp)>) -> Stream<G, (Tr::KeyOwned, Tr::ValOwned, G::Timestamp, Tr::Diff)>
     where
-        G::Timestamp: Data+Lattice+Ord+TotalOrder,
         Tr::KeyOwned: ExchangeData+Hashable,
         Tr::ValOwned: ExchangeData,
-        Tr::Diff: ExchangeData+Semigroup,
+        Tr::Diff: ExchangeData,
         Tr: 'static,
     {
         // while the arrangement is already correctly distributed, the query stream may not be.
@@ -408,24 +394,22 @@ where
 
 use crate::difference::Multiply;
 // Direct join implementations.
-impl<G: Scope, Tr> Arranged<G, Tr>
+impl<G, T1> Arranged<G, T1>
 where
-    G::Timestamp: Lattice+Ord,
-    Tr: TraceReader<Time=G::Timestamp> + Clone + 'static,
-    Tr::Diff: Semigroup,
+    G: Scope<Timestamp=T1::Time>,
+    T1: TraceReader + Clone + 'static,
 {
     /// A direct implementation of the `JoinCore::join_core` method.
-    pub fn join_core<Tr2,I,L>(&self, other: &Arranged<G,Tr2>, mut result: L) -> Collection<G,I::Item,<Tr::Diff as Multiply<Tr2::Diff>>::Output>
+    pub fn join_core<T2,I,L>(&self, other: &Arranged<G,T2>, mut result: L) -> Collection<G,I::Item,<T1::Diff as Multiply<T2::Diff>>::Output>
     where
-        Tr2: for<'a> TraceReader<Key<'a>=Tr::Key<'a>,Time=G::Timestamp>+Clone+'static,
-        Tr2::Diff: Semigroup,
-        Tr::Diff: Multiply<Tr2::Diff>,
-        <Tr::Diff as Multiply<Tr2::Diff>>::Output: Semigroup,
+        T2: for<'a> TraceReader<Key<'a>=T1::Key<'a>,Time=T1::Time>+Clone+'static,
+        T1::Diff: Multiply<T2::Diff>,
+        <T1::Diff as Multiply<T2::Diff>>::Output: Semigroup,
         I: IntoIterator,
         I::Item: Data,
-        L: FnMut(Tr::Key<'_>,Tr::Val<'_>,Tr2::Val<'_>)->I+'static
+        L: FnMut(T1::Key<'_>,T1::Val<'_>,T2::Val<'_>)->I+'static
     {
-        let result = move |k: Tr::Key<'_>, v1: Tr::Val<'_>, v2: Tr2::Val<'_>, t: &G::Timestamp, r1: &Tr::Diff, r2: &Tr2::Diff| {
+        let result = move |k: T1::Key<'_>, v1: T1::Val<'_>, v2: T2::Val<'_>, t: &G::Timestamp, r1: &T1::Diff, r2: &T2::Diff| {
             let t = t.clone();
             let r = (r1.clone()).multiply(r2);
             result(k, v1, v2).into_iter().map(move |d| (d, t.clone(), r.clone()))
@@ -433,14 +417,13 @@ where
         self.join_core_internal_unsafe(other, result)
     }
     /// A direct implementation of the `JoinCore::join_core_internal_unsafe` method.
-    pub fn join_core_internal_unsafe<Tr2,I,L,D,ROut> (&self, other: &Arranged<G,Tr2>, result: L) -> Collection<G,D,ROut>
+    pub fn join_core_internal_unsafe<T2,I,L,D,ROut> (&self, other: &Arranged<G,T2>, result: L) -> Collection<G,D,ROut>
     where
-        Tr2: for<'a> TraceReader<Key<'a>=Tr::Key<'a>, Time=G::Timestamp>+Clone+'static,
-        Tr2::Diff: Semigroup,
+        T2: for<'a> TraceReader<Key<'a>=T1::Key<'a>, Time=T1::Time>+Clone+'static,
         D: Data,
         ROut: Semigroup,
         I: IntoIterator<Item=(D, G::Timestamp, ROut)>,
-        L: FnMut(Tr::Key<'_>, Tr::Val<'_>,Tr2::Val<'_>,&G::Timestamp,&Tr::Diff,&Tr2::Diff)->I+'static,
+        L: FnMut(T1::Key<'_>, T1::Val<'_>,T2::Val<'_>,&G::Timestamp,&T1::Diff,&T2::Diff)->I+'static,
     {
         use crate::operators::join::join_traces;
         join_traces(self, other, result)
@@ -449,16 +432,15 @@ where
 
 // Direct reduce implementations.
 use crate::difference::Abelian;
-impl<G: Scope, T1> Arranged<G, T1>
+impl<G, T1> Arranged<G, T1>
 where
-    G::Timestamp: Lattice+Ord,
-    T1: TraceReader<Time=G::Timestamp>+Clone+'static,
-    T1::Diff: Semigroup,
+    G: Scope<Timestamp = T1::Time>,
+    T1: TraceReader + Clone + 'static,
 {
     /// A direct implementation of `ReduceCore::reduce_abelian`.
     pub fn reduce_abelian<L, T2>(&self, name: &str, mut logic: L) -> Arranged<G, TraceAgent<T2>>
     where
-        T2: for<'a> Trace<Key<'a>= T1::Key<'a>, Time=G::Timestamp>+'static,
+        T2: for<'a> Trace<Key<'a>= T1::Key<'a>, Time=T1::Time>+'static,
         T2::ValOwned: Data,
         T2::Diff: Abelian,
         T2::Batch: Batch,
@@ -477,9 +459,8 @@ where
     /// A direct implementation of `ReduceCore::reduce_core`.
     pub fn reduce_core<L, T2>(&self, name: &str, logic: L) -> Arranged<G, TraceAgent<T2>>
     where
-        T2: for<'a> Trace<Key<'a>=T1::Key<'a>, Time=G::Timestamp>+'static,
+        T2: for<'a> Trace<Key<'a>=T1::Key<'a>, Time=T1::Time>+'static,
         T2::ValOwned: Data,
-        T2::Diff: Semigroup,
         T2::Batch: Batch,
         T2::Builder: Builder<Output=T2::Batch, Item = ((T1::KeyOwned, T2::ValOwned), T2::Time, T2::Diff)>,
         L: FnMut(T1::Key<'_>, &[(T1::Val<'_>, T1::Diff)], &mut Vec<(<T2::Cursor as Cursor>::ValOwned,T2::Diff)>, &mut Vec<(<T2::Cursor as Cursor>::ValOwned, T2::Diff)>)+'static,
@@ -490,10 +471,10 @@ where
 }
 
 
-impl<'a, G: Scope, Tr> Arranged<Child<'a, G, G::Timestamp>, Tr>
+impl<'a, G, Tr> Arranged<Child<'a, G, G::Timestamp>, Tr>
 where
-    G::Timestamp: Lattice+Ord,
-    Tr: TraceReader<Time=G::Timestamp> + Clone,
+    G: Scope<Timestamp=Tr::Time>,
+    Tr: TraceReader + Clone,
 {
     /// Brings an arranged collection out of a nested region.
     ///
diff --git a/src/operators/arrange/upsert.rs b/src/operators/arrange/upsert.rs
index 4ad592f9a..e9d1744ff 100644
--- a/src/operators/arrange/upsert.rs
+++ b/src/operators/arrange/upsert.rs
@@ -108,7 +108,6 @@ use timely::progress::Timestamp;
 use timely::progress::Antichain;
 use timely::dataflow::operators::Capability;
 
-use crate::lattice::Lattice;
 use crate::operators::arrange::arrangement::Arranged;
 use crate::trace::Builder;
 use crate::trace::{self, Trace, TraceReader, Batch, Cursor};
@@ -131,11 +130,11 @@ pub fn arrange_from_upsert<G, Tr>(
     name: &str,
 ) -> Arranged<G, TraceAgent<Tr>>
 where
-    G: Scope,
-    G::Timestamp: Lattice+Ord+TotalOrder+ExchangeData,
+    G: Scope<Timestamp=Tr::Time>,
+    Tr: Trace+TraceReader<Diff=isize>+'static,
     Tr::KeyOwned: ExchangeData+Hashable+std::hash::Hash,
     Tr::ValOwned: ExchangeData,
-    Tr: Trace+TraceReader<Time=G::Timestamp,Diff=isize>+'static,
+    Tr::Time: TotalOrder+ExchangeData,
     Tr::Batch: Batch,
     Tr::Builder: Builder<Item = ((Tr::KeyOwned, Tr::ValOwned), Tr::Time, Tr::Diff)>,
 {
diff --git a/src/operators/arrange/writer.rs b/src/operators/arrange/writer.rs
index 5792a7a0f..acc049d30 100644
--- a/src/operators/arrange/writer.rs
+++ b/src/operators/arrange/writer.rs
@@ -8,7 +8,6 @@ use std::cell::RefCell;
 
 use timely::progress::{Antichain, Timestamp};
 
-use crate::lattice::Lattice;
 use crate::trace::{Trace, Batch, BatchReader};
 use crate::trace::wrappers::rc::TraceBox;
 
@@ -23,7 +22,6 @@ use super::TraceReplayInstruction;
 pub struct TraceWriter<Tr>
 where
     Tr: Trace,
-    Tr::Time: Lattice+Timestamp+Ord+Clone+std::fmt::Debug+'static,
     Tr::Batch: Batch,
 {
     /// Current upper limit.
@@ -37,7 +35,6 @@ where
 impl<Tr> TraceWriter<Tr>
 where
     Tr: Trace,
-    Tr::Time: Lattice+Timestamp+Ord+Clone+std::fmt::Debug+'static,
     Tr::Batch: Batch,
 {
     /// Creates a new `TraceWriter`.
@@ -107,7 +104,6 @@ where
 impl<Tr> Drop for TraceWriter<Tr>
 where
     Tr: Trace,
-    Tr::Time: Lattice+Timestamp+Ord+Clone+std::fmt::Debug+'static,
     Tr::Batch: Batch,
 {
     fn drop(&mut self) {
diff --git a/src/operators/count.rs b/src/operators/count.rs
index d03be592a..0779bde06 100644
--- a/src/operators/count.rs
+++ b/src/operators/count.rs
@@ -50,12 +50,13 @@ where G::Timestamp: TotalOrder+Lattice+Ord {
     }
 }
 
-impl<G: Scope, T1> CountTotal<G, T1::KeyOwned, T1::Diff> for Arranged<G, T1>
+impl<G, T1> CountTotal<G, T1::KeyOwned, T1::Diff> for Arranged<G, T1>
 where
-    G::Timestamp: TotalOrder+Lattice+Ord,
-    T1: for<'a> TraceReader<Val<'a>=&'a (), Time=G::Timestamp>+Clone+'static,
+    G: Scope<Timestamp=T1::Time>,
+    T1: for<'a> TraceReader<Val<'a>=&'a ()>+Clone+'static,
     T1::KeyOwned: ExchangeData,
-    T1::Diff: ExchangeData+Semigroup,
+    T1::Time: TotalOrder,
+    T1::Diff: ExchangeData,
 {
     fn count_total_core<R2: Semigroup + From<i8>>(&self) -> Collection<G, (T1::KeyOwned, T1::Diff), R2> {
 
diff --git a/src/operators/join.rs b/src/operators/join.rs
index 62156cecb..ee1c28724 100644
--- a/src/operators/join.rs
+++ b/src/operators/join.rs
@@ -163,12 +163,10 @@ where
 
 impl<G, K, V, Tr> Join<G, K, V, Tr::Diff> for Arranged<G, Tr>
 where
-    G: Scope,
-    G::Timestamp: Lattice+Ord,
-    Tr: for<'a> TraceReader<Time=G::Timestamp, Key<'a> = &'a K, Val<'a> = &'a V>+Clone+'static,
+    G: Scope<Timestamp=Tr::Time>,
+    Tr: for<'a> TraceReader<Key<'a> = &'a K, Val<'a> = &'a V>+Clone+'static,
     K: ExchangeData+Hashable,
     V: Data + 'static,
-    Tr::Diff: Semigroup,
 {
     fn join_map<V2: ExchangeData, R2: ExchangeData+Semigroup, D: Data, L>(&self, other: &Collection<G, (K, V2), R2>, mut logic: L) -> Collection<G, D, <Tr::Diff as Multiply<R2>>::Output>
     where 
@@ -233,7 +231,6 @@ pub trait JoinCore<G: Scope, K: 'static + ?Sized, V: 'static + ?Sized, R: Semigr
     fn join_core<Tr2,I,L> (&self, stream2: &Arranged<G,Tr2>, result: L) -> Collection<G,I::Item,<R as Multiply<Tr2::Diff>>::Output>
     where
         Tr2: for<'a> TraceReader<Key<'a>=&'a K, Time=G::Timestamp>+Clone+'static,
-        Tr2::Diff: Semigroup,
         R: Multiply<Tr2::Diff>,
         <R as Multiply<Tr2::Diff>>::Output: Semigroup,
         I: IntoIterator,
@@ -277,7 +274,6 @@ pub trait JoinCore<G: Scope, K: 'static + ?Sized, V: 'static + ?Sized, R: Semigr
     fn join_core_internal_unsafe<Tr2,I,L,D,ROut> (&self, stream2: &Arranged<G,Tr2>, result: L) -> Collection<G,D,ROut>
     where
         Tr2: for<'a> TraceReader<Key<'a>=&'a K, Time=G::Timestamp>+Clone+'static,
-        Tr2::Diff: Semigroup,
         D: Data,
         ROut: Semigroup,
         I: IntoIterator<Item=(D, G::Timestamp, ROut)>,
@@ -297,7 +293,6 @@ where
     fn join_core<Tr2,I,L> (&self, stream2: &Arranged<G,Tr2>, result: L) -> Collection<G,I::Item,<R as Multiply<Tr2::Diff>>::Output>
     where
         Tr2: for<'a> TraceReader<Key<'a>=&'a K, Time=G::Timestamp>+Clone+'static,
-        Tr2::Diff: Semigroup,
         R: Multiply<Tr2::Diff>,
         <R as Multiply<Tr2::Diff>>::Output: Semigroup,
         I: IntoIterator,
@@ -311,7 +306,6 @@ where
     fn join_core_internal_unsafe<Tr2,I,L,D,ROut> (&self, stream2: &Arranged<G,Tr2>, result: L) -> Collection<G,D,ROut>
     where
         Tr2: for<'a> TraceReader<Key<'a>=&'a K, Time=G::Timestamp>+Clone+'static,
-        Tr2::Diff: Semigroup,
         I: IntoIterator<Item=(D, G::Timestamp, ROut)>,
         L: FnMut(&K,&V,Tr2::Val<'_>,&G::Timestamp,&R,&Tr2::Diff)->I+'static,
         D: Data,
@@ -331,12 +325,9 @@ where
 /// The "correctness" of this method depends heavily on the behavior of the supplied `result` function.
 pub fn join_traces<G, T1, T2, I,L,D,R>(arranged1: &Arranged<G,T1>, arranged2: &Arranged<G,T2>, mut result: L) -> Collection<G, D, R>
 where
-    G: Scope,
-    G::Timestamp: Lattice+Ord,
-    T1: TraceReader<Time=G::Timestamp>+Clone+'static,
-    T1::Diff: Semigroup,
-    T2: for<'a> TraceReader<Key<'a>=T1::Key<'a>, Time=G::Timestamp>+Clone+'static,
-    T2::Diff: Semigroup,
+    G: Scope<Timestamp=T1::Time>,
+    T1: TraceReader+Clone+'static,
+    T2: for<'a> TraceReader<Key<'a>=T1::Key<'a>, Time=T1::Time>+Clone+'static,
     D: Data,
     R: Semigroup,
     I: IntoIterator<Item=(D, G::Timestamp, R)>,
@@ -589,8 +580,6 @@ where
     R: Semigroup,
     C1: Cursor<Time=T>,
     C2: for<'a> Cursor<Key<'a>=C1::Key<'a>, Time=T>,
-    C1::Diff: Semigroup,
-    C2::Diff: Semigroup,
     D: Ord+Clone+Data,
 {
     trace: C1,
@@ -606,8 +595,6 @@ impl<T, R, C1, C2, D> Deferred<T, R, C1, C2, D>
 where
     C1: Cursor<Time=T>,
     C2: for<'a> Cursor<Key<'a>=C1::Key<'a>, Time=T>,
-    C1::Diff: Semigroup,
-    C2::Diff: Semigroup,
     T: Timestamp+Lattice+Ord,
     R: Semigroup,
     D: Clone+Data,
@@ -702,9 +689,6 @@ struct JoinThinker<'a, C1, C2>
 where
     C1: Cursor,
     C2: Cursor<Time = C1::Time>,
-    C1::Time: Lattice+Ord+Clone,
-    C1::Diff: Semigroup,
-    C2::Diff: Semigroup,
 {
     pub history1: ValueHistory<'a, C1>,
     pub history2: ValueHistory<'a, C2>,
@@ -714,9 +698,6 @@ impl<'a, C1, C2> JoinThinker<'a, C1, C2>
 where
     C1: Cursor,
     C2: Cursor<Time = C1::Time>,
-    C1::Time: Lattice+Ord+Clone,
-    C1::Diff: Semigroup,
-    C2::Diff: Semigroup,
 {
     fn new() -> Self {
         JoinThinker {
diff --git a/src/operators/mod.rs b/src/operators/mod.rs
index 66c85d00a..47b370a38 100644
--- a/src/operators/mod.rs
+++ b/src/operators/mod.rs
@@ -18,17 +18,16 @@ pub mod join;
 pub mod count;
 pub mod threshold;
 
-use crate::difference::Semigroup;
 use crate::lattice::Lattice;
 use crate::trace::Cursor;
 
 /// An accumulation of (value, time, diff) updates.
-struct EditList<'a, C: Cursor> where C::Time: Sized, C::Diff: Sized {
+struct EditList<'a, C: Cursor> {
     values: Vec<(C::Val<'a>, usize)>,
     edits: Vec<(C::Time, C::Diff)>,
 }
 
-impl<'a, C: Cursor> EditList<'a, C> where C::Time: Ord+Clone, C::Diff: Semigroup {
+impl<'a, C: Cursor> EditList<'a, C> {
     /// Creates an empty list of edits.
     #[inline]
     fn new() -> Self {
@@ -82,18 +81,13 @@ impl<'a, C: Cursor> EditList<'a, C> where C::Time: Ord+Clone, C::Diff: Semigroup
     }
 }
 
-struct ValueHistory<'storage, C: Cursor> where C::Time: Sized, C::Diff: Sized {
-
+struct ValueHistory<'storage, C: Cursor> {
     edits: EditList<'storage, C>,
     history: Vec<(C::Time, C::Time, usize, usize)>,     // (time, meet, value_index, edit_offset)
     buffer: Vec<((C::Val<'storage>, C::Time), C::Diff)>,   // where we accumulate / collapse updates.
 }
 
-impl<'storage, C: Cursor> ValueHistory<'storage, C>
-where
-    C::Time: Lattice+Ord+Clone,
-    C::Diff: Semigroup,
-{
+impl<'storage, C: Cursor> ValueHistory<'storage, C> {
     fn new() -> Self {
         ValueHistory {
             edits: EditList::new(),
@@ -159,23 +153,11 @@ where
     }
 }
 
-struct HistoryReplay<'storage, 'history, C>
-where
-    'storage: 'history,
-    C: Cursor,
-    C::Time: Lattice+Ord+Clone+'history,
-    C::Diff: Semigroup+'history,
-{
+struct HistoryReplay<'storage, 'history, C: Cursor> {
     replay: &'history mut ValueHistory<'storage, C>
 }
 
-impl<'storage, 'history, C> HistoryReplay<'storage, 'history, C>
-where
-    'storage: 'history,
-    C: Cursor,
-    C::Time: Lattice+Ord+Clone+'history,
-    C::Diff: Semigroup+'history,
-{
+impl<'storage, 'history, C: Cursor> HistoryReplay<'storage, 'history, C> {
     fn time(&self) -> Option<&C::Time> { self.replay.history.last().map(|x| &x.0) }
     fn meet(&self) -> Option<&C::Time> { self.replay.history.last().map(|x| &x.1) }
     fn edit(&self) -> Option<(C::Val<'storage>, &C::Time, &C::Diff)> {
diff --git a/src/operators/reduce.rs b/src/operators/reduce.rs
index 3dd66a917..7f322c00e 100644
--- a/src/operators/reduce.rs
+++ b/src/operators/reduce.rs
@@ -80,10 +80,10 @@ impl<G, K, V, R> Reduce<G, K, V, R> for Collection<G, (K, V), R>
     }
 }
 
-impl<G: Scope, K: Data, V: Data, T1, R: Semigroup> Reduce<G, K, V, R> for Arranged<G, T1>
+impl<G, K: Data, V: Data, T1, R: Semigroup> Reduce<G, K, V, R> for Arranged<G, T1>
 where
-    G::Timestamp: Lattice+Ord,
-    T1: for<'a> TraceReader<Key<'a>=&'a K, KeyOwned=K, Val<'a>=&'a V, Time=G::Timestamp, Diff=R>+Clone+'static,
+    G: Scope<Timestamp=T1::Time>,
+    T1: for<'a> TraceReader<Key<'a>=&'a K, KeyOwned=K, Val<'a>=&'a V, Diff=R>+Clone+'static,
 {
     fn reduce_named<L, V2: Data, R2: Abelian>(&self, name: &str, logic: L) -> Collection<G, (K, V2), R2>
         where L: FnMut(&K, &[(&V, R)], &mut Vec<(V2, R2)>)+'static {
@@ -157,10 +157,10 @@ where G::Timestamp: Lattice+Ord {
     }
 }
 
-impl<G: Scope, K: Data, T1, R1: Semigroup> Threshold<G, K, R1> for Arranged<G, T1>
+impl<G, K: Data, T1, R1: Semigroup> Threshold<G, K, R1> for Arranged<G, T1>
 where
-    G::Timestamp: Lattice+Ord,
-    T1: for<'a> TraceReader<Key<'a>=&'a K, KeyOwned=K, Val<'a>=&'a (), Time=G::Timestamp, Diff=R1>+Clone+'static,
+    G: Scope<Timestamp=T1::Time>,
+    T1: for<'a> TraceReader<Key<'a>=&'a K, KeyOwned=K, Val<'a>=&'a (), Diff=R1>+Clone+'static,
 {
     fn threshold_named<R2: Abelian, F: FnMut(&K,&R1)->R2+'static>(&self, name: &str, mut thresh: F) -> Collection<G, K, R2> {
         self.reduce_abelian::<_,KeySpine<_,_,_>>(name, move |k,s,t| t.push(((), thresh(k, &s[0].1))))
@@ -207,10 +207,10 @@ where
     }
 }
 
-impl<G: Scope, K: Data, T1, R: Semigroup> Count<G, K, R> for Arranged<G, T1>
+impl<G, K: Data, T1, R: Semigroup> Count<G, K, R> for Arranged<G, T1>
 where
-    G::Timestamp: Lattice+Ord,
-    T1: for<'a> TraceReader<Key<'a>=&'a K, KeyOwned=K, Val<'a>=&'a (), Time=G::Timestamp, Diff=R>+Clone+'static,
+    G: Scope<Timestamp=T1::Time>,
+    T1: for<'a> TraceReader<Key<'a>=&'a K, KeyOwned=K, Val<'a>=&'a (), Diff=R>+Clone+'static,
 {
     fn count_core<R2: Abelian + From<i8>>(&self) -> Collection<G, (K, R), R2> {
         self.reduce_abelian::<_,ValSpine<_,_,_,_>>("Count", |_k,s,t| t.push((s[0].1.clone(), R2::from(1i8))))
@@ -272,7 +272,6 @@ pub trait ReduceCore<G: Scope, K: ToOwned + ?Sized, V: ToOwned + ?Sized, R: Semi
         where
             T2: for<'a> Trace<Key<'a>=&'a K, Time=G::Timestamp>+'static,
             T2::ValOwned: Data,
-            T2::Diff: Semigroup,
             T2::Batch: Batch,
             T2::Builder: Builder<Output=T2::Batch, Item = ((K::Owned, T2::ValOwned), T2::Time, T2::Diff)>,
             L: FnMut(&K, &[(&V, R)], &mut Vec<(<T2::Cursor as Cursor>::ValOwned,T2::Diff)>, &mut Vec<(<T2::Cursor as Cursor>::ValOwned, T2::Diff)>)+'static,
@@ -291,7 +290,6 @@ where
     fn reduce_core<L, T2>(&self, name: &str, logic: L) -> Arranged<G, TraceAgent<T2>>
         where
             T2::ValOwned: Data,
-            T2::Diff: Semigroup,
             T2: for<'a> Trace<Key<'a>=&'a K, Time=G::Timestamp>+'static,
             T2::Batch: Batch,
             T2::Builder: Builder<Output=T2::Batch, Item = ((K::Owned, T2::ValOwned), T2::Time, T2::Diff)>,
@@ -307,13 +305,10 @@ where
 /// This method exists to provide reduce functionality without opinions about qualifying trace types.
 pub fn reduce_trace<G, T1, T2, L>(trace: &Arranged<G, T1>, name: &str, mut logic: L) -> Arranged<G, TraceAgent<T2>>
 where
-    G: Scope,
-    G::Timestamp: Lattice+Ord,
-    T1: TraceReader<Time=G::Timestamp> + Clone + 'static,
-    T1::Diff: Semigroup,
-    T2: for<'a> Trace<Key<'a>=T1::Key<'a>, Time=G::Timestamp> + 'static,
+    G: Scope<Timestamp=T1::Time>,
+    T1: TraceReader + Clone + 'static,
+    T2: for<'a> Trace<Key<'a>=T1::Key<'a>, Time=T1::Time> + 'static,
     T2::ValOwned: Data,
-    T2::Diff: Semigroup,
     T2::Batch: Batch,
     T2::Builder: Builder<Output=T2::Batch, Item = ((T1::KeyOwned, T2::ValOwned), T2::Time, T2::Diff)>,
     L: FnMut(T1::Key<'_>, &[(T1::Val<'_>, T1::Diff)], &mut Vec<(T2::ValOwned,T2::Diff)>, &mut Vec<(T2::ValOwned, T2::Diff)>)+'static,
@@ -632,10 +627,6 @@ where
     C1: Cursor,
     C2: Cursor<Key<'a> = C1::Key<'a>, Time = C1::Time>,
     C3: Cursor<Key<'a> = C1::Key<'a>, Val<'a> = C1::Val<'a>, Time = C1::Time, Diff = C1::Diff>,
-    C2::ValOwned: Ord + Clone,
-    C1::Time: Lattice+Ord+Clone,
-    C1::Diff: Semigroup,
-    C2::Diff: Semigroup,
 {
     fn new() -> Self;
     fn compute<L>(
@@ -662,7 +653,6 @@ where
 /// Implementation based on replaying historical and new updates together.
 mod history_replay {
 
-    use crate::difference::Semigroup;
     use crate::lattice::Lattice;
     use crate::trace::Cursor;
     use crate::operators::ValueHistory;
@@ -674,15 +664,11 @@ mod history_replay {
 
     /// The `HistoryReplayer` is a compute strategy based on moving through existing inputs, interesting times, etc in
     /// time order, maintaining consolidated representations of updates with respect to future interesting times.
-    pub struct HistoryReplayer<'a, C1, C2, C3>//V1, V2, T, R1, R2>
+    pub struct HistoryReplayer<'a, C1, C2, C3>
     where
         C1: Cursor,
         C2: Cursor<Key<'a> = C1::Key<'a>, Time = C1::Time>,
         C3: Cursor<Key<'a> = C1::Key<'a>, Val<'a> = C1::Val<'a>, Time = C1::Time, Diff = C1::Diff>,
-        C2::ValOwned: Ord + Clone,
-        C1::Time: Lattice+Ord+Clone,
-        C1::Diff: Semigroup,
-        C2::Diff: Semigroup,
     {
         input_history: ValueHistory<'a, C1>,
         output_history: ValueHistory<'a, C2>,
@@ -702,10 +688,6 @@ mod history_replay {
         C1: Cursor,
         C2: Cursor<Key<'a> = C1::Key<'a>, Time = C1::Time>,
         C3: Cursor<Key<'a> = C1::Key<'a>, Val<'a> = C1::Val<'a>, Time = C1::Time, Diff = C1::Diff>,
-        C2::ValOwned: Ord + Clone,
-        C1::Time: Lattice+Ord+Clone,
-        C1::Diff: Semigroup,
-        C2::Diff: Semigroup,
     {
         fn new() -> Self {
             HistoryReplayer {
diff --git a/src/operators/threshold.rs b/src/operators/threshold.rs
index 86f60a0fc..1358d8e3b 100644
--- a/src/operators/threshold.rs
+++ b/src/operators/threshold.rs
@@ -92,12 +92,13 @@ where G::Timestamp: TotalOrder+Lattice+Ord {
     }
 }
 
-impl<G: Scope, K, T1> ThresholdTotal<G, K, T1::Diff> for Arranged<G, T1>
+impl<G, K, T1> ThresholdTotal<G, K, T1::Diff> for Arranged<G, T1>
 where
-    G::Timestamp: TotalOrder+Lattice+Ord,
-    T1: for<'a> TraceReader<Key<'a>=&'a K, Val<'a>=&'a (), Time=G::Timestamp>+Clone+'static,
+    G: Scope<Timestamp=T1::Time>,
+    T1: for<'a> TraceReader<Key<'a>=&'a K, Val<'a>=&'a ()>+Clone+'static,
     K: ExchangeData,
-    T1::Diff: ExchangeData+Semigroup,
+    T1::Time: TotalOrder,
+    T1::Diff: ExchangeData,
 {
     fn threshold_semigroup<R2, F>(&self, mut thresh: F) -> Collection<G, K, R2>
     where
diff --git a/src/trace/cursor/mod.rs b/src/trace/cursor/mod.rs
index 1f4dbb74c..46fb4a6ba 100644
--- a/src/trace/cursor/mod.rs
+++ b/src/trace/cursor/mod.rs
@@ -5,6 +5,10 @@
 //! 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).
 
+use timely::progress::Timestamp;
+use crate::difference::Semigroup;
+use crate::lattice::Lattice;
+
 pub mod cursor_list;
 
 pub use self::cursor_list::CursorList;
@@ -63,9 +67,9 @@ pub trait Cursor {
     /// Owned version of the above.
     type ValOwned: Ord + Clone;
     /// Timestamps associated with updates
-    type Time;
+    type Time: Timestamp + Lattice + Ord + Clone;
     /// Associated update.
-    type Diff: ?Sized;
+    type Diff: Semigroup + ?Sized;
 
     /// Storage required by the cursor.
     type Storage;
@@ -117,11 +121,7 @@ pub trait Cursor {
     fn rewind_vals(&mut self, storage: &Self::Storage);
 
     /// Rewinds the cursor and outputs its contents to a Vec
-    fn to_vec(&mut self, storage: &Self::Storage) -> Vec<((Self::KeyOwned, Self::ValOwned), Vec<(Self::Time, Self::Diff)>)>
-    where
-        Self::Time: Clone,
-        Self::Diff: Clone,
-    {
+    fn to_vec(&mut self, storage: &Self::Storage) -> Vec<((Self::KeyOwned, Self::ValOwned), Vec<(Self::Time, Self::Diff)>)> {
         let mut out = Vec::new();
         self.rewind_keys(storage);
         self.rewind_vals(storage);
diff --git a/src/trace/implementations/mod.rs b/src/trace/implementations/mod.rs
index f908df3a6..199c1c170 100644
--- a/src/trace/implementations/mod.rs
+++ b/src/trace/implementations/mod.rs
@@ -108,9 +108,6 @@ impl<U: Update> Layout for Vector<U>
 where
     U::Key: 'static,
     U::Val: 'static,
-// where
-//     U::Key: ToOwned<Owned = U::Key> + Sized + Clone + 'static,
-//     U::Val: ToOwned<Owned = U::Val> + Sized + Clone + 'static,
 {
     type Target = U;
     type KeyContainer = Vec<U::Key>;
diff --git a/src/trace/implementations/spine_fueled.rs b/src/trace/implementations/spine_fueled.rs
index 13271712a..9ddc2952b 100644
--- a/src/trace/implementations/spine_fueled.rs
+++ b/src/trace/implementations/spine_fueled.rs
@@ -69,11 +69,7 @@
 //! have paid back any "debt" to higher layers by continuing to provide fuel as updates arrive.
 
 
-use std::fmt::Debug;
-
 use crate::logging::Logger;
-use crate::difference::Semigroup;
-use crate::lattice::Lattice;
 use crate::trace::{Batch, Batcher, Builder, BatchReader, Trace, TraceReader, ExertionLogic};
 use crate::trace::cursor::CursorList;
 use crate::trace::Merger;
@@ -89,8 +85,6 @@ use ::timely::order::PartialOrder;
 /// other immutable collections.
 pub struct Spine<B: Batch, BA, BU>
 where
-    B::Time: Lattice+Ord,
-    B::Diff: Semigroup,
     // Intended constraints:
     // BA: Batcher<Time = B::Time>,
     // BU: Builder<Item=BA::Item, Time=BA::Time, Output = B>,
@@ -112,8 +106,6 @@ where
 impl<B, BA, BU> TraceReader for Spine<B, BA, BU>
 where
     B: Batch+Clone+'static,
-    B::Time: Lattice+timely::progress::Timestamp+Ord+Clone+Debug,
-    B::Diff: Semigroup,
 {
     type Key<'a> = B::Key<'a>;
     type KeyOwned = B::KeyOwned;
@@ -260,8 +252,6 @@ where
 impl<B, BA, BU> Trace for Spine<B, BA, BU>
 where
     B: Batch+Clone+'static,
-    B::Time: Lattice+timely::progress::Timestamp+Ord+Clone+Debug,
-    B::Diff: Semigroup,
     BA: Batcher<Time = B::Time>,
     BU: Builder<Item=BA::Item, Time=BA::Time, Output = B>,
 {
@@ -340,24 +330,14 @@ where
 }
 
 // Drop implementation allows us to log batch drops, to zero out maintained totals.
-impl<B, BA, BU> Drop for Spine<B, BA, BU>
-where
-    B: Batch,
-    B::Time: Lattice+Ord,
-    B::Diff: Semigroup,
-{
+impl<B: Batch, BA, BU> Drop for Spine<B, BA, BU> {
     fn drop(&mut self) {
         self.drop_batches();
     }
 }
 
 
-impl<B, BA, BU> Spine<B, BA, BU>
-where
-    B: Batch,
-    B::Time: Lattice+Ord,
-    B::Diff: Semigroup,
-{
+impl<B: Batch, BA, BU> Spine<B, BA, BU> {
     /// Drops and logs batches. Used in `set_logical_compaction` and drop.
     fn drop_batches(&mut self) {
         if let Some(logger) = &self.logger {
@@ -398,12 +378,7 @@ where
     }
 }
 
-impl<B, BA, BU> Spine<B, BA, BU>
-where
-    B: Batch,
-    B::Time: Lattice+timely::progress::Timestamp+Ord+Clone+Debug,
-    B::Diff: Semigroup,
-{
+impl<B: Batch, BA, BU> Spine<B, BA, BU> {
     /// Determine the amount of effort we should exert in the absence of updates.
     ///
     /// This method prepares an iterator over batches, including the level, count, and length of each layer.
diff --git a/src/trace/mod.rs b/src/trace/mod.rs
index 98ae340cc..670a4568f 100644
--- a/src/trace/mod.rs
+++ b/src/trace/mod.rs
@@ -17,7 +17,8 @@ use timely::progress::{Antichain, frontier::AntichainRef};
 use timely::progress::Timestamp;
 
 use crate::trace::cursor::MyTrait;
-
+use crate::difference::Semigroup;
+use crate::lattice::Lattice;
 // use ::difference::Semigroup;
 pub use self::cursor::Cursor;
 pub use self::description::Description;
@@ -56,9 +57,9 @@ pub trait TraceReader {
     /// Owned version of the above.
     type ValOwned: Ord + Clone;
     /// Timestamps associated with updates
-    type Time;
+    type Time: Timestamp + Lattice + Ord + Clone;
     /// Associated update.
-    type Diff;
+    type Diff: Semigroup;
 
     /// The type of an immutable collection of updates.
     type Batch: for<'a> BatchReader<Key<'a> = Self::Key<'a>, KeyOwned = Self::KeyOwned, Val<'a> = Self::Val<'a>, ValOwned = Self::ValOwned, Time = Self::Time, Diff = Self::Diff>+Clone+'static;
@@ -172,10 +173,7 @@ pub trait TraceReader {
     ///
     ///
     #[inline]
-    fn read_upper(&mut self, target: &mut Antichain<Self::Time>)
-    where
-        Self::Time: Timestamp,
-    {
+    fn read_upper(&mut self, target: &mut Antichain<Self::Time>) {
         target.clear();
         target.insert(<Self::Time as timely::progress::Timestamp>::minimum());
         self.map_batches(|batch| {
@@ -189,10 +187,7 @@ pub trait TraceReader {
     /// contents of `upper` will advance `upper` to `batch.upper`.
     /// Taken across all batches, this should advance `upper` across
     /// empty batch regions.
-    fn advance_upper(&mut self, upper: &mut Antichain<Self::Time>)
-    where
-        Self::Time: Timestamp,
-    {
+    fn advance_upper(&mut self, upper: &mut Antichain<Self::Time>) {
         self.map_batches(|batch| {
             if batch.is_empty() && batch.lower() == upper {
                 upper.clone_from(batch.upper());
@@ -270,9 +265,9 @@ where
     /// Owned version of the above.
     type ValOwned: Ord + Clone;
     /// Timestamps associated with updates
-    type Time: Timestamp;
+    type Time: Timestamp + Lattice + Ord + Clone;
     /// Associated update.
-    type Diff;
+    type Diff: Semigroup;
 
     /// The type used to enumerate the batch's contents.
     type Cursor: for<'a> Cursor<Storage=Self, Key<'a> = Self::Key<'a>, KeyOwned = Self::KeyOwned, Val<'a> = Self::Val<'a>, ValOwned = Self::ValOwned, Time = Self::Time, Diff = Self::Diff>;
diff --git a/src/trace/wrappers/enter.rs b/src/trace/wrappers/enter.rs
index 374246218..49f3a1823 100644
--- a/src/trace/wrappers/enter.rs
+++ b/src/trace/wrappers/enter.rs
@@ -2,7 +2,6 @@
 
 // use timely::progress::nested::product::Product;
 use timely::progress::timestamp::Refines;
-use timely::progress::Timestamp;
 use timely::progress::{Antichain, frontier::AntichainRef};
 
 use crate::lattice::Lattice;
@@ -10,19 +9,13 @@ use crate::trace::{TraceReader, BatchReader, Description};
 use crate::trace::cursor::Cursor;
 
 /// Wrapper to provide trace to nested scope.
-pub struct TraceEnter<Tr, TInner>
-where
-    Tr: TraceReader,
-{
+pub struct TraceEnter<Tr: TraceReader, TInner> {
     trace: Tr,
     stash1: Antichain<Tr::Time>,
     stash2: Antichain<TInner>,
 }
 
-impl<Tr,TInner> Clone for TraceEnter<Tr, TInner>
-where
-    Tr: TraceReader+Clone,
-{
+impl<Tr: TraceReader + Clone, TInner> Clone for TraceEnter<Tr, TInner> {
     fn clone(&self) -> Self {
         TraceEnter {
             trace: self.trace.clone(),
@@ -36,8 +29,6 @@ impl<Tr, TInner> TraceReader for TraceEnter<Tr, TInner>
 where
     Tr: TraceReader,
     Tr::Batch: Clone,
-    Tr::Time: Timestamp,
-    Tr::Diff: 'static,
     TInner: Refines<Tr::Time>+Lattice,
 {
     type Key<'a> = Tr::Key<'a>;
@@ -99,7 +90,6 @@ where
 impl<Tr, TInner> TraceEnter<Tr, TInner>
 where
     Tr: TraceReader,
-    Tr::Time: Timestamp,
     TInner: Refines<Tr::Time>+Lattice,
 {
     /// Makes a new trace wrapper
@@ -123,7 +113,6 @@ pub struct BatchEnter<B, TInner> {
 impl<B, TInner> BatchReader for BatchEnter<B, TInner>
 where
     B: BatchReader,
-    B::Time: Timestamp,
     TInner: Refines<B::Time>+Lattice,
 {
     type Key<'a> = B::Key<'a>;
@@ -145,7 +134,6 @@ where
 impl<B, TInner> BatchEnter<B, TInner>
 where
     B: BatchReader,
-    B::Time: Timestamp,
     TInner: Refines<B::Time>+Lattice,
 {
     /// Makes a new batch wrapper
@@ -179,7 +167,6 @@ impl<C, TInner> CursorEnter<C, TInner> {
 impl<C, TInner> Cursor for CursorEnter<C, TInner>
 where
     C: Cursor,
-    C::Time: Timestamp,
     TInner: Refines<C::Time>+Lattice,
 {
     type Key<'a> = C::Key<'a>;
@@ -233,7 +220,6 @@ impl<C, TInner> BatchCursorEnter<C, TInner> {
 
 impl<TInner, C: Cursor> Cursor for BatchCursorEnter<C, TInner>
 where
-    C::Time: Timestamp,
     TInner: Refines<C::Time>+Lattice,
 {
     type Key<'a> = C::Key<'a>;
diff --git a/src/trace/wrappers/enter_at.rs b/src/trace/wrappers/enter_at.rs
index 0b39d7174..7f67234d9 100644
--- a/src/trace/wrappers/enter_at.rs
+++ b/src/trace/wrappers/enter_at.rs
@@ -1,7 +1,6 @@
 //! Wrappers to provide trace access to nested scopes.
 
 use timely::progress::timestamp::Refines;
-use timely::progress::Timestamp;
 use timely::progress::{Antichain, frontier::AntichainRef};
 
 use crate::lattice::Lattice;
@@ -16,10 +15,7 @@ use crate::trace::cursor::Cursor;
 /// and which will be applied to compaction frontiers as they are communicated
 /// back to the wrapped traces. A better explanation is pending, and until that
 /// happens use this construct at your own peril!
-pub struct TraceEnter<Tr, TInner, F, G>
-where
-    Tr: TraceReader,
-{
+pub struct TraceEnter<Tr: TraceReader, TInner, F, G> {
     trace: Tr,
     stash1: Antichain<Tr::Time>,
     stash2: Antichain<TInner>,
@@ -48,9 +44,7 @@ impl<Tr, TInner, F, G> TraceReader for TraceEnter<Tr, TInner, F, G>
 where
     Tr: TraceReader,
     Tr::Batch: Clone,
-    Tr::Time: Timestamp,
     TInner: Refines<Tr::Time>+Lattice,
-    Tr::Diff: 'static,
     F: 'static,
     F: FnMut(Tr::Key<'_>, Tr::Val<'_>, &Tr::Time)->TInner+Clone,
     G: FnMut(&TInner)->Tr::Time+Clone+'static,
@@ -115,7 +109,6 @@ where
 impl<Tr, TInner, F, G> TraceEnter<Tr, TInner, F, G>
 where
     Tr: TraceReader,
-    Tr::Time: Timestamp,
     TInner: Refines<Tr::Time>+Lattice,
 {
     /// Makes a new trace wrapper
@@ -142,7 +135,6 @@ pub struct BatchEnter<B, TInner, F> {
 impl<B, TInner, F> BatchReader for BatchEnter<B, TInner, F>
 where
     B: BatchReader,
-    B::Time: Timestamp,
     TInner: Refines<B::Time>+Lattice,
     F: FnMut(B::Key<'_>, <B::Cursor as Cursor>::Val<'_>, &B::Time)->TInner+Clone,
 {
@@ -165,7 +157,6 @@ where
 impl<B, TInner, F> BatchEnter<B, TInner, F>
 where
     B: BatchReader,
-    B::Time: Timestamp,
     TInner: Refines<B::Time>+Lattice,
 {
     /// Makes a new batch wrapper
@@ -202,7 +193,6 @@ impl<C, TInner, F> CursorEnter<C, TInner, F> {
 impl<C, TInner, F> Cursor for CursorEnter<C, TInner, F>
 where
     C: Cursor,
-    C::Time: Timestamp,
     TInner: Refines<C::Time>+Lattice,
     F: FnMut(C::Key<'_>, C::Val<'_>, &C::Time)->TInner,
 {
@@ -262,7 +252,6 @@ impl<C, TInner, F> BatchCursorEnter<C, TInner, F> {
 
 impl<TInner, C: Cursor, F> Cursor for BatchCursorEnter<C, TInner, F>
 where
-    C::Time: Timestamp,
     TInner: Refines<C::Time>+Lattice,
     F: FnMut(C::Key<'_>, C::Val<'_>, &C::Time)->TInner,
 {
diff --git a/src/trace/wrappers/filter.rs b/src/trace/wrappers/filter.rs
index e6d3e4823..385285529 100644
--- a/src/trace/wrappers/filter.rs
+++ b/src/trace/wrappers/filter.rs
@@ -1,6 +1,5 @@
 //! Wrapper for filtered trace.
 
-use timely::progress::Timestamp;
 use timely::progress::frontier::AntichainRef;
 
 use crate::trace::{TraceReader, BatchReader, Description};
@@ -29,8 +28,6 @@ impl<Tr, F> TraceReader for TraceFilter<Tr, F>
 where
     Tr: TraceReader,
     Tr::Batch: Clone,
-    Tr::Time: Timestamp,
-    Tr::Diff: 'static,
     F: FnMut(Tr::Key<'_>, Tr::Val<'_>)->bool+Clone+'static,
 {
     type Key<'a> = Tr::Key<'a>;
@@ -64,7 +61,6 @@ where
 impl<Tr, F> TraceFilter<Tr, F>
 where
     Tr: TraceReader,
-    Tr::Time: Timestamp,
 {
     /// Makes a new trace wrapper
     pub fn make_from(trace: Tr, logic: F) -> Self {
@@ -86,7 +82,6 @@ pub struct BatchFilter<B, F> {
 impl<B, F> BatchReader for BatchFilter<B, F>
 where
     B: BatchReader,
-    B::Time: Timestamp,
     F: FnMut(B::Key<'_>, B::Val<'_>)->bool+Clone+'static
 {
     type Key<'a> = B::Key<'a>;
@@ -108,7 +103,6 @@ where
 impl<B, F> BatchFilter<B, F>
 where
     B: BatchReader,
-    B::Time: Timestamp,
 {
     /// Makes a new batch wrapper
     pub fn make_from(batch: B, logic: F) -> Self {
@@ -137,7 +131,6 @@ impl<C, F> CursorFilter<C, F> {
 impl<C, F> Cursor for CursorFilter<C, F>
 where
     C: Cursor,
-    C::Time: Timestamp,
     F: FnMut(C::Key<'_>, C::Val<'_>)->bool+'static
 {
     type Key<'a> = C::Key<'a>;
@@ -193,7 +186,6 @@ impl<C, F> BatchCursorFilter<C, F> {
 
 impl<C: Cursor, F> Cursor for BatchCursorFilter<C, F>
 where
-    C::Time: Timestamp,
     F: FnMut(C::Key<'_>, C::Val<'_>)->bool+'static,
 {
     type Key<'a> = C::Key<'a>;
diff --git a/src/trace/wrappers/freeze.rs b/src/trace/wrappers/freeze.rs
index 43e48124f..9115cd244 100644
--- a/src/trace/wrappers/freeze.rs
+++ b/src/trace/wrappers/freeze.rs
@@ -24,7 +24,6 @@ use timely::dataflow::operators::Map;
 use timely::progress::frontier::AntichainRef;
 
 use crate::operators::arrange::Arranged;
-use crate::lattice::Lattice;
 use crate::trace::{TraceReader, BatchReader, Description};
 use crate::trace::cursor::Cursor;
 
@@ -35,10 +34,8 @@ use crate::trace::cursor::Cursor;
 /// module-level documentation.
 pub fn freeze<G, T, F>(arranged: &Arranged<G, T>, func: F) -> Arranged<G, TraceFreeze<T, F>>
 where
-    G: Scope,
-    G::Timestamp: Lattice+Ord,
-    T: TraceReader<Time=G::Timestamp>+Clone,
-    T::Diff: 'static,
+    G: Scope<Timestamp=T::Time>,
+    T: TraceReader+Clone,
     F: Fn(&G::Timestamp)->Option<G::Timestamp>+'static,
 {
     let func1 = Rc::new(func);
@@ -53,7 +50,6 @@ where
 pub struct TraceFreeze<Tr, F>
 where
     Tr: TraceReader,
-    Tr::Time: Lattice+Clone+'static,
     F: Fn(&Tr::Time)->Option<Tr::Time>,
 {
     trace: Tr,
@@ -63,7 +59,6 @@ where
 impl<Tr,F> Clone for TraceFreeze<Tr, F>
 where
     Tr: TraceReader+Clone,
-    Tr::Time: Lattice+Clone+'static,
     F: Fn(&Tr::Time)->Option<Tr::Time>,
 {
     fn clone(&self) -> Self {
@@ -78,8 +73,6 @@ impl<Tr, F> TraceReader for TraceFreeze<Tr, F>
 where
     Tr: TraceReader,
     Tr::Batch: Clone,
-    Tr::Time: Lattice+Clone+'static,
-    Tr::Diff: 'static,
     F: Fn(&Tr::Time)->Option<Tr::Time>+'static,
 {
     type Key<'a> = Tr::Key<'a>;
@@ -117,8 +110,6 @@ impl<Tr, F> TraceFreeze<Tr, F>
 where
     Tr: TraceReader,
     Tr::Batch: Clone,
-    Tr::Time: Lattice+Clone+'static,
-    Tr::Diff: 'static,
     F: Fn(&Tr::Time)->Option<Tr::Time>,
 {
     /// Makes a new trace wrapper
@@ -146,7 +137,6 @@ impl<B: Clone, F> Clone for BatchFreeze<B, F> {
 impl<B, F> BatchReader for BatchFreeze<B, F>
 where
     B: BatchReader,
-    B::Time: Clone,
     F: Fn(&B::Time)->Option<B::Time>,
 {
     type Key<'a> = B::Key<'a>;
@@ -168,7 +158,6 @@ where
 impl<B, F> BatchFreeze<B, F>
 where
     B: BatchReader,
-    B::Time: Clone,
     F: Fn(&B::Time)->Option<B::Time>
 {
     /// Makes a new batch wrapper
@@ -192,7 +181,6 @@ impl<C, F> CursorFreeze<C, F> {
 impl<C, F> Cursor for CursorFreeze<C, F>
 where
     C: Cursor,
-    C::Time: Sized,
     F: Fn(&C::Time)->Option<C::Time>,
 {
     type Key<'a> = C::Key<'a>;
diff --git a/src/trace/wrappers/frontier.rs b/src/trace/wrappers/frontier.rs
index 196e6e345..9d9d50307 100644
--- a/src/trace/wrappers/frontier.rs
+++ b/src/trace/wrappers/frontier.rs
@@ -6,7 +6,6 @@
 //! accumulated updates) and no updates at times greater or equal to `upper` (even as parts of batches
 //! that span that time).
 
-use timely::progress::Timestamp;
 use timely::progress::{Antichain, frontier::AntichainRef};
 
 use crate::trace::{TraceReader, BatchReader, Description};
@@ -14,10 +13,7 @@ use crate::trace::cursor::Cursor;
 use crate::lattice::Lattice;
 
 /// Wrapper to provide trace to nested scope.
-pub struct TraceFrontier<Tr>
-where
-    Tr: TraceReader,
-{
+pub struct TraceFrontier<Tr: TraceReader> {
     trace: Tr,
     /// Frontier to which all update times will be advanced.
     since: Antichain<Tr::Time>,
@@ -25,11 +21,7 @@ where
     until: Antichain<Tr::Time>,
 }
 
-impl<Tr> Clone for TraceFrontier<Tr>
-where
-    Tr: TraceReader+Clone,
-    Tr::Time: Clone,
-{
+impl<Tr: TraceReader + Clone> Clone for TraceFrontier<Tr> {
     fn clone(&self) -> Self {
         TraceFrontier {
             trace: self.trace.clone(),
@@ -39,13 +31,7 @@ where
     }
 }
 
-impl<Tr> TraceReader for TraceFrontier<Tr>
-where
-    Tr: TraceReader,
-    Tr::Batch: Clone,
-    Tr::Time: Timestamp+Lattice,
-    Tr::Diff: 'static,
-{
+impl<Tr: TraceReader> TraceReader for TraceFrontier<Tr> {
     type Key<'a> = Tr::Key<'a>;
     type KeyOwned = Tr::KeyOwned;
     type Val<'a> = Tr::Val<'a>;
@@ -76,11 +62,7 @@ where
     }
 }
 
-impl<Tr> TraceFrontier<Tr>
-where
-    Tr: TraceReader,
-    Tr::Time: Timestamp,
-{
+impl<Tr: TraceReader> TraceFrontier<Tr> {
     /// Makes a new trace wrapper
     pub fn make_from(trace: Tr, since: AntichainRef<Tr::Time>, until: AntichainRef<Tr::Time>) -> Self {
         TraceFrontier {
@@ -100,11 +82,7 @@ pub struct BatchFrontier<B: BatchReader> {
     until: Antichain<B::Time>,
 }
 
-impl<B> BatchReader for BatchFrontier<B>
-where
-    B: BatchReader,
-    B::Time: Timestamp+Lattice,
-{
+impl<B: BatchReader> BatchReader for BatchFrontier<B> {
     type Key<'a> = B::Key<'a>;
     type KeyOwned = B::KeyOwned;
     type Val<'a> = B::Val<'a>;
@@ -121,11 +99,7 @@ where
     fn description(&self) -> &Description<B::Time> { self.batch.description() }
 }
 
-impl<B> BatchFrontier<B>
-where
-    B: BatchReader,
-    B::Time: Timestamp+Lattice,
-{
+impl<B: BatchReader> BatchFrontier<B> {
     /// Makes a new batch wrapper
     pub fn make_from(batch: B, since: AntichainRef<B::Time>, until: AntichainRef<B::Time>) -> Self {
         BatchFrontier {
@@ -153,11 +127,7 @@ impl<C, T> CursorFrontier<C, T> where T: Clone {
     }
 }
 
-impl<C, T> Cursor for CursorFrontier<C, T>
-where
-    C: Cursor<Time=T>,
-    T: Timestamp+Lattice,
-{
+impl<C: Cursor> Cursor for CursorFrontier<C, C::Time> {
     type Key<'a> = C::Key<'a>;
     type KeyOwned = C::KeyOwned;
     type Val<'a> = C::Val<'a>;
@@ -206,7 +176,7 @@ pub struct BatchCursorFrontier<C: Cursor> {
     until: Antichain<C::Time>,
 }
 
-impl<C: Cursor> BatchCursorFrontier<C> where C::Time: Clone {
+impl<C: Cursor> BatchCursorFrontier<C> {
     fn new(cursor: C, since: AntichainRef<C::Time>, until: AntichainRef<C::Time>) -> Self {
         BatchCursorFrontier {
             cursor,
@@ -218,7 +188,6 @@ impl<C: Cursor> BatchCursorFrontier<C> where C::Time: Clone {
 
 impl<C: Cursor> Cursor for BatchCursorFrontier<C>
 where
-    C::Time: Timestamp+Lattice,
     C::Storage: BatchReader,
 {
     type Key<'a> = C::Key<'a>;
diff --git a/src/trace/wrappers/rc.rs b/src/trace/wrappers/rc.rs
index 8d17bb49c..ceda2e479 100644
--- a/src/trace/wrappers/rc.rs
+++ b/src/trace/wrappers/rc.rs
@@ -16,7 +16,6 @@ use std::cell::RefCell;
 
 use timely::progress::{Antichain, frontier::{AntichainRef, MutableAntichain}};
 
-use crate::lattice::Lattice;
 use crate::trace::TraceReader;
 
 /// A wrapper around a trace which tracks the frontiers of all referees.
@@ -24,11 +23,7 @@ use crate::trace::TraceReader;
 /// This is an internal type, unlikely to be useful to higher-level programs, but exposed just in case.
 /// This type is equivalent to a `RefCell`, in that it wraps the mutable state that multiple referrers
 /// may influence.
-pub struct TraceBox<Tr>
-where
-    Tr::Time: Lattice+Ord+Clone+'static,
-    Tr: TraceReader
-{
+pub struct TraceBox<Tr: TraceReader> {
     /// accumulated holds on times for advancement.
     pub logical_compaction: MutableAntichain<Tr::Time>,
     /// accumulated holds on times for distinction.
@@ -37,11 +32,7 @@ where
     pub trace: Tr,
 }
 
-impl<Tr> TraceBox<Tr>
-where
-    Tr::Time: Lattice+Ord+Clone+'static,
-    Tr: TraceReader,
-{
+impl<Tr: TraceReader> TraceBox<Tr> {
     /// Moves an existing trace into a shareable trace wrapper.
     ///
     /// The trace may already exist and have non-initial advance and distinguish frontiers. The boxing
@@ -80,22 +71,14 @@ where
 /// As long as the handle exists, the wrapped trace should continue to exist and will not advance its
 /// timestamps past the frontier maintained by the handle. The intent is that such a handle appears as
 /// if it is a privately maintained trace, despite being backed by shared resources.
-pub struct TraceRc<Tr>
-where
-    Tr::Time: Lattice+Ord+Clone+'static,
-    Tr: TraceReader,
-{
+pub struct TraceRc<Tr: TraceReader> {
     logical_compaction: Antichain<Tr::Time>,
     physical_compaction: Antichain<Tr::Time>,
     /// Wrapped trace. Please be gentle when using.
     pub wrapper: Rc<RefCell<TraceBox<Tr>>>,
 }
 
-impl<Tr> TraceReader for TraceRc<Tr>
-where
-    Tr::Time: Lattice+Ord+Clone+'static,
-    Tr: TraceReader,
-{
+impl<Tr: TraceReader> TraceReader for TraceRc<Tr> {
     type Key<'a> = Tr::Key<'a>;
     type KeyOwned = Tr::KeyOwned;
     type Val<'a> = Tr::Val<'a>;
@@ -133,11 +116,7 @@ where
     }
 }
 
-impl<Tr> TraceRc<Tr>
-where
-    Tr::Time: Lattice+Ord+Clone+'static,
-    Tr: TraceReader,
-{
+impl<Tr: TraceReader> TraceRc<Tr> {
     /// Allocates a new handle from an existing wrapped wrapper.
     pub fn make_from(trace: Tr) -> (Self, Rc<RefCell<TraceBox<Tr>>>) {
 
@@ -153,11 +132,7 @@ where
     }
 }
 
-impl<Tr> Clone for TraceRc<Tr>
-where
-    Tr::Time: Lattice+Ord+Clone,
-    Tr: TraceReader,
-{
+impl<Tr: TraceReader> Clone for TraceRc<Tr> {
     fn clone(&self) -> Self {
         // increase ref counts for this frontier
         self.wrapper.borrow_mut().adjust_logical_compaction(Antichain::new().borrow(), self.logical_compaction.borrow());
@@ -170,11 +145,7 @@ where
     }
 }
 
-impl<Tr> Drop for TraceRc<Tr>
-where
-    Tr::Time: Lattice+Ord+Clone+'static,
-    Tr: TraceReader,
-{
+impl<Tr: TraceReader> Drop for TraceRc<Tr> {
     fn drop(&mut self) {
         self.wrapper.borrow_mut().adjust_logical_compaction(self.logical_compaction.borrow(), Antichain::new().borrow());
         self.wrapper.borrow_mut().adjust_physical_compaction(self.physical_compaction.borrow(), Antichain::new().borrow());