diff --git a/differential-dataflow/src/operators/co_reduce.rs b/differential-dataflow/src/operators/co_reduce.rs
new file mode 100644
index 000000000..53d10d451
--- /dev/null
+++ b/differential-dataflow/src/operators/co_reduce.rs
@@ -0,0 +1,179 @@
+//! A key-wise reduction over several co-arranged inputs.
+//!
+//! The driver mirrors [`reduce_with_tactic`](crate::operators::reduce::reduce_with_tactic), with one
+//! source trace per input. Batches reach the tactic tagged by their input, `(i, batch)`, so any
+//! [`ReduceTactic`] whose backend reads tagged batches runs unchanged.
+//!
+//! The interval retired is bounded by the meet of the inputs' progress. An input running ahead of
+//! the others can hand the tactic batches holding times beyond the interval. The tactic must defer
+//! the times it finds there, as it does output times.
+
+use timely::progress::frontier::Antichain;
+use timely::progress::Timestamp;
+use timely::dataflow::operators::CapabilitySet;
+use timely::dataflow::operators::generic::OutputBuilder;
+use timely::dataflow::operators::generic::builder_rc::OperatorBuilder;
+use timely::dataflow::channels::pact::Pipeline;
+
+use crate::operators::arrange::{Arranged, TraceAgent};
+use crate::operators::reduce::ReduceTactic;
+use crate::trace::{ExertionLogic, Trace, TraceReader};
+
+/// Per-input state of the driver.
+struct Side<Tr: TraceReader> {
+    trace: Tr,
+    /// Received batches not yet handed to the tactic, with their capabilities, in order.
+    queued: Vec<(CapabilitySet<Tr::Time>, Tr::Batch, Antichain<Tr::Time>)>,
+    /// The upper of the last received batch, advanced past empty batches in the trace.
+    received: Antichain<Tr::Time>,
+    /// The bound through which batches have been handed to the tactic, a batch boundary.
+    handed: Antichain<Tr::Time>,
+}
+
+impl<Tr: TraceReader> Side<Tr> {
+    fn new(trace: Tr) -> Self {
+        let min = Antichain::from_elem(<Tr::Time as Timestamp>::minimum());
+        Side { trace, queued: Vec::new(), received: min.clone(), handed: min }
+    }
+}
+
+/// Drives a key-wise reduction over `inputs`, at least one, using a supplied [`ReduceTactic`].
+///
+/// The tactic sees each batch tagged by the index of the input it came from. Its output at a time
+/// `t` must be a function of each key's input accumulations at `t`. Beyond the contract of
+/// [`ReduceTactic::retire`], it must defer every time at or beyond `upper` that a new input batch
+/// holds, and leave its input unread only when no held time lies below `upper`.
+pub fn co_reduce_with_tactic<'scope, Tr1, Tr2, T>(
+    inputs: Vec<Arranged<'scope, Tr1>>,
+    name: &str,
+    mut tactic: T,
+) -> Arranged<'scope, TraceAgent<Tr2>>
+where
+    Tr1: TraceReader + 'static,
+    Tr2: Trace<Time = Tr1::Time> + 'static,
+    T: ReduceTactic<Tr1::Time, (usize, Tr1::Batch), Tr2::Batch> + 'static,
+{
+    assert!(!inputs.is_empty(), "co_reduce_with_tactic: no inputs");
+    let scope = inputs[0].stream.scope();
+    let mut builder = OperatorBuilder::new(name.to_string(), scope);
+    let operator_info = builder.operator_info();
+    let (output, stream) = builder.new_output();
+    let mut output = OutputBuilder::from(output);
+    let mut handles = Vec::with_capacity(inputs.len());
+    let mut sides = Vec::with_capacity(inputs.len());
+    for input in inputs {
+        handles.push(builder.new_input(input.stream, Pipeline));
+        sides.push(Side::new(input.trace));
+    }
+
+    let logger = scope.worker().logger_for::<crate::logging::DifferentialEventBuilder>("differential/arrange").map(Into::into);
+    let activator = Some(scope.activator_for(std::rc::Rc::clone(&operator_info.address)));
+    let mut empty = Tr2::new(operator_info.clone(), logger.clone(), activator);
+    if let Some(exert_logic) = scope.worker().config().get::<ExertionLogic>("differential/default_exert_logic").cloned() {
+        empty.set_exert_logic(exert_logic);
+    }
+    let (mut output_reader, mut output_writer) = TraceAgent::new(empty, operator_info, logger);
+    let result_trace = output_reader.clone();
+
+    builder.build(move |_capabilities| {
+        // Capabilities for the interesting times the tactic withholds. Queued batches hold their own.
+        let mut capabilities = CapabilitySet::<Tr1::Time>::default();
+        let mut upper_limit = Antichain::from_elem(<Tr1::Time as Timestamp>::minimum());
+        let mut lower_limit = Antichain::from_elem(<Tr1::Time as Timestamp>::minimum());
+
+        move |frontiers| {
+            let mut output = output.activate();
+
+            lower_limit.clone_from(&upper_limit);
+
+            for (side, handle) in sides.iter_mut().zip(handles.iter_mut()) {
+                handle.for_each(|capability, batches| {
+                    let capability = capability.retain_stamp(0);
+                    // A batch keeps its capability until it is handed over. An empty span adds no
+                    // interesting time, so only its upper is kept.
+                    for batch in batches.drain(..) {
+                        side.received.clone_from(batch.upper());
+                        if let Some(inner) = batch.inner {
+                            side.queued.push((capability.clone(), inner, batch.desc.lower().clone()));
+                        }
+                    }
+                });
+            }
+
+            // Each input's progress, as in the unary driver, and the meet of them all.
+            let mut limit = Antichain::new();
+            for (side, frontier) in sides.iter_mut().zip(frontiers) {
+                side.trace.advance_upper(&mut side.received);
+                let mut joined = Antichain::new();
+                crate::lattice::antichain_join_into(&side.received.borrow()[..], &frontier.frontier()[..], &mut joined);
+                for time in joined { limit.insert(time); }
+            }
+            upper_limit = limit;
+
+            if upper_limit != lower_limit {
+
+                // The history each input had before its newly handed batches.
+                let mut source_batches = Vec::new();
+                for (index, side) in sides.iter_mut().enumerate() {
+                    let batches = side.trace.batches_through(side.handed.borrow()).expect("failed to acquire source batches");
+                    source_batches.extend(batches.into_iter().map(|b| (index, b)));
+                }
+                let output_batches = output_reader.batches_through(lower_limit.borrow()).expect("failed to acquire output batches");
+
+                // Hand over every queued batch, unless no capability, held or queued, lies below
+                // `upper_limit`. The tactic then returns before reading its input, which would
+                // lose the batches, so they stay queued. Otherwise a handed batch's times at or
+                // beyond `upper_limit` are the tactic's to defer, as it does the output times it
+                // finds there. Holding back only some batches could strand a later one's times
+                // below `upper_limit`, and waiting for a batch boundary could deadlock a loop.
+                let below = |caps: &CapabilitySet<Tr1::Time>| caps.iter().any(|c| !upper_limit.less_equal(c.time()));
+                let hand = below(&capabilities) || sides.iter().any(|side| side.queued.iter().any(|(caps, _, _)| below(caps)));
+                let mut input_batches = Vec::new();
+                for (index, side) in sides.iter_mut().enumerate() {
+                    let take = if hand { side.queued.len() } else { 0 };
+                    for (caps, batch, _) in side.queued.drain(..take) {
+                        for capability in caps.iter() { capabilities.insert(capability.clone()); }
+                        input_batches.push((index, batch));
+                    }
+                    side.handed = match side.queued.first() {
+                        Some((_, _, lower)) => lower.clone(),
+                        None => side.received.clone(),
+                    };
+                }
+
+                let held: Antichain<Tr1::Time> = capabilities.iter().map(|c| c.time().clone()).collect();
+                let (produced, new_frontier) = tactic.retire(source_batches, output_batches, input_batches, &lower_limit, &upper_limit, &held);
+
+                debug_assert!(
+                    produced.as_ref().is_none_or(|batch| batch.lower() == &lower_limit && batch.upper() == &upper_limit),
+                    "ReduceTactic::retire output must span [lower, upper)",
+                );
+
+                if let Some(batch) = produced {
+                    let retiring = capabilities
+                        .iter()
+                        .filter(|c| !upper_limit.less_equal(c.time()))
+                        .cloned()
+                        .collect::<CapabilitySet<_>>();
+                    output.session(&retiring).give(batch.clone());
+                    let stamp = retiring.iter().map(|c| c.time().clone()).collect::<timely::progress::Stamp<_>>();
+                    output_writer.insert(batch, stamp);
+                }
+
+                capabilities.downgrade(new_frontier);
+                output_writer.seal(upper_limit.clone());
+
+                for side in sides.iter_mut() {
+                    side.trace.set_logical_compaction(upper_limit.borrow());
+                    side.trace.set_physical_compaction(side.handed.borrow());
+                }
+                output_reader.set_logical_compaction(upper_limit.borrow());
+                output_reader.set_physical_compaction(upper_limit.borrow());
+            }
+
+            output_writer.exert();
+        }
+    });
+
+    Arranged { stream, trace: result_trace }
+}
diff --git a/differential-dataflow/src/operators/mod.rs b/differential-dataflow/src/operators/mod.rs
index 7c2f662da..19067bdef 100644
--- a/differential-dataflow/src/operators/mod.rs
+++ b/differential-dataflow/src/operators/mod.rs
@@ -13,6 +13,7 @@ pub mod cursor;
 pub mod history;
 pub mod int_proxy;
 pub mod reduce;
+pub mod co_reduce;
 pub mod iterate;
 pub mod join;
 pub mod count;
diff --git a/differential-dataflow/tests/co_reduce.rs b/differential-dataflow/tests/co_reduce.rs
new file mode 100644
index 000000000..4878ea090
--- /dev/null
+++ b/differential-dataflow/tests/co_reduce.rs
@@ -0,0 +1,365 @@
+//! Tests for `co_reduce_with_tactic` over the proxy reduce tactic and its reference backend.
+
+use std::rc::Rc;
+use std::sync::{Arc, Mutex};
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+use timely::dataflow::channels::pact::Pipeline;
+use timely::order::Product;
+use timely::progress::{Antichain, Timestamp};
+
+use differential_dataflow::VecCollection;
+use differential_dataflow::hashable::Hashable;
+use differential_dataflow::lattice::Lattice;
+use differential_dataflow::operators::arrange::{Arranged, TraceAgent};
+use differential_dataflow::input::InputSession;
+use differential_dataflow::operators::arrange::arrangement::arrange_core;
+use differential_dataflow::operators::co_reduce::co_reduce_with_tactic;
+use differential_dataflow::operators::iterate::Iterate;
+use differential_dataflow::operators::int_proxy::reduce::ProxyReduceTactic;
+use differential_dataflow::operators::int_proxy::vec_backend::VecReduceBackend;
+use differential_dataflow::operators::reduce::ReduceTactic;
+use differential_dataflow::trace::chunk::ChunkBatch;
+use differential_dataflow::trace::chunk::vec::{ChunkBatcher as VChunkBatcher, ChunkSpine as VChunkSpine, VecChunk};
+use differential_dataflow::trace::cursor::Cursor;
+use differential_dataflow::trace::{Navigable, Span};
+
+type Batch<T = u64> = Rc<ChunkBatch<VecChunk<u64, (u64, u64), T, i64>>>;
+type Spine<T = u64> = VChunkSpine<u64, (u64, u64), T, i64>;
+
+/// Reads tagged batches as one list of plain batches, which reduces the sum of the inputs. Counts
+/// the handed batches that hold a time at or beyond `upper`.
+struct Untag<Tac> {
+    inner: Tac,
+    ahead: Arc<AtomicUsize>,
+}
+
+impl<T: Timestamp + Lattice, Tac: ReduceTactic<T, Batch<T>, Batch<T>>> ReduceTactic<T, (usize, Batch<T>), Batch<T>> for Untag<Tac> {
+    fn retire(
+        &mut self,
+        source_batches: Vec<(usize, Batch<T>)>,
+        output_batches: Vec<Batch<T>>,
+        input_batches: Vec<(usize, Batch<T>)>,
+        lower: &Antichain<T>,
+        upper: &Antichain<T>,
+        held: &Antichain<T>,
+    ) -> (Option<Span<T, Batch<T>>>, Antichain<T>) {
+        for (_, batch) in &input_batches {
+            let mut beyond = false;
+            for chunk in &batch.chunks {
+                let mut c = chunk.cursor();
+                while c.key_valid(chunk) {
+                    while c.val_valid(chunk) {
+                        c.map_times(chunk, |t, _| beyond |= upper.less_equal(t));
+                        c.step_val(chunk);
+                    }
+                    c.step_key(chunk);
+                }
+            }
+            if beyond { self.ahead.fetch_add(1, Ordering::Relaxed); }
+        }
+        let untag = |batches: Vec<(usize, Batch<T>)>| batches.into_iter().map(|(_, b)| b).collect();
+        self.inner.retire(untag(source_batches), output_batches, untag(input_batches), lower, upper, held)
+    }
+}
+
+/// Arranges `c` by the hash of its key, as the reference backend reads it.
+fn arrange<'s, T: Timestamp + Lattice>(c: VecCollection<'s, T, (u64, u64), i64>) -> Arranged<'s, TraceAgent<Spine<T>>> {
+    let hashed = c.map(|(k, v)| (k.hashed(), (k, v)));
+    arrange_core::<Pipeline, Vec<((u64, (u64, u64)), T, i64)>, _, Spine<T>>(hashed.inner, Pipeline, "Arrange", VChunkBatcher::new)
+}
+
+#[expect(clippy::ptr_arg, reason = "the signature the reduce logic takes")]
+fn max_logic(_k: &u64, input: &[(u64, i64)], current: &mut Vec<(u64, i64)>, updates: &mut Vec<(u64, i64)>) {
+    if let Some(m) = input.iter().filter(|(_, d)| *d > 0).map(|(v, _)| *v).max() {
+        updates.push((m, 1));
+    }
+    for (w, d) in current.iter() {
+        updates.push((*w, -*d));
+    }
+}
+
+/// Input `a` runs twenty ticks ahead of input `b`, which advances one time at a time. The driver
+/// hands over `a`'s batches, whose times lie beyond the interval it retires, and the output still
+/// matches the reduce of the concatenation.
+#[test]
+fn input_ahead_matches_concat() {
+    let got = Arc::new(Mutex::new(Vec::new()));
+    let want = Arc::new(Mutex::new(Vec::new()));
+    let ahead = Arc::new(AtomicUsize::new(0));
+    let (g, w, seen) = (Arc::clone(&got), Arc::clone(&want), Arc::clone(&ahead));
+    timely::execute_directly(move |worker| {
+        let mut a = InputSession::<u64, (u64, u64), i64>::new();
+        let mut b = InputSession::<u64, (u64, u64), i64>::new();
+        let (g, w, seen) = (Arc::clone(&g), Arc::clone(&w), Arc::clone(&seen));
+        let probe = worker.dataflow::<u64, _, _>(|scope| {
+            let (ca, cb) = (a.to_collection(scope), b.to_collection(scope));
+            let tactic = Untag { inner: ProxyReduceTactic::new(VecReduceBackend::with_window(max_logic, 3)), ahead: seen };
+            co_reduce_with_tactic::<_, Spine, _>(vec![arrange(ca.clone()), arrange(cb.clone())], "CoReduce", tactic)
+                .as_collection(|_h, kw: &(u64, u64)| (kw.0, kw.1))
+                .inspect(move |(d, t, r)| g.lock().unwrap().push((*d, *t, *r)));
+            ca.concat(cb)
+                .reduce(|_k, input, output| {
+                    if let Some(m) = input.iter().filter(|(_, d)| *d > 0).map(|(v, _)| *v).max() { output.push((*m, 1)); }
+                })
+                .inspect(move |(d, t, r)| w.lock().unwrap().push((*d, *t, *r)))
+                .probe()
+                .0
+        });
+
+        // A deterministic stream of insertions over keys 0..5, each later retracted.
+        let mut state = 0x9E37_79B9_7F4A_7C15u64;
+        let mut next = move |bound: u64| { state ^= state << 13; state ^= state >> 7; state ^= state << 17; state % bound };
+        let mut live_a = Vec::new();
+        for t in 0..20 {
+            a.advance_to(t);
+            for _ in 0..4 {
+                let row = (next(5), next(30));
+                a.update(row, 1);
+                live_a.push(row);
+            }
+            if t % 3 == 2 { a.update(live_a.swap_remove(0), -1); }
+        }
+        a.advance_to(20);
+        a.flush();
+        let mut live_b = Vec::new();
+        for t in 0..20 {
+            b.advance_to(t);
+            for _ in 0..2 {
+                let row = (next(5), next(30));
+                b.update(row, 1);
+                live_b.push(row);
+            }
+            if t % 2 == 1 { b.update(live_b.swap_remove(0), -1); }
+            b.advance_to(t + 1);
+            b.flush();
+            // `a` stays twenty ticks ahead, with a batch of its own each round.
+            let row = (next(5), next(30));
+            a.update(row, 1);
+            live_a.push(row);
+            if t % 4 == 3 { a.update(live_a.swap_remove(0), -1); }
+            a.advance_to(21 + t);
+            a.flush();
+            for _ in 0..4 { worker.step(); }
+        }
+        a.close();
+        b.close();
+        while !probe.done() { worker.step(); }
+    });
+    assert!(ahead.load(Ordering::Relaxed) >= 10, "few handed batches held a time beyond the interval");
+    let (mut got, mut want) = (got.lock().unwrap().clone(), want.lock().unwrap().clone());
+    differential_dataflow::consolidation::consolidate_updates(&mut got);
+    differential_dataflow::consolidation::consolidate_updates(&mut want);
+    assert!(!want.is_empty());
+    assert_eq!(got, want);
+}
+
+#[expect(clippy::ptr_arg, reason = "the signature the reduce logic takes")]
+fn min_logic(_k: &u64, input: &[(u64, i64)], current: &mut Vec<(u64, i64)>, updates: &mut Vec<(u64, i64)>) {
+    if let Some(m) = input.iter().filter(|(_, d)| *d > 0).map(|(v, _)| *v).min() {
+        updates.push((m, 1));
+    }
+    for (w, d) in current.iter() {
+        updates.push((*w, -*d));
+    }
+}
+
+/// Inside an iterative scope, input `a` enters from outside and runs several outer epochs ahead
+/// of the loop's feedback, which counts each key's least value down to zero. The driver hands
+/// over `a`'s batches, whose times lie beyond the interval it retires while the loop iterates,
+/// and the reduce's output at every iteration still matches the reduce of the concatenation.
+#[test]
+fn input_ahead_in_loop_matches_concat() {
+    let got = Arc::new(Mutex::new(Vec::new()));
+    let want = Arc::new(Mutex::new(Vec::new()));
+    let ahead = Arc::new(AtomicUsize::new(0));
+    let (g, w, seen) = (Arc::clone(&got), Arc::clone(&want), Arc::clone(&ahead));
+    timely::execute_directly(move |worker| {
+        let mut a = InputSession::<u64, (u64, u64), i64>::new();
+        let mut b = InputSession::<u64, (u64, u64), i64>::new();
+        let (g, w, seen) = (Arc::clone(&g), Arc::clone(&w), Arc::clone(&seen));
+        let probe = worker.dataflow::<u64, _, _>(|scope| {
+            let (ca, cb) = (a.to_collection(scope), b.to_collection(scope));
+            let (la, lb) = (ca.clone(), cb.clone());
+            let co = scope.iterate(move |inner, x| {
+                // The loop's own input: `b` and each key's least value less one, down to zero,
+                // which is the fixed point.
+                let step = lb.enter(inner).concat(x.map(|(k, v): (u64, u64)| (k, v.saturating_sub(1))));
+                let tactic = Untag { inner: ProxyReduceTactic::new(VecReduceBackend::with_window(min_logic, 3)), ahead: seen };
+                co_reduce_with_tactic::<_, Spine<Product<u64, u64>>, _>(vec![arrange(la.enter(inner)), arrange(step)], "CoReduce", tactic)
+                    .as_collection(|_h, kw: &(u64, u64)| (kw.0, kw.1))
+                    .inspect(move |(d, t, r)| g.lock().unwrap().push((*d, *t, *r)))
+            }).probe().0;
+            let reference = scope.iterate(move |inner, x| {
+                let step = cb.enter(inner).concat(x.map(|(k, v): (u64, u64)| (k, v.saturating_sub(1))));
+                ca.enter(inner).concat(step).reduce(|_k, input, output| {
+                    if let Some(m) = input.iter().filter(|(_, d)| *d > 0).map(|(v, _)| *v).min() { output.push((*m, 1)); }
+                })
+                .inspect(move |(d, t, r)| w.lock().unwrap().push((*d, *t, *r)))
+            }).probe().0;
+            (co, reference)
+        });
+
+        // A deterministic stream of insertions over keys 0..5, each later retracted.
+        let mut state = 0x2545_F491_4F6C_DD1Du64;
+        let mut next = move |bound: u64| { state ^= state << 13; state ^= state >> 7; state ^= state << 17; state % bound };
+        let mut live_a = Vec::new();
+        for t in 0..6 {
+            a.advance_to(t);
+            for _ in 0..3 {
+                let row = (next(5), 5 + next(20));
+                a.update(row, 1);
+                live_a.push(row);
+            }
+            if t % 2 == 1 { a.update(live_a.swap_remove(0), -1); }
+        }
+        a.advance_to(6);
+        a.flush();
+        let mut live_b = Vec::new();
+        for t in 0..24 {
+            b.advance_to(t);
+            for _ in 0..2 {
+                let row = (next(5), 5 + next(20));
+                b.update(row, 1);
+                live_b.push(row);
+            }
+            if t % 2 == 1 { b.update(live_b.swap_remove(0), -1); }
+            b.advance_to(t + 1);
+            b.flush();
+            // `a` stays six epochs ahead, with a batch of its own each round.
+            let row = (next(5), 5 + next(20));
+            a.update(row, 1);
+            live_a.push(row);
+            if t % 3 == 2 { a.update(live_a.swap_remove(0), -1); }
+            a.advance_to(7 + t);
+            a.flush();
+            // A few steps, so the loop iterates while `a` is ahead.
+            for _ in 0..8 { worker.step(); }
+        }
+        a.close();
+        b.close();
+        while !probe.0.done() || !probe.1.done() { worker.step(); }
+    });
+    assert!(ahead.load(Ordering::Relaxed) >= 20, "few handed batches held a time beyond the interval");
+    let (mut got, mut want) = (got.lock().unwrap().clone(), want.lock().unwrap().clone());
+    differential_dataflow::consolidation::consolidate_updates(&mut got);
+    differential_dataflow::consolidation::consolidate_updates(&mut want);
+    assert!(!want.is_empty());
+    assert_eq!(got, want);
+}
+
+/// Records, for each handed batch, the `lower` of the retire that handed it and the batch's times.
+struct Record<Tac> {
+    inner: Tac,
+    handed: Arc<Mutex<Vec<(u64, Vec<u64>)>>>,
+}
+
+impl<Tac: ReduceTactic<u64, (usize, Batch), Batch>> ReduceTactic<u64, (usize, Batch), Batch> for Record<Tac> {
+    fn retire(
+        &mut self,
+        source_batches: Vec<(usize, Batch)>,
+        output_batches: Vec<Batch>,
+        input_batches: Vec<(usize, Batch)>,
+        lower: &Antichain<u64>,
+        upper: &Antichain<u64>,
+        held: &Antichain<u64>,
+    ) -> (Option<Span<u64, Batch>>, Antichain<u64>) {
+        for (_, batch) in &input_batches {
+            let mut times = Vec::new();
+            for chunk in &batch.chunks {
+                let mut c = chunk.cursor();
+                while c.key_valid(chunk) {
+                    while c.val_valid(chunk) {
+                        c.map_times(chunk, |t, _| times.push(*t));
+                        c.step_val(chunk);
+                    }
+                    c.step_key(chunk);
+                }
+            }
+            let at = lower.elements().first().copied().unwrap_or(u64::MAX);
+            self.handed.lock().unwrap().push((at, times));
+        }
+        self.inner.retire(source_batches, output_batches, input_batches, lower, upper, held)
+    }
+}
+
+#[expect(clippy::ptr_arg, reason = "the signature the reduce logic takes")]
+fn count_logic(_k: &u64, input: &[(u64, i64)], current: &mut Vec<(u64, i64)>, updates: &mut Vec<(u64, i64)>) {
+    let count: i64 = input.iter().map(|(_, d)| *d).sum();
+    if count != 0 {
+        updates.push((u64::try_from(count).expect("negative count"), 1));
+    }
+    for (w, d) in current.iter() {
+        updates.push((*w, -*d));
+    }
+}
+
+/// Input `a` holds its only batch at time 10 while input `b` advances through times 0 to 10 without
+/// updates. No capability lies below the interval, so the driver keeps `a`'s batch queued, neither
+/// handing it to the tactic nor counting it as history. Once `b` passes 10 with updates of its own
+/// on other keys, the driver hands the batch over once, and the per-key counts match the reduce of
+/// the concatenation.
+#[test]
+fn queued_beyond_interval_matches_concat() {
+    let got = Arc::new(Mutex::new(Vec::new()));
+    let want = Arc::new(Mutex::new(Vec::new()));
+    let handed = Arc::new(Mutex::new(Vec::new()));
+    let (g, w, h) = (Arc::clone(&got), Arc::clone(&want), Arc::clone(&handed));
+    timely::execute_directly(move |worker| {
+        let mut a = InputSession::<u64, (u64, u64), i64>::new();
+        let mut b = InputSession::<u64, (u64, u64), i64>::new();
+        let (g, w, h) = (Arc::clone(&g), Arc::clone(&w), Arc::clone(&h));
+        let probe = worker.dataflow::<u64, _, _>(|scope| {
+            let (ca, cb) = (a.to_collection(scope), b.to_collection(scope));
+            let untag = Untag { inner: ProxyReduceTactic::new(VecReduceBackend::with_window(count_logic, 3)), ahead: Arc::new(AtomicUsize::new(0)) };
+            let tactic = Record { inner: untag, handed: h };
+            co_reduce_with_tactic::<_, Spine, _>(vec![arrange(ca.clone()), arrange(cb.clone())], "CoReduce", tactic)
+                .as_collection(|_h, kw: &(u64, u64)| (kw.0, kw.1))
+                .inspect(move |(d, t, r)| g.lock().unwrap().push((*d, *t, *r)));
+            ca.concat(cb)
+                .reduce(|_k, input, output| {
+                    let count: i64 = input.iter().map(|(_, d)| *d).sum();
+                    if count != 0 { output.push((u64::try_from(count).expect("negative count"), 1)); }
+                })
+                .inspect(move |(d, t, r)| w.lock().unwrap().push((*d, *t, *r)))
+                .probe()
+                .0
+        });
+
+        // `a` has updates only at time 10, on keys 0 to 2. Its input advances to 10 before the
+        // updates, so the batch's capability is at 10.
+        a.advance_to(10);
+        a.flush();
+        for k in 0..3 {
+            for v in 0..=k { a.update((k, v), 1); }
+        }
+        a.advance_to(11);
+        a.flush();
+        // `b` advances one empty time at a time, stepping so the driver retires each interval
+        // while `a`'s batch stays queued.
+        for t in 0..10 {
+            b.advance_to(t + 1);
+            b.flush();
+            for _ in 0..4 { worker.step(); }
+        }
+        // `b` then has updates at time 11, on keys 3 and 4.
+        b.advance_to(11);
+        for k in 3..5 {
+            for v in 0..k { b.update((k, v), 1); }
+        }
+        b.advance_to(12);
+        b.flush();
+        a.close();
+        b.close();
+        while !probe.done() { worker.step(); }
+    });
+    let (mut got, mut want) = (got.lock().unwrap().clone(), want.lock().unwrap().clone());
+    differential_dataflow::consolidation::consolidate_updates(&mut got);
+    differential_dataflow::consolidation::consolidate_updates(&mut want);
+    assert_eq!(want.len(), 5, "every key has one count");
+    assert_eq!(got, want);
+    // The batch holding time 10 reaches the tactic exactly once, in a retire starting at 10.
+    let handed = handed.lock().unwrap().clone();
+    let at_ten: Vec<_> = handed.iter().filter(|(_, times)| times.contains(&10)).map(|(at, _)| *at).collect();
+    assert_eq!(at_ten, vec![10], "the batch at time 10 was not held back until the interval reached it: {handed:?}");
+}
diff --git a/interactive/README.md b/interactive/README.md
index a47ee9f07..43366a031 100644
--- a/interactive/README.md
+++ b/interactive/README.md
@@ -277,9 +277,10 @@ A program moves through four parts, each using only the ones before it.
 2. **Rewrites** turn a program into another program. `passes/` holds the passes install runs,
    through one entry point, `passes::run`: dead-code removal, structural optimization, map
    composition, arrangement sharing, invariant motion, projection (fields nothing reads
-   become `()`), and the as-of drop. None is needed to run a program, and each can be switched off: `DDIR_PASSES` on the server and
+   become `()`), the as-of drop, and `merge-reduce`, which reduces a concatenation through its
+   leaves' arrangements. None is needed to run a program, and each can be switched off: `DDIR_PASSES` on the server and
    `ddir-plan --passes` take a list such as `none` or `all,-projection`. The default
-   excludes projection; `all` enables every pass. `explain/` produces a
+   excludes projection, so `merge-reduce` is on; `all` enables every pass. `explain/` produces a
    program that explains its own outputs.
 3. **The runtime** renders a program to differential dataflow. `backend/` holds the `Backend`
    trait and `render_tree`, which turns the scope tree into operators. `runtime/` is today's
diff --git a/interactive/src/backend/corgi.rs b/interactive/src/backend/corgi.rs
index c79baebd7..8955d3416 100644
--- a/interactive/src/backend/corgi.rs
+++ b/interactive/src/backend/corgi.rs
@@ -17,6 +17,7 @@ use differential_dataflow::AsCollection;
 use differential_dataflow::Collection;
 use differential_dataflow::operators::join::join_with_tactic;
 use differential_dataflow::operators::reduce::reduce_with_tactic;
+use differential_dataflow::operators::co_reduce::co_reduce_with_tactic;
 use differential_dataflow::trace::Span;
 use differential_dataflow::trace::chunk::ChunkBatch;
 use differential_dataflow::operators::arrange::arrangement::arrange_core;
@@ -388,6 +389,34 @@ impl Backend for CorgiBackend {
         Arr::built(reduce_with_tactic::<_, CTrace, _>(arranged, "CorgiReduce", ProxyReduceTactic::new(backend).with_key_batch_size(256)))
     }
 
+    fn reduce_many<'s>(inputs: Vec<Self::Arr<'s>>, signs: Option<Vec<Diff>>, reducer: &Reducer, limit: Option<usize>, shapes: Vec<st::RowShape>) -> Self::Arr<'s> {
+        // The backend reads each input's batches tagged by input, and a merged reduce reads their
+        // diffs times the input's sign.
+        assert!(shapes.len() == inputs.len(), "reduce: {} shapes for {} inputs", shapes.len(), inputs.len());
+        let backend = match signs {
+            Some(signs) => {
+                // A merged reduce's inputs share one row shape, which the backend compiles at.
+                assert!(signs.len() == inputs.len(), "reduce: {} signs for {} inputs", signs.len(), inputs.len());
+                assert!(shapes.iter().all(|shape| *shape == shapes[0]), "reduce: merged inputs differ in shape: {shapes:?}");
+                CorgiReduceBackend::new(reducer.clone(), limit, shapes[0].clone()).with_signs(signs)
+            },
+            None => {
+                // A grouped reduce's inputs share a key shape, and the backend compiles at each
+                // input's value shape.
+                assert!(limit.is_none(), "reduce: a grouped reduce has no limit");
+                assert!(shapes.iter().all(|shape| shape.0 == shapes[0].0), "reduce: grouped inputs differ in key shape: {shapes:?}");
+                let kshape = shapes[0].0.clone();
+                CorgiReduceBackend::grouped(reducer.clone(), kshape, shapes.into_iter().map(|shape| shape.1).collect(), 1 << 12)
+            },
+        };
+        // As for the join, the inputs are read as of the join of their times. Every program time
+        // is at or beyond each import's time, so this reads each input as the unary reduce would.
+        let since = inputs.iter().map(|a| a.since.clone()).reduce(|a, b| differential_dataflow::lattice::Lattice::join(&a, &b)).expect("a reduce has an input");
+        let backend = BackendFrontier::new(backend, Antichain::from_elem(since));
+        let arranged = inputs.into_iter().map(|a| a.arranged).collect();
+        Arr::built(co_reduce_with_tactic::<_, CTrace, _>(arranged, "CorgiReduceMany", ProxyReduceTactic::new(backend).with_key_batch_size(256)))
+    }
+
     fn inspect<'s>(c: Collection<'s, Time, CC>, label: String) -> Collection<'s, Time, CC> {
         use std::fmt::Write;
         c.inner
diff --git a/interactive/src/backend/mod.rs b/interactive/src/backend/mod.rs
index e431679d9..b17a2fe35 100644
--- a/interactive/src/backend/mod.rs
+++ b/interactive/src/backend/mod.rs
@@ -54,6 +54,10 @@ pub(crate) trait Backend {
     fn half_join<'s>(stream: Collection<'s, Time, Self::Container>, arrangement: Self::Arr<'s>, strict: bool, projection: &Lambda, level: Level, shapes: (st::RowShape, st::RowShape)) -> Collection<'s, Time, Self::Container>;
     /// See `scope_ir::Node::Reduce`; `shape` is the input's row shape.
     fn reduce<'s>(a: Self::Arr<'s>, reducer: &Reducer, limit: Option<usize>, shape: st::RowShape) -> Self::Arr<'s>;
+    /// A reduce over several arrangements, without arranging their union. See
+    /// `scope_ir::ReduceInput`. `signs` holds each input's sign for a merged reduce and is `None`
+    /// for a grouped one. `shapes` are the inputs' row shapes.
+    fn reduce_many<'s>(inputs: Vec<Self::Arr<'s>>, signs: Option<Vec<crate::ir::Diff>>, reducer: &Reducer, limit: Option<usize>, shapes: Vec<st::RowShape>) -> Self::Arr<'s>;
     fn inspect<'s>(c: Collection<'s, Time, Self::Container>, label: String) -> Collection<'s, Time, Self::Container>;
 }
 
@@ -106,7 +110,8 @@ pub(crate) enum Rendered<'s, B: Backend> {
     Collection(Collection<'s, Time, B::Container>),
     Arrangement(B::Arr<'s>),
     /// An imported arrangement that the scope also reads as rows: both forms, so the rows
-    /// are flattened out of it once rather than once per use.
+    /// are flattened out of it once rather than once per use. Also imported rows that the
+    /// scope reads as an arrangement, so they are arranged once rather than once per reader.
     Both(B::Arr<'s>, Collection<'s, Time, B::Container>),
 }
 
@@ -171,6 +176,25 @@ fn resolve<'s, B: Backend>(
     }
 }
 
+/// The arrangement of `r`. An import that arrived as rows is arranged at its first such read,
+/// and the import then holds both forms, so every later reader shares that one arrangement.
+fn arranged<'s, B: Backend>(
+    items: &[RItem<'s, B>],
+    imports: &mut [Rendered<'s, B>],
+    var_cols: &[Collection<'s, Time, B::Container>],
+    r: &st::Ref,
+) -> B::Arr<'s> {
+    if let st::Ref::Import(i) = r {
+        if let Rendered::Collection(c) = &imports[*i] {
+            // A trace import rendered as rows (arranged imports off) has no `Arrange` item, as
+            // lowering treats it as arranged, so each index reader would arrange it again.
+            let a = B::arrange(c.clone());
+            imports[*i] = Rendered::Both(a, c.clone());
+        }
+    }
+    resolve(items, imports, var_cols, r).arrange()
+}
+
 /// Whether scope `s` reads import `k` as rows: as a linear op's, concat's, or inspect's input,
 /// or as a bind or export. A child's import is not a read: the arrangement enters the child.
 fn reads_rows(s: &st::Scope, k: usize) -> bool {
@@ -214,7 +238,7 @@ pub(crate) fn render_scope<'s, B: Backend>(
         (c.key, c.val)
     };
     // An arranged import that is also read as rows gets its rows flattened once, here.
-    let imports: Vec<Rendered<'s, B>> = imports.into_iter().enumerate().map(|(k, imp)| match imp {
+    let mut imports: Vec<Rendered<'s, B>> = imports.into_iter().enumerate().map(|(k, imp)| match imp {
         Rendered::Arrangement(a) if reads_rows(s, k) => {
             let rows = B::as_collection(a.clone());
             Rendered::Both(a, rows)
@@ -247,20 +271,31 @@ pub(crate) fn render_scope<'s, B: Backend>(
                         for r in &refs[1..] { c = c.concat(resolve(&items, &imports, &var_cols, r).collection()); }
                         Rendered::Collection(c)
                     },
-                    st::Node::Arrange(r) => Rendered::Arrangement(resolve(&items, &imports, &var_cols, r).arrange()),
+                    st::Node::Arrange(r) => Rendered::Arrangement(arranged(&items, &mut imports, &var_cols, r)),
                     st::Node::Join { left, right, projection } => {
-                        let l = resolve(&items, &imports, &var_cols, left).arrange();
-                        let r = resolve(&items, &imports, &var_cols, right).arrange();
+                        let l = arranged(&items, &mut imports, &var_cols, left);
+                        let r = arranged(&items, &mut imports, &var_cols, right);
                         Rendered::Collection(B::join(l, r, projection, (shape_of(left), shape_of(right))))
                     },
                     st::Node::HalfJoin { stream, arrangement, strict, projection } => {
                         let c = resolve(&items, &imports, &var_cols, stream).collection();
-                        let a = resolve(&items, &imports, &var_cols, arrangement).arrange();
+                        let a = arranged(&items, &mut imports, &var_cols, arrangement);
                         Rendered::Collection(B::half_join(c, a, *strict, projection, level, (shape_of(stream), shape_of(arrangement))))
                     },
-                    st::Node::Reduce { input, reducer, limit } => {
-                        let a = resolve(&items, &imports, &var_cols, input).arrange();
-                        Rendered::Arrangement(B::reduce(a, reducer, *limit, shape_of(input)))
+                    st::Node::Reduce { input, reducer, limit } => match input.as_single() {
+                        Some(input) => {
+                            let a = arranged(&items, &mut imports, &var_cols, input);
+                            Rendered::Arrangement(B::reduce(a, reducer, *limit, shape_of(input)))
+                        },
+                        // Every input is arranged, and the reduce reads the arrangements directly.
+                        None => {
+                            let arrs = input.refs().map(|r| arranged(&items, &mut imports, &var_cols, r)).collect();
+                            let signs = match input {
+                                st::ReduceInput::Merged(inputs) => Some(inputs.iter().map(|(_, sign)| *sign).collect()),
+                                st::ReduceInput::Grouped(_) => None,
+                            };
+                            Rendered::Arrangement(B::reduce_many(arrs, signs, reducer, *limit, input.refs().map(shape_of).collect()))
+                        },
                     },
                     st::Node::Inspect { input, label } => {
                         let c = resolve(&items, &imports, &var_cols, input).collection();
diff --git a/interactive/src/explain/mod.rs b/interactive/src/explain/mod.rs
index 353203755..85894aa21 100644
--- a/interactive/src/explain/mod.rs
+++ b/interactive/src/explain/mod.rs
@@ -21,7 +21,7 @@
 //! of the depth structurally.
 
 use crate::ir::LinearOp;
-use crate::scope_ir::{Bind, Export, Import, Item, Node, Program, Ref, Scope, Source, Var};
+use crate::scope_ir::{Bind, Export, Import, Item, Node, Program, ReduceInput, Ref, Scope, Source, Var};
 
 /// A value-producing site in an original tree: the `path` of `Sub` item
 /// indices from the root, then the site within that scope. Sites are ops and
@@ -87,7 +87,7 @@ fn clone_node(node: &Node, m: impl Fn(&Ref) -> Ref) -> Node {
         Node::Arrange(r) => Node::Arrange(m(r)),
         Node::Join { left, right, projection } => Node::Join { left: m(left), right: m(right), projection: projection.clone() },
         Node::HalfJoin { stream, arrangement, strict, projection } => Node::HalfJoin { stream: m(stream), arrangement: m(arrangement), strict: *strict, projection: projection.clone() },
-        Node::Reduce { input, reducer, limit } => Node::Reduce { input: m(input), reducer: reducer.clone(), limit: *limit },
+        Node::Reduce { input, reducer, limit } => Node::Reduce { input: { let mut input = input.clone(); input.for_each_ref(|r| *r = m(r)); input }, reducer: reducer.clone(), limit: *limit },
         Node::Inspect { input, label } => Node::Inspect { input: m(input), label: label.clone() },
     }
 }
@@ -139,8 +139,12 @@ fn clone_rec(orig: &Scope, out: &mut Scope, import_map: &[Ref], path: &[usize],
                 // A limited reduce depends only on the values it hands its lambda, and these can
                 // differ from round to round as values come and go: they are a site of their own.
                 if let Node::Reduce { input, limit: Some(k), .. } = node {
+                    // A merged reduce keeps its inputs and signs, so the lambda sees the same
+                    // consolidated values as in the original.
+                    let mut mapped = input.clone();
+                    mapped.for_each_ref(|r| *r = map_ref(r, &locals, &subs, import_map, var_base));
                     let presented = Node::Reduce {
-                        input: map_ref(input, &locals, &subs, import_map, var_base),
+                        input: mapped,
                         reducer: Reducer::Expr(crate::parse::Reducer::Distinct.lambda()),
                         limit: Some(*k),
                     };
@@ -373,7 +377,7 @@ impl Sb {
     }
     fn reduce(&mut self, input: Ref, reducer: Reducer) -> Ref {
         let a = self.op(Node::Arrange(input));
-        self.op(Node::Reduce { input: a, reducer, limit: None })
+        self.op(Node::Reduce { input: ReduceInput::single(a), reducer, limit: None })
     }
     fn variable(&mut self, name: &str) -> Ref {
         let v = self.s.vars.len();
@@ -1023,25 +1027,30 @@ impl<'a> Reverse<'a> {
             Node::Arrange(input) | Node::Inspect { input, .. } => {
                 self.push(ex, path, input, dep_this);
             }
+            // Each input, merged or grouped, contributes the rows at the demanded keys.
             Node::Reduce { input, limit: None, .. } => {
-                let target = resolve(self.orig, path, input);
-                let side = self.side(&target);
-                let (dep, out_len) = align(ex, dep_this, path, target_path(&target));
-                let contrib = ex.emit_lookup_keyed(dep, &side, out_len);
-                self.contribs.entry(target).or_default().push(contrib);
+                for r in input.refs() {
+                    let target = resolve(self.orig, path, r);
+                    let side = self.side(&target);
+                    let (dep, out_len) = align(ex, dep_this.clone(), path, target_path(&target));
+                    let contrib = ex.emit_lookup_keyed(dep, &side, out_len);
+                    self.contribs.entry(target).or_default().push(contrib);
+                }
             }
             // A limited reduce reads only each key's first values. Its output at a chain is decided
             // by the values first at that chain and at every chain before it, so it depends on the
             // values it handed its lambda at those chains, and on every input row holding them up
             // to the demanded chain: with them, each round's first values are as in the reference.
             Node::Reduce { input, limit: Some(_), .. } => {
-                let target = resolve(self.orig, path, input);
-                let side = self.side(&target);
                 let presented = self.side(&Target::Site(Addr { path: path.to_vec(), site: Site::Presented(i) }));
                 let values = ex.emit_lookup_presented(dep_this, &presented, path.len());
-                let (dep, out_len) = align(ex, values, path, target_path(&target));
-                let contrib = ex.emit_lookup_shape_preserving(dep, &side, out_len);
-                self.contribs.entry(target).or_default().push(contrib);
+                for r in input.refs() {
+                    let target = resolve(self.orig, path, r);
+                    let side = self.side(&target);
+                    let (dep, out_len) = align(ex, values.clone(), path, target_path(&target));
+                    let contrib = ex.emit_lookup_shape_preserving(dep, &side, out_len);
+                    self.contribs.entry(target).or_default().push(contrib);
+                }
             }
             // It reads its stream's whole times, as `lift` does.
             Node::HalfJoin { .. } => panic!("explain: half_join is not supported"),
diff --git a/interactive/src/lambda.rs b/interactive/src/lambda.rs
index 4e1aaca35..f4ece4b1b 100644
--- a/interactive/src/lambda.rs
+++ b/interactive/src/lambda.rs
@@ -404,8 +404,21 @@ pub(crate) fn compile_flatmap(list: &Lambda, kshape: &Shape, vshape: &Shape) ->
 /// values') → a corgi `List` column of `(val, diff)`, one list per key. The result is compiled at
 /// that input, so the backend narrows it without compiling it again.
 pub(crate) fn compile_reduce(lambda: &Lambda, kshape: &Shape, vshape: &Shape) -> Res<corgi::Compiled> {
-    let list = Shape::List(Box::new(Shape::Prod(vec![vshape.clone(), Shape::Int])));
-    match slot_graph(lambda, &[kshape.clone(), list])? {
+    compile_grouped_reduce(lambda, kshape, std::slice::from_ref(vshape))
+}
+
+/// The rows a `reduce` lambda reads over inputs of values `vshapes`: the key, then one list of
+/// `(val, diff)` per input. One input gives the `(key, vals)` of a plain reduce.
+pub(crate) fn reduce_rows(kshape: &Shape, vshapes: &[Shape]) -> Vec<Shape> {
+    std::iter::once(kshape.clone())
+        .chain(vshapes.iter().map(|v| Shape::List(Box::new(Shape::Prod(vec![v.clone(), Shape::Int])))))
+        .collect()
+}
+
+/// [`compile_reduce`] over `(key, vals_0, .., vals_{n-1})`, one list of `(val, diff)` per input of
+/// value shape `vshapes[i]`, as a grouped reduce hands them.
+pub(crate) fn compile_grouped_reduce(lambda: &Lambda, kshape: &Shape, vshapes: &[Shape]) -> Res<corgi::Compiled> {
+    match slot_graph(lambda, &reduce_rows(kshape, vshapes))? {
         (g, Shape::List(e)) if matches!(&*e, Shape::Prod(fs) if fs.len() == 2 && fs[1] == Shape::Int) => Ok(g),
         (_, other) => Err(format!("reduce output is not a list of (val, diff): {other}")),
     }
diff --git a/interactive/src/lower.rs b/interactive/src/lower.rs
index 7ff7c21de..6f9dcb1b7 100644
--- a/interactive/src/lower.rs
+++ b/interactive/src/lower.rs
@@ -195,7 +195,8 @@ fn resolve_expr(expr: &mut Expr, here: &[String], item: Option<&str>,
             resolve_expr(l, here, item, scopes, plan);
             resolve_expr(r, here, item, scopes, plan);
         }
-        Expr::Concat(parts) => for part in parts { resolve_expr(part, here, item, scopes, plan); },
+        Expr::Concat(parts) | Expr::GroupedReduce(parts, _) => for part in parts { resolve_expr(part, here, item, scopes, plan); },
+        Expr::List(parts) => for (_, part) in parts { resolve_expr(part, here, item, scopes, plan); },
         Expr::Input(..) | Expr::Import(_) | Expr::Name(_) | Expr::ResolvedPath { .. } => {},
     }
 }
@@ -251,7 +252,8 @@ fn expr_free_names(expr: &Expr, out: &mut BTreeSet<RefName>) {
             | Expr::FlatMap(e, _) | Expr::Lift(e) | Expr::JoinFunction(e, _)
             | Expr::Inspect(e, _) | Expr::Arrange(e) => expr_free_names(e, out),
         Expr::Join(l, r, _) | Expr::HalfJoin(l, r, _, _) => { expr_free_names(l, out); expr_free_names(r, out); },
-        Expr::Concat(es) => { for e in es { expr_free_names(e, out); } },
+        Expr::Concat(es) | Expr::GroupedReduce(es, _) => { for e in es { expr_free_names(e, out); } },
+        Expr::List(es) => { for (_, e) in es { expr_free_names(e, out); } },
     }
 }
 
@@ -298,8 +300,20 @@ fn collect_body_references(body: &[Stmt], out: &mut BTreeSet<RefName>) {
 
 use crate::scope_ir as st;
 
-pub(crate) fn is_arranged(input: &st::Ref, items: &[st::Item]) -> bool {
-    matches!(input, st::Ref::Local(i) if matches!(&items[*i], st::Item::Op(st::Node::Arrange(_) | st::Node::Reduce { .. })))
+/// Whether `input` is already an arrangement. A local item is one when it is an
+/// arrange or a reduce. An import is one when it names a trace, or when it enters
+/// a parent item that is itself arranged (`parent_arranged`, indexed by import id).
+/// Input imports are collections.
+pub(crate) fn is_arranged(input: &st::Ref, items: &[st::Item], imports: &[st::Import], parent_arranged: &[bool]) -> bool {
+    match input {
+        st::Ref::Local(i) => matches!(&items[*i], st::Item::Op(st::Node::Arrange(_) | st::Node::Reduce { .. })),
+        st::Ref::Import(i) => match &imports[*i].from {
+            st::Source::Trace(_) => true,
+            st::Source::Parent(_) => parent_arranged[*i],
+            st::Source::Input(_) => false,
+        },
+        _ => false,
+    }
 }
 
 pub fn lower_tree(mut stmts: Vec<Stmt>) -> st::Program {
@@ -311,9 +325,9 @@ pub fn lower_tree(mut stmts: Vec<Stmt>) -> st::Program {
     resolve_body(&mut stmts, &[], &scopes, &mut plan);
     let empty = HashMap::new();
     let mut distinct = HashMap::new();
-    let mut program = st::Program { root: lower_scope_tree(&[], &stmts, &empty, &[], &plan, true, &mut distinct) };
+    let mut program = st::Program { root: lower_scope_tree(&[], &stmts, &empty, &[], &plan, true, None, &mut distinct) };
     let (shapes, _) = crate::shapes::infer(&program, &|_| None, 1);
-    crate::reducers::expand_distinct(&mut program.root, &shapes, &distinct, &mut Vec::new());
+    crate::reducers::expand_distinct(&mut program.root, &shapes, &distinct, &[], &mut Vec::new());
     program
 }
 
@@ -328,6 +342,8 @@ struct ScopeLower {
     /// The statement being lowered, which names the items it pushes.
     statement: String,
     imports: Vec<st::Import>,
+    /// Per import, whether it enters an arranged item of the parent scope.
+    parent_arranged: Vec<bool>,
     input_import: HashMap<usize, usize>, // input n  -> import idx (root, deduped)
     trace_import: HashMap<String, usize>, // trace name -> import idx (root, deduped)
     env: HashMap<RefName, st::Ref>,        // local names, qualified child exports, and imports
@@ -341,7 +357,7 @@ impl ScopeLower {
         st::Ref::Local(i)
     }
     fn arrange(&mut self, input: st::Ref) -> st::Ref {
-        if is_arranged(&input, &self.items) { input }
+        if is_arranged(&input, &self.items, &self.imports, &self.parent_arranged) { input }
         else { self.push(st::Node::Arrange(input)) }
     }
     /// Input `n`, named as written (`input "name"`), or `input{n}` if it is unnamed.
@@ -351,6 +367,7 @@ impl ScopeLower {
         let i = self.imports.len();
         let name = name.map_or_else(|| format!("input{n}"), str::to_string);
         self.imports.push(st::Import { name, from: st::Source::Input(n), shape: None });
+        self.parent_arranged.push(false);
         self.input_import.insert(n, i);
         st::Ref::Import(i)
     }
@@ -359,6 +376,7 @@ impl ScopeLower {
         if let Some(&i) = self.trace_import.get(name) { return st::Ref::Import(i); }
         let i = self.imports.len();
         self.imports.push(st::Import { name: name.to_string(), from: st::Source::Trace(name.to_string()), shape: None });
+        self.parent_arranged.push(false);
         self.trace_import.insert(name.to_string(), i);
         st::Ref::Import(i)
     }
@@ -402,21 +420,38 @@ impl ScopeLower {
                 let rr = self.lower_expr(r); let ra = self.arrange(rr);
                 self.push(st::Node::HalfJoin { stream, arrangement: ra, strict: *strict, projection: p.clone() })
             },
+            Expr::Reduce(e, red) if matches!(&**e, Expr::List(parts) if parts.len() != 1 || parts[0].0 < 0) => {
+                let Expr::List(parts) = &**e else { unreachable!() };
+                // Each element is an input of its own, so its sign becomes the input's sign and no
+                // `negate` is built. A merged distinct is not a by-record site: no arrangement of
+                // the sum exists to be keyed by the record, and `Distinct` handles any values.
+                let inputs = parts.iter().map(|(sign, part)| { let r = self.lower_expr(part); (self.arrange(r), *sign) }).collect();
+                self.push(st::Node::Reduce { input: st::ReduceInput::Merged(inputs), reducer: crate::ir::Reducer::Expr(red.lambda()), limit: red.limit() })
+            },
             Expr::Reduce(e, red)=> {
+                // `[e]` is `e`.
+                let e = match &**e { Expr::List(parts) => &parts[0].1, e => e };
                 let r = self.lower_expr(e);
                 let a = if matches!(red, Reducer::Distinct) {
                     // Once shapes are known, lower distinct by key or by whole record.
                     self.distinct.push(self.items.len());
                     r
                 } else { self.arrange(r) };
-                self.push(st::Node::Reduce { input: a, reducer: crate::ir::Reducer::Expr(red.lambda()), limit: red.limit() })
+                self.push(st::Node::Reduce { input: st::ReduceInput::single(a), reducer: crate::ir::Reducer::Expr(red.lambda()), limit: red.limit() })
+            },
+            // A grouped reduce reads every input arranged, as a join does.
+            Expr::GroupedReduce(es, lambda) => {
+                let inputs = es.iter().map(|input| { let r = self.lower_expr(input); self.arrange(r) }).collect();
+                self.push(st::Node::Reduce { input: st::ReduceInput::Grouped(inputs), reducer: crate::ir::Reducer::Expr(lambda.clone()), limit: None })
             },
             Expr::Inspect(e, l) => { let r = self.lower_expr(e); self.push(st::Node::Inspect { input: r, label: l.clone() }) },
+            Expr::List(_) => unreachable!("the parser admits a list only as the input of a reduce"),
             Expr::Concat(es)    => { let rs: Vec<st::Ref> = es.iter().map(|e| self.lower_expr(e)).collect(); self.push(st::Node::Concat(rs)) },
         }
     }
 }
 
+#[expect(clippy::too_many_arguments, reason = "the scope tree walk threads its environment through parameters")]
 fn lower_scope_tree(
     address: &[String],
     body: &[Stmt],
@@ -424,6 +459,7 @@ fn lower_scope_tree(
     exports_wanted: &[PathKey],
     plan: &PathPlan,
     is_root: bool,
+    parent: Option<&ScopeLower>,
     distinct: &mut HashMap<Vec<String>, Vec<usize>>,
 ) -> st::Scope {
     let scope_name = scope_label(address);
@@ -434,6 +470,7 @@ fn lower_scope_tree(
         labels: Vec::new(),
         statement: String::new(),
         imports: Vec::new(),
+        parent_arranged: Vec::new(),
         input_import: HashMap::new(),
         trace_import: HashMap::new(),
         env: HashMap::new(),
@@ -453,6 +490,7 @@ fn lower_scope_tree(
                 RefName::Path(key) => panic!("path `{}` is unavailable in scope `{scope_name}`", key.display()),
             });
             let i = s.imports.len();
+            s.parent_arranged.push(parent.is_some_and(|p| is_arranged(&from, &p.items, &p.imports, &p.parent_arranged)));
             s.imports.push(st::Import { name: match &name {
                 RefName::Plain(n) => n.clone(),
                 RefName::Path(key) => key.display(),
@@ -558,7 +596,7 @@ fn lower_scope_tree(
                 let mut child_address = address.to_vec();
                 child_address.push(name.clone());
                 let wanted: Vec<PathKey> = plan.exports.get(&child_address).into_iter().flatten().cloned().collect();
-                let child = lower_scope_tree(&child_address, b, &s.env, &wanted, plan, false, distinct);
+                let child = lower_scope_tree(&child_address, b, &s.env, &wanted, plan, false, Some(&s), distinct);
                 let slots = export_slots(&wanted, &child_address);
                 let cidx = s.items.len();
                 s.items.push(st::Item::Sub(child));
@@ -662,13 +700,47 @@ mod tree_tests {
             let inputs = match item {
                 st::Item::Op(st::Node::Join { left, right, .. }) => vec![left, right],
                 st::Item::Op(st::Node::HalfJoin { arrangement, .. }) => vec![arrangement],
-                st::Item::Op(st::Node::Reduce { input, .. }) => vec![input],
+                st::Item::Op(st::Node::Reduce { input, .. }) => input.refs().collect(),
                 _ => Vec::new(),
             };
-            for input in inputs { assert!(is_arranged(input, &program.root.items), "{item:?}"); }
+            for input in inputs { assert!(is_arranged(input, &program.root.items, &program.root.imports, &[]), "{item:?}"); }
         }
     }
 
+    #[test]
+    fn arranged_trace_import_is_not_rearranged() {
+        let program = lower_tree(parse(r#"
+            let x = import "p::x" : (int, int);
+            output "o" = x | min;
+        "#));
+        assert!(!program.root.items.iter().any(|i| matches!(i, st::Item::Op(st::Node::Arrange(_)))));
+        assert!(program.root.items.iter().any(|i| matches!(i, st::Item::Op(st::Node::Reduce { input, .. }) if matches!(input.as_single(), Some(Ref::Import(_))))));
+    }
+
+    #[test]
+    fn arranged_parent_is_not_rearranged_in_child() {
+        let program = lower_tree(parse(r#"
+            let a = input 0 : (int, int) | arrange;
+            s: { let m = ::a | min; }
+            output "o" = s::m;
+        "#));
+        let s = child(&program.root, "s");
+        assert!(!s.items.iter().any(|i| matches!(i, st::Item::Op(st::Node::Arrange(_)))));
+    }
+
+    #[test]
+    fn child_rearranges_a_parent_rewritten_by_record_distinct() {
+        let program = lower_tree(parse(r#"
+            let a = input 0 : (int, int);
+            let d = a | distinct;
+            s: { let m = ::d | min; }
+            output "o" = s::m;
+        "#));
+        // A by-record distinct ends in a map, so the child must arrange its import.
+        let s = child(&program.root, "s");
+        assert!(s.items.iter().any(|i| matches!(i, st::Item::Op(st::Node::Arrange(Ref::Import(_))))));
+    }
+
     #[test]
     fn keeps_explicit_arranges_and_scope_boundaries() {
         let program = lower_tree(parse(r#"
@@ -684,7 +756,9 @@ mod tree_tests {
         }).collect();
         assert!(arranges.iter().any(|input| matches!(input, Ref::ChildExport(..))));
         let inner = child(&program.root, "inner");
-        assert!(matches!(&inner.items[0], st::Item::Op(st::Node::Arrange(Ref::Import(_)))));
+        // The arranged parent item is entered as an arrangement, so the child reads it as is.
+        assert!(matches!(&inner.items[0], st::Item::Op(st::Node::Reduce { input, .. }) if matches!(input.as_single(), Some(Ref::Import(_)))));
+        assert!(!inner.items.iter().any(|item| matches!(item, st::Item::Op(st::Node::Arrange(_)))));
     }
 
     #[test]
diff --git a/interactive/src/parse/mod.rs b/interactive/src/parse/mod.rs
index 06d957a74..8ec4eea81 100644
--- a/interactive/src/parse/mod.rs
+++ b/interactive/src/parse/mod.rs
@@ -58,6 +58,10 @@ pub enum Expr {
     /// `stream | half_join(arrangement, strict, projection)`: see `scope_ir::Node::HalfJoin`.
     HalfJoin(Box<Expr>, Box<Expr>, bool, Lambda),
     Reduce(Box<Expr>, Reducer),
+    /// `a | reduce(b, .., (k, la, lb, ..) -> out)`: a reduce over two or more co-keyed inputs, the
+    /// first of them `a`, whose lambda is handed one `(val, diff)` list per input. See
+    /// `scope_ir::ReduceInput::Grouped`.
+    GroupedReduce(Vec<Expr>, Lambda),
     Filter(Box<Expr>, Lambda),
     Negate(Box<Expr>),
     /// Append the current user-iter coord (at the operator's scope depth)
@@ -79,6 +83,9 @@ pub enum Expr {
     Inspect(Box<Expr>, String),
     Concat(Vec<Expr>),
     Arrange(Box<Expr>),
+    /// `[e, -f, ..]`: the signed elements, each sign `1` or `-1`. Only a reduce reads one, as its
+    /// input (`Reduce(List(..), _)`), the sum of its elements.
+    List(Vec<(crate::ir::Diff, Expr)>),
 }
 
 #[derive(Debug)]
diff --git a/interactive/src/parse/pipe.rs b/interactive/src/parse/pipe.rs
index fc7540180..f74b1181a 100644
--- a/interactive/src/parse/pipe.rs
+++ b/interactive/src/parse/pipe.rs
@@ -40,7 +40,19 @@
 //!   non-zero diffs, a `List` of `(val, diff)` in value order, and `out` the key's output, a
 //!   `List` of `(val, diff)`. `| reduce(limit n, (k, vals) -> out)` hands the lambda only each
 //!   key's first `n` values (`n` at least one), whatever their diffs; `min` is
-//!   `reduce(limit 1, (_, vals) -> (vals head.0, 1) enlist)`.
+//!   `reduce(limit 1, (_, vals) -> (vals head.0, 1) enlist)`. `limit` is the keyword only when an
+//!   integer follows it.
+//! - `a | reduce(b, c, (k, la, lb, lc) -> out)`: reduce over co-keyed inputs, `a` and the
+//!   collections before the lambda: the lambda is handed the key and one `(val, diff)` list per
+//!   input, `la` the values of `a`, each in value order and empty where its input holds nothing at
+//!   the key. Equal values of two inputs stay in their own lists. The inputs share a key shape and
+//!   may differ in value shape. `out` is as for `reduce`. It takes no `limit`, and no bracket list.
+//! - `[a, -b] | min` (also `distinct`, `count`, `collect`, `reduce(..)`): reduce the signed sum of
+//!   a bracket list of collections, as `a - b | min` does but without arranging the sum. Each element
+//!   is an optional `-` and a pipe expression up to the next `,` or `]`, and the sign covers the
+//!   whole element. A list is no collection: only a reduce reads one, so it must be followed by one
+//!   of those stages. `[e]` is `e`, except that a list of any length, `[e]` included, cannot take
+//!   extra reduce inputs.
 //! - `| filter((k, v) -> mask)` — keep rows where the lambda gives a nonzero `Int`.
 //! - `| flatmap((k, v) -> list)` — UNNEST: explode the `List` the lambda gives into one row per
 //!   element, value `(pos, element)`.
@@ -84,12 +96,12 @@
 //! # Lambdas
 //!
 //! A slot runs `let pat = input in body` in corgi's ML syntax, with `input` the tuple of the
-//! slot's rows: `(key, val)` for a linear op, `(key, left val, right val)` for a join, and
-//! `(key, vals)` for `reduce`. For example, `map(((src, dst), ()) -> (src, dst))` keys each row
-//! of pairs by its first field. Operators are postfix (`(a, b) add`, `xs len`,
-//! `(mask, a, b) select`); `x.N` is a tuple's field, `(e)` a one-field tuple and `()` unit;
-//! `[1, 2]` is a list of constants and `(xs, ys) append` concatenates. A `--` comment may sit
-//! inside a lambda. The language is corgi's (its `frontend/ml.rs` and `NOTES.md`).
+//! slot's rows: `(key, val)` for a linear op, `(key, left val, right val)` for a join,
+//! `(key, vals)` for `reduce`, and `(key, vals_0, vals_1, ..)` for a reduce over several inputs.
+//! For example, `map(((src, dst), ()) -> (src, dst))` keys each row of pairs by its first field.
+//! Operators are postfix (`(a, b) add`, `xs len`, `(mask, a, b) select`); `x.N` is a tuple's
+//! field, `(e)` a one-field tuple and `()` unit; `[1, 2]` is a list of constants and
+//! `(xs, ys) append` concatenates. A `--` comment may sit inside a lambda. The language is corgi's (its `frontend/ml.rs` and `NOTES.md`).
 //!
 //! A lambda is parsed in its program's scope, which names what the program has not defined:
 //!
@@ -122,11 +134,13 @@ enum Token {
     Ident(String), Int(i64), Str(String),
     /// A slot written as a corgi lambda, `pat -> body`, kept as corgi source.
     Lambda { pat: String, body: String },
-    LParen, RParen, LBrace, RBrace,
+    LParen, RParen, LBrace, RBrace, LBracket, RBracket,
     Comma, Semi, Colon, ColonColon, Eq,
     Pipe, Plus, Minus, Eof,
 }
 
+const LIST_MISUSE: &str = "a list of collections is the input of a reduce";
+
 /// A shape before names in type declarations have been resolved.
 enum TypeShape {
     Unit, Int, Float,
@@ -253,6 +267,8 @@ fn lex(input: &str) -> Vec<Token> {
                 }
             },
             ')' => { chars.next(); tokens.push(Token::RParen); },
+            '[' => { chars.next(); tokens.push(Token::LBracket); },
+            ']' => { chars.next(); tokens.push(Token::RBracket); },
             '{' => { chars.next(); tokens.push(Token::LBrace); },
             '}' => { chars.next(); tokens.push(Token::RBrace); },
             ',' => { chars.next(); tokens.push(Token::Comma); },
@@ -523,8 +539,21 @@ impl Parser {
 
     /// An atom followed by stages, applied left to right: `| op`, `+ atom` and `- atom`. A run of
     /// `+`/`-` stages is one `Concat`.
+    ///
+    /// A bracket list `[e, -f]` is only the input of a reduce, so it must start the expression
+    /// and the next stage must be `| min`, `| distinct`, `| count`, `| collect` or `| reduce(`.
     fn parse_pipe_expr(&mut self) -> Expr {
-        let mut expr = self.parse_atom();
+        let mut expr = if *self.peek() == Token::LBracket {
+            let list = self.parse_list();
+            // The token stream ends in `Eof`, so a `Pipe` has a successor.
+            let reduces = *self.peek() == Token::Pipe && match &self.tokens[self.pos + 1] {
+                Token::Min | Token::Distinct | Token::Count | Token::Collect => true,
+                Token::Ident(word) => word == "reduce",
+                _ => false,
+            };
+            assert!(reduces, "{LIST_MISUSE}");
+            list
+        } else { self.parse_atom() };
         let mut concat = false;
         loop {
             let part = match self.peek() {
@@ -542,6 +571,23 @@ impl Parser {
         expr
     }
 
+    /// `[` element `,` element `]`, each element an optional `-` and a pipe expression that ends at
+    /// the next top-level `,` or `]`. The sign covers the whole element.
+    fn parse_list(&mut self) -> Expr {
+        self.expect(&Token::LBracket);
+        let mut elements = Vec::new();
+        loop {
+            let sign = if *self.peek() == Token::Minus { self.next(); -1 } else { 1 };
+            elements.push((sign, self.parse_pipe_expr()));
+            match self.next() {
+                Token::Comma => {},
+                Token::RBracket => break,
+                other => panic!("Expected `,` or `]` in a list, got {:?}", other),
+            }
+        }
+        Expr::List(elements)
+    }
+
     fn parse_atom(&mut self) -> Expr {
         match self.peek().clone() {
             Token::Input => {
@@ -578,6 +624,7 @@ impl Parser {
                 else { Expr::Name(parts.pop().unwrap()) }
             },
             Token::LParen => { self.next(); let e = self.parse_pipe_expr(); self.expect(&Token::RParen); e },
+            Token::LBracket => panic!("{LIST_MISUSE}"),
             other => panic!("Unexpected token in atom: {:?}", other),
         }
     }
@@ -624,7 +671,8 @@ impl Parser {
             Token::Ident(name) if name == "reduce" => {
                 self.next(); self.expect(&Token::LParen);
                 // `reduce(limit k, (k, vals) -> …)`: the lambda is handed each key's first `k` values.
-                let limit = if matches!(self.peek(), Token::Ident(word) if word == "limit") {
+                // `limit` is the keyword only before an integer, else it names a collection.
+                let limit = if matches!(self.peek(), Token::Ident(word) if word == "limit") && matches!(self.tokens[self.pos + 1], Token::Int(_)) {
                     self.next();
                     let k = match self.next() {
                         Token::Int(k) if k > 0 => k as usize,
@@ -633,9 +681,20 @@ impl Parser {
                     self.expect(&Token::Comma);
                     Some(k)
                 } else { None };
+                // `reduce(b, c, (k, la, lb, lc) -> …)`: the collections before the lambda are further
+                // inputs of a grouped reduce.
+                let mut inputs = Vec::new();
+                while !matches!(self.peek(), Token::Lambda { .. }) {
+                    inputs.push(self.parse_pipe_expr());
+                    self.expect(&Token::Comma);
+                }
                 let lambda = self.lambda();
                 self.expect(&Token::RParen);
-                Expr::Reduce(Box::new(lhs), Reducer::Expr(lambda, limit))
+                if inputs.is_empty() { return Expr::Reduce(Box::new(lhs), Reducer::Expr(lambda, limit)); }
+                assert!(!matches!(lhs, Expr::List(_)), "a list of collections cannot take extra reduce inputs");
+                assert!(limit.is_none(), "a reduce over several inputs takes no limit");
+                inputs.insert(0, lhs);
+                Expr::GroupedReduce(inputs, lambda)
             },
             Token::FlatMap => { self.next(); Expr::FlatMap(Box::new(lhs), self.slot()) },
             Token::Arrange => { self.next(); Expr::Arrange(Box::new(lhs)) },
diff --git a/interactive/src/passes/arrangements.rs b/interactive/src/passes/arrangements.rs
index 8d533836f..cc1bc5b61 100644
--- a/interactive/src/passes/arrangements.rs
+++ b/interactive/src/passes/arrangements.rs
@@ -21,7 +21,8 @@ fn key(r: &Ref) -> (u8, usize, usize) {
     }
 }
 
-fn arranged(scope: &Scope, imports: &[bool], r: &Ref) -> bool {
+/// Whether `r` is statically arranged in `scope`, whose imports are arranged as `imports` says.
+pub(super) fn arranged(scope: &Scope, imports: &[bool], r: &Ref) -> bool {
     match r {
         Ref::Local(i) => matches!(scope.items[*i], Item::Op(Node::Arrange(_) | Node::Reduce { .. })),
         Ref::Import(i) => imports[*i],
@@ -30,7 +31,8 @@ fn arranged(scope: &Scope, imports: &[bool], r: &Ref) -> bool {
     }
 }
 
-fn child_imports(scope: &Scope, imports: &[bool], child: &Scope) -> Vec<bool> {
+/// Per import of `child`, whether it reads an arranged value of `scope`.
+pub(super) fn child_imports(scope: &Scope, imports: &[bool], child: &Scope) -> Vec<bool> {
     child.imports.iter().map(|i| match &i.from {
         Source::Parent(r) => arranged(scope, imports, r),
         _ => false,
diff --git a/interactive/src/passes/as_of.rs b/interactive/src/passes/as_of.rs
index 4cdbe55cd..280bf27e0 100644
--- a/interactive/src/passes/as_of.rs
+++ b/interactive/src/passes/as_of.rs
@@ -103,7 +103,8 @@ fn uses(s: &Scope) -> Vec<Vec<Use>> {
                 add(arrangement, Use::Other);
             }
             Item::Op(Node::Linear { input, ops }) => add(input, if ops.iter().all(keeps_times) { Use::Linear(c) } else { Use::Other }),
-            Item::Op(Node::Arrange(r) | Node::Reduce { input: r, .. } | Node::Inspect { input: r, .. }) => add(r, Use::Other),
+            Item::Op(Node::Arrange(r) | Node::Inspect { input: r, .. }) => add(r, Use::Other),
+            Item::Op(Node::Reduce { input, .. }) => for r in input.refs() { add(r, Use::Other); },
             Item::Op(Node::Join { left, right, .. }) => { add(left, Use::Other); add(right, Use::Other); }
             Item::Op(Node::Concat(refs)) => for r in refs { add(r, Use::Other); },
             Item::Sub(child) => for imp in &child.imports {
diff --git a/interactive/src/passes/dead_code.rs b/interactive/src/passes/dead_code.rs
index 130d20631..6f63eeb1b 100644
--- a/interactive/src/passes/dead_code.rs
+++ b/interactive/src/passes/dead_code.rs
@@ -64,7 +64,8 @@ fn analyze(scope: &Scope, exports: Option<&[bool]>) -> Live {
                 if !live.items[i] { continue; }
                 match node {
                     Node::Linear { input, .. } | Node::Arrange(input)
-                    | Node::Reduce { input, .. } | Node::Inspect { input, .. } => live.mark(input),
+                    | Node::Inspect { input, .. } => live.mark(input),
+                    Node::Reduce { input, .. } => for r in input.refs() { live.mark(r); },
                     Node::Join { left, right, .. } => { live.mark(left); live.mark(right); }
                     Node::HalfJoin { stream, arrangement, .. } => { live.mark(stream); live.mark(arrangement); }
                     Node::Concat(refs) => for r in refs { live.mark(r); },
diff --git a/interactive/src/passes/merge_reduce.rs b/interactive/src/passes/merge_reduce.rs
new file mode 100644
index 000000000..d8c242f3a
--- /dev/null
+++ b/interactive/src/passes/merge_reduce.rs
@@ -0,0 +1,242 @@
+//! Reduce a concatenation through its leaves' arrangements.
+//!
+//! `reduce(arrange(concat(±x1, .., ±xn)))`, where the arrange, the concat, and any negation of a
+//! part have no other reader, becomes a reduce over `Merged([(x1, ±1), .., (xn, ±1)])`. Nested
+//! single-use concats flatten, and single-use negations fold into the signs, so two of them cancel.
+//! Any other operator ends a leaf. The rewrite fires only when a leaf is statically arranged: an
+//! `Arrange` or `Reduce` item, or an import of an arranged value. The reduce reads that leaf's
+//! arrangement as it is. The other leaves go into one new signed `Concat` under one new `Arrange`,
+//! which holds what the old arrangement held of them, so the arranged leaves are no longer copied.
+//! A single unarranged leaf gets its own `Arrange` and keeps its sign as the input's sign.
+//!
+//! The pass must run before code motion: hoisting can move a loop-invariant negation out of an
+//! iterative scope, where its import is no longer one this pass can fold.
+
+use crate::scope_ir::{Item, Node, ReduceInput, Ref, Scope};
+use crate::ir::{Diff, LinearOp};
+use super::arrangements::{arranged, child_imports};
+use super::structural::{compact, use_counts};
+
+/// Rewrite every scope of the tree rooted at `scope`, whose imports are arranged as `imports`
+/// says. Returns how many reduces were rewritten.
+pub(super) fn run(scope: &mut Scope, imports: &[bool]) -> usize {
+    let mut count = rewrite_scope(scope, imports);
+    for i in 0..scope.items.len() {
+        let Item::Sub(child) = &scope.items[i] else { continue };
+        let arranged_imports = child_imports(scope, imports, child);
+        let Item::Sub(sub) = &mut scope.items[i] else { unreachable!() };
+        count += run(sub, &arranged_imports);
+    }
+    count
+}
+
+/// The signed leaves of `r` read with `sign`, through single-use concats and negations, which are
+/// added to `absorbed`.
+fn leaves(scope: &Scope, uses: &[usize], r: &Ref, sign: Diff, absorbed: &mut Vec<usize>, out: &mut Vec<(Ref, Diff)>) {
+    if let Ref::Local(n) = r {
+        if uses[*n] == 1 {
+            match &scope.items[*n] {
+                Item::Op(Node::Concat(refs)) => {
+                    absorbed.push(*n);
+                    for part in refs { leaves(scope, uses, part, sign, absorbed, out); }
+                    return;
+                }
+                Item::Op(Node::Linear { input, ops }) if !ops.is_empty() && ops.iter().all(|op| matches!(op, LinearOp::Negate)) => {
+                    absorbed.push(*n);
+                    let sign = if ops.len() % 2 == 1 { -sign } else { sign };
+                    leaves(scope, uses, input, sign, absorbed, out);
+                    return;
+                }
+                _ => {}
+            }
+        }
+    }
+    out.push((r.clone(), sign));
+}
+
+#[expect(clippy::needless_range_loop, reason = "the loops index `inserted` while a closure borrows it mutably")]
+fn rewrite_scope(scope: &mut Scope, imports: &[bool]) -> usize {
+    let count = scope.items.len();
+    let uses = use_counts(scope, &vec![false; count]);
+    let mut dead = vec![false; count];
+    // Per rewritten reduce, the items it needs, in dependency order, inserted just before it.
+    let mut inserted: Vec<Vec<usize>> = vec![Vec::new(); count];
+    let mut rewrites = 0;
+    for i in 0..count {
+        let Item::Op(Node::Reduce { input, .. }) = &scope.items[i] else { continue };
+        let Some(Ref::Local(j)) = input.as_single() else { continue };
+        let j = *j;
+        let Item::Op(Node::Arrange(source)) = &scope.items[j] else { continue };
+        if uses[j] != 1 { continue; }
+        let (mut absorbed, mut found) = (vec![j], Vec::new());
+        leaves(scope, &uses, source, 1, &mut absorbed, &mut found);
+        // Only a concat or a negation makes a merged reduce, and only an arranged leaf saves.
+        if absorbed.len() == 1 || !found.iter().any(|(r, _)| arranged(scope, imports, r)) { continue; }
+        let mut merged = Vec::with_capacity(found.len());
+        let mut rest = Vec::new();
+        for (leaf, sign) in found {
+            if arranged(scope, imports, &leaf) { merged.push((leaf, sign)); } else { rest.push((leaf, sign)); }
+        }
+        let mut add = |target: &mut Scope, node: Node| {
+            let at = target.items.len();
+            target.items.push(Item::Op(node));
+            if target.labels.len() == at { target.labels.push(target.labels[i].clone()); }
+            inserted[i].push(at);
+            Ref::Local(at)
+        };
+        if rest.is_empty() {
+            // Every leaf is arranged already.
+        } else if let [(leaf, sign)] = &rest[..] {
+            let arr = add(scope, Node::Arrange(leaf.clone()));
+            merged.push((arr, *sign));
+        } else {
+            // A negated part is a negate node feeding the concat, as `a - b` lowers.
+            let parts = rest.into_iter().map(|(leaf, sign)| {
+                if sign < 0 { add(scope, Node::Linear { input: leaf, ops: vec![LinearOp::Negate] }) } else { leaf }
+            }).collect();
+            let concat = add(scope, Node::Concat(parts));
+            let arr = add(scope, Node::Arrange(concat));
+            merged.push((arr, 1));
+        }
+        for n in absorbed { dead[n] = true; }
+        let Item::Op(Node::Reduce { input: rewritten, .. }) = &mut scope.items[i] else { unreachable!() };
+        *rewritten = ReduceInput::Merged(merged);
+        rewrites += 1;
+    }
+    if rewrites == 0 { return 0; }
+    // The new arranges go just before their reduces, and the absorbed items go.
+    let mut order = Vec::with_capacity(scope.items.len());
+    for i in 0..count {
+        order.extend(inserted[i].iter().copied());
+        order.push(i);
+    }
+    let dead: Vec<bool> = order.iter().map(|&i| i < count && dead[i]).collect();
+    scope.reorder(&order);
+    scope.names.retain(|(_, r)| !matches!(r, Ref::Local(k) if dead[*k]));
+    compact(scope, &dead);
+    rewrites
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::scope_ir::{Item, Node, ReduceInput, Ref, Scope};
+    use crate::ir::LinearOp;
+
+    fn optimized(src: &str, config: &crate::passes::Config) -> crate::scope_ir::Program {
+        let mut p = crate::lower::lower_tree(crate::parse::pipe::parse(src));
+        crate::passes::run(&mut p, &|_| Some((corgi::Shape::Int, corgi::Shape::Int)), config, &crate::server::host_time(0), 1, &mut |_, _, _| {});
+        p
+    }
+
+    fn reduces(scope: &Scope) -> Vec<ReduceInput> {
+        scope.items.iter().flat_map(|item| match item {
+            Item::Op(Node::Reduce { input, .. }) => vec![input.clone()],
+            Item::Sub(child) => reduces(child),
+            _ => Vec::new(),
+        }).collect()
+    }
+
+    /// The only reduce's merged inputs.
+    fn merged(scope: &Scope) -> Vec<(Ref, i64)> {
+        let [ReduceInput::Merged(inputs)] = &reduces(scope)[..] else { panic!("{:?}", reduces(scope)) };
+        inputs.clone()
+    }
+
+    fn default() -> crate::passes::Config { crate::passes::Config::default() }
+
+    /// The unarranged leaves share one arrangement of a signed concat, and an arranged leaf is read as it is.
+    #[test]
+    fn shares_one_arrangement_for_unarranged_leaves() {
+        let src = r#"
+            let a = input 0 : (int, ()) | arrange;
+            let b = input 1 : (int, ());
+            let c = input 2 : (int, ());
+            let d = input 3 : (int, ());
+            output "out" = a + b + c - d | distinct;
+        "#;
+        let p = optimized(src, &default());
+        let inputs = merged(&p.root);
+        assert_eq!(inputs.iter().map(|(_, s)| *s).collect::<Vec<_>>(), vec![1, 1], "{inputs:?}");
+        assert!(matches!(p.root.items[match &inputs[0].0 { Ref::Local(i) => *i, r => panic!("{r:?}") }], Item::Op(Node::Arrange(_))));
+        let Ref::Local(arr) = inputs[1].0 else { panic!("{:?}", inputs[1]) };
+        let Item::Op(Node::Arrange(Ref::Local(concat))) = &p.root.items[arr] else { panic!("{:?}", p.root.items[arr]) };
+        let Item::Op(Node::Concat(parts)) = &p.root.items[*concat] else { panic!("{:?}", p.root.items[*concat]) };
+        assert_eq!(parts.len(), 3);
+        let negated = parts.iter().filter(|part| matches!(part, Ref::Local(n) if matches!(&p.root.items[*n], Item::Op(Node::Linear { ops, .. }) if ops == &[LinearOp::Negate]))).count();
+        assert_eq!(negated, 1, "{parts:?}");
+        assert_eq!(p.root.items.iter().filter(|item| matches!(item, Item::Op(Node::Concat(_)))).count(), 1);
+    }
+
+    /// One unarranged leaf gets its own arrangement and keeps its sign.
+    #[test]
+    fn single_unarranged_leaf_keeps_its_sign() {
+        let src = r#"
+            let a = input 0 : (int, int) | arrange;
+            let b = input 1 : (int, int);
+            output "out" = a - b | count;
+        "#;
+        let p = optimized(src, &default());
+        let inputs = merged(&p.root);
+        assert_eq!(inputs.iter().map(|(_, s)| *s).collect::<Vec<_>>(), vec![1, -1]);
+        let Ref::Local(arr) = inputs[1].0 else { panic!("{:?}", inputs[1]) };
+        assert!(matches!(p.root.items[arr], Item::Op(Node::Arrange(Ref::Import(_)))), "{:?}", p.root.items[arr]);
+        assert!(!p.root.items.iter().any(|item| matches!(item, Item::Op(Node::Concat(_)))));
+    }
+
+    /// With no arranged leaf, or a concat read elsewhere, the reduce stays.
+    #[test]
+    fn no_arranged_leaf_no_rewrite() {
+        let src = r#"let b = input 0 : (int, int); let c = input 1 : (int, int); output "out" = b + c | count;"#;
+        let p = optimized(src, &default());
+        assert!(merged(&p.root).len() == 1 && reduces(&p.root)[0].as_single().is_some());
+        assert!(p.root.items.iter().any(|item| matches!(item, Item::Op(Node::Concat(_)))));
+    }
+
+    /// A concat another output also reads stays, and the reduce keeps its single input.
+    #[test]
+    fn shared_concat_no_rewrite() {
+        let src = r#"
+            let a = input 0 : (int, int) | arrange;
+            let b = input 1 : (int, int);
+            let u = a + b;
+            output "out" = u | count;
+            output "u" = u;
+        "#;
+        let p = optimized(src, &default());
+        assert!(reduces(&p.root)[0].as_single().is_some(), "{:?}", reduces(&p.root));
+    }
+
+    /// A loop-invariant negation of an outer arrangement folds into a sign before hoisting can
+    /// move it out of the loop.
+    #[test]
+    fn loop_negation_folds_before_hoisting() {
+        let src = r#"
+            let seed = input 0 : (int, ()) | arrange;
+            let blocked = input 1 : (int, ()) | arrange;
+            s: { set x = (::seed - ::blocked + x) | distinct; }
+            output "o" = s::x;
+        "#;
+        let p = optimized(src, &crate::passes::Config::all());
+        let Some(Item::Sub(child)) = p.root.items.iter().find(|item| matches!(item, Item::Sub(_))) else { panic!("{:?}", p.root.items) };
+        let folded = reduces(child).iter().any(|input| matches!(input, ReduceInput::Merged(v) if v.iter().any(|(r, s)| *s == -1 && matches!(r, Ref::Import(_)))));
+        assert!(folded, "{:?}", reduces(child));
+    }
+
+    /// A negation another reader uses stays a node and is not folded into a sign.
+    #[test]
+    fn shared_negation_is_not_absorbed() {
+        let src = r#"
+            let a = input 0 : (int, int) | arrange;
+            let b = input 1 : (int, int) | arrange;
+            let nb = b | negate;
+            output "out" = a + nb | count;
+            output "nb" = nb;
+        "#;
+        let p = optimized(src, &default());
+        let inputs = merged(&p.root);
+        assert!(inputs.iter().all(|(_, s)| *s == 1), "{inputs:?}");
+        assert_eq!(inputs.len(), 2, "{inputs:?}");
+        let negates = p.root.items.iter().filter(|item| matches!(item, Item::Op(Node::Linear { ops, .. }) if ops == &[LinearOp::Negate])).count();
+        assert_eq!(negates, 1, "{:?}", p.root.items);
+    }
+}
diff --git a/interactive/src/passes/mod.rs b/interactive/src/passes/mod.rs
index c5ce065c6..2ef7e3146 100644
--- a/interactive/src/passes/mod.rs
+++ b/interactive/src/passes/mod.rs
@@ -7,6 +7,7 @@ mod canonical;
 pub mod projection;
 pub(crate) mod reduce_demand;
 mod as_of;
+mod merge_reduce;
 mod timing;
 pub use timing::{Measurement, Pass, Timings};
 
@@ -63,6 +64,8 @@ pub struct Config {
     pub projection: bool,
     /// Drop updates at the as-of time that only strict half joins would read.
     pub as_of_drop: bool,
+    /// Reduce a single-use concatenation through the arrangements of its arranged leaves.
+    pub merge_reduce: bool,
 }
 
 impl Default for Config {
@@ -71,10 +74,10 @@ impl Default for Config {
 
 impl Config {
     /// The names `parse` takes, in reporting order.
-    pub const NAMES: [&'static str; 7] = ["dead-code", "structural", "collapse-parent-arranges", "hoist-invariant", "compose-maps", "projection", "as-of-drop"];
+    pub const NAMES: [&'static str; 8] = ["dead-code", "structural", "collapse-parent-arranges", "hoist-invariant", "compose-maps", "projection", "as-of-drop", "merge-reduce"];
 
-    pub fn all() -> Self { Self { structural: true, collapse_parent_arranges: true, hoist_invariant: true, compose_maps: true, dead_code: true, projection: true, as_of_drop: true } }
-    pub fn none() -> Self { Self { structural: false, collapse_parent_arranges: false, hoist_invariant: false, compose_maps: false, dead_code: false, projection: false, as_of_drop: false } }
+    pub fn all() -> Self { Self { structural: true, collapse_parent_arranges: true, hoist_invariant: true, compose_maps: true, dead_code: true, projection: true, as_of_drop: true, merge_reduce: true } }
+    pub fn none() -> Self { Self { structural: false, collapse_parent_arranges: false, hoist_invariant: false, compose_maps: false, dead_code: false, projection: false, as_of_drop: false, merge_reduce: false } }
 
     /// Start from the default passes and apply comma-separated words in order: `all`, `none`, a pass
     /// name to turn it on, or `-name` to turn it off. So `none`, `-projection` and
@@ -96,7 +99,7 @@ impl Config {
 
     /// The passes switched off, by name, in schedule order.
     pub fn off(&self) -> Vec<&'static str> {
-        let on = [self.dead_code, self.structural, self.collapse_parent_arranges, self.hoist_invariant, self.compose_maps, self.projection, self.as_of_drop];
+        let on = [self.dead_code, self.structural, self.collapse_parent_arranges, self.hoist_invariant, self.compose_maps, self.projection, self.as_of_drop, self.merge_reduce];
         Self::NAMES.into_iter().zip(on).filter(|(_, on)| !on).map(|(name, _)| name).collect()
     }
 
@@ -109,6 +112,7 @@ impl Config {
             "dead-code" => Some(&mut self.dead_code),
             "projection" => Some(&mut self.projection),
             "as-of-drop" => Some(&mut self.as_of_drop),
+            "merge-reduce" => Some(&mut self.merge_reduce),
             _ => None,
         }
     }
@@ -169,12 +173,12 @@ pub fn run(
             from: ItemName::new(scope, ordinals, from), to: ItemName::new(scope, ordinals, to),
         });
     });
-    for pass in [Pass::DeadCode, Pass::ComposeMaps, Pass::MergeImports] {
+    for pass in [Pass::DeadCode, Pass::ComposeMaps, Pass::MergeImports, Pass::MergeReduce] {
         let count = timings.pass(pass).changes;
         if count > 0 { changes.push(Change::Rewritten { pass, count }); }
     }
     timings.optimizer.record(start.elapsed(), changes.iter().map(Change::count).sum());
-    for (on, name) in [(config.dead_code, "dead-code"), (config.structural, "structural"), (config.collapse_parent_arranges, "collapse-parent-arranges"), (config.hoist_invariant, "hoist-invariant"), (config.compose_maps, "compose-maps")] {
+    for (on, name) in [(config.dead_code, "dead-code"), (config.structural, "structural"), (config.collapse_parent_arranges, "collapse-parent-arranges"), (config.hoist_invariant, "hoist-invariant"), (config.compose_maps, "compose-maps"), (config.merge_reduce, "merge-reduce")] {
         if !on { changes.push(Change::Off(name)); }
     }
     timings.observe("after optimizer", program, &changes, observe);
@@ -240,6 +244,13 @@ pub fn optimize(program: &mut Program) {
 }
 
 fn optimize_with(program: &mut Program, source: &dyn Fn(&Source) -> Option<RowShape>, root: usize, config: &Config, timings: &mut Timings, observe: &mut Observe<'_>) {
+    // Merge reduces of concatenations before hoisting can move a negation out of a loop, where
+    // its import is no longer one the pass can fold.
+    let merge_reduce = |staged: &mut Program, times: &mut Timings| {
+        let imports: Vec<bool> = staged.root.imports.iter().map(|i| matches!(i.from, Source::Trace(_))).collect();
+        times.pass_mut(Pass::MergeReduce).rewrites(|| merge_reduce::run(&mut staged.root, &imports))
+    };
+    if config.merge_reduce { merge_reduce(program, timings); }
     // Move pure statements before fusion can absorb them into a time-sensitive chain.
     // Finish dependent moves too: a hoisted arrange can expose a join, then a map.
     if config.hoist_invariant {
@@ -251,6 +262,7 @@ fn optimize_with(program: &mut Program, source: &dyn Fn(&Source) -> Option<RowSh
     loop {
         timings.optimizer_rounds += 1;
         let mut changed = false;
+        if config.merge_reduce { changed |= merge_reduce(program, timings); }
         // Remove dead readers before structural fusion counts uses. This shares
         // the optimizer's fixed point; liveness itself makes one backward walk.
         if config.dead_code {
diff --git a/interactive/src/passes/projection.rs b/interactive/src/passes/projection.rs
index 807122bc5..a78e1cdb1 100644
--- a/interactive/src/passes/projection.rs
+++ b/interactive/src/passes/projection.rs
@@ -11,7 +11,7 @@ use corgi::Shape;
 use crate::ir::{Lambda, LinearOp};
 use crate::lambda::Projection;
 use crate::level::Level;
-use crate::scope_ir::{self as st, Item, Node, Ref, Source};
+use crate::scope_ir::{self as st, Item, Node, ReduceInput, Ref, Source};
 use crate::shapes::{self, CollShape, ItemShapes, ScopeShapes};
 
 #[derive(Clone, Debug)]
@@ -563,8 +563,8 @@ fn build_scope(
                         )?;
                     }
                     Node::Reduce { input, .. } => {
-                        let input = plan.at(input)?;
-                        builder.opaque(&output, &[input]);
+                        let inputs = input.refs().map(|r| plan.at(r)).collect::<Result<Vec<_>, _>>()?;
+                        builder.opaque(&output, &inputs);
                     }
                     Node::Inspect { input, .. } => {
                         // Inspection is observable even if its collection has
@@ -761,7 +761,10 @@ fn rewrite_scope(scope: &mut st::Scope, plan: &PlannedScope, live: &[bool]) -> u
                     *projection = new;
                 }
             }
-            (Item::Op(Node::Reduce { input, reducer, .. }), PlannedItem::Op { output, .. }) => {
+            // A merged reduce's inputs share one row shape, so the mask goes into its reducer as for
+            // one input. A grouped reduce's reducer reads a list per input and is not narrowed.
+            (Item::Op(Node::Reduce { input: input @ ReduceInput::Merged(_), reducer, .. }), PlannedItem::Op { output, .. }) => {
+                let input = input.first();
                 if needs_mask(&output.shape.1, &output.val, live) {
                     let value = mask_part("input", &output.shape.1, &output.val, live);
                     let shape = &plan.at(input).expect("reduce input").shape;
@@ -778,8 +781,8 @@ fn rewrite_scope(scope: &mut st::Scope, plan: &PlannedScope, live: &[bool]) -> u
             Item::Op(node) => match node {
                 Node::Linear { input, .. }
                 | Node::Arrange(input)
-                | Node::Reduce { input, .. }
                 | Node::Inspect { input, .. } => remap_ref(input, &remap),
+                Node::Reduce { input, .. } => input.for_each_ref(|r| remap_ref(r, &remap)),
                 Node::Join { left, right, .. } => {
                     remap_ref(left, &remap);
                     remap_ref(right, &remap);
@@ -882,7 +885,9 @@ fn fuse_reduce_maps(scope: &mut st::Scope, shapes: &ScopeShapes, level: Level) -
         }
         if projections.is_empty() { continue; }
         let Item::Op(Node::Reduce { input, reducer, .. }) = &mut scope.items[j] else { unreachable!() };
-        let Some(shape) = shapes.of(input) else { continue };
+        // A grouped reduce's reducer is not narrowed, and a merged one's inputs share a shape.
+        if matches!(input, ReduceInput::Grouped(_)) { continue; }
+        let Some(shape) = shapes.of(input.first()) else { continue };
         for projection in &projections { *reducer = reducer.project(projection, &shape.key, &shape.val); }
         changed += projections.len();
         let Item::Op(Node::Linear { ops, .. }) = &mut scope.items[i] else { unreachable!() };
diff --git a/interactive/src/passes/structural.rs b/interactive/src/passes/structural.rs
index 48d49bc60..fee852a48 100644
--- a/interactive/src/passes/structural.rs
+++ b/interactive/src/passes/structural.rs
@@ -71,7 +71,8 @@ pub(super) fn use_counts(scope: &Scope, dead: &[bool]) -> Vec<usize> {
         match item {
             Item::Op(node) => match node {
                 Node::Linear { input, .. } | Node::Arrange(input)
-                | Node::Reduce { input, .. } | Node::Inspect { input, .. } => tally(input),
+                | Node::Inspect { input, .. } => tally(input),
+                Node::Reduce { input, .. } => input.refs().for_each(&mut tally),
                 Node::Join { left, right, .. } => { tally(left); tally(right); },
                 Node::HalfJoin { stream, arrangement, .. } => { tally(stream); tally(arrangement); },
                 Node::Concat(refs) => for r in refs { tally(r); },
diff --git a/interactive/src/passes/timing.rs b/interactive/src/passes/timing.rs
index 7879f7a99..fb269552a 100644
--- a/interactive/src/passes/timing.rs
+++ b/interactive/src/passes/timing.rs
@@ -48,10 +48,10 @@ impl Measurement {
 
 /// The order used by the timing table; these names do not change pass configuration.
 #[derive(Clone, Copy, Debug)]
-pub enum Pass { DeadCode, Structural, ComposeMaps, HoistInvariant, CollapseParentArranges, MergeImports, ShapeInference }
+pub enum Pass { DeadCode, Structural, ComposeMaps, HoistInvariant, CollapseParentArranges, MergeImports, ShapeInference, MergeReduce }
 
 impl Pass {
-    pub const ALL: [Self; 7] = [Self::DeadCode, Self::Structural, Self::ComposeMaps, Self::HoistInvariant, Self::CollapseParentArranges, Self::MergeImports, Self::ShapeInference];
+    pub const ALL: [Self; 8] = [Self::DeadCode, Self::Structural, Self::ComposeMaps, Self::HoistInvariant, Self::CollapseParentArranges, Self::MergeImports, Self::ShapeInference, Self::MergeReduce];
 
     pub fn name(self) -> &'static str {
         match self {
@@ -62,6 +62,7 @@ impl Pass {
             Self::CollapseParentArranges => "collapse-parent-arranges",
             Self::MergeImports => "merge_imports",
             Self::ShapeInference => "shape inference",
+            Self::MergeReduce => "merge-reduce",
         }
     }
 }
@@ -77,7 +78,7 @@ pub struct Timings {
     pub projection: Measurement,
     pub as_of_drop: Measurement,
     pub observers: Measurement,
-    pub passes: [Measurement; 7],
+    pub passes: [Measurement; 8],
     /// Complete optimizer rounds, including the final round with no changes.
     pub optimizer_rounds: usize,
     /// Hoisting rounds before structural fusion, including the final stable round.
diff --git a/interactive/src/plan.rs b/interactive/src/plan.rs
index 84d02a4db..0f2556f2f 100644
--- a/interactive/src/plan.rs
+++ b/interactive/src/plan.rs
@@ -392,9 +392,9 @@ fn linear(op: &LinearOp) -> String {
     }
 }
 
-fn reducer(reducer: &Reducer, limit: Option<usize>) -> String {
+fn reducer(reducer: &Reducer, limit: Option<usize>, rest: String) -> String {
     match reducer {
-        Reducer::Expr(l) => format!("reduce({}input -> {})", ddp::limit_text(limit), l.src),
+        Reducer::Expr(l) => format!("reduce({rest}{}input -> {})", ddp::limit_text(limit), l.src),
     }
 }
 
@@ -405,7 +405,7 @@ fn node(node: &Node, names: &Names) -> String {
         Node::Arrange(input) => format!("{} | arrange", names.of(input)),
         Node::Join { left, right, projection } => format!("{} | join({}, {})", names.of(left), names.of(right), source_lambda(projection)),
         Node::HalfJoin { stream, arrangement, strict, projection } => format!("{} | half_join({}, strict={strict}, {})", names.of(stream), names.of(arrangement), source_lambda(projection)),
-        Node::Reduce { input, reducer: r, limit } => format!("{} | {}", names.of(input), reducer(r, *limit)),
+        Node::Reduce { input, reducer: red, limit } => format!("{} | {}", ddp::reduce_head(input, |r| names.of(r)), reducer(red, *limit, ddp::grouped_rest(input, |r| names.of(r)))),
         Node::Inspect { input, label } => format!("{} | inspect({})", names.of(input), quote(label)),
     }
 }
@@ -446,8 +446,8 @@ fn printed_node(node: &Node, names: &Names, shapes: &ScopeShapes, depth: usize,
             format!("{} | half_join({}, strict={strict}, {})", names.of(stream), names.of(arrangement), slots.lambda(projection, input, &format!("{at}/half_join")))
         }
         Node::Reduce { input, reducer: Reducer::Expr(l), limit } => {
-            let input_shape = shapes.of(input).map(|s| Shape::Prod(vec![s.key, Shape::List(Box::new(Shape::Prod(vec![s.val, Shape::Int])))]));
-            format!("{} | reduce({}{})", names.of(input), ddp::limit_text(*limit), slots.lambda(l, input_shape, &format!("{at}/reduce")))
+            let input_shape = shapes.reduce_input(input);
+            format!("{} | reduce({}{}{})", ddp::reduce_head(input, |r| names.of(r)), ddp::grouped_rest(input, |r| names.of(r)), ddp::limit_text(*limit), slots.lambda(l, input_shape, &format!("{at}/reduce")))
         }
         _ => self::node(node, names)
     }
@@ -483,7 +483,7 @@ fn reads(node: &Node) -> Vec<(&Ref, &'static str)> {
         Node::Arrange(input) => vec![(input, "arrange/reuse")],
         Node::Join { left, right, .. } => vec![(left, "index"), (right, "index")],
         Node::HalfJoin { stream, arrangement, .. } => vec![(stream, "rows"), (arrangement, "index")],
-        Node::Reduce { input, .. } => vec![(input, "index")],
+        Node::Reduce { input, .. } => input.refs().map(|r| (r, "index")).collect(),
     }
 }
 
diff --git a/interactive/src/plan/compare.rs b/interactive/src/plan/compare.rs
index af1d09478..72dbcb654 100644
--- a/interactive/src/plan/compare.rs
+++ b/interactive/src/plan/compare.rs
@@ -2,7 +2,7 @@
 //! Scalar equality is equality of graphs compiled at the known input type, not sampled values.
 
 use crate::ir::{Lambda, LinearOp, Reducer};
-use crate::scope_ir::{Item, Node, Ref, Scope, Source};
+use crate::scope_ir::{Item, Node, ReduceInput, Ref, Scope, Source};
 use crate::shapes::{ItemShapes, ScopeShapes};
 use super::Report;
 
@@ -28,6 +28,13 @@ struct Mapping {
 }
 
 impl Mapping {
+    fn same_reduce(&self, a: &ReduceInput, b: &ReduceInput) -> bool {
+        match (a, b) {
+            (ReduceInput::Merged(a), ReduceInput::Merged(b)) => a.len() == b.len() && a.iter().zip(b).all(|((a, x), (b, y))| x == y && self.same(a, b)),
+            (ReduceInput::Grouped(a), ReduceInput::Grouped(b)) => a.len() == b.len() && a.iter().zip(b).all(|(a, b)| self.same(a, b)),
+            _ => false,
+        }
+    }
     fn same(&self, a: &Ref, b: &Ref) -> bool {
         match (a, b) {
             (Ref::Import(a), Ref::Import(b)) => self.imports.get(*a) == Some(b),
@@ -68,8 +75,7 @@ fn input_shapes(node: &Node, shapes: &ScopeShapes) -> Option<Vec<corgi::Shape>>
             vec![Shape::Prod(vec![s.key, fields.first()?.clone(), a.val])]
         }
         Node::Reduce { input, .. } => {
-            let shape = shapes.of(input)?;
-            vec![Shape::Prod(vec![shape.key, Shape::List(Box::new(Shape::Prod(vec![shape.val, Shape::Int])))])]
+            vec![shapes.reduce_input(input)?]
         }
         _ => Vec::new(),
     })
@@ -98,7 +104,7 @@ fn node(a: &Node, b: &Node, map: &Mapping, scalar: bool, inputs: &[corgi::Shape]
         (Node::Arrange(a), Node::Arrange(b)) => map.same(a, b),
         (Node::Join { left: a, right: b, projection: p }, Node::Join { left: c, right: d, projection: q }) => map.same(a, c) && map.same(b, d) && (!scalar || lambda(p, q, inputs.first())),
         (Node::HalfJoin { stream: a, arrangement: b, strict: s, projection: p }, Node::HalfJoin { stream: c, arrangement: d, strict: t, projection: q }) => map.same(a, c) && map.same(b, d) && s == t && (!scalar || lambda(p, q, inputs.first())),
-        (Node::Reduce { input: a, reducer: x, limit: s }, Node::Reduce { input: b, reducer: y, limit: t }) => map.same(a, b) && s == t && (!scalar || reducer(x, y, inputs.first())),
+        (Node::Reduce { input: a, reducer: x, limit: s }, Node::Reduce { input: b, reducer: y, limit: t }) => map.same_reduce(a, b) && s == t && (!scalar || reducer(x, y, inputs.first())),
         (Node::Inspect { input: a, label: x }, Node::Inspect { input: b, label: y }) => map.same(a, b) && x == y,
         _ => false,
     }
diff --git a/interactive/src/plan/ddp.rs b/interactive/src/plan/ddp.rs
index 789cb6f2b..3d4e0b82e 100644
--- a/interactive/src/plan/ddp.rs
+++ b/interactive/src/plan/ddp.rs
@@ -5,7 +5,7 @@ use std::fmt::Write;
 
 use corgi::Shape;
 use crate::ir::{Lambda, LinearOp, Reducer};
-use crate::scope_ir::{Item, Node, Ref, Scope, Source};
+use crate::scope_ir::{Item, Node, ReduceInput, Ref, Scope, Source};
 use crate::shapes::{self, ItemShapes, ScopeShapes};
 use super::{Form, Report};
 use crate::parse::{Expr, InputRef, Stmt};
@@ -423,11 +423,11 @@ impl Printer<'_> {
             Node::Reduce { input, reducer, limit } => {
                 let word = match reducer {
                     Reducer::Expr(l) => {
-                        let input = shapes.of(input).map(|s| Shape::Prod(vec![s.key, Shape::List(Box::new(Shape::Prod(vec![s.val, Shape::Int])))]));
-                        format!("reduce({}{})", limit_text(*limit), self.lambda(l, input)?)
+                        let shape = shapes.reduce_input(input);
+                        format!("reduce({}{}{})", grouped_rest(input, |r| names.of(r)), limit_text(*limit), self.lambda(l, shape)?)
                     }
                 };
-                format!("{} | {word}", names.of(input))
+                format!("{} | {word}", reduce_head(input, |r| names.of(r)))
             }
             Node::Inspect { input, label } => {
                 if identifier(label) != *label { return Err(format!("inspect label {label:?} is not a DDP identifier")); }
@@ -445,6 +445,27 @@ fn aliases(aliases: &[(&String, &Ref)], names: &Names, defined: &mut BTreeSet<St
     }
 }
 
+/// The text before a reduce's `| reduce(..)`: the one input of a plain reduce, else the bracket
+/// list of a merged reduce, `[a, -b]`, or the first input of a grouped one.
+pub(crate) fn reduce_head(input: &ReduceInput, name: impl Fn(&Ref) -> String) -> String {
+    match input {
+        ReduceInput::Merged(v) => match v.as_slice() {
+            [(r, 1)] => name(r),
+            _ => format!("[{}]", v.iter().map(|(r, s)| format!("{}{}", if *s < 0 { "-" } else { "" }, name(r))).collect::<Vec<_>>().join(", ")),
+        },
+        ReduceInput::Grouped(v) => name(&v[0]),
+    }
+}
+
+/// A grouped reduce's inputs after the first, each followed by a comma and a space, as written
+/// before its lambda: `b, c, `. Empty for a merged reduce.
+pub(crate) fn grouped_rest(input: &ReduceInput, name: impl Fn(&Ref) -> String) -> String {
+    match input {
+        ReduceInput::Merged(_) => String::new(),
+        ReduceInput::Grouped(v) => v[1..].iter().map(|r| format!("{}, ", name(r))).collect(),
+    }
+}
+
 /// A reduce's limit as DDP writes it, before its lambda: `limit 1, `.
 pub(crate) fn limit_text(limit: Option<usize>) -> String {
     limit.map_or(String::new(), |k| format!("limit {k}, "))
diff --git a/interactive/src/plan/ddp/parsed.rs b/interactive/src/plan/ddp/parsed.rs
index 23185e9c4..9740c2499 100644
--- a/interactive/src/plan/ddp/parsed.rs
+++ b/interactive/src/plan/ddp/parsed.rs
@@ -72,11 +72,15 @@ impl Printer<'_> {
             Expr::Join(left, right, l) => format!("{} | join({}, {})", self.expression(left)?, self.expression(right)?, self.parsed_lambda(l)?),
             Expr::HalfJoin(stream, arrangement, strict, l) => format!("{} | half_join({}, {}, {})", self.expression(stream)?, self.expression(arrangement)?, u8::from(*strict), self.parsed_lambda(l)?),
             Expr::Reduce(input, reducer) => {
-                let lambda = if matches!(reducer, crate::parse::Reducer::Distinct) {
+                // A list of several elements, or a negated one, is no collection to key by its
+                // records, and `distinct` handles any values. `[e]` is `e`, and keys by record.
+                let merged_list = matches!(&**input, Expr::List(parts) if parts.len() > 1 || parts.iter().any(|(sign, _)| *sign < 0));
+                let by_record = matches!(reducer, crate::parse::Reducer::Distinct) && !merged_list;
+                let lambda = if by_record {
                     self.parsed_lambda(&crate::reducers::unit_distinct())?
                 } else { self.parsed_lambda(&reducer.lambda())? };
                 let input = self.expression(input)?;
-                if matches!(reducer, crate::parse::Reducer::Distinct) {
+                if by_record {
                     // Parsed syntax has no inferred shapes. Key by the whole record,
                     // which also preserves unit-valued distinct's meaning.
                     format!("{input} | map((k, v) -> ((k, v), ())) | reduce({lambda}) | map((kv, ()) -> kv)")
@@ -84,12 +88,20 @@ impl Printer<'_> {
                     format!("{input} | reduce({}{lambda})", super::limit_text(reducer.limit()))
                 }
             }
+            Expr::GroupedReduce(inputs, l) => {
+                let rest = inputs[1..].iter().map(|input| self.expression(input)).collect::<Result<Vec<_>, _>>()?;
+                format!("{} | reduce({}, {})", self.expression(&inputs[0])?, rest.join(", "), self.parsed_lambda(l)?)
+            }
             Expr::Negate(input) | Expr::Lift(input) | Expr::LiftIter(input) | Expr::Arrange(input) => {
                 let word = match expr { Expr::Negate(_) => "negate", Expr::Lift(_) => "lift", Expr::LiftIter(_) => "lift_iter", _ => "arrange" };
                 format!("{} | {word}", self.expression(input)?)
             }
             Expr::Inspect(input, label) => format!("{} | inspect({label})", self.expression(input)?),
             Expr::Concat(parts) => parts.iter().map(|part| self.atom(part)).collect::<Result<Vec<_>, _>>()?.join(" + "),
+            Expr::List(parts) => {
+                let parts = parts.iter().map(|(sign, part)| Ok(format!("{}{}", if *sign < 0 { "-" } else { "" }, self.expression(part)?))).collect::<Result<Vec<_>, String>>()?;
+                format!("[{}]", parts.join(", "))
+            }
         })
     }
 }
diff --git a/interactive/src/reducers.rs b/interactive/src/reducers.rs
index f33f27921..1e70e979b 100644
--- a/interactive/src/reducers.rs
+++ b/interactive/src/reducers.rs
@@ -2,6 +2,7 @@
 //! `vals` is nonempty, ordered, and holds `(value, nonzero diff)` pairs.
 
 use crate::ir::{Lambda, Reducer};
+use crate::scope_ir::ReduceInput;
 use crate::lambda::Projection;
 
 /// Distinct after its input has been keyed by the whole record.
@@ -16,6 +17,7 @@ pub(crate) fn expand_distinct(
     scope: &mut crate::scope_ir::Scope,
     shapes: &crate::shapes::ScopeShapes,
     pending: &std::collections::HashMap<Vec<String>, Vec<usize>>,
+    parent_arranged: &[bool],
     path: &mut Vec<String>,
 ) {
     use crate::scope_ir::{Item, Node, Ref, Source};
@@ -32,26 +34,36 @@ pub(crate) fn expand_distinct(
         let distinct = sites.peek() == Some(&i);
         if distinct { sites.next(); }
         let by_record = distinct && match &item {
-            Item::Op(Node::Reduce { input, .. }) => !shapes.of(input).is_some_and(|s| s.val == corgi::Shape::Unit),
+            Item::Op(Node::Reduce { input, .. }) => {
+                // Lowering registers only the plain reduce of one positive input as a site.
+                let input = input.as_single().expect("a distinct site reads one input");
+                !shapes.of(input).is_some_and(|s| s.val == corgi::Shape::Unit)
+            }
             _ => false,
         };
         match &mut item {
             Item::Op(node) => node.for_each_ref(|r| remap_ref(r, &remap)),
             Item::Sub(child) => {
                 let crate::shapes::ItemShapes::Sub(shapes) = &shapes.items[i] else { unreachable!() };
-                path.push(child.name.clone());
-                expand_distinct(child, shapes, pending, path);
-                path.pop();
                 for import in &mut child.imports {
                     if let Source::Parent(r) = &mut import.from { remap_ref(r, &remap); }
                 }
+                // A by-record distinct ends in a map, so an import that lowering took
+                // to be arranged may not be. Recompute it against the rewritten items.
+                let entering: Vec<bool> = child.imports.iter().map(|import| match &import.from {
+                    Source::Parent(r) => crate::lower::is_arranged(r, &items, &scope.imports, parent_arranged),
+                    _ => false,
+                }).collect();
+                path.push(child.name.clone());
+                expand_distinct(child, shapes, pending, &entering, path);
+                path.pop();
             }
         }
         let mut push = |mut node: Node| {
             // Distinct can replace a Reduce with a map back from the record key.
             // Check consumers after remapping, when their actual input is known.
             let mut arrange = |input: &mut Ref| {
-                if !crate::lower::is_arranged(input, &items) {
+                if !crate::lower::is_arranged(input, &items, &scope.imports, parent_arranged) {
                     let r = Ref::Local(items.len());
                     items.push(Item::Op(Node::Arrange(input.clone())));
                     labels.push(scope.labels[i].clone());
@@ -61,7 +73,7 @@ pub(crate) fn expand_distinct(
             match &mut node {
                 Node::Join { left, right, .. } => { arrange(left); arrange(right); }
                 Node::HalfJoin { arrangement, .. } => arrange(arrangement),
-                Node::Reduce { input, .. } => arrange(input),
+                Node::Reduce { input, .. } => input.for_each_ref(&mut arrange),
                 _ => {}
             }
             let r = Ref::Local(items.len());
@@ -71,13 +83,14 @@ pub(crate) fn expand_distinct(
         };
         if distinct {
             let Item::Op(Node::Reduce { input, .. }) = item else { unreachable!() };
+            let input = input.as_single().cloned().expect("a distinct site reads one input");
             let input = if by_record {
                 push(Node::Linear { input, ops: vec![LinearOp::Project(Lambda::new("let (k, v) = input in ((k, v), ())".into(), &corgi::Scope::default()))] })
             } else { input };
             // Both paths now have unit values: either they were known to be unit,
             // or the map above keyed the collection by its whole record.
             let reducer = Reducer::Expr(unit_distinct());
-            let output = push(Node::Reduce { input, reducer, limit: None });
+            let output = push(Node::Reduce { input: ReduceInput::single(input), reducer, limit: None });
             if by_record {
                 push(Node::Linear { input: output, ops: vec![LinearOp::Project(Lambda::new("let (kv, ()) = input in kv".into(), &corgi::Scope::default()))] });
             }
diff --git a/interactive/src/runtime/reduce.rs b/interactive/src/runtime/reduce.rs
index e291ef56f..2c17dfb28 100644
--- a/interactive/src/runtime/reduce.rs
+++ b/interactive/src/runtime/reduce.rs
@@ -49,6 +49,24 @@ use crate::ir::{Diff, Reducer};
 
 type CBatch<T> = Rc<ChunkBatch<CorgiChunk<T, Diff>>>;
 
+/// An input batch of a reduce: a plain batch, or one tagged by the input of a reduce over several
+/// arrangements it came from.
+pub(crate) trait InBatch<T: ColTime> {
+    /// The input the batch came from. A plain batch comes from input 0.
+    fn tag(&self) -> usize;
+    fn batch(&self) -> &CBatch<T>;
+}
+
+impl<T: ColTime> InBatch<T> for CBatch<T> {
+    fn tag(&self) -> usize { 0 }
+    fn batch(&self) -> &CBatch<T> { self }
+}
+
+impl<T: ColTime> InBatch<T> for (usize, CBatch<T>) {
+    fn tag(&self) -> usize { self.0 }
+    fn batch(&self) -> &CBatch<T> { &self.1 }
+}
+
 /// Values named by id: id `i` is row `refs[i].1` of `columns[refs[i].0]`.
 #[derive(Default)]
 struct Pool {
@@ -65,7 +83,13 @@ impl Pool {
 
 /// The rows `refs` names, each a `(column, row)` of `columns`, as one column.
 fn gather_refs(columns: &[CValue], refs: impl Iterator<Item = (usize, usize)>) -> CValue {
-    let srcs: Vec<Option<&CValue>> = columns.iter().map(Some).collect();
+    gather_some(columns, |_| true, refs)
+}
+
+/// [`gather_refs`] reading only the columns `keep` selects, which `refs` names alone. The other
+/// columns may have another shape.
+fn gather_some(columns: &[CValue], keep: impl Fn(usize) -> bool, refs: impl Iterator<Item = (usize, usize)>) -> CValue {
+    let srcs: Vec<Option<&CValue>> = columns.iter().enumerate().map(|(i, c)| keep(i).then_some(c)).collect();
     let (tags, offs): (Vec<usize>, Vec<usize>) = refs.unzip();
     gather_lanes(&srcs, &tags, &offs)
 }
@@ -158,6 +182,13 @@ pub(crate) struct CorgiReduceBackend<T> {
     window_size: usize,
     /// The retire in progress.
     retire: Retire,
+    /// Each input's sign, by input index. A merged reduce reads the signed sum of its inputs.
+    signs: Vec<Diff>,
+    /// For a grouped reduce, each input's value shape: the graph is handed one list per input.
+    grouped: Option<Vec<Shape>>,
+    /// For a grouped reduce, the input each column of `input` is a chunk of, found by the retire's
+    /// first window.
+    input_tags: Vec<usize>,
 }
 
 /// A retire's keys and where its input chunks hold them, found once by its first window.
@@ -222,9 +253,32 @@ impl<T> CorgiReduceBackend<T> {
         let project_values = limit.is_none() && crate::passes::reduce_demand::projection(&compiled).is_some();
         let narrowed = corgi::narrow(compiled, &Demand::All)
             .unwrap_or_else(|e| panic!("reduce: narrowing a compiled graph at {input}: {e}"));
+        Self::from_parts(narrowed.graph, Reads::new(narrowed.input, &input), project_values, limit, window_size)
+    }
+
+    /// The backend of a grouped reduce over inputs of `kshape` keys, input `i` of `vshapes[i]`
+    /// values. Its input batches are tagged by input, and its graph is handed each key and one
+    /// `(val, diff)` list per input.
+    ///
+    /// The graph reads its input whole: keys and values are gathered whole, and equal values of
+    /// different inputs never share an id.
+    pub(crate) fn grouped(reducer: Reducer, kshape: Shape, vshapes: Vec<Shape>, window_size: usize) -> Self {
+        assert!(vshapes.len() >= 2, "a grouped reduce has several inputs");
+        let Reducer::Expr(lambda) = reducer;
+        let compiled = crate::lambda::compile_grouped_reduce(&lambda, &kshape, &vshapes)
+            .unwrap_or_else(|e| panic!("reduce: type error at key {kshape} and values {vshapes:?}: {e}"));
+        let input = Shape::Prod(crate::lambda::reduce_rows(&kshape, &vshapes));
+        let reads = Reads { key: true, value: Demand::All, argument: Demand::All, shape: input };
+        let mut backend = Self::from_parts(compiled.graph().clone(), reads, false, None, window_size);
+        backend.signs = vec![1; vshapes.len()];
+        backend.grouped = Some(vshapes);
+        backend
+    }
+
+    fn from_parts(graph: Graph<NumOp>, reads: Reads, project_values: bool, limit: Option<usize>, window_size: usize) -> Self {
         CorgiReduceBackend {
-            graph: narrowed.graph,
-            reads: Reads::new(narrowed.input, &input),
+            graph,
+            reads,
             project_values,
             limit,
             input: Pool::default(),
@@ -234,8 +288,19 @@ impl<T> CorgiReduceBackend<T> {
             rows: (Vec::new(), Vec::new(), ColTimes::default(), Vec::new()),
             window_size: window_size.max(1),
             retire: Retire::default(),
+            signs: vec![1],
+            grouped: None,
+            input_tags: Vec::new(),
         }
     }
+
+    /// The backend of a merged reduce, which reads input `i`'s diffs times `signs[i]`. Its input
+    /// batches are tagged by input.
+    pub(crate) fn with_signs(mut self, signs: Vec<Diff>) -> Self {
+        assert!(!signs.is_empty(), "a merged reduce has an input");
+        self.signs = signs;
+        self
+    }
 }
 
 /// Where `chunks` hold the ascending `keys`.
@@ -259,18 +324,23 @@ fn search<T: ColTime>(chunks: &[&CorgiChunk<T, Diff>], keys: &[i64]) -> Matches
 /// of `refs`, where it is recorded as the `(chunk, row)` of one of its rows. The keys `colliding`
 /// marks (by index; empty when none do) hold several real keys under one identifier: their rows are
 /// first split by real key, so that an id names one real key's value, and the row it is recorded
-/// at holds that key.
+/// at holds that key. With `signs`, chunk `i`'s diffs count `signs[i]` times. Only the chunks
+/// `keep` selects are read, and only their values are gathered, so the others may hold values of
+/// another shape.
+#[expect(clippy::too_many_arguments, reason = "a gather of chunks, keys, matches and sinks")]
 fn present<T: ColTime + Ord>(
     chunks: &[&CorgiChunk<T, Diff>],
+    signs: Option<&[Diff]>,
     keys: &[i64],
     matches: &Matches,
     colliding: &[bool],
     projected: Option<&[CValue]>,
+    keep: impl Fn(usize) -> bool,
     refs: &mut Vec<(usize, usize)>,
     bridge: &mut ProxyBridge<T, Diff, i64>,
 ) {
-    // The matched `(chunk, row)`s, key by key, and each one's key index.
-    let mut runs: Vec<_> = matches.iter().enumerate()
+    // The matched `(chunk, row)`s of the kept chunks, key by key, and each one's key index.
+    let mut runs: Vec<_> = matches.iter().enumerate().filter(|(chunk, _)| keep(*chunk))
         .flat_map(|(chunk, found)| found.iter().map(move |(key, rows)| (*key, chunk, rows.clone())))
         .collect();
     runs.sort_by_key(|run| run.0);
@@ -294,8 +364,9 @@ fn present<T: ColTime + Ord>(
         whole = chunks.iter().map(|chunk| chunk.vals().clone()).collect::<Vec<_>>();
         &whole
     };
-    let (sorted, groups) = sort_blocks(&labels, &gather_refs(vals, rows.iter().copied()));
-    let update = |(chunk, row): (usize, usize)| (chunks[chunk].times().get(row), chunks[chunk].diffs()[row]);
+    let (sorted, groups) = sort_blocks(&labels, &gather_some(vals, &keep, rows.iter().copied()));
+    // A chunk's diffs count times its sign, before equal values consolidate.
+    let update = |(chunk, row): (usize, usize)| (chunks[chunk].times().get(row), chunks[chunk].diffs()[row] * signs.map_or(1, |s| s[chunk]));
     let (mut start, mut updates) = (0, Vec::new());
     for group in groups.chunk_by(|a, b| a == b) {
         let members = &sorted[start..start + group.len()];
@@ -341,11 +412,12 @@ fn split_real_keys<T: ColTime>(
     (labels, rows, Some(label_keys))
 }
 
-fn chunks_of<T>(batches: &[CBatch<T>]) -> Vec<&CorgiChunk<T, Diff>>
+fn chunks_of<T, B>(batches: &[B]) -> Vec<&CorgiChunk<T, Diff>>
 where
     T: ColTime,
+    B: InBatch<T>,
 {
-    batches.iter().flat_map(|b| b.chunks.iter()).collect()
+    batches.iter().flat_map(|b| b.batch().chunks.iter()).collect()
 }
 
 /// A retire's keys, ascending: those the novel batches touch, and the `changed` set the harness
@@ -386,6 +458,31 @@ where
         if blocks.is_empty() {
             return (CValue::Unit(0), Vec::new(), vec![0; ends.len()]);
         }
+        let keys = if self.reads.key { recover_key(&gather_refs(&self.key_columns, key_refs.into_iter())) } else { CValue::Unit(key_refs.len()) };
+        let argument = match &self.grouped {
+            None => self.merged_argument(&blocks, keys, input),
+            Some(vshapes) => self.grouped_argument(vshapes, &blocks, ends, keys, input),
+        };
+        let shape = corgi::shape_of_value(&argument);
+        assert!(shape == self.reads.shape, "reduce: input read as {shape} reached an operator narrowed to {}", self.reads.shape);
+        let (bounds, elems) = corgi::eval_graph(&self.graph, argument).into_list("reduce output").unwrap();
+        let mut fields = elems.into_prod("reduce output").unwrap();
+        let out_diffs = fields.pop().unwrap().into_i64("reduce output diffs").unwrap().to_vec();
+        let out_vals = fields.pop().unwrap();
+
+        // Each bracket's end among the output rows; brackets without input add none.
+        let list_ends = bounds.to_vec();
+        let (mut out_ends, mut blocks, mut emitted) = (Vec::with_capacity(ends.len()), blocks.iter().zip(list_ends).peekable(), 0);
+        for bi in 0..ends.len() {
+            if let Some((_, end)) = blocks.next_if(|((b, _), _)| *b == bi) { emitted = end; }
+            out_ends.push(emitted);
+        }
+        (out_vals, out_diffs, out_ends)
+    }
+
+    /// The argument of a reduce over one list: `(keys, vals)`, one list per block, projected by
+    /// what the reducer reads.
+    fn merged_argument(&self, blocks: &[(usize, usize)], keys: CValue, input: &[(u64, Diff)]) -> CValue {
         let vals = match self.reads.value {
             Demand::None => CValue::Unit(input.len()),
             _ => self.input.gather(&input.iter().map(|&(id, _)| id).collect::<Vec<_>>()),
@@ -394,7 +491,7 @@ where
         // Projected values may tie; whole ones ascend.
         if cfg!(debug_assertions) && self.reads.value == Demand::All {
             let mut start = 0;
-            for &(_, end) in &blocks {
+            for &(_, end) in blocks {
                 for i in start + 1..end {
                     assert!(compare_at(&vals, i - 1, &vals, i).is_lt(), "reduce: a bracket's values are not strictly ascending");
                 }
@@ -402,28 +499,49 @@ where
             }
             assert!(input.iter().all(|&(_, diff)| diff != 0), "reduce: a bracket holds a zero diff");
         }
-        let keys = if self.reads.key { recover_key(&gather_refs(&self.key_columns, key_refs.into_iter())) } else { CValue::Unit(key_refs.len()) };
         let lists = CValue::List(Bounds::offsets(blocks.iter().map(|b| b.1).collect()), Box::new(CValue::Prod(vec![vals, diffs])));
-        let argument = self.reads.argument.project(CValue::Prod(vec![keys, lists])).expect("the reduce's input has the shape its demand is on");
-        let shape = corgi::shape_of_value(&argument);
-        assert!(shape == self.reads.shape, "reduce: input read as {shape} reached an operator narrowed to {}", self.reads.shape);
-        let (bounds, elems) = corgi::eval_graph(&self.graph, argument).into_list("reduce output").unwrap();
-        let mut fields = elems.into_prod("reduce output").unwrap();
-        let out_diffs = fields.pop().unwrap().into_i64("reduce output diffs").unwrap().to_vec();
-        let out_vals = fields.pop().unwrap();
+        self.reads.argument.project(CValue::Prod(vec![keys, lists])).expect("the reduce's input has the shape its demand is on")
+    }
 
-        // Each bracket's end among the output rows; brackets without input add none.
-        let list_ends = bounds.to_vec();
-        let (mut out_ends, mut blocks, mut emitted) = (Vec::with_capacity(ends.len()), blocks.iter().zip(list_ends).peekable(), 0);
-        for bi in 0..ends.len() {
-            if let Some((_, end)) = blocks.next_if(|((b, _), _)| *b == bi) { emitted = end; }
-            out_ends.push(emitted);
+    /// The argument of a grouped reduce: `(keys, vals_0, .., vals_{n-1})`, each `vals_i` one list
+    /// per block of the `(val, diff)`s input `i` holds in it. A block's ids ascend by input and then
+    /// by value, so each list is in value order.
+    fn grouped_argument(&self, vshapes: &[Shape], blocks: &[(usize, usize)], ends: &[usize], keys: CValue, input: &[(u64, Diff)]) -> CValue {
+        let n = vshapes.len();
+        let (mut ids, mut diffs, mut list_ends) = (vec![Vec::new(); n], vec![Vec::new(); n], vec![Vec::new(); n]);
+        for &(bi, end) in blocks {
+            let start = if bi == 0 { 0 } else { ends[bi - 1] };
+            for &(id, diff) in &input[start..end] {
+                let tag = self.input_tags[self.input.refs[id as usize].0];
+                ids[tag].push(id);
+                diffs[tag].push(diff);
+            }
+            for (tag, list) in list_ends.iter_mut().enumerate() { list.push(ids[tag].len()); }
         }
-        (out_vals, out_diffs, out_ends)
+        let mut argument = Vec::with_capacity(n + 1);
+        argument.push(keys);
+        for tag in 0..n {
+            let vals = if ids[tag].is_empty() { CValue::empty(&vshapes[tag]) } else {
+                gather_some(&self.input.columns, |c| self.input_tags[c] == tag, ids[tag].iter().map(|&id| self.input.refs[id as usize]))
+            };
+            if cfg!(debug_assertions) {
+                let mut start = 0;
+                for &end in &list_ends[tag] {
+                    for i in start + 1..end {
+                        assert!(compare_at(&vals, i - 1, &vals, i).is_lt(), "reduce: an input's values are not strictly ascending");
+                    }
+                    start = end;
+                }
+                assert!(diffs[tag].iter().all(|&diff| diff != 0), "reduce: an input's list holds a zero diff");
+            }
+            let diffs = CValue::i64(std::mem::take(&mut diffs[tag]));
+            argument.push(CValue::List(Bounds::offsets(std::mem::take(&mut list_ends[tag])), Box::new(CValue::Prod(vec![vals, diffs]))));
+        }
+        CValue::Prod(argument)
     }
 }
 
-impl<T> ProxyReduceBackend<T, CBatch<T>, CBatch<T>> for CorgiReduceBackend<T>
+impl<T, B: InBatch<T>> ProxyReduceBackend<T, B, CBatch<T>> for CorgiReduceBackend<T>
 where
     T: ColTime + Ord,
 {
@@ -437,7 +555,7 @@ where
         self.rows = (Vec::new(), Vec::new(), ColTimes::default(), Vec::new());
     }
 
-    fn next_window(&mut self, instance: &ReduceInstance<'_, T, CBatch<T>, CBatch<T>>, changed: &[i64], from: &mut KeyPosition<i64>, window: &mut ReduceWindow<T, Diff, Diff, i64>) {
+    fn next_window(&mut self, instance: &ReduceInstance<'_, T, B, CBatch<T>>, changed: &[i64], from: &mut KeyPosition<i64>, window: &mut ReduceWindow<T, Diff, Diff, i64>) {
         if *from == KeyPosition::End {
             return;
         }
@@ -445,6 +563,17 @@ where
         let mut in_chunks = chunks_of(instance.source_batches);
         let prior = in_chunks.len();
         in_chunks.extend(novel_chunks.iter().copied());
+        // Each input chunk's input, in the order of `in_chunks`, and its sign. Only a reduce with a
+        // negated input or several grouped ones builds them, so a unary reduce reads its chunks as
+        // before.
+        let signed = self.signs.iter().any(|sign| *sign != 1);
+        let in_tags: Vec<usize> = if signed || self.grouped.is_some() {
+            instance.source_batches.iter().chain(instance.input_batches)
+                .flat_map(|b| std::iter::repeat_n(b.tag(), b.batch().chunks.len()))
+                .collect()
+        } else { Vec::new() };
+        let in_signs: Option<Vec<Diff>> = signed.then(|| in_tags.iter().map(|tag| self.signs[*tag]).collect());
+        let in_signs = in_signs.as_deref();
         let out_chunks = chunks_of(instance.output_batches);
 
         // The first window finds the retire's keys, where the input holds them, and the columns
@@ -460,6 +589,7 @@ where
             self.output = Pool { columns: out_chunks.iter().map(|chunk| chunk.vals().clone()).collect(), refs: Vec::new() };
             self.output_keys.clear();
             self.key_columns = in_chunks.iter().chain(&out_chunks).map(|chunk| chunk.keys().clone()).collect();
+            if self.grouped.is_some() { self.input_tags = in_tags.clone(); }
         }
 
         // Windows are bounded, as their presentations are all live at once.
@@ -498,11 +628,24 @@ where
         // survives in `window.seeds` above. Input ids name rows for this window only.
         self.input.refs.clear();
         let projected = (self.project_values && self.reads.value != Demand::All).then_some(&self.input.columns[..]);
-        present(&in_chunks, keys, &matches, colliding, projected, &mut self.input.refs, &mut window.input);
+        match &self.grouped {
+            None => present(&in_chunks, in_signs, keys, &matches, colliding, projected, |_| true, &mut self.input.refs, &mut window.input),
+            // A grouped reduce presents each input on its own, so equal values of two inputs get
+            // two ids. Each input's ids follow the previous input's, so under a key, and under each
+            // real key, ids ascend by input and then by value. `reduce_lambda` splits a bracket by
+            // input in that order.
+            Some(vshapes) => {
+                let start = window.input.len();
+                for tag in 0..vshapes.len() {
+                    present(&in_chunks, None, keys, &matches, colliding, None, |chunk| in_tags[chunk] == tag, &mut self.input.refs, &mut window.input);
+                }
+                window.input[start..].sort_unstable_by(|a, b| (a.0, &a.1).cmp(&(b.0, &b.1)));
+            }
+        }
         // The output history, same keys. Output ids name rows for the whole retire, and the rows
         // that hold their keys are at the same positions of the output chunks' key columns.
         let fresh = self.output.refs.len();
-        present(&out_chunks, keys, &out_matches, colliding, None, &mut self.output.refs, &mut window.output);
+        present(&out_chunks, None, keys, &out_matches, colliding, None, |_| true, &mut self.output.refs, &mut window.output);
         self.output_keys.extend(self.output.refs[fresh..].iter().map(|&(chunk, row)| (in_chunks.len() + chunk, row)));
 
         *from = retire.keys.get(retire.window.end).map_or(KeyPosition::End, |key| KeyPosition::At(*key));
@@ -527,6 +670,16 @@ where
                 sub_input.extend_from_slice(&input[start..end]);
                 if self.retire.colliding.binary_search(key).is_ok() {
                     sub_input[lo..].sort_by_key(|&(id, _)| id);
+                    // A grouped reduce's ids ascend by input before real key, so its real keys are
+                    // made contiguous by comparing them. Each keeps its ids in order, by input and
+                    // then by value.
+                    if self.grouped.is_some() {
+                        let (refs, columns) = (&self.input.refs, &self.key_columns);
+                        sub_input[lo..].sort_by(|a, b| {
+                            let ((c0, r0), (c1, r1)) = (refs[a.0 as usize], refs[b.0 as usize]);
+                            compare_at(&columns[c0], r0, &columns[c1], r1).then(a.0.cmp(&b.0))
+                        });
+                    }
                     for i in lo + 1..sub_input.len() {
                         let ((c0, r0), (c1, r1)) = (self.input.refs[sub_input[i - 1].0 as usize], self.input.refs[sub_input[i].0 as usize]);
                         if compare_at(&self.key_columns[c0], r0, &self.key_columns[c1], r1).is_ne() { sub_ends.push(i); }
@@ -734,6 +887,12 @@ mod tests {
         assert!(backend.project_values);
     }
 
+    /// The corrections of a backend over plain input batches. The backend reads plain and tagged
+    /// batches, so the batch type is named here.
+    fn corrections(backend: &mut CorgiReduceBackend<Time>, keys: &[i64], in_ends: &[usize], input: &[(u64, Diff)], out_ends: &[usize], output: &[(u64, Diff)]) -> (Vec<(u64, Diff)>, Vec<usize>) {
+        ProxyReduceBackend::<Time, CBatch<Time>, CBatch<Time>>::reduce_corrections(backend, keys, in_ends, input, out_ends, output)
+    }
+
     /// The rows of a column of `Int` leaves, products of them, or units, as vectors.
     fn rows_of(col: &CValue) -> Vec<Vec<u64>> {
         let fields: Vec<Vec<i64>> = match col {
@@ -805,7 +964,7 @@ mod tests {
                 let owned = chunks(&rows, size, key_shape, val_shape);
                 let chunks: Vec<_> = owned.iter().collect();
                 let (mut refs, mut bridge) = (Vec::new(), Vec::new());
-                present(&chunks, &keys, &search(&chunks, &keys), &[], None, &mut refs, &mut bridge);
+                present(&chunks, None, &keys, &search(&chunks, &keys), &[], None, |_| true, &mut refs, &mut bridge);
                 assert!(bridge.windows(2).all(|w| (w[0].0, &w[0].1) < (w[1].0, &w[1].1)));
                 let pool = Pool { columns: chunks.iter().map(|chunk| chunk.vals().clone()).collect(), refs };
                 let values = rows_of(&pool.gather(&bridge.iter().map(|r| r.0.1).collect::<Vec<_>>()));
@@ -832,7 +991,7 @@ mod tests {
         // Key 0 counts 5 and has output 5 twice; key 1 counts 3 and has output 7; key 2 counts 0.
         let input = [(0, 2), (1, 3), (0, 3), (0, 1), (1, -1)];
         let output = [(0, 1), (1, 1), (2, 1)];
-        let (corr, ends) = backend.reduce_corrections(&[10, 11, 12], &[2, 3, 5], &input, &[2, 3, 3], &output);
+        let (corr, ends) = corrections(&mut backend, &[10, 11, 12], &[2, 3, 5], &input, &[2, 3, 3], &output);
         assert_eq!((corr.clone(), ends), (vec![(1, -1), (2, -1), (3, 1)], vec![1, 3, 3]));
         assert_eq!(rows_of(&backend.output.gather(&[3])), vec![vec![3]]);
     }
@@ -848,13 +1007,13 @@ mod tests {
         backend.output = Pool { columns: vec![ints(vec![5])], refs: vec![(0, 0)] };
         backend.output_keys = vec![(0, 0)];
         for _ in 0..64 {
-            assert_eq!(backend.reduce_corrections(&[10], &[1], &[(0, 5)], &[1], &[(0, 1)]), (vec![], vec![0]));
+            assert_eq!(corrections(&mut backend, &[10], &[1], &[(0, 5)], &[1], &[(0, 1)]), (vec![], vec![0]));
             assert_eq!((backend.output.columns.len(), backend.output.refs.len()), (1, 1));
         }
-        assert_eq!(backend.reduce_corrections(&[10], &[1], &[(0, 3)], &[1], &[(0, 1)]), (vec![(0, -1), (1, 1)], vec![2]));
+        assert_eq!(corrections(&mut backend, &[10], &[1], &[(0, 3)], &[1], &[(0, 1)]), (vec![(0, -1), (1, 1)], vec![2]));
         assert_eq!((backend.output.columns.len(), backend.output.refs.len()), (2, 2));
         for _ in 0..64 {
-            assert_eq!(backend.reduce_corrections(&[10], &[1], &[(0, 3)], &[1], &[(1, 1)]), (vec![], vec![0]));
+            assert_eq!(corrections(&mut backend, &[10], &[1], &[(0, 3)], &[1], &[(1, 1)]), (vec![], vec![0]));
             assert_eq!((backend.output.columns.len(), backend.output.refs.len()), (2, 2));
         }
         assert_eq!(rows_of(&backend.output.gather(&[0, 1])), vec![vec![5], vec![3]]);
@@ -912,7 +1071,7 @@ mod tests {
                 let shape = (corgi::shape_of_value(&recover_key(&key_shape(&[0]))), corgi::shape_of_value(&val_shape(&[(0, 0)])));
                 // Distinct reads its values whole, so the input pool holds what was presented.
                 let mut backend = CorgiReduceBackend::<Time>::with_window(Reducer::Expr(crate::parse::Reducer::Distinct.lambda()), None, shape, window_size);
-                backend.begin(Description::new(lower.clone(), Antichain::new(), lower.clone()));
+                ProxyReduceBackend::<Time, CBatch<Time>, CBatch<Time>>::begin(&mut backend, Description::new(lower.clone(), Antichain::new(), lower.clone()));
                 let (mut inputs, mut seeds, mut outputs) = (BTreeMap::new(), BTreeSet::new(), BTreeMap::new());
                 let (mut window, mut from) = (ReduceWindow::default(), KeyPosition::Start);
                 while from != KeyPosition::End {
@@ -1011,4 +1170,65 @@ mod tests {
             }
         }
     }
+
+    /// A grouped reduce's real keys sharing an identifier are reduced apart, and each keeps one list
+    /// per input. As for `colliding_keys_reduce_apart`, a forged identifier lane holding three real
+    /// keys gives what the true hash lane gives, over two retires and at every window size. The
+    /// inputs' value shapes differ, and equal values in two inputs stay apart.
+    #[test]
+    fn grouped_colliding_keys_reduce_apart() {
+        use timely::progress::{Antichain, Timestamp};
+        use differential_dataflow::operators::int_proxy::reduce::ProxyReduceTactic;
+        use differential_dataflow::operators::reduce::ReduceTactic;
+        use crate::runtime::chunk::recover_key;
+        use crate::runtime::feed::print;
+        use corgi::Shape;
+
+        let pair = Shape::Prod(vec![Shape::Int, Shape::Int]);
+        // Two retires' inputs, per input: the first at outer times 0 and 1, the second from 2 on.
+        let early = [random_rows(0x51ED_270B_2A4F_3C11, 200, 6), random_rows(0x7777_1234, 150, 6)]
+            .map(|rows| rows.into_iter().filter(|r| r.2.first().copied().unwrap_or(0) < 2).collect::<Vec<_>>());
+        let late = [random_rows(0x0BAD_5EED, 120, 6), random_rows(0xFEED_0BAD, 90, 6)].map(|rows| rows.into_iter()
+            .map(|(k, v, t, d)| (k, v, Time::new(std::iter::once(t.first().copied().unwrap_or(0) + 2).chain(t.iter().skip(1).copied()).collect()), d))
+            .collect::<Vec<_>>());
+        let stamp = |outer| crate::server::host_time(outer);
+        let lambda = crate::ir::Lambda::new("let (_, va, vb) = input in ((va, vb), 1) enlist".into(), &corgi::Scope::default());
+        // Input 0 has pair values, input 1 their first field only, so equal first fields of the
+        // two inputs meet.
+        let run = |forged: bool, window_size: usize| {
+            let batch = |input: usize, rows: &[(u64, (u64, u64), Time, Diff)]| -> (usize, CBatch<Time>) {
+                let (a, b): (Vec<u64>, Vec<u64>) = rows.iter().map(|r| (r.0, r.0 * 7)).unzip();
+                let keys = CValue::Prod(vec![ints(a), ints(b)]);
+                let keys = if forged { CValue::Prod(vec![ints(rows.iter().map(|r| r.0 % 2).collect()), keys]) } else { present_key(keys) };
+                let vals = if input == 0 {
+                    CValue::Prod(vec![ints(rows.iter().map(|r| r.1.0).collect()), ints(rows.iter().map(|r| r.1.1).collect())])
+                } else { ints(rows.iter().map(|r| r.1.0).collect()) };
+                let chunk = CorgiChunk::from_columns(keys, vals, rows.iter().map(|r| r.2.clone()).collect(), rows.iter().map(|r| r.3).collect());
+                (input, Rc::new(ChunkBatch::new(vec![chunk])))
+            };
+            let backend = CorgiReduceBackend::<Time>::grouped(Reducer::Expr(lambda.clone()), pair.clone(), vec![pair.clone(), Shape::Int], window_size);
+            let mut tactic = ProxyReduceTactic::new(backend);
+            let held = Antichain::from_elem(Time::minimum());
+            let novel = |rows: &[Vec<_>; 2]| vec![batch(0, &rows[0]), batch(1, &rows[1])];
+            let (first, _) = tactic.retire(Vec::new(), Vec::new(), novel(&early), &held, &Antichain::from_elem(stamp(2)), &held);
+            let first = first.and_then(|span| span.inner).into_iter().collect::<Vec<_>>();
+            let (second, _) = tactic.retire(novel(&early), first.clone(), novel(&late), &Antichain::from_elem(stamp(2)), &Antichain::new(), &held);
+            let mut netted = BTreeMap::new();
+            for done in first.iter().chain(second.and_then(|span| span.inner).as_ref()) {
+                for chunk in done.chunks.iter() {
+                    let keys = recover_key(chunk.keys());
+                    for i in 0..chunk.diffs().len() {
+                        *netted.entry((print(&keys, i), print(chunk.vals(), i), chunk.times().get(i))).or_insert(0) += chunk.diffs()[i];
+                    }
+                }
+            }
+            netted.retain(|_, diff| *diff != 0);
+            netted
+        };
+        let expected = run(false, usize::MAX);
+        assert!(!expected.is_empty());
+        for window_size in [1, 5, usize::MAX] {
+            assert_eq!(run(true, window_size), expected, "window_size={window_size}");
+        }
+    }
 }
diff --git a/interactive/src/scope_ir.rs b/interactive/src/scope_ir.rs
index ea47e6ed9..bf63b152e 100644
--- a/interactive/src/scope_ir.rs
+++ b/interactive/src/scope_ir.rs
@@ -35,7 +35,7 @@
 //! imports targeting the same definition are the same entity, so facts
 //! learned at a definition propagate to every importer along its edges.
 
-use crate::ir::{Lambda, LinearOp, Reducer};
+use crate::ir::{Diff, Lambda, LinearOp, Reducer};
 
 type ItemId = usize; // index into `Scope::items`
 type ImportId = usize; // index into `Scope::imports`
@@ -127,26 +127,78 @@ pub enum Node {
     HalfJoin { stream: Ref, arrangement: Ref, strict: bool, projection: Lambda },
     /// `reducer`'s lambda over each key and its values. With `limit = Some(k)` it is handed only
     /// the key's first `k` values of non-zero net, in value order, whatever their sums.
-    Reduce { input: Ref, reducer: Reducer, limit: Option<usize> },
+    ///
+    /// `input` names one or more arranged inputs, see [`ReduceInput`]. A `Grouped` input has no
+    /// limit.
+    Reduce { input: ReduceInput, reducer: Reducer, limit: Option<usize> },
     Inspect { input: Ref, label: String },
 }
 
+/// The inputs of a `Reduce`, all arranged and all of one key shape.
+#[derive(Clone, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
+pub enum ReduceInput {
+    /// The signed union of the inputs: each key's values are the consolidated sum of every input's
+    /// updates, each multiplied by its input's sign, as if the inputs were concatenated (negative
+    /// ones negated) and arranged. All inputs share one row shape and every sign is `1` or `-1`.
+    /// `Merged([(x, 1)])` is the plain reduce of `x`.
+    Merged(Vec<(Ref, Diff)>),
+    /// Grouped: the reducer is handed each key's values one list per input, `(key, vals_0, ..,
+    /// vals_{n-1})`, each `vals_i` input `i`'s consolidated `(val, diff)` list in value order,
+    /// empty where the input holds nothing at the key. Equal values of different inputs never
+    /// merge. Inputs share a key shape. Their value shapes may differ.
+    Grouped(Vec<Ref>),
+}
+
+impl ReduceInput {
+    /// The plain reduce of `r`.
+    pub fn single(r: Ref) -> Self { ReduceInput::Merged(vec![(r, 1)]) }
+    /// The input of a plain reduce, `Merged([(r, 1)])`.
+    pub fn as_single(&self) -> Option<&Ref> {
+        match self { ReduceInput::Merged(v) if v.len() == 1 && v[0].1 == 1 => Some(&v[0].0), _ => None }
+    }
+    /// As [`Self::as_single`], mutably.
+    pub fn as_single_mut(&mut self) -> Option<&mut Ref> {
+        match self { ReduceInput::Merged(v) if v.len() == 1 && v[0].1 == 1 => Some(&mut v[0].0), _ => None }
+    }
+    /// The first input, which fixes the key shape, and for `Merged` the row shape.
+    pub fn first(&self) -> &Ref {
+        match self { ReduceInput::Merged(v) => &v[0].0, ReduceInput::Grouped(v) => &v[0] }
+    }
+    /// Every input, in order.
+    pub fn refs(&self) -> impl Iterator<Item = &Ref> {
+        let (merged, grouped): (&[(Ref, Diff)], &[Ref]) = match self {
+            ReduceInput::Merged(v) => (v, &[]),
+            ReduceInput::Grouped(v) => (&[], v),
+        };
+        merged.iter().map(|(r, _)| r).chain(grouped)
+    }
+    /// Applies `f` to every input, in order.
+    pub fn for_each_ref(&mut self, mut f: impl FnMut(&mut Ref)) {
+        match self {
+            ReduceInput::Merged(v) => for (r, _) in v { f(r) },
+            ReduceInput::Grouped(v) => for r in v { f(r) },
+        }
+    }
+}
+
 impl Node {
     pub(crate) fn refs(&self) -> impl Iterator<Item = &Ref> {
-        let (first, second, rest): (_, _, &[_]) = match self {
+        let (first, second, rest, reduce): (_, _, &[_], _) = match self {
             Self::Linear { input, .. } | Self::Arrange(input)
-            | Self::Reduce { input, .. } | Self::Inspect { input, .. } => (Some(input), None, &[]),
-            Self::Join { left, right, .. } => (Some(left), Some(right), &[]),
-            Self::HalfJoin { stream, arrangement, .. } => (Some(stream), Some(arrangement), &[]),
-            Self::Concat(refs) => (None, None, refs),
+            | Self::Inspect { input, .. } => (Some(input), None, &[], None),
+            Self::Reduce { input, .. } => (None, None, &[], Some(input)),
+            Self::Join { left, right, .. } => (Some(left), Some(right), &[], None),
+            Self::HalfJoin { stream, arrangement, .. } => (Some(stream), Some(arrangement), &[], None),
+            Self::Concat(refs) => (None, None, refs, None),
         };
-        first.into_iter().chain(second).chain(rest)
+        first.into_iter().chain(second).chain(rest).chain(reduce.into_iter().flat_map(ReduceInput::refs))
     }
 
     pub(crate) fn for_each_ref(&mut self, mut f: impl FnMut(&mut Ref)) {
         match self {
+            Self::Reduce { input, .. } => input.for_each_ref(f),
             Self::Linear { input, .. } | Self::Arrange(input)
-            | Self::Reduce { input, .. } | Self::Inspect { input, .. } => f(input),
+            | Self::Inspect { input, .. } => f(input),
             Self::Join { left, right, .. } => { f(left); f(right); }
             Self::HalfJoin { stream, arrangement, .. } => { f(stream); f(arrangement); }
             Self::Concat(refs) => for r in refs { f(r); },
@@ -325,7 +377,14 @@ fn dump_scope_body(s: &Scope, indent: usize) {
                     Node::Arrange(r) => format!("{} | arrange", fmt_ref(r)),
                     Node::Join { left, right, .. } => format!("join({}, {})", fmt_ref(left), fmt_ref(right)),
                     Node::HalfJoin { stream, arrangement, strict, .. } => format!("{} | half_join({}, {})", fmt_ref(stream), fmt_ref(arrangement), *strict as u8),
-                    Node::Reduce { input, reducer, limit } => format!("{} | {:?} limit={limit:?}", fmt_ref(input), reducer),
+                    Node::Reduce { input, reducer, limit } => {
+                        // The DDP forms: `[a, -b] | ..` for a merged reduce, `a | reduce(b, c, ..)` for a grouped one.
+                        match input {
+                            ReduceInput::Merged(v) if matches!(v.as_slice(), [(_, 1)]) => format!("{} | {:?} limit={limit:?}", fmt_ref(&v[0].0), reducer),
+                            ReduceInput::Merged(v) => format!("[{}] | {:?} limit={limit:?}", v.iter().map(|(leaf, sign)| format!("{}{}", if *sign < 0 { "-" } else { "" }, fmt_ref(leaf))).collect::<Vec<_>>().join(", "), reducer),
+                            ReduceInput::Grouped(v) => format!("{} | reduce({}, {:?})", fmt_ref(&v[0]), v[1..].iter().map(fmt_ref).collect::<Vec<_>>().join(", "), reducer),
+                        }
+                    }
                     Node::Inspect { input, label } => format!("{} | inspect({})", fmt_ref(input), label),
                 };
                 println!("{}n{} = {};", pad2, i, desc);
@@ -392,4 +451,11 @@ mod tests {
         assert!(matches!(prog.root.imports[0].from, Source::Input(0)));
         assert!(matches!(reach.binds[0].value, Ref::Local(1)));
     }
+
+    #[test]
+    fn reduce_input_single_round_trips() {
+        assert_eq!(ReduceInput::single(Ref::Local(3)).as_single(), Some(&Ref::Local(3)));
+        assert_eq!(ReduceInput::Merged(vec![(Ref::Local(3), -1)]).as_single(), None);
+        assert_eq!(ReduceInput::Grouped(vec![Ref::Local(1), Ref::Local(2)]).refs().count(), 2);
+    }
 }
diff --git a/interactive/src/shapes.rs b/interactive/src/shapes.rs
index c54e57f77..4f97d8440 100644
--- a/interactive/src/shapes.rs
+++ b/interactive/src/shapes.rs
@@ -64,6 +64,22 @@ impl ScopeShapes {
             st::Ref::ChildExport(i, e) => match &self.items[*i] { ItemShapes::Sub(c) => c.exports[*e].clone(), ItemShapes::Op(_) => None },
         }
     }
+    /// The shape a reduce's lambda reads: `(key, vals)`, with a flat `(key, vals_0, .., vals_{n-1})`
+    /// for a grouped reduce. `None` while a shape it needs is unknown. A merged reduce's inputs
+    /// share one shape, so any known one gives it.
+    pub fn reduce_input(&self, input: &st::ReduceInput) -> Option<Shape> {
+        let (key, vals): (Shape, Vec<Shape>) = match input {
+            st::ReduceInput::Merged(inputs) => {
+                let c = inputs.iter().find_map(|(r, _)| self.of(r))?;
+                (c.key, vec![c.val])
+            }
+            st::ReduceInput::Grouped(inputs) => {
+                let known = inputs.iter().map(|r| self.of(r)).collect::<Option<Vec<_>>>()?;
+                (known[0].key.clone(), known.into_iter().map(|c| c.val).collect())
+            }
+        };
+        Some(Shape::Prod(crate::lambda::reduce_rows(&key, &vals)))
+    }
     /// The scope at `path` (indices of `Sub` items from this one).
     pub(crate) fn at(&self, path: &[usize]) -> &ScopeShapes {
         match path.split_first() {
@@ -275,11 +291,11 @@ fn pair_shape(projection: &Lambda, rows: &[Shape]) -> Result<(Shape, Shape), Str
     }
 }
 
-/// The output value shape of `reduce(lambda)` over a key of shape `key` with values of shape `val`:
-/// the lambda reads the key and a `List` of `(val, diff)`, and must give a `List` of `(val, diff)`.
-fn reduce_shape(lambda: &Lambda, key: &Shape, val: &Shape) -> Result<Shape, String> {
-    let env = [key.clone(), Shape::List(Box::new(Shape::Prod(vec![val.clone(), Shape::Int])))];
-    match slot_shape(lambda, &env).map_err(|e| format!("reduce: {e}"))? {
+/// The output value shape of `reduce(lambda)` over a key of shape `key` with inputs of value shapes
+/// `vals`: the lambda reads the key and one `List` of `(val, diff)` per input, and must give a
+/// `List` of `(val, diff)`.
+fn reduce_shape(lambda: &Lambda, key: &Shape, vals: &[Shape]) -> Result<Shape, String> {
+    match slot_shape(lambda, &crate::lambda::reduce_rows(key, vals)).map_err(|e| format!("reduce: {e}"))? {
         Shape::List(e) => match *e {
             Shape::Prod(mut fs) if fs.len() == 2 && fs[1] == Shape::Int => Ok(fs.swap_remove(0)),
             other => Err(format!("reduce: output elements of shape {other}, not (val, diff)")),
@@ -342,15 +358,47 @@ fn infer_node(node: &st::Node, shapes: &ScopeShapes, level: Level, at: &str, pro
                 Err(e) => fail(format!("half_join: {e}")),
             }
         }
-        st::Node::Reduce { input, reducer, .. } => {
-            let c = shapes.of(input)?;
+        st::Node::Reduce { input: st::ReduceInput::Merged(inputs), reducer, .. } => {
+            // The inputs are summed, so any one whose shape is known gives the row shape. In a loop
+            // the others may be known only through this reduce.
+            let known: Vec<CollShape> = inputs.iter().filter_map(|(r, _)| shapes.of(r)).collect();
+            let c = known.first()?.clone();
+            if let Some(other) = known.iter().find(|o| o.key != c.key || o.val != c.val) {
+                return fail(format!("reduce over inputs ({}, {}) and ({}, {})", c.key, c.val, other.key, other.val));
+            }
             let Reducer::Expr(lambda) = reducer;
-            let v = match reduce_shape(lambda, &c.key, &c.val) {
+            let v = match reduce_shape(lambda, &c.key, std::slice::from_ref(&c.val)) {
                 Ok(v) => v,
                 Err(e) => return fail(e),
             };
             Some(CollShape::new(c.key, v, level))
         }
+        st::Node::Reduce { input: st::ReduceInput::Grouped(inputs), reducer, .. } => {
+            // The lambda reads every input's values, so it types only once all their shapes are
+            // known. Inference revisits this reduce as they become known, so one still unknown
+            // when the scope settles is reported, by its position.
+            let mut known = Vec::with_capacity(inputs.len());
+            for (i, r) in inputs.iter().enumerate() {
+                match shapes.of(r) {
+                    Some(c) => known.push(c),
+                    None => {
+                        problems.unknown.push(format!("{at}: reduce input {i} ({r:?}) has no shape"));
+                        return None;
+                    }
+                }
+            }
+            // The inputs share a key shape, and each keeps its own value shape.
+            let key = known[0].key.clone();
+            if let Some(other) = known.iter().find(|o| o.key != key) {
+                return fail(format!("reduce over inputs keyed by {key} and {}", other.key));
+            }
+            let vals: Vec<Shape> = known.into_iter().map(|c| c.val).collect();
+            let Reducer::Expr(lambda) = reducer;
+            match reduce_shape(lambda, &key, &vals) {
+                Ok(v) => Some(CollShape::new(key, v, level)),
+                Err(e) => fail(e),
+            }
+        }
     }
 }
 
diff --git a/interactive/tests/difftest.rs b/interactive/tests/difftest.rs
index fd81f16ce..e812005bd 100644
--- a/interactive/tests/difftest.rs
+++ b/interactive/tests/difftest.rs
@@ -529,6 +529,60 @@ impl Gen {
                     val = v2;
                     op
                 }
+                // A bracket list of the stream and 1 to 3 signed collections of its shape, reduced
+                // as one merged reduce. A marker, rewritten below into the list that is the next
+                // op's source, with that reduce as the next op.
+                90..=92 => {
+                    let others: Vec<Coll> = self.colls.iter().filter(|c| c.key == key && c.val == val).cloned().collect();
+                    if others.is_empty() { continue; }
+                    let mut elements = Vec::new();
+                    for _ in 0..1 + self.rng.below(3) {
+                        let other = self.rng.pick(&others).clone();
+                        elements.push(format!("{}{}", if self.rng.chance(50) { "-" } else { "" }, other.name));
+                    }
+                    let (text, v2) = match self.rng.below(5) {
+                        0 => ("distinct".to_string(), val.clone()),
+                        1 => ("count".to_string(), Sh::Int),
+                        2 => ("min".to_string(), val.clone()),
+                        _ => self.reducer(&val),
+                    };
+                    ops.push(Op::Plain { text: format!("__list {}", elements.join(", ")), same_shape: true });
+                    concat_shapes.push((key.clone(), val.clone()));
+                    // The reduce stays with its list: dropping it would leave a list alone.
+                    ops.push(Op::Plain { text, same_shape: false });
+                    val = v2;
+                    continue;
+                }
+                // A grouped reduce over the stream and 1 to 3 collections of its key, whose values
+                // may have other shapes.
+                93..=95 => {
+                    let candidates: Vec<Coll> = self.colls.iter().filter(|c| c.key == key).cloned().collect();
+                    if candidates.is_empty() { continue; }
+                    let mut picked: Vec<Coll> = (0..1 + self.rng.below(3)).map(|_| self.rng.pick(&candidates).clone()).collect();
+                    // When some collection of the key holds another value shape, the first input
+                    // after the stream is one.
+                    let differing: Vec<Coll> = candidates.iter().filter(|c| c.val != val).cloned().collect();
+                    if !differing.is_empty() { picked[0] = self.rng.pick(&differing).clone(); }
+                    let others = picked;
+                    let names = others.iter().map(|c| c.name.clone()).collect::<Vec<_>>().join(", ");
+                    let lists: Vec<String> = (0..=others.len()).map(|i| format!("l{i}")).collect();
+                    let lens: Vec<String> = lists.iter().map(|l| format!("{l} len")).collect();
+                    // The lambda binds one list per input, the stream's first.
+                    let last = others.last().unwrap().val.clone();
+                    let (body, v2) = match self.rng.below(4) {
+                        0 => {
+                            let sum = lens.iter().skip(1).fold(lens[0].clone(), |acc, l| format!("({acc}, {l}) add"));
+                            (format!("({sum}, 1) enlist"), Sh::Int)
+                        }
+                        1 => (format!("(({}), 1) enlist", lens.join(", ")), Sh::Tup(vec![Sh::Int; lens.len()])),
+                        // The contents of the first list, and of the last, a list of another shape.
+                        2 => ("l0 map ((v, _) -> (v, 1))".to_string(), val.clone()),
+                        _ => (format!("l{} map ((v, _) -> (v, 1))", others.len()), last),
+                    };
+                    let op = Op::Plain { text: format!("reduce({names}, (_, {}) -> {body})", lists.join(", ")), same_shape: v2 == val };
+                    val = v2;
+                    op
+                }
                 _ => {
                     let others: Vec<Coll> = self.colls.iter().filter(|c| c.key == key && c.val == val).cloned().collect();
                     if others.is_empty() { continue; }
@@ -550,6 +604,16 @@ impl Gen {
         let mut concat_shapes = concat_shapes.into_iter();
         for op in ops {
             match &op {
+                Op::Plain { text, .. } if text.starts_with("__list ") => {
+                    let (mk, mv) = concat_shapes.next().unwrap();
+                    // As for a concat, the list's first element is a named let.
+                    if !lowered.is_empty() {
+                        let mid = self.name();
+                        self.push_let(Let { name: mid.clone(), var: false, src: src_text.clone(), ops: std::mem::take(&mut lowered), key: mk, val: mv });
+                        src_text = mid;
+                    }
+                    src_text = format!("[{src_text}, {}]", &text["__list ".len()..]);
+                }
                 Op::Plain { text, .. } if text.starts_with("__concat ") => {
                     let rest = &text["__concat ".len()..];
                     let (sign, other) = rest.split_at(1);
@@ -586,7 +650,7 @@ impl Gen {
             true
         } else {
             let names: Vec<&Coll> = l.src.split(|c: char| !(c.is_alphanumeric() || c == '_')).filter_map(named).collect();
-            !l.src.contains(" - ") && names.iter().all(|c| c.positive)
+            !l.src.contains(" - ") && !l.src.contains(", -") && names.iter().all(|c| c.positive)
         };
         for op in &l.ops {
             match op {
@@ -1387,10 +1451,11 @@ fn parse_case(text: &str) -> Case {
 /// Draw independently of generation, so minimization and new generator draws keep the subset.
 fn subset(seed: u64) -> Config {
     if let Ok(text) = std::env::var("DIFFTEST_PASSES") { return Config::parse(&text).unwrap(); }
-    let bits = Rng(seed ^ 0x7061_7373_6573).below(128);
+    let bits = Rng(seed ^ 0x7061_7373_6573).below(256);
     Config { structural: bits & 1 != 0, compose_maps: bits & 2 != 0,
         dead_code: bits & 4 != 0, projection: bits & 8 != 0, as_of_drop: bits & 16 != 0,
-        collapse_parent_arranges: bits & 32 != 0, hoist_invariant: bits & 64 != 0 }
+        collapse_parent_arranges: bits & 32 != 0, hoist_invariant: bits & 64 != 0,
+        merge_reduce: bits & 128 != 0 }
 }
 
 fn pass_names(config: Config) -> String {
diff --git a/interactive/tests/plan_pairs.rs b/interactive/tests/plan_pairs.rs
index 2259e85a7..239f4dc3e 100644
--- a/interactive/tests/plan_pairs.rs
+++ b/interactive/tests/plan_pairs.rs
@@ -75,7 +75,8 @@ fn check_scope(scope: &Scope, parent: Option<(&Scope, usize)>, labels: bool, ori
         match item {
             Item::Op(node) => match node {
                 Node::Linear { input, .. } | Node::Arrange(input)
-                | Node::Reduce { input, .. } | Node::Inspect { input, .. } => check_ref(input, i),
+                | Node::Inspect { input, .. } => check_ref(input, i),
+                Node::Reduce { input, .. } => input.refs().for_each(|r| check_ref(r, i)),
                 Node::Concat(refs) => for r in refs { check_ref(r, i); },
                 Node::Join { left, right, .. } => { check_ref(left, i); check_ref(right, i); }
                 Node::HalfJoin { stream, arrangement, .. } => { check_ref(stream, i); check_ref(arrangement, i); }
diff --git a/interactive/tests/plan_pairs/expected/access_shared.lowered--optimized.diff b/interactive/tests/plan_pairs/expected/access_shared.lowered--optimized.diff
index d31a8e110..4fd700f6b 100644
--- a/interactive/tests/plan_pairs/expected/access_shared.lowered--optimized.diff
+++ b/interactive/tests/plan_pairs/expected/access_shared.lowered--optimized.diff
@@ -1,6 +1,6 @@
 --- lowered
 +++ optimized
-@@ -4,35 +4,33 @@
+@@ -4,6 +4,8 @@
  let grants = input 0 : (int, (Member, Access));
  let groups = input 1 : (int, Member);
  let blocks = input 2 : (int, Member);
@@ -9,16 +9,14 @@
  let members_map = groups | map((grp, who) -> (grp inject Member::Group, who));
  let members = members_map | arrange;
  barring: {
-     -- Time lanes: epoch, then 1 scope coordinates; this scope enters at zero.
+@@ -11,26 +13,24 @@
      var barred : (Member, int);
      let barred_idx = barred | arrange;
--    let members_idx = ::members | arrange;
--    let beyond = barred_idx | join(members_idx, (_grp, doc, who) -> (who, doc));
+     let beyond = barred_idx | join(::members, (_grp, doc, who) -> (who, doc));
 -    let barred_map = ::blocks | map((doc, who) -> (who, doc));
 -    let barred_rows = barred_map + beyond;
 -    let barred_map2 = barred_rows | map((k, v) -> ((k, v), ()));
 -    let barred_idx2 = barred_map2 | arrange;
-+    let beyond = barred_idx | join(::members, (_grp, doc, who) -> (who, doc));
 +    let barred_rows = ::blocks_map + beyond;
 +    let barred_map = barred_rows | map((k, v) -> ((k, v), ()));
 +    let barred_idx2 = barred_map | arrange;
@@ -35,11 +33,9 @@
      var allowed : ((Member, int), Access);
      let inherited_map = allowed | map(((who, doc), acc) -> (who, (doc, acc)));
      let inherited_idx = inherited_map | arrange;
--    let members_idx = ::members | arrange;
--    let inherited = inherited_idx | join(members_idx, (_grp, (doc, acc), who) -> ((who, doc), acc));
+     let inherited = inherited_idx | join(::members, (_grp, (doc, acc), who) -> ((who, doc), acc));
 -    let offered_map = ::grants | map((doc, (who, acc)) -> ((who, doc), acc));
 -    let offered = offered_map + inherited;
-+    let inherited = inherited_idx | join(::members, (_grp, (doc, acc), who) -> ((who, doc), acc));
 +    let offered = ::grants_map + inherited;
      let offered_idx = offered | arrange;
 -    let barred_idx = ::barred | arrange;
diff --git a/interactive/tests/plan_pairs/expected/access_shared.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/access_shared.parsed--lowered.diff
index ecce6a3d2..e1deac20a 100644
--- a/interactive/tests/plan_pairs/expected/access_shared.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/access_shared.parsed--lowered.diff
@@ -1,6 +1,6 @@
 --- parsed
 +++ lowered
-@@ -1,19 +1,43 @@
+@@ -1,19 +1,41 @@
  type Access = Owner | Edit | View;
  type Member = User int | Group int;
 +-- Time lanes: epoch.
@@ -14,8 +14,7 @@
 +    -- Time lanes: epoch, then 1 scope coordinates; this scope enters at zero.
 +    var barred : (Member, int);
 +    let barred_idx = barred | arrange;
-+    let members_idx = ::members | arrange;
-+    let beyond = barred_idx | join(members_idx, (_grp, doc, who) -> (who, doc));
++    let beyond = barred_idx | join(::members, (_grp, doc, who) -> (who, doc));
 +    let barred_map = ::blocks | map((doc, who) -> (who, doc));
 +    let barred_rows = barred_map + beyond;
 +    let barred_map2 = barred_rows | map((k, v) -> ((k, v), ()));
@@ -34,8 +33,7 @@
 +    var allowed : ((Member, int), Access);
 +    let inherited_map = allowed | map(((who, doc), acc) -> (who, (doc, acc)));
 +    let inherited_idx = inherited_map | arrange;
-+    let members_idx = ::members | arrange;
-+    let inherited = inherited_idx | join(members_idx, (_grp, (doc, acc), who) -> ((who, doc), acc));
++    let inherited = inherited_idx | join(::members, (_grp, (doc, acc), who) -> ((who, doc), acc));
 +    let offered_map = ::grants | map((doc, (who, acc)) -> ((who, doc), acc));
 +    let offered = offered_map + inherited;
 +    let offered_idx = offered | arrange;
diff --git a/interactive/tests/plan_pairs/expected/as_of_shared.ddp b/interactive/tests/plan_pairs/expected/as_of_shared.ddp
index 58f316f05..559f3e286 100644
--- a/interactive/tests/plan_pairs/expected/as_of_shared.ddp
+++ b/interactive/tests/plan_pairs/expected/as_of_shared.ddp
@@ -3,9 +3,8 @@
 let rows = import "rows::rows" : (int, int);
 let lifted = rows | lift;
 let lifted_filter = lifted | filter((_, (_, (t0))) -> (t0, 0) ne);
-let rows_idx = rows | arrange;
-let strict_join = lifted_filter | half_join(rows_idx, 1, (k, v, _) -> (k, v));
-let inclusive_join = lifted | half_join(rows_idx, 0, (k, v, _) -> (k, v));
+let strict_join = lifted_filter | half_join(rows, 1, (k, v, _) -> (k, v));
+let inclusive_join = lifted | half_join(rows, 0, (k, v, _) -> (k, v));
 -- Renderer: build an export arrangement.
 output "strict" = strict_join;
 -- Renderer: build an export arrangement.
diff --git a/interactive/tests/plan_pairs/expected/as_of_shared.lowered--optimized.diff b/interactive/tests/plan_pairs/expected/as_of_shared.lowered--optimized.diff
index ce2169f66..e69de29bb 100644
--- a/interactive/tests/plan_pairs/expected/as_of_shared.lowered--optimized.diff
+++ b/interactive/tests/plan_pairs/expected/as_of_shared.lowered--optimized.diff
@@ -1,12 +0,0 @@
---- lowered
-+++ optimized
-@@ -4,8 +4,7 @@
- let lifted = rows | lift;
- let rows_idx = rows | arrange;
- let strict_join = lifted | half_join(rows_idx, 1, (k, v, _) -> (k, v));
--let rows_idx2 = rows | arrange;
--let inclusive_join = lifted | half_join(rows_idx2, 0, (k, v, _) -> (k, v));
-+let inclusive_join = lifted | half_join(rows_idx, 0, (k, v, _) -> (k, v));
- -- Renderer: build an export arrangement.
- output "strict" = strict_join;
- -- Renderer: build an export arrangement.
diff --git a/interactive/tests/plan_pairs/expected/as_of_shared.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/as_of_shared.parsed--lowered.diff
index bc62f1210..396cae967 100644
--- a/interactive/tests/plan_pairs/expected/as_of_shared.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/as_of_shared.parsed--lowered.diff
@@ -1,16 +1,14 @@
 --- parsed
 +++ lowered
-@@ -1,4 +1,12 @@
+@@ -1,4 +1,10 @@
 +-- Time lanes: epoch.
 +-- Trace imports use provider arrangements; history advances to G = (0, []).
  let rows = import "rows::rows" : (int, int);
  let lifted = rows | lift;
 -output "strict" = lifted | half_join(rows, 1, (k, v, _) -> (k, v));
 -output "inclusive" = lifted | half_join(rows, 0, (k, v, _) -> (k, v));
-+let rows_idx = rows | arrange;
-+let strict_join = lifted | half_join(rows_idx, 1, (k, v, _) -> (k, v));
-+let rows_idx2 = rows | arrange;
-+let inclusive_join = lifted | half_join(rows_idx2, 0, (k, v, _) -> (k, v));
++let strict_join = lifted | half_join(rows, 1, (k, v, _) -> (k, v));
++let inclusive_join = lifted | half_join(rows, 0, (k, v, _) -> (k, v));
 +-- Renderer: build an export arrangement.
 +output "strict" = strict_join;
 +-- Renderer: build an export arrangement.
diff --git a/interactive/tests/plan_pairs/expected/as_of_shared.projected--as-of.diff b/interactive/tests/plan_pairs/expected/as_of_shared.projected--as-of.diff
index 0176e83bc..3608be2a8 100644
--- a/interactive/tests/plan_pairs/expected/as_of_shared.projected--as-of.diff
+++ b/interactive/tests/plan_pairs/expected/as_of_shared.projected--as-of.diff
@@ -1,13 +1,12 @@
 --- projected
 +++ as-of
-@@ -2,8 +2,9 @@
+@@ -2,7 +2,8 @@
  -- Trace imports use provider arrangements; history advances to G = (0, []).
  let rows = import "rows::rows" : (int, int);
  let lifted = rows | lift;
+-let strict_join = lifted | half_join(rows, 1, (k, v, _) -> (k, v));
 +let lifted_filter = lifted | filter((_, (_, (t0))) -> (t0, 0) ne);
- let rows_idx = rows | arrange;
--let strict_join = lifted | half_join(rows_idx, 1, (k, v, _) -> (k, v));
-+let strict_join = lifted_filter | half_join(rows_idx, 1, (k, v, _) -> (k, v));
- let inclusive_join = lifted | half_join(rows_idx, 0, (k, v, _) -> (k, v));
++let strict_join = lifted_filter | half_join(rows, 1, (k, v, _) -> (k, v));
+ let inclusive_join = lifted | half_join(rows, 0, (k, v, _) -> (k, v));
  -- Renderer: build an export arrangement.
  output "strict" = strict_join;
diff --git a/interactive/tests/plan_pairs/expected/as_of_strict.ddp b/interactive/tests/plan_pairs/expected/as_of_strict.ddp
index d658ee19a..4e2403862 100644
--- a/interactive/tests/plan_pairs/expected/as_of_strict.ddp
+++ b/interactive/tests/plan_pairs/expected/as_of_strict.ddp
@@ -2,7 +2,6 @@
 -- Trace imports use provider arrangements; history advances to G = (0, []).
 let rows = import "rows::rows" : (int, int);
 let out_rows = rows | lift | filter((_, (_, (t0))) -> (t0, 0) ne);
-let rows_idx = rows | arrange;
-let out_join = out_rows | half_join(rows_idx, 1, (k, v, _) -> (k, v));
+let out_join = out_rows | half_join(rows, 1, (k, v, _) -> (k, v));
 -- Renderer: build an export arrangement.
 output "out" = out_join;
diff --git a/interactive/tests/plan_pairs/expected/as_of_strict.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/as_of_strict.parsed--lowered.diff
index eaa3a8aca..23ce5459e 100644
--- a/interactive/tests/plan_pairs/expected/as_of_strict.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/as_of_strict.parsed--lowered.diff
@@ -1,12 +1,11 @@
 --- parsed
 +++ lowered
-@@ -1,2 +1,8 @@
+@@ -1,2 +1,7 @@
 +-- Time lanes: epoch.
 +-- Trace imports use provider arrangements; history advances to G = (0, []).
  let rows = import "rows::rows" : (int, int);
 -output "out" = rows | lift | half_join(rows, 1, (k, v, _) -> (k, v));
 +let out_rows = rows | lift;
-+let rows_idx = rows | arrange;
-+let out_join = out_rows | half_join(rows_idx, 1, (k, v, _) -> (k, v));
++let out_join = out_rows | half_join(rows, 1, (k, v, _) -> (k, v));
 +-- Renderer: build an export arrangement.
 +output "out" = out_join;
diff --git a/interactive/tests/plan_pairs/expected/as_of_strict.projected--as-of.diff b/interactive/tests/plan_pairs/expected/as_of_strict.projected--as-of.diff
index c58167001..561be9e94 100644
--- a/interactive/tests/plan_pairs/expected/as_of_strict.projected--as-of.diff
+++ b/interactive/tests/plan_pairs/expected/as_of_strict.projected--as-of.diff
@@ -6,6 +6,6 @@
  let rows = import "rows::rows" : (int, int);
 -let out_rows = rows | lift;
 +let out_rows = rows | lift | filter((_, (_, (t0))) -> (t0, 0) ne);
- let rows_idx = rows | arrange;
- let out_join = out_rows | half_join(rows_idx, 1, (k, v, _) -> (k, v));
+ let out_join = out_rows | half_join(rows, 1, (k, v, _) -> (k, v));
  -- Renderer: build an export arrangement.
+ output "out" = out_join;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic01_oneoff.ddp b/interactive/tests/plan_pairs/expected/ldbc_ic01_oneoff.ddp
index caeff6f00..9001b1aa7 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic01_oneoff.ddp
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic01_oneoff.ddp
@@ -11,49 +11,41 @@ let email = import "graph::email.by_person" : (int, List(int));
 let language = import "graph::language.by_person" : (int, List(int));
 let hop1_map = request | map(((rid, who, name), ()) -> (who, (rid, who, name)));
 let hop1_idx = hop1_map | arrange;
-let friend_idx = friend | arrange;
-let hop1 = hop1_idx | join(friend_idx, (_, req, (f, _)) -> (f, (req, 1)));
+let hop1 = hop1_idx | join(friend, (_, req, (f, _)) -> (f, (req, 1)));
 let hop1_idx2 = hop1 | arrange;
-let hop2 = hop1_idx2 | join(friend_idx, (_, (req, _), (g, _)) -> (g, (req, 2)));
+let hop2 = hop1_idx2 | join(friend, (_, (req, _), (g, _)) -> (g, (req, 2)));
 let hop2_idx = hop2 | arrange;
-let hop3 = hop2_idx | join(friend_idx, (_, (req, _), (h, _)) -> (h, (req, 3)));
+let hop3 = hop2_idx | join(friend, (_, (req, _), (h, _)) -> (h, (req, 3)));
 let circle_rows = hop1 + hop2 + hop3;
 let circle_rows2 = circle_rows | filter((node, ((_, who, _), _)) -> (node, who) ne) | map((node, ((rid, _, name), d)) -> ((rid, node, name), d));
 let circle_idx = circle_rows2 | arrange;
 let circle = circle_idx | reduce(limit 1, (_, vals) -> let first = vals head in (first.0, 1) enlist);
 let found_map = circle | map(((rid, node, name), d) -> (node, (rid, name, d)));
 let found_idx = found_map | arrange;
-let person_idx = person | arrange;
-let found_join = found_idx | join(person_idx, (node, (rid, name, d), (first, last, gender, birthday, created, ip, browser, home, _, _, _)) -> ((first, name) eq, (home, (rid, node, d, last, gender, birthday, created, ip, browser))));
+let found_join = found_idx | join(person, (node, (rid, name, d), (first, last, gender, birthday, created, ip, browser, home, _, _, _)) -> ((first, name) eq, (home, (rid, node, d, last, gender, birthday, created, ip, browser))));
 let found_rows = found_join | filter((named, _) -> named) | map((_, row) -> row);
 let found_idx2 = found_rows | arrange;
-let place_idx = place | arrange;
-let found = found_idx2 | join(place_idx, (_, (rid, node, d, last, gender, birthday, created, ip, browser), (town, _, _)) -> ((rid, node), (d, (last, gender, birthday, created, ip, browser, town))));
+let found = found_idx2 | join(place, (_, (rid, node, d, last, gender, birthday, created, ip, browser), (town, _, _)) -> ((rid, node), (d, (last, gender, birthday, created, ip, browser, town))));
 let who = found | map(((rid, node), _) -> (node, rid));
 let who_idx = who | arrange;
-let email_idx = email | arrange;
-let emails_join = who_idx | join(email_idx, (node, rid, value) -> ((rid, node), value));
+let emails_join = who_idx | join(email, (node, rid, value) -> ((rid, node), value));
 let emails_idx = emails_join | arrange;
 let emails = emails_idx | reduce((_, vals) -> let lists = vals map ((v, d) -> (v, (0, d) range) cap_list map ((v, _) -> v)) in let flat = lists flatten in (flat.1, 1) enlist);
-let language_idx = language | arrange;
-let langs_join = who_idx | join(language_idx, (node, rid, value) -> ((rid, node), value));
+let langs_join = who_idx | join(language, (node, rid, value) -> ((rid, node), value));
 let langs_idx = langs_join | arrange;
 let langs = langs_idx | reduce((_, vals) -> let lists = vals map ((v, d) -> (v, (0, d) range) cap_list map ((v, _) -> v)) in let flat = lists flatten in (flat.1, 1) enlist);
-let study_idx = study | arrange;
-let school_join = who_idx | join(study_idx, (node, rid, (at, year)) -> (at, (rid, node, year)));
+let school_join = who_idx | join(study, (node, rid, (at, year)) -> (at, (rid, node, year)));
 let school_idx = school_join | arrange;
-let org_idx = org | arrange;
-let school_join2 = school_idx | join(org_idx, (_, (rid, node, year), (name, _, at)) -> (at, (rid, node, name, year)));
+let school_join2 = school_idx | join(org, (_, (rid, node, year), (name, _, at)) -> (at, (rid, node, name, year)));
 let school_idx2 = school_join2 | arrange;
-let school_join3 = school_idx2 | join(place_idx, (_, (rid, node, name, year), (where, _, _)) -> ((rid, node), (name, year, where)));
+let school_join3 = school_idx2 | join(place, (_, (rid, node, name, year), (where, _, _)) -> ((rid, node), (name, year, where)));
 let school_idx3 = school_join3 | arrange;
 let school = school_idx3 | reduce((_, vals) -> let lists = vals map ((v, d) -> (v, (0, d) range) cap_list map ((v, _) -> v)) in let flat = lists flatten in (flat.1, 1) enlist);
-let work_idx = work | arrange;
-let jobs_join = who_idx | join(work_idx, (node, rid, (at, year)) -> (at, (rid, node, year)));
+let jobs_join = who_idx | join(work, (node, rid, (at, year)) -> (at, (rid, node, year)));
 let jobs_idx = jobs_join | arrange;
-let jobs_join2 = jobs_idx | join(org_idx, (_, (rid, node, year), (name, _, at)) -> (at, (rid, node, name, year)));
+let jobs_join2 = jobs_idx | join(org, (_, (rid, node, year), (name, _, at)) -> (at, (rid, node, name, year)));
 let jobs_idx2 = jobs_join2 | arrange;
-let jobs_join3 = jobs_idx2 | join(place_idx, (_, (rid, node, name, year), (where, _, _)) -> ((rid, node), (name, year, where)));
+let jobs_join3 = jobs_idx2 | join(place, (_, (rid, node, name, year), (where, _, _)) -> ((rid, node), (name, year, where)));
 let jobs_idx3 = jobs_join3 | arrange;
 let jobs = jobs_idx3 | reduce((_, vals) -> let lists = vals map ((v, d) -> (v, (0, d) range) cap_list map ((v, _) -> v)) in let flat = lists flatten in (flat.1, 1) enlist);
 let found_idx3 = found | arrange;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic01_oneoff.lowered--optimized.diff b/interactive/tests/plan_pairs/expected/ldbc_ic01_oneoff.lowered--optimized.diff
index 3d9dea0c4..07feccb25 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic01_oneoff.lowered--optimized.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic01_oneoff.lowered--optimized.diff
@@ -1,16 +1,8 @@
 --- lowered
 +++ optimized
-@@ -14,23 +14,19 @@
- let friend_idx = friend | arrange;
- let hop1 = hop1_idx | join(friend_idx, (_, req, (f, _)) -> (f, (req, 1)));
- let hop1_idx2 = hop1 | arrange;
--let friend_idx2 = friend | arrange;
--let hop2 = hop1_idx2 | join(friend_idx2, (_, (req, _), (g, _)) -> (g, (req, 2)));
-+let hop2 = hop1_idx2 | join(friend_idx, (_, (req, _), (g, _)) -> (g, (req, 2)));
+@@ -17,36 +17,31 @@
  let hop2_idx = hop2 | arrange;
--let friend_idx3 = friend | arrange;
--let hop3 = hop2_idx | join(friend_idx3, (_, (req, _), (h, _)) -> (h, (req, 3)));
-+let hop3 = hop2_idx | join(friend_idx, (_, (req, _), (h, _)) -> (h, (req, 3)));
+ let hop3 = hop2_idx | join(friend, (_, (req, _), (h, _)) -> (h, (req, 3)));
  let circle_rows = hop1 + hop2 + hop3;
 -let circle_filter = circle_rows | filter((node, ((_, who, _), _)) -> (node, who) ne);
 -let circle_map = circle_filter | map((node, ((rid, _, name), d)) -> ((rid, node, name), d));
@@ -20,52 +12,39 @@
  let circle = circle_idx | reduce(limit 1, (_, vals) -> let first = vals head in (first.0, 1) enlist);
  let found_map = circle | map(((rid, node, name), d) -> (node, (rid, name, d)));
  let found_idx = found_map | arrange;
- let person_idx = person | arrange;
- let found_join = found_idx | join(person_idx, (node, (rid, name, d), (first, last, gender, birthday, created, ip, browser, home, _, _, _)) -> ((first, name) eq, (home, (rid, node, d, last, gender, birthday, created, ip, browser))));
+ let found_join = found_idx | join(person, (node, (rid, name, d), (first, last, gender, birthday, created, ip, browser, home, _, _, _)) -> ((first, name) eq, (home, (rid, node, d, last, gender, birthday, created, ip, browser))));
 -let found_filter = found_join | filter((named, _) -> named);
 -let found_map2 = found_filter | map((_, row) -> row);
 -let found_idx2 = found_map2 | arrange;
 +let found_rows = found_join | filter((named, _) -> named) | map((_, row) -> row);
 +let found_idx2 = found_rows | arrange;
- let place_idx = place | arrange;
- let found = found_idx2 | join(place_idx, (_, (rid, node, d, last, gender, birthday, created, ip, browser), (town, _, _)) -> ((rid, node), (d, (last, gender, birthday, created, ip, browser, town))));
+ let found = found_idx2 | join(place, (_, (rid, node, d, last, gender, birthday, created, ip, browser), (town, _, _)) -> ((rid, node), (d, (last, gender, birthday, created, ip, browser, town))));
  let who = found | map(((rid, node), _) -> (node, rid));
-@@ -39,61 +35,51 @@
- let emails_join = who_idx | join(email_idx, (node, rid, value) -> ((rid, node), value));
+ let who_idx = who | arrange;
+ let emails_join = who_idx | join(email, (node, rid, value) -> ((rid, node), value));
  let emails_idx = emails_join | arrange;
  let emails = emails_idx | reduce((_, vals) -> let lists = vals map ((v, d) -> (v, (0, d) range) cap_list map ((v, _) -> v)) in let flat = lists flatten in (flat.1, 1) enlist);
 -let who_idx2 = who | arrange;
- let language_idx = language | arrange;
--let langs_join = who_idx2 | join(language_idx, (node, rid, value) -> ((rid, node), value));
-+let langs_join = who_idx | join(language_idx, (node, rid, value) -> ((rid, node), value));
+-let langs_join = who_idx2 | join(language, (node, rid, value) -> ((rid, node), value));
++let langs_join = who_idx | join(language, (node, rid, value) -> ((rid, node), value));
  let langs_idx = langs_join | arrange;
  let langs = langs_idx | reduce((_, vals) -> let lists = vals map ((v, d) -> (v, (0, d) range) cap_list map ((v, _) -> v)) in let flat = lists flatten in (flat.1, 1) enlist);
 -let who_idx3 = who | arrange;
- let study_idx = study | arrange;
--let school_join = who_idx3 | join(study_idx, (node, rid, (at, year)) -> (at, (rid, node, year)));
-+let school_join = who_idx | join(study_idx, (node, rid, (at, year)) -> (at, (rid, node, year)));
+-let school_join = who_idx3 | join(study, (node, rid, (at, year)) -> (at, (rid, node, year)));
++let school_join = who_idx | join(study, (node, rid, (at, year)) -> (at, (rid, node, year)));
  let school_idx = school_join | arrange;
- let org_idx = org | arrange;
- let school_join2 = school_idx | join(org_idx, (_, (rid, node, year), (name, _, at)) -> (at, (rid, node, name, year)));
+ let school_join2 = school_idx | join(org, (_, (rid, node, year), (name, _, at)) -> (at, (rid, node, name, year)));
  let school_idx2 = school_join2 | arrange;
--let place_idx2 = place | arrange;
--let school_join3 = school_idx2 | join(place_idx2, (_, (rid, node, name, year), (where, _, _)) -> ((rid, node), (name, year, where)));
-+let school_join3 = school_idx2 | join(place_idx, (_, (rid, node, name, year), (where, _, _)) -> ((rid, node), (name, year, where)));
+ let school_join3 = school_idx2 | join(place, (_, (rid, node, name, year), (where, _, _)) -> ((rid, node), (name, year, where)));
  let school_idx3 = school_join3 | arrange;
  let school = school_idx3 | reduce((_, vals) -> let lists = vals map ((v, d) -> (v, (0, d) range) cap_list map ((v, _) -> v)) in let flat = lists flatten in (flat.1, 1) enlist);
 -let who_idx4 = who | arrange;
- let work_idx = work | arrange;
--let jobs_join = who_idx4 | join(work_idx, (node, rid, (at, year)) -> (at, (rid, node, year)));
-+let jobs_join = who_idx | join(work_idx, (node, rid, (at, year)) -> (at, (rid, node, year)));
+-let jobs_join = who_idx4 | join(work, (node, rid, (at, year)) -> (at, (rid, node, year)));
++let jobs_join = who_idx | join(work, (node, rid, (at, year)) -> (at, (rid, node, year)));
  let jobs_idx = jobs_join | arrange;
--let org_idx2 = org | arrange;
--let jobs_join2 = jobs_idx | join(org_idx2, (_, (rid, node, year), (name, _, at)) -> (at, (rid, node, name, year)));
-+let jobs_join2 = jobs_idx | join(org_idx, (_, (rid, node, year), (name, _, at)) -> (at, (rid, node, name, year)));
+ let jobs_join2 = jobs_idx | join(org, (_, (rid, node, year), (name, _, at)) -> (at, (rid, node, name, year)));
  let jobs_idx2 = jobs_join2 | arrange;
--let place_idx3 = place | arrange;
--let jobs_join3 = jobs_idx2 | join(place_idx3, (_, (rid, node, name, year), (where, _, _)) -> ((rid, node), (name, year, where)));
-+let jobs_join3 = jobs_idx2 | join(place_idx, (_, (rid, node, name, year), (where, _, _)) -> ((rid, node), (name, year, where)));
- let jobs_idx3 = jobs_join3 | arrange;
+@@ -55,32 +50,28 @@
  let jobs = jobs_idx3 | reduce((_, vals) -> let lists = vals map ((v, d) -> (v, (0, d) range) cap_list map ((v, _) -> v)) in let flat = lists flatten in (flat.1, 1) enlist);
  let found_idx3 = found | arrange;
  let with1_join = found_idx3 | join(emails, (key, row, list) -> (key, (row, list)));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic01_oneoff.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/ldbc_ic01_oneoff.parsed--lowered.diff
index ae8295b3c..717218d8e 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic01_oneoff.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic01_oneoff.parsed--lowered.diff
@@ -6,7 +6,7 @@
  let request = input 0 : ((int, int, List(int)), ());
  let person = import "graph::person" : (int, (List(int), List(int), List(int), int, int, List(int), List(int), int, int, int, int));
  let friend = import "graph::friend" : (int, (int, int));
-@@ -7,20 +9,99 @@
+@@ -7,20 +9,86 @@
  let work = import "graph::work.by_person" : (int, (int, int));
  let email = import "graph::email.by_person" : (int, List(int));
  let language = import "graph::language.by_person" : (int, List(int));
@@ -17,14 +17,11 @@
 -let found = circle | map(((rid, node, name), d) -> (node, (rid, name, d))) | join(person, (node, (rid, name, d), (first, last, gender, birthday, created, ip, browser, home, _, _, _)) -> ((first, name) eq, (home, (rid, node, d, last, gender, birthday, created, ip, browser)))) | filter((named, _) -> named) | map((_, row) -> row) | join(place, (_, (rid, node, d, last, gender, birthday, created, ip, browser), (town, _, _)) -> ((rid, node), (d, (last, gender, birthday, created, ip, browser, town))));
 +let hop1_map = request | map(((rid, who, name), ()) -> (who, (rid, who, name)));
 +let hop1_idx = hop1_map | arrange;
-+let friend_idx = friend | arrange;
-+let hop1 = hop1_idx | join(friend_idx, (_, req, (f, _)) -> (f, (req, 1)));
++let hop1 = hop1_idx | join(friend, (_, req, (f, _)) -> (f, (req, 1)));
 +let hop1_idx2 = hop1 | arrange;
-+let friend_idx2 = friend | arrange;
-+let hop2 = hop1_idx2 | join(friend_idx2, (_, (req, _), (g, _)) -> (g, (req, 2)));
++let hop2 = hop1_idx2 | join(friend, (_, (req, _), (g, _)) -> (g, (req, 2)));
 +let hop2_idx = hop2 | arrange;
-+let friend_idx3 = friend | arrange;
-+let hop3 = hop2_idx | join(friend_idx3, (_, (req, _), (h, _)) -> (h, (req, 3)));
++let hop3 = hop2_idx | join(friend, (_, (req, _), (h, _)) -> (h, (req, 3)));
 +let circle_rows = hop1 + hop2 + hop3;
 +let circle_filter = circle_rows | filter((node, ((_, who, _), _)) -> (node, who) ne);
 +let circle_map = circle_filter | map((node, ((rid, _, name), d)) -> ((rid, node, name), d));
@@ -32,13 +29,11 @@
 +let circle = circle_idx | reduce(limit 1, (_, vals) -> let first = vals head in (first.0, 1) enlist);
 +let found_map = circle | map(((rid, node, name), d) -> (node, (rid, name, d)));
 +let found_idx = found_map | arrange;
-+let person_idx = person | arrange;
-+let found_join = found_idx | join(person_idx, (node, (rid, name, d), (first, last, gender, birthday, created, ip, browser, home, _, _, _)) -> ((first, name) eq, (home, (rid, node, d, last, gender, birthday, created, ip, browser))));
++let found_join = found_idx | join(person, (node, (rid, name, d), (first, last, gender, birthday, created, ip, browser, home, _, _, _)) -> ((first, name) eq, (home, (rid, node, d, last, gender, birthday, created, ip, browser))));
 +let found_filter = found_join | filter((named, _) -> named);
 +let found_map2 = found_filter | map((_, row) -> row);
 +let found_idx2 = found_map2 | arrange;
-+let place_idx = place | arrange;
-+let found = found_idx2 | join(place_idx, (_, (rid, node, d, last, gender, birthday, created, ip, browser), (town, _, _)) -> ((rid, node), (d, (last, gender, birthday, created, ip, browser, town))));
++let found = found_idx2 | join(place, (_, (rid, node, d, last, gender, birthday, created, ip, browser), (town, _, _)) -> ((rid, node), (d, (last, gender, birthday, created, ip, browser, town))));
  let who = found | map(((rid, node), _) -> (node, rid));
 -let emails = who | join(email, (node, rid, value) -> ((rid, node), value)) | reduce((_, vals) -> let lists = vals map ((v, d) -> (v, (0, d) range) cap_list map ((v, _) -> v)) in let flat = lists flatten in (flat.1, 1) enlist);
 -let langs = who | join(language, (node, rid, value) -> ((rid, node), value)) | reduce((_, vals) -> let lists = vals map ((v, d) -> (v, (0, d) range) cap_list map ((v, _) -> v)) in let flat = lists flatten in (flat.1, 1) enlist);
@@ -50,35 +45,27 @@
 -let with4 = (with3 | join(jobs, (key, (row, e, l, s), list) -> (key, (row, e, l, s, list)))) + (with3 + (with3 | join(jobs, (key, row, _) -> (key, row)) | negate) | map((key, (row, e, l, s)) -> (key, (row, e, l, s, [] : List((List(int), int, List(int)))))));
 -let ranked = with4 | map(((rid, node), ((d, (last, gender, birthday, created, ip, browser, town)), e, l, s, w)) -> (rid, ((d, last, node), (gender, birthday, created, ip, browser, town, e, l, s, w)))) | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 20) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 20) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 20) min in let before = (end, count) sub in let keep = (((20, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
 +let who_idx = who | arrange;
-+let email_idx = email | arrange;
-+let emails_join = who_idx | join(email_idx, (node, rid, value) -> ((rid, node), value));
++let emails_join = who_idx | join(email, (node, rid, value) -> ((rid, node), value));
 +let emails_idx = emails_join | arrange;
 +let emails = emails_idx | reduce((_, vals) -> let lists = vals map ((v, d) -> (v, (0, d) range) cap_list map ((v, _) -> v)) in let flat = lists flatten in (flat.1, 1) enlist);
 +let who_idx2 = who | arrange;
-+let language_idx = language | arrange;
-+let langs_join = who_idx2 | join(language_idx, (node, rid, value) -> ((rid, node), value));
++let langs_join = who_idx2 | join(language, (node, rid, value) -> ((rid, node), value));
 +let langs_idx = langs_join | arrange;
 +let langs = langs_idx | reduce((_, vals) -> let lists = vals map ((v, d) -> (v, (0, d) range) cap_list map ((v, _) -> v)) in let flat = lists flatten in (flat.1, 1) enlist);
 +let who_idx3 = who | arrange;
-+let study_idx = study | arrange;
-+let school_join = who_idx3 | join(study_idx, (node, rid, (at, year)) -> (at, (rid, node, year)));
++let school_join = who_idx3 | join(study, (node, rid, (at, year)) -> (at, (rid, node, year)));
 +let school_idx = school_join | arrange;
-+let org_idx = org | arrange;
-+let school_join2 = school_idx | join(org_idx, (_, (rid, node, year), (name, _, at)) -> (at, (rid, node, name, year)));
++let school_join2 = school_idx | join(org, (_, (rid, node, year), (name, _, at)) -> (at, (rid, node, name, year)));
 +let school_idx2 = school_join2 | arrange;
-+let place_idx2 = place | arrange;
-+let school_join3 = school_idx2 | join(place_idx2, (_, (rid, node, name, year), (where, _, _)) -> ((rid, node), (name, year, where)));
++let school_join3 = school_idx2 | join(place, (_, (rid, node, name, year), (where, _, _)) -> ((rid, node), (name, year, where)));
 +let school_idx3 = school_join3 | arrange;
 +let school = school_idx3 | reduce((_, vals) -> let lists = vals map ((v, d) -> (v, (0, d) range) cap_list map ((v, _) -> v)) in let flat = lists flatten in (flat.1, 1) enlist);
 +let who_idx4 = who | arrange;
-+let work_idx = work | arrange;
-+let jobs_join = who_idx4 | join(work_idx, (node, rid, (at, year)) -> (at, (rid, node, year)));
++let jobs_join = who_idx4 | join(work, (node, rid, (at, year)) -> (at, (rid, node, year)));
 +let jobs_idx = jobs_join | arrange;
-+let org_idx2 = org | arrange;
-+let jobs_join2 = jobs_idx | join(org_idx2, (_, (rid, node, year), (name, _, at)) -> (at, (rid, node, name, year)));
++let jobs_join2 = jobs_idx | join(org, (_, (rid, node, year), (name, _, at)) -> (at, (rid, node, name, year)));
 +let jobs_idx2 = jobs_join2 | arrange;
-+let place_idx3 = place | arrange;
-+let jobs_join3 = jobs_idx2 | join(place_idx3, (_, (rid, node, name, year), (where, _, _)) -> ((rid, node), (name, year, where)));
++let jobs_join3 = jobs_idx2 | join(place, (_, (rid, node, name, year), (where, _, _)) -> ((rid, node), (name, year, where)));
 +let jobs_idx3 = jobs_join3 | arrange;
 +let jobs = jobs_idx3 | reduce((_, vals) -> let lists = vals map ((v, d) -> (v, (0, d) range) cap_list map ((v, _) -> v)) in let flat = lists flatten in (flat.1, 1) enlist);
 +let found_idx3 = found | arrange;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic02_oneoff.ddp b/interactive/tests/plan_pairs/expected/ldbc_ic02_oneoff.ddp
index 28571e75b..16293a022 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic02_oneoff.ddp
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic02_oneoff.ddp
@@ -9,30 +9,24 @@ let latest = import "ic2s::latest" : (int, (int, int));
 let newest = import "ic2s::newest" : (int, int);
 let friends_map = request | map(((rid, who, max), ()) -> (who, (rid, max)));
 let friends_idx = friends_map | arrange;
-let friend_idx = friend | arrange;
-let friends = friends_idx | join(friend_idx, (_, req, (f, _)) -> (f, req));
+let friends = friends_idx | join(friend, (_, req, (f, _)) -> (f, req));
 let friends_idx2 = friends | arrange;
-let newest_idx = newest | arrange;
-let ahead = friends_idx2 | join(newest_idx, (f, (rid, max), neg) -> (f, (rid, max, neg neg)));
+let ahead = friends_idx2 | join(newest, (f, (rid, max), neg) -> (f, (rid, max, neg neg)));
 let fast_filter = ahead | filter((_, (_, max, last)) -> (last, max) lt);
 let fast_idx = fast_filter | arrange;
-let latest_idx = latest | arrange;
-let fast = fast_idx | join(latest_idx, (f, (rid, _, _), (neg, id)) -> (rid, ((neg, id), f)));
+let fast = fast_idx | join(latest, (f, (rid, _, _), (neg, id)) -> (rid, ((neg, id), f)));
 let slow_filter = ahead | filter((_, (_, max, last)) -> (last, max) ge);
 let slow_idx = slow_filter | arrange;
-let by_author_idx = by_author | arrange;
-let slow_join = slow_idx | join(by_author_idx, (f, (rid, max, _), (neg, id)) -> (rid, ((neg, id), f, max)));
+let slow_join = slow_idx | join(by_author, (f, (rid, max, _), (neg, id)) -> (rid, ((neg, id), f, max)));
 let slow = slow_join | filter((_, ((neg, _), _, max)) -> (neg neg, max) lt) | map((rid, (order, f, _)) -> (rid, (order, f)));
 let top_rows = fast + slow;
 let top_idx = top_rows | arrange;
 let top = top_idx | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 20) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 20) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 20) min in let before = (end, count) sub in let keep = (((20, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
 let answer_map = top | map((rid, (rank, ((neg, id), f))) -> (id, (rid, rank, neg neg, f)));
 let answer_idx = answer_map | arrange;
-let message_idx = message | arrange;
-let answer_join = answer_idx | join(message_idx, (id, (rid, rank, created, f), (_, _, _, _, content, image, _, _, _, _, _, _, _)) -> (f, (rid, rank, id, ((content len, 0) gt, content, image) select, created)));
+let answer_join = answer_idx | join(message, (id, (rid, rank, created, f), (_, _, _, _, content, image, _, _, _, _, _, _, _)) -> (f, (rid, rank, id, ((content len, 0) gt, content, image) select, created)));
 let answer_idx2 = answer_join | arrange;
-let person_idx = person | arrange;
-let answer = answer_idx2 | join(person_idx, (f, (rid, rank, id, body, created), (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, rank), (f, first, last, id, body, created)));
+let answer = answer_idx2 | join(person, (f, (rid, rank, id, body, created), (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, rank), (f, first, last, id, body, created)));
 let answer_idx3 = answer | arrange;
 -- Renderer: publish the existing arrangement.
 output "answer" = answer_idx3;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic02_oneoff.lowered--optimized.diff b/interactive/tests/plan_pairs/expected/ldbc_ic02_oneoff.lowered--optimized.diff
index 720d75625..65ca7ed81 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic02_oneoff.lowered--optimized.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic02_oneoff.lowered--optimized.diff
@@ -1,9 +1,9 @@
 --- lowered
 +++ optimized
-@@ -22,8 +22,7 @@
+@@ -18,8 +18,7 @@
+ let slow_filter = ahead | filter((_, (_, max, last)) -> (last, max) ge);
  let slow_idx = slow_filter | arrange;
- let by_author_idx = by_author | arrange;
- let slow_join = slow_idx | join(by_author_idx, (f, (rid, max, _), (neg, id)) -> (rid, ((neg, id), f, max)));
+ let slow_join = slow_idx | join(by_author, (f, (rid, max, _), (neg, id)) -> (rid, ((neg, id), f, max)));
 -let slow_filter2 = slow_join | filter((_, ((neg, _), _, max)) -> (neg neg, max) lt);
 -let slow = slow_filter2 | map((rid, (order, f, _)) -> (rid, (order, f)));
 +let slow = slow_join | filter((_, ((neg, _), _, max)) -> (neg neg, max) lt) | map((rid, (order, f, _)) -> (rid, (order, f)));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic02_oneoff.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/ldbc_ic02_oneoff.parsed--lowered.diff
index e9a8173ac..05f571156 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic02_oneoff.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic02_oneoff.parsed--lowered.diff
@@ -6,7 +6,7 @@
  let request = input 0 : ((int, int, int), ());
  let person = import "graph::person" : (int, (List(int), List(int), List(int), int, int, List(int), List(int), int, int, int, int));
  let message = import "graph::message" : (int, (int, int, int, int, List(int), List(int), int, List(int), int, int, int, int, int));
-@@ -5,10 +7,33 @@
+@@ -5,10 +7,27 @@
  let by_author = import "ic2s::by_author" : (int, (int, int));
  let latest = import "ic2s::latest" : (int, (int, int));
  let newest = import "ic2s::newest" : (int, int);
@@ -19,19 +19,15 @@
 -output "answer" = answer | arrange;
 +let friends_map = request | map(((rid, who, max), ()) -> (who, (rid, max)));
 +let friends_idx = friends_map | arrange;
-+let friend_idx = friend | arrange;
-+let friends = friends_idx | join(friend_idx, (_, req, (f, _)) -> (f, req));
++let friends = friends_idx | join(friend, (_, req, (f, _)) -> (f, req));
 +let friends_idx2 = friends | arrange;
-+let newest_idx = newest | arrange;
-+let ahead = friends_idx2 | join(newest_idx, (f, (rid, max), neg) -> (f, (rid, max, neg neg)));
++let ahead = friends_idx2 | join(newest, (f, (rid, max), neg) -> (f, (rid, max, neg neg)));
 +let fast_filter = ahead | filter((_, (_, max, last)) -> (last, max) lt);
 +let fast_idx = fast_filter | arrange;
-+let latest_idx = latest | arrange;
-+let fast = fast_idx | join(latest_idx, (f, (rid, _, _), (neg, id)) -> (rid, ((neg, id), f)));
++let fast = fast_idx | join(latest, (f, (rid, _, _), (neg, id)) -> (rid, ((neg, id), f)));
 +let slow_filter = ahead | filter((_, (_, max, last)) -> (last, max) ge);
 +let slow_idx = slow_filter | arrange;
-+let by_author_idx = by_author | arrange;
-+let slow_join = slow_idx | join(by_author_idx, (f, (rid, max, _), (neg, id)) -> (rid, ((neg, id), f, max)));
++let slow_join = slow_idx | join(by_author, (f, (rid, max, _), (neg, id)) -> (rid, ((neg, id), f, max)));
 +let slow_filter2 = slow_join | filter((_, ((neg, _), _, max)) -> (neg neg, max) lt);
 +let slow = slow_filter2 | map((rid, (order, f, _)) -> (rid, (order, f)));
 +let top_rows = fast + slow;
@@ -39,11 +35,9 @@
 +let top = top_idx | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 20) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 20) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 20) min in let before = (end, count) sub in let keep = (((20, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
 +let answer_map = top | map((rid, (rank, ((neg, id), f))) -> (id, (rid, rank, neg neg, f)));
 +let answer_idx = answer_map | arrange;
-+let message_idx = message | arrange;
-+let answer_join = answer_idx | join(message_idx, (id, (rid, rank, created, f), (_, _, _, _, content, image, _, _, _, _, _, _, _)) -> (f, (rid, rank, id, ((content len, 0) gt, content, image) select, created)));
++let answer_join = answer_idx | join(message, (id, (rid, rank, created, f), (_, _, _, _, content, image, _, _, _, _, _, _, _)) -> (f, (rid, rank, id, ((content len, 0) gt, content, image) select, created)));
 +let answer_idx2 = answer_join | arrange;
-+let person_idx = person | arrange;
-+let answer = answer_idx2 | join(person_idx, (f, (rid, rank, id, body, created), (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, rank), (f, first, last, id, body, created)));
++let answer = answer_idx2 | join(person, (f, (rid, rank, id, body, created), (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, rank), (f, first, last, id, body, created)));
 +let answer_idx3 = answer | arrange;
 +-- Renderer: publish the existing arrangement.
 +output "answer" = answer_idx3;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic03_oneoff.ddp b/interactive/tests/plan_pairs/expected/ldbc_ic03_oneoff.ddp
index 6c59ef154..4954350bb 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic03_oneoff.ddp
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic03_oneoff.ddp
@@ -8,37 +8,32 @@ let by_name = import "graph::place.by_name" : (List(int), int);
 let sent_from = import "ic3s::sent_from" : (int, (int, int));
 let asked_map = request | map(((rid, who, x, y, start, days), ()) -> (x, (rid, who, y, start, (start, (days, 86400000) mul) add)));
 let asked_idx = asked_map | arrange;
-let by_name_idx = by_name | arrange;
-let asked_join = asked_idx | join(by_name_idx, (_, req, x) -> (x, req));
+let asked_join = asked_idx | join(by_name, (_, req, x) -> (x, req));
 let asked_idx2 = asked_join | arrange;
-let place_idx = place | arrange;
-let asked_join2 = asked_idx2 | join(place_idx, (x, (rid, who, y, start, end), (_, kind, _)) -> ((kind, [67,111,117,110,116,114,121]) eq, (y, (rid, who, x, start, end))));
+let asked_join2 = asked_idx2 | join(place, (x, (rid, who, y, start, end), (_, kind, _)) -> ((kind, [67,111,117,110,116,114,121]) eq, (y, (rid, who, x, start, end))));
 let asked_rows = asked_join2 | filter((country, _) -> country) | map((_, row) -> row);
 let asked_idx3 = asked_rows | arrange;
-let asked_join3 = asked_idx3 | join(by_name_idx, (_, req, y) -> (y, req));
+let asked_join3 = asked_idx3 | join(by_name, (_, req, y) -> (y, req));
 let asked_idx4 = asked_join3 | arrange;
-let asked_join4 = asked_idx4 | join(place_idx, (y, (rid, who, x, start, end), (_, kind, _)) -> ((kind, [67,111,117,110,116,114,121]) eq, (rid, (who, x, y, start, end))));
+let asked_join4 = asked_idx4 | join(place, (y, (rid, who, x, start, end), (_, kind, _)) -> ((kind, [67,111,117,110,116,114,121]) eq, (rid, (who, x, y, start, end))));
 let asked = asked_join4 | filter((country, _) -> country) | map((_, row) -> row);
 let window_map = asked | map((rid, (_, x, _, start, end)) -> (x, (rid, start, end, 1, 0)));
 let window_map2 = asked | map((rid, (_, _, y, start, end)) -> (y, (rid, start, end, 0, 1)));
 let window = window_map + window_map2;
 let window_idx = window | arrange;
-let sent_from_idx = sent_from | arrange;
-let visits_join = window_idx | join(sent_from_idx, (_, (rid, start, end, ix, iy), (author, created)) -> ((rid, author), (created, start, end, ix, iy)));
+let visits_join = window_idx | join(sent_from, (_, (rid, start, end, ix, iy), (author, created)) -> ((rid, author), (created, start, end, ix, iy)));
 let visits = visits_join | filter((_, (created, start, end, _, _)) -> ((created, start) ge, (created, end) lt) all) | map((key, (_, _, _, ix, iy)) -> (key, (ix, iy)));
 let hop1_map = asked | map((rid, (who, x, y, _, _)) -> (who, (rid, who, x, y)));
 let hop1_idx = hop1_map | arrange;
-let friend_idx = friend | arrange;
-let hop1 = hop1_idx | join(friend_idx, (_, req, (f, _)) -> (f, req));
+let hop1 = hop1_idx | join(friend, (_, req, (f, _)) -> (f, req));
 let hop1_idx2 = hop1 | arrange;
-let hop2 = hop1_idx2 | join(friend_idx, (_, req, (g, _)) -> (g, req));
+let hop2 = hop1_idx2 | join(friend, (_, req, (g, _)) -> (g, req));
 let circle_rows = hop1 + hop2;
 let circle_filter = circle_rows | filter((node, (_, who, _, _)) -> (node, who) ne);
 let circle_idx = circle_filter | arrange;
-let person_idx = person | arrange;
-let circle_join = circle_idx | join(person_idx, (node, (rid, _, x, y), (_, _, _, _, _, _, _, city, _, _, _)) -> (city, (rid, node, x, y)));
+let circle_join = circle_idx | join(person, (node, (rid, _, x, y), (_, _, _, _, _, _, _, city, _, _, _)) -> (city, (rid, node, x, y)));
 let circle_idx2 = circle_join | arrange;
-let circle_join2 = circle_idx2 | join(place_idx, (_, (rid, node, x, y), (_, _, home)) -> ((rid, node), (x, y, home)));
+let circle_join2 = circle_idx2 | join(place, (_, (rid, node, x, y), (_, _, home)) -> ((rid, node), (x, y, home)));
 let circle_rows2 = circle_join2 | filter((_, (x, y, home)) -> ((home, x) ne, (home, y) ne) all) | map((key, _) -> (key, ()));
 let circle_idx3 = circle_rows2 | arrange;
 let circle = circle_idx3 | reduce((_, vals) -> vals map (((), _) -> ((), 1)));
@@ -53,7 +48,7 @@ let in_y = in_y_idx | reduce((_, vals) -> let diffs = vals map ((_, d) -> d) in
 let counts = in_x | join(in_y, (key, nx, ny) -> (key, (nx, ny)));
 let ranked_map = counts | map(((rid, node), (nx, ny)) -> (node, (rid, nx, ny)));
 let ranked_idx = ranked_map | arrange;
-let ranked_join = ranked_idx | join(person_idx, (node, (rid, nx, ny), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, (((nx, ny) add neg, node), (first, last, nx, ny))));
+let ranked_join = ranked_idx | join(person, (node, (rid, nx, ny), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, (((nx, ny) add neg, node), (first, last, nx, ny))));
 let ranked_idx2 = ranked_join | arrange;
 let ranked = ranked_idx2 | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 20) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 20) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 20) min in let before = (end, count) sub in let keep = (((20, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
 let answer = ranked | map((rid, (rank, ((_, node), (first, last, nx, ny)))) -> ((rid, rank), (node, first, last, nx, ny, (nx, ny) add)));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic03_oneoff.lowered--optimized.diff b/interactive/tests/plan_pairs/expected/ldbc_ic03_oneoff.lowered--optimized.diff
index d76be3a0f..6888d9a8b 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic03_oneoff.lowered--optimized.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic03_oneoff.lowered--optimized.diff
@@ -8,54 +8,39 @@
  let friend = import "graph::friend" : (int, (int, int));
  let place = import "graph::place" : (int, (List(int), List(int), int));
  let by_name = import "graph::place.by_name" : (List(int), int);
-@@ -14,58 +13,47 @@
+@@ -12,21 +11,18 @@
+ let asked_join = asked_idx | join(by_name, (_, req, x) -> (x, req));
  let asked_idx2 = asked_join | arrange;
- let place_idx = place | arrange;
- let asked_join2 = asked_idx2 | join(place_idx, (x, (rid, who, y, start, end), (_, kind, _)) -> ((kind, [67,111,117,110,116,114,121]) eq, (y, (rid, who, x, start, end))));
+ let asked_join2 = asked_idx2 | join(place, (x, (rid, who, y, start, end), (_, kind, _)) -> ((kind, [67,111,117,110,116,114,121]) eq, (y, (rid, who, x, start, end))));
 -let asked_filter = asked_join2 | filter((country, _) -> country);
 -let asked_map2 = asked_filter | map((_, row) -> row);
 -let asked_idx3 = asked_map2 | arrange;
--let by_name_idx2 = by_name | arrange;
--let asked_join3 = asked_idx3 | join(by_name_idx2, (_, req, y) -> (y, req));
 +let asked_rows = asked_join2 | filter((country, _) -> country) | map((_, row) -> row);
 +let asked_idx3 = asked_rows | arrange;
-+let asked_join3 = asked_idx3 | join(by_name_idx, (_, req, y) -> (y, req));
+ let asked_join3 = asked_idx3 | join(by_name, (_, req, y) -> (y, req));
  let asked_idx4 = asked_join3 | arrange;
--let place_idx2 = place | arrange;
--let asked_join4 = asked_idx4 | join(place_idx2, (y, (rid, who, x, start, end), (_, kind, _)) -> ((kind, [67,111,117,110,116,114,121]) eq, (rid, (who, x, y, start, end))));
+ let asked_join4 = asked_idx4 | join(place, (y, (rid, who, x, start, end), (_, kind, _)) -> ((kind, [67,111,117,110,116,114,121]) eq, (rid, (who, x, y, start, end))));
 -let asked_filter2 = asked_join4 | filter((country, _) -> country);
 -let asked = asked_filter2 | map((_, row) -> row);
-+let asked_join4 = asked_idx4 | join(place_idx, (y, (rid, who, x, start, end), (_, kind, _)) -> ((kind, [67,111,117,110,116,114,121]) eq, (rid, (who, x, y, start, end))));
 +let asked = asked_join4 | filter((country, _) -> country) | map((_, row) -> row);
  let window_map = asked | map((rid, (_, x, _, start, end)) -> (x, (rid, start, end, 1, 0)));
  let window_map2 = asked | map((rid, (_, _, y, start, end)) -> (y, (rid, start, end, 0, 1)));
  let window = window_map + window_map2;
  let window_idx = window | arrange;
- let sent_from_idx = sent_from | arrange;
- let visits_join = window_idx | join(sent_from_idx, (_, (rid, start, end, ix, iy), (author, created)) -> ((rid, author), (created, start, end, ix, iy)));
+ let visits_join = window_idx | join(sent_from, (_, (rid, start, end, ix, iy), (author, created)) -> ((rid, author), (created, start, end, ix, iy)));
 -let visits_filter = visits_join | filter((_, (created, start, end, _, _)) -> ((created, start) ge, (created, end) lt) all);
 -let visits = visits_filter | map((key, (_, _, _, ix, iy)) -> (key, (ix, iy)));
 +let visits = visits_join | filter((_, (created, start, end, _, _)) -> ((created, start) ge, (created, end) lt) all) | map((key, (_, _, _, ix, iy)) -> (key, (ix, iy)));
  let hop1_map = asked | map((rid, (who, x, y, _, _)) -> (who, (rid, who, x, y)));
  let hop1_idx = hop1_map | arrange;
- let friend_idx = friend | arrange;
- let hop1 = hop1_idx | join(friend_idx, (_, req, (f, _)) -> (f, req));
- let hop1_idx2 = hop1 | arrange;
--let friend_idx2 = friend | arrange;
--let hop2 = hop1_idx2 | join(friend_idx2, (_, req, (g, _)) -> (g, req));
-+let hop2 = hop1_idx2 | join(friend_idx, (_, req, (g, _)) -> (g, req));
- let circle_rows = hop1 + hop2;
- let circle_filter = circle_rows | filter((node, (_, who, _, _)) -> (node, who) ne);
- let circle_idx = circle_filter | arrange;
- let person_idx = person | arrange;
- let circle_join = circle_idx | join(person_idx, (node, (rid, _, x, y), (_, _, _, _, _, _, _, city, _, _, _)) -> (city, (rid, node, x, y)));
+ let hop1 = hop1_idx | join(friend, (_, req, (f, _)) -> (f, req));
+@@ -38,19 +34,16 @@
+ let circle_join = circle_idx | join(person, (node, (rid, _, x, y), (_, _, _, _, _, _, _, city, _, _, _)) -> (city, (rid, node, x, y)));
  let circle_idx2 = circle_join | arrange;
--let place_idx3 = place | arrange;
--let circle_join2 = circle_idx2 | join(place_idx3, (_, (rid, node, x, y), (_, _, home)) -> ((rid, node), (x, y, home)));
+ let circle_join2 = circle_idx2 | join(place, (_, (rid, node, x, y), (_, _, home)) -> ((rid, node), (x, y, home)));
 -let circle_filter2 = circle_join2 | filter((_, (x, y, home)) -> ((home, x) ne, (home, y) ne) all);
 -let circle_map = circle_filter2 | map((key, _) -> (key, ()));
 -let circle_idx3 = circle_map | arrange;
-+let circle_join2 = circle_idx2 | join(place_idx, (_, (rid, node, x, y), (_, _, home)) -> ((rid, node), (x, y, home)));
 +let circle_rows2 = circle_join2 | filter((_, (x, y, home)) -> ((home, x) ne, (home, y) ne) all) | map((key, _) -> (key, ()));
 +let circle_idx3 = circle_rows2 | arrange;
  let circle = circle_idx3 | reduce((_, vals) -> vals map (((), _) -> ((), 1)));
@@ -75,10 +60,3 @@
  let in_y = in_y_idx | reduce((_, vals) -> let diffs = vals map ((_, d) -> d) in let n = diffs fold_add in (n, (n, 1)) enlist filter);
  let counts = in_x | join(in_y, (key, nx, ny) -> (key, (nx, ny)));
  let ranked_map = counts | map(((rid, node), (nx, ny)) -> (node, (rid, nx, ny)));
- let ranked_idx = ranked_map | arrange;
--let person_idx2 = person | arrange;
--let ranked_join = ranked_idx | join(person_idx2, (node, (rid, nx, ny), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, (((nx, ny) add neg, node), (first, last, nx, ny))));
-+let ranked_join = ranked_idx | join(person_idx, (node, (rid, nx, ny), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, (((nx, ny) add neg, node), (first, last, nx, ny))));
- let ranked_idx2 = ranked_join | arrange;
- let ranked = ranked_idx2 | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 20) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 20) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 20) min in let before = (end, count) sub in let keep = (((20, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
- let answer = ranked | map((rid, (rank, ((_, node), (first, last, nx, ny)))) -> ((rid, rank), (node, first, last, nx, ny, (nx, ny) add)));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic03_oneoff.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/ldbc_ic03_oneoff.parsed--lowered.diff
index 5da749f99..8cc9c4327 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic03_oneoff.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic03_oneoff.parsed--lowered.diff
@@ -6,7 +6,7 @@
  let request = input 0 : ((int, int, List(int), List(int), int, int), ());
  let person = import "graph::person" : (int, (List(int), List(int), List(int), int, int, List(int), List(int), int, int, int, int));
  let message = import "graph::message" : (int, (int, int, int, int, List(int), List(int), int, List(int), int, int, int, int, int));
-@@ -5,16 +7,68 @@
+@@ -5,16 +7,58 @@
  let place = import "graph::place" : (int, (List(int), List(int), int));
  let by_name = import "graph::place.by_name" : (List(int), int);
  let sent_from = import "ic3s::sent_from" : (int, (int, int));
@@ -21,44 +21,35 @@
 -let in_y = seen | filter((_, (_, iy)) -> (iy, 1) eq) | map((key, _) -> (key, ())) | reduce((_, vals) -> let diffs = vals map ((_, d) -> d) in let n = diffs fold_add in (n, (n, 1)) enlist filter);
 +let asked_map = request | map(((rid, who, x, y, start, days), ()) -> (x, (rid, who, y, start, (start, (days, 86400000) mul) add)));
 +let asked_idx = asked_map | arrange;
-+let by_name_idx = by_name | arrange;
-+let asked_join = asked_idx | join(by_name_idx, (_, req, x) -> (x, req));
++let asked_join = asked_idx | join(by_name, (_, req, x) -> (x, req));
 +let asked_idx2 = asked_join | arrange;
-+let place_idx = place | arrange;
-+let asked_join2 = asked_idx2 | join(place_idx, (x, (rid, who, y, start, end), (_, kind, _)) -> ((kind, [67,111,117,110,116,114,121]) eq, (y, (rid, who, x, start, end))));
++let asked_join2 = asked_idx2 | join(place, (x, (rid, who, y, start, end), (_, kind, _)) -> ((kind, [67,111,117,110,116,114,121]) eq, (y, (rid, who, x, start, end))));
 +let asked_filter = asked_join2 | filter((country, _) -> country);
 +let asked_map2 = asked_filter | map((_, row) -> row);
 +let asked_idx3 = asked_map2 | arrange;
-+let by_name_idx2 = by_name | arrange;
-+let asked_join3 = asked_idx3 | join(by_name_idx2, (_, req, y) -> (y, req));
++let asked_join3 = asked_idx3 | join(by_name, (_, req, y) -> (y, req));
 +let asked_idx4 = asked_join3 | arrange;
-+let place_idx2 = place | arrange;
-+let asked_join4 = asked_idx4 | join(place_idx2, (y, (rid, who, x, start, end), (_, kind, _)) -> ((kind, [67,111,117,110,116,114,121]) eq, (rid, (who, x, y, start, end))));
++let asked_join4 = asked_idx4 | join(place, (y, (rid, who, x, start, end), (_, kind, _)) -> ((kind, [67,111,117,110,116,114,121]) eq, (rid, (who, x, y, start, end))));
 +let asked_filter2 = asked_join4 | filter((country, _) -> country);
 +let asked = asked_filter2 | map((_, row) -> row);
 +let window_map = asked | map((rid, (_, x, _, start, end)) -> (x, (rid, start, end, 1, 0)));
 +let window_map2 = asked | map((rid, (_, _, y, start, end)) -> (y, (rid, start, end, 0, 1)));
 +let window = window_map + window_map2;
 +let window_idx = window | arrange;
-+let sent_from_idx = sent_from | arrange;
-+let visits_join = window_idx | join(sent_from_idx, (_, (rid, start, end, ix, iy), (author, created)) -> ((rid, author), (created, start, end, ix, iy)));
++let visits_join = window_idx | join(sent_from, (_, (rid, start, end, ix, iy), (author, created)) -> ((rid, author), (created, start, end, ix, iy)));
 +let visits_filter = visits_join | filter((_, (created, start, end, _, _)) -> ((created, start) ge, (created, end) lt) all);
 +let visits = visits_filter | map((key, (_, _, _, ix, iy)) -> (key, (ix, iy)));
 +let hop1_map = asked | map((rid, (who, x, y, _, _)) -> (who, (rid, who, x, y)));
 +let hop1_idx = hop1_map | arrange;
-+let friend_idx = friend | arrange;
-+let hop1 = hop1_idx | join(friend_idx, (_, req, (f, _)) -> (f, req));
++let hop1 = hop1_idx | join(friend, (_, req, (f, _)) -> (f, req));
 +let hop1_idx2 = hop1 | arrange;
-+let friend_idx2 = friend | arrange;
-+let hop2 = hop1_idx2 | join(friend_idx2, (_, req, (g, _)) -> (g, req));
++let hop2 = hop1_idx2 | join(friend, (_, req, (g, _)) -> (g, req));
 +let circle_rows = hop1 + hop2;
 +let circle_filter = circle_rows | filter((node, (_, who, _, _)) -> (node, who) ne);
 +let circle_idx = circle_filter | arrange;
-+let person_idx = person | arrange;
-+let circle_join = circle_idx | join(person_idx, (node, (rid, _, x, y), (_, _, _, _, _, _, _, city, _, _, _)) -> (city, (rid, node, x, y)));
++let circle_join = circle_idx | join(person, (node, (rid, _, x, y), (_, _, _, _, _, _, _, city, _, _, _)) -> (city, (rid, node, x, y)));
 +let circle_idx2 = circle_join | arrange;
-+let place_idx3 = place | arrange;
-+let circle_join2 = circle_idx2 | join(place_idx3, (_, (rid, node, x, y), (_, _, home)) -> ((rid, node), (x, y, home)));
++let circle_join2 = circle_idx2 | join(place, (_, (rid, node, x, y), (_, _, home)) -> ((rid, node), (x, y, home)));
 +let circle_filter2 = circle_join2 | filter((_, (x, y, home)) -> ((home, x) ne, (home, y) ne) all);
 +let circle_map = circle_filter2 | map((key, _) -> (key, ()));
 +let circle_idx3 = circle_map | arrange;
@@ -77,8 +68,7 @@
 -let ranked = counts | map(((rid, node), (nx, ny)) -> (node, (rid, nx, ny))) | join(person, (node, (rid, nx, ny), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, (((nx, ny) add neg, node), (first, last, nx, ny)))) | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 20) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 20) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 20) min in let before = (end, count) sub in let keep = (((20, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
 +let ranked_map = counts | map(((rid, node), (nx, ny)) -> (node, (rid, nx, ny)));
 +let ranked_idx = ranked_map | arrange;
-+let person_idx2 = person | arrange;
-+let ranked_join = ranked_idx | join(person_idx2, (node, (rid, nx, ny), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, (((nx, ny) add neg, node), (first, last, nx, ny))));
++let ranked_join = ranked_idx | join(person, (node, (rid, nx, ny), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, (((nx, ny) add neg, node), (first, last, nx, ny))));
 +let ranked_idx2 = ranked_join | arrange;
 +let ranked = ranked_idx2 | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 20) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 20) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 20) min in let before = (end, count) sub in let keep = (((20, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
  let answer = ranked | map((rid, (rank, ((_, node), (first, last, nx, ny)))) -> ((rid, rank), (node, first, last, nx, ny, (nx, ny) add)));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic04_oneoff.ddp b/interactive/tests/plan_pairs/expected/ldbc_ic04_oneoff.ddp
index 24b911415..762269a70 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic04_oneoff.ddp
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic04_oneoff.ddp
@@ -6,14 +6,11 @@ let posts = import "ic4s::posts" : (int, (int, int));
 let tags = import "ic4s::tags" : (int, (int, List(int)));
 let seen_map = request | map(((rid, who, start, days), ()) -> (who, (rid, start, (start, (days, 86400000) mul) add)));
 let seen_idx = seen_map | arrange;
-let friend_idx = friend | arrange;
-let seen_join = seen_idx | join(friend_idx, (_, req, (f, _)) -> (f, req));
+let seen_join = seen_idx | join(friend, (_, req, (f, _)) -> (f, req));
 let seen_idx2 = seen_join | arrange;
-let posts_idx = posts | arrange;
-let seen_join2 = seen_idx2 | join(posts_idx, (_, (rid, start, end), (m, created)) -> (m, (rid, created, start, end)));
+let seen_join2 = seen_idx2 | join(posts, (_, (rid, start, end), (m, created)) -> (m, (rid, created, start, end)));
 let seen_idx3 = seen_join2 | arrange;
-let tags_idx = tags | arrange;
-let seen = seen_idx3 | join(tags_idx, (_, (rid, created, start, end), (t, name)) -> ((rid, t), (name, created, start, end)));
+let seen = seen_idx3 | join(tags, (_, (rid, created, start, end), (t, name)) -> ((rid, t), (name, created, start, end)));
 let before_rows = seen | filter((_, (_, created, start, _)) -> (created, start) lt) | map((key, _) -> (key, ()));
 let before_idx = before_rows | arrange;
 let before = before_idx | reduce((_, vals) -> vals map (((), _) -> ((), 1)));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic04_oneoff.lowered--optimized.diff b/interactive/tests/plan_pairs/expected/ldbc_ic04_oneoff.lowered--optimized.diff
index 34b756169..77f833e40 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic04_oneoff.lowered--optimized.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic04_oneoff.lowered--optimized.diff
@@ -11,10 +11,10 @@
  let posts = import "ic4s::posts" : (int, (int, int));
  let tags = import "ic4s::tags" : (int, (int, List(int)));
  let seen_map = request | map(((rid, who, start, days), ()) -> (who, (rid, start, (start, (days, 86400000) mul) add)));
-@@ -17,9 +14,8 @@
+@@ -14,9 +11,8 @@
+ let seen_join2 = seen_idx2 | join(posts, (_, (rid, start, end), (m, created)) -> (m, (rid, created, start, end)));
  let seen_idx3 = seen_join2 | arrange;
- let tags_idx = tags | arrange;
- let seen = seen_idx3 | join(tags_idx, (_, (rid, created, start, end), (t, name)) -> ((rid, t), (name, created, start, end)));
+ let seen = seen_idx3 | join(tags, (_, (rid, created, start, end), (t, name)) -> ((rid, t), (name, created, start, end)));
 -let before_filter = seen | filter((_, (_, created, start, _)) -> (created, start) lt);
 -let before_map = before_filter | map((key, _) -> (key, ()));
 -let before_idx = before_map | arrange;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic04_oneoff.optimized--projected.diff b/interactive/tests/plan_pairs/expected/ldbc_ic04_oneoff.optimized--projected.diff
index 8f7c454e0..8cb00be83 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic04_oneoff.optimized--projected.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic04_oneoff.optimized--projected.diff
@@ -1,6 +1,6 @@
 --- optimized
 +++ projected
-@@ -19,9 +19,10 @@
+@@ -16,9 +16,10 @@
  let before = before_idx | reduce((_, vals) -> vals map (((), _) -> ((), 1)));
  let during = seen | filter((_, (_, created, start, end)) -> ((created, start) ge, (created, end) lt) all);
  let during_idx = during | arrange;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic04_oneoff.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/ldbc_ic04_oneoff.parsed--lowered.diff
index 2adc6878e..6082d787a 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic04_oneoff.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic04_oneoff.parsed--lowered.diff
@@ -6,7 +6,7 @@
  let request = input 0 : ((int, int, int, int), ());
  let message = import "graph::message" : (int, (int, int, int, int, List(int), List(int), int, List(int), int, int, int, int, int));
  let friend = import "graph::friend" : (int, (int, int));
-@@ -5,11 +7,32 @@
+@@ -5,11 +7,29 @@
  let mtag = import "graph::mtag.by_tag" : (int, int);
  let posts = import "ic4s::posts" : (int, (int, int));
  let tags = import "ic4s::tags" : (int, (int, List(int)));
@@ -14,14 +14,11 @@
 -let before = seen | filter((_, (_, created, start, _)) -> (created, start) lt) | map((key, _) -> (key, ())) | map((k, v) -> ((k, v), ())) | reduce((_, vals) -> vals map (((), _) -> ((), 1))) | map((kv, ()) -> kv);
 +let seen_map = request | map(((rid, who, start, days), ()) -> (who, (rid, start, (start, (days, 86400000) mul) add)));
 +let seen_idx = seen_map | arrange;
-+let friend_idx = friend | arrange;
-+let seen_join = seen_idx | join(friend_idx, (_, req, (f, _)) -> (f, req));
++let seen_join = seen_idx | join(friend, (_, req, (f, _)) -> (f, req));
 +let seen_idx2 = seen_join | arrange;
-+let posts_idx = posts | arrange;
-+let seen_join2 = seen_idx2 | join(posts_idx, (_, (rid, start, end), (m, created)) -> (m, (rid, created, start, end)));
++let seen_join2 = seen_idx2 | join(posts, (_, (rid, start, end), (m, created)) -> (m, (rid, created, start, end)));
 +let seen_idx3 = seen_join2 | arrange;
-+let tags_idx = tags | arrange;
-+let seen = seen_idx3 | join(tags_idx, (_, (rid, created, start, end), (t, name)) -> ((rid, t), (name, created, start, end)));
++let seen = seen_idx3 | join(tags, (_, (rid, created, start, end), (t, name)) -> ((rid, t), (name, created, start, end)));
 +let before_filter = seen | filter((_, (_, created, start, _)) -> (created, start) lt);
 +let before_map = before_filter | map((key, _) -> (key, ()));
 +let before_idx = before_map | arrange;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic04_standing.ddp b/interactive/tests/plan_pairs/expected/ldbc_ic04_standing.ddp
index 6439534ce..6ea21adad 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic04_standing.ddp
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic04_standing.ddp
@@ -4,9 +4,7 @@ let message = import "graph::message" : (int, (int, int, int, int, List(int), Li
 let tag = import "graph::tag" : (int, (List(int), int));
 let mtag = import "graph::mtag.by_tag" : (int, int);
 let posts = message | filter((_, (kind, _, _, _, _, _, _, _, _, _, _, _, _)) -> (kind, 0) eq) | map((id, (_, created, who, _, _, _, _, _, _, _, _, _, _)) -> (who, (id, created)));
-let mtag_idx = mtag | arrange;
-let tag_idx = tag | arrange;
-let tags = mtag_idx | join(tag_idx, (t, m, (name, _)) -> (m, (t, name)));
+let tags = mtag | join(tag, (t, m, (name, _)) -> (m, (t, name)));
 let posts_idx = posts | arrange;
 let tags_idx = tags | arrange;
 -- Renderer: publish the existing arrangement.
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic04_standing.lowered--optimized.diff b/interactive/tests/plan_pairs/expected/ldbc_ic04_standing.lowered--optimized.diff
index 4d697215a..56a49aab2 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic04_standing.lowered--optimized.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic04_standing.lowered--optimized.diff
@@ -10,6 +10,6 @@
 -let posts_filter = message | filter((_, (kind, _, _, _, _, _, _, _, _, _, _, _, _)) -> (kind, 0) eq);
 -let posts = posts_filter | map((id, (_, created, who, _, _, _, _, _, _, _, _, _, _)) -> (who, (id, created)));
 +let posts = message | filter((_, (kind, _, _, _, _, _, _, _, _, _, _, _, _)) -> (kind, 0) eq) | map((id, (_, created, who, _, _, _, _, _, _, _, _, _, _)) -> (who, (id, created)));
- let mtag_idx = mtag | arrange;
- let tag_idx = tag | arrange;
- let tags = mtag_idx | join(tag_idx, (t, m, (name, _)) -> (m, (t, name)));
+ let tags = mtag | join(tag, (t, m, (name, _)) -> (m, (t, name)));
+ let posts_idx = posts | arrange;
+ let tags_idx = tags | arrange;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic04_standing.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/ldbc_ic04_standing.parsed--lowered.diff
index b6a53a507..f7fa5abf5 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic04_standing.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic04_standing.parsed--lowered.diff
@@ -1,6 +1,6 @@
 --- parsed
 +++ lowered
-@@ -1,8 +1,17 @@
+@@ -1,8 +1,15 @@
 +-- Time lanes: epoch.
 +-- Trace imports use provider arrangements; history advances to G = (0, []).
  let message = import "graph::message" : (int, (int, int, int, int, List(int), List(int), int, List(int), int, int, int, int, int));
@@ -8,14 +8,11 @@
  let tag = import "graph::tag" : (int, (List(int), int));
  let mtag = import "graph::mtag.by_tag" : (int, int);
 -let posts = message | filter((_, (kind, _, _, _, _, _, _, _, _, _, _, _, _)) -> (kind, 0) eq) | map((id, (_, created, who, _, _, _, _, _, _, _, _, _, _)) -> (who, (id, created)));
--let tags = mtag | join(tag, (t, m, (name, _)) -> (m, (t, name)));
--output "posts" = posts | arrange;
--output "tags" = tags | arrange;
 +let posts_filter = message | filter((_, (kind, _, _, _, _, _, _, _, _, _, _, _, _)) -> (kind, 0) eq);
 +let posts = posts_filter | map((id, (_, created, who, _, _, _, _, _, _, _, _, _, _)) -> (who, (id, created)));
-+let mtag_idx = mtag | arrange;
-+let tag_idx = tag | arrange;
-+let tags = mtag_idx | join(tag_idx, (t, m, (name, _)) -> (m, (t, name)));
+ let tags = mtag | join(tag, (t, m, (name, _)) -> (m, (t, name)));
+-output "posts" = posts | arrange;
+-output "tags" = tags | arrange;
 +let posts_idx = posts | arrange;
 +let tags_idx = tags | arrange;
 +-- Renderer: publish the existing arrangement.
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic05_oneoff.ddp b/interactive/tests/plan_pairs/expected/ldbc_ic05_oneoff.ddp
index 9c4fe9ccf..c278ba203 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic05_oneoff.ddp
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic05_oneoff.ddp
@@ -10,34 +10,28 @@ let first = import "ic5s::first" : (int, int);
 let lowest = import "ic5s::lowest" : (int, int);
 let hop1_map = request | map(((rid, who, date), ()) -> (who, (rid, who, date)));
 let hop1_idx = hop1_map | arrange;
-let person_idx = person | arrange;
-let hop1_join = hop1_idx | join(person_idx, (who, req, _) -> (who, req));
+let hop1_join = hop1_idx | join(person, (who, req, _) -> (who, req));
 let hop1_idx2 = hop1_join | arrange;
-let friend_idx = friend | arrange;
-let hop1 = hop1_idx2 | join(friend_idx, (_, req, (f, _)) -> (f, req));
+let hop1 = hop1_idx2 | join(friend, (_, req, (f, _)) -> (f, req));
 let hop1_idx3 = hop1 | arrange;
-let hop2 = hop1_idx3 | join(friend_idx, (_, req, (g, _)) -> (g, req));
+let hop2 = hop1_idx3 | join(friend, (_, req, (g, _)) -> (g, req));
 let circle_rows = hop1 + hop2;
 let circle_rows2 = circle_rows | filter((node, (_, who, _)) -> (node, who) ne) | map((node, (rid, _, date)) -> ((node, rid, date), ()));
 let circle_idx = circle_rows2 | arrange;
 let circle_reduce = circle_idx | reduce((_, vals) -> vals map (((), _) -> ((), 1)));
 let circle = circle_reduce | map(((node, rid, date), ()) -> (node, (rid, date)));
 let circle_idx2 = circle | arrange;
-let member_idx = member | arrange;
-let after_join = circle_idx2 | join(member_idx, (node, (rid, date), (f, since)) -> ((node, f), (rid, date, since)));
+let after_join = circle_idx2 | join(member, (node, (rid, date), (f, since)) -> ((node, f), (rid, date, since)));
 let after = after_join | filter((_, (_, date, since)) -> (since, date) gt) | map((key, (rid, _, _)) -> (key, rid));
 let after_idx = after | arrange;
-let posted_idx = posted | arrange;
-let busy_join = after_idx | join(posted_idx, ((_, f), rid, n) -> ((rid, f), n));
+let busy_join = after_idx | join(posted, ((_, f), rid, n) -> ((rid, f), n));
 let busy_rows = busy_join | join_function((key, n) -> ((key, ()), (0), n) enlist);
 let busy_idx = busy_rows | arrange;
 let busy = busy_idx | reduce((_, vals) -> let diffs = vals map ((_, d) -> d) in let n = diffs fold_add in (n, (n, 1)) enlist filter);
-let first_idx = first | arrange;
-let timed = circle_idx2 | join(first_idx, (node, (rid, date), since) -> (node, (rid, date, since)));
+let timed = circle_idx2 | join(first, (node, (rid, date), since) -> (node, (rid, date, since)));
 let fast_filter = timed | filter((_, (_, date, since)) -> (since, date) gt);
 let fast_idx = fast_filter | arrange;
-let lowest_idx = lowest | arrange;
-let fast = fast_idx | join(lowest_idx, (_, (rid, _, _), f) -> ((rid, f), ()));
+let fast = fast_idx | join(lowest, (_, (rid, _, _), f) -> ((rid, f), ()));
 let slow_rows = timed | filter((_, (_, date, since)) -> (since, date) le) | map((node, (rid, _, _)) -> ((node, rid), ()));
 let slow_idx = slow_rows | arrange;
 let slow_map = after | map(((node, f), rid) -> ((node, rid), f));
@@ -53,8 +47,7 @@ let quiet = quiet_rows | map((key, ()) -> (key, 0));
 let ranked_rows = busy + quiet;
 let ranked_map = ranked_rows | map(((rid, f), n) -> (f, (rid, n)));
 let ranked_idx = ranked_map | arrange;
-let forum_idx = forum | arrange;
-let ranked_join = ranked_idx | join(forum_idx, (f, (rid, n), (title, _, _)) -> (rid, ((n neg, f), title)));
+let ranked_join = ranked_idx | join(forum, (f, (rid, n), (title, _, _)) -> (rid, ((n neg, f), title)));
 let ranked_idx2 = ranked_join | arrange;
 let ranked = ranked_idx2 | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 20) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 20) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 20) min in let before = (end, count) sub in let keep = (((20, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
 let answer = ranked | map((rid, (rank, ((neg, _), title))) -> ((rid, rank), (title, neg neg)));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic05_oneoff.lowered--optimized.diff b/interactive/tests/plan_pairs/expected/ldbc_ic05_oneoff.lowered--optimized.diff
index 3d777b080..7f44a8726 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic05_oneoff.lowered--optimized.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic05_oneoff.lowered--optimized.diff
@@ -8,13 +8,9 @@
  let friend = import "graph::friend" : (int, (int, int));
  let forum = import "graph::forum" : (int, (List(int), int, int));
  let member = import "graph::member.by_person" : (int, (int, int));
-@@ -17,37 +16,32 @@
- let friend_idx = friend | arrange;
- let hop1 = hop1_idx2 | join(friend_idx, (_, req, (f, _)) -> (f, req));
+@@ -17,30 +16,26 @@
  let hop1_idx3 = hop1 | arrange;
--let friend_idx2 = friend | arrange;
--let hop2 = hop1_idx3 | join(friend_idx2, (_, req, (g, _)) -> (g, req));
-+let hop2 = hop1_idx3 | join(friend_idx, (_, req, (g, _)) -> (g, req));
+ let hop2 = hop1_idx3 | join(friend, (_, req, (g, _)) -> (g, req));
  let circle_rows = hop1 + hop2;
 -let circle_filter = circle_rows | filter((node, (_, who, _)) -> (node, who) ne);
 -let circle_map = circle_filter | map((node, (rid, _, date)) -> ((node, rid, date), ()));
@@ -24,25 +20,21 @@
  let circle_reduce = circle_idx | reduce((_, vals) -> vals map (((), _) -> ((), 1)));
  let circle = circle_reduce | map(((node, rid, date), ()) -> (node, (rid, date)));
  let circle_idx2 = circle | arrange;
- let member_idx = member | arrange;
- let after_join = circle_idx2 | join(member_idx, (node, (rid, date), (f, since)) -> ((node, f), (rid, date, since)));
+ let after_join = circle_idx2 | join(member, (node, (rid, date), (f, since)) -> ((node, f), (rid, date, since)));
 -let after_filter = after_join | filter((_, (_, date, since)) -> (since, date) gt);
 -let after = after_filter | map((key, (rid, _, _)) -> (key, rid));
 +let after = after_join | filter((_, (_, date, since)) -> (since, date) gt) | map((key, (rid, _, _)) -> (key, rid));
  let after_idx = after | arrange;
- let posted_idx = posted | arrange;
- let busy_join = after_idx | join(posted_idx, ((_, f), rid, n) -> ((rid, f), n));
+ let busy_join = after_idx | join(posted, ((_, f), rid, n) -> ((rid, f), n));
  let busy_rows = busy_join | join_function((key, n) -> ((key, ()), (0), n) enlist);
  let busy_idx = busy_rows | arrange;
  let busy = busy_idx | reduce((_, vals) -> let diffs = vals map ((_, d) -> d) in let n = diffs fold_add in (n, (n, 1)) enlist filter);
 -let circle_idx3 = circle | arrange;
- let first_idx = first | arrange;
--let timed = circle_idx3 | join(first_idx, (node, (rid, date), since) -> (node, (rid, date, since)));
-+let timed = circle_idx2 | join(first_idx, (node, (rid, date), since) -> (node, (rid, date, since)));
+-let timed = circle_idx3 | join(first, (node, (rid, date), since) -> (node, (rid, date, since)));
++let timed = circle_idx2 | join(first, (node, (rid, date), since) -> (node, (rid, date, since)));
  let fast_filter = timed | filter((_, (_, date, since)) -> (since, date) gt);
  let fast_idx = fast_filter | arrange;
- let lowest_idx = lowest | arrange;
- let fast = fast_idx | join(lowest_idx, (_, (rid, _, _), f) -> ((rid, f), ()));
+ let fast = fast_idx | join(lowest, (_, (rid, _, _), f) -> ((rid, f), ()));
 -let slow_filter = timed | filter((_, (_, date, since)) -> (since, date) le);
 -let slow_map = slow_filter | map((node, (rid, _, _)) -> ((node, rid), ()));
 -let slow_idx = slow_map | arrange;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic05_oneoff.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/ldbc_ic05_oneoff.parsed--lowered.diff
index 33d36ad7d..fd8b9eb59 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic05_oneoff.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic05_oneoff.parsed--lowered.diff
@@ -6,7 +6,7 @@
  let request = input 0 : ((int, int, int), ());
  let person = import "graph::person" : (int, (List(int), List(int), List(int), int, int, List(int), List(int), int, int, int, int));
  let message = import "graph::message" : (int, (int, int, int, int, List(int), List(int), int, List(int), int, int, int, int, int));
-@@ -7,16 +9,61 @@
+@@ -7,16 +9,53 @@
  let posted = import "ic5s::posted" : ((int, int), int);
  let first = import "ic5s::first" : (int, int);
  let lowest = import "ic5s::lowest" : (int, int);
@@ -23,14 +23,11 @@
 -let ranked = busy + quiet | map(((rid, f), n) -> (f, (rid, n))) | join(forum, (f, (rid, n), (title, _, _)) -> (rid, ((n neg, f), title))) | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 20) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 20) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 20) min in let before = (end, count) sub in let keep = (((20, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
 +let hop1_map = request | map(((rid, who, date), ()) -> (who, (rid, who, date)));
 +let hop1_idx = hop1_map | arrange;
-+let person_idx = person | arrange;
-+let hop1_join = hop1_idx | join(person_idx, (who, req, _) -> (who, req));
++let hop1_join = hop1_idx | join(person, (who, req, _) -> (who, req));
 +let hop1_idx2 = hop1_join | arrange;
-+let friend_idx = friend | arrange;
-+let hop1 = hop1_idx2 | join(friend_idx, (_, req, (f, _)) -> (f, req));
++let hop1 = hop1_idx2 | join(friend, (_, req, (f, _)) -> (f, req));
 +let hop1_idx3 = hop1 | arrange;
-+let friend_idx2 = friend | arrange;
-+let hop2 = hop1_idx3 | join(friend_idx2, (_, req, (g, _)) -> (g, req));
++let hop2 = hop1_idx3 | join(friend, (_, req, (g, _)) -> (g, req));
 +let circle_rows = hop1 + hop2;
 +let circle_filter = circle_rows | filter((node, (_, who, _)) -> (node, who) ne);
 +let circle_map = circle_filter | map((node, (rid, _, date)) -> ((node, rid, date), ()));
@@ -38,23 +35,19 @@
 +let circle_reduce = circle_idx | reduce((_, vals) -> vals map (((), _) -> ((), 1)));
 +let circle = circle_reduce | map(((node, rid, date), ()) -> (node, (rid, date)));
 +let circle_idx2 = circle | arrange;
-+let member_idx = member | arrange;
-+let after_join = circle_idx2 | join(member_idx, (node, (rid, date), (f, since)) -> ((node, f), (rid, date, since)));
++let after_join = circle_idx2 | join(member, (node, (rid, date), (f, since)) -> ((node, f), (rid, date, since)));
 +let after_filter = after_join | filter((_, (_, date, since)) -> (since, date) gt);
 +let after = after_filter | map((key, (rid, _, _)) -> (key, rid));
 +let after_idx = after | arrange;
-+let posted_idx = posted | arrange;
-+let busy_join = after_idx | join(posted_idx, ((_, f), rid, n) -> ((rid, f), n));
++let busy_join = after_idx | join(posted, ((_, f), rid, n) -> ((rid, f), n));
 +let busy_rows = busy_join | join_function((key, n) -> ((key, ()), (0), n) enlist);
 +let busy_idx = busy_rows | arrange;
 +let busy = busy_idx | reduce((_, vals) -> let diffs = vals map ((_, d) -> d) in let n = diffs fold_add in (n, (n, 1)) enlist filter);
 +let circle_idx3 = circle | arrange;
-+let first_idx = first | arrange;
-+let timed = circle_idx3 | join(first_idx, (node, (rid, date), since) -> (node, (rid, date, since)));
++let timed = circle_idx3 | join(first, (node, (rid, date), since) -> (node, (rid, date, since)));
 +let fast_filter = timed | filter((_, (_, date, since)) -> (since, date) gt);
 +let fast_idx = fast_filter | arrange;
-+let lowest_idx = lowest | arrange;
-+let fast = fast_idx | join(lowest_idx, (_, (rid, _, _), f) -> ((rid, f), ()));
++let fast = fast_idx | join(lowest, (_, (rid, _, _), f) -> ((rid, f), ()));
 +let slow_filter = timed | filter((_, (_, date, since)) -> (since, date) le);
 +let slow_map = slow_filter | map((node, (rid, _, _)) -> ((node, rid), ()));
 +let slow_idx = slow_map | arrange;
@@ -71,8 +64,7 @@
 +let ranked_rows = busy + quiet;
 +let ranked_map = ranked_rows | map(((rid, f), n) -> (f, (rid, n)));
 +let ranked_idx = ranked_map | arrange;
-+let forum_idx = forum | arrange;
-+let ranked_join = ranked_idx | join(forum_idx, (f, (rid, n), (title, _, _)) -> (rid, ((n neg, f), title)));
++let ranked_join = ranked_idx | join(forum, (f, (rid, n), (title, _, _)) -> (rid, ((n neg, f), title)));
 +let ranked_idx2 = ranked_join | arrange;
 +let ranked = ranked_idx2 | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 20) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 20) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 20) min in let before = (end, count) sub in let keep = (((20, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
  let answer = ranked | map((rid, (rank, ((neg, _), title))) -> ((rid, rank), (title, neg neg)));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic06_oneoff.ddp b/interactive/tests/plan_pairs/expected/ldbc_ic06_oneoff.ddp
index e9e5f8a34..f4bd79293 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic06_oneoff.ddp
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic06_oneoff.ddp
@@ -10,40 +10,33 @@ let tagged = import "graph::mtag.by_tag" : (int, int);
 let tags_of = import "graph::mtag.by_message" : (int, int);
 let hop1_map = request | map(((rid, who, _), ()) -> (who, (rid, who)));
 let hop1_idx = hop1_map | arrange;
-let person_idx = person | arrange;
-let hop1_join = hop1_idx | join(person_idx, (who, req, _) -> (who, req));
+let hop1_join = hop1_idx | join(person, (who, req, _) -> (who, req));
 let hop1_idx2 = hop1_join | arrange;
-let friend_idx = friend | arrange;
-let hop1 = hop1_idx2 | join(friend_idx, (_, (rid, who), (f, _)) -> (f, (rid, who)));
+let hop1 = hop1_idx2 | join(friend, (_, (rid, who), (f, _)) -> (f, (rid, who)));
 let hop1_idx3 = hop1 | arrange;
-let hop2 = hop1_idx3 | join(friend_idx, (_, (rid, who), (g, _)) -> (g, (rid, who)));
+let hop2 = hop1_idx3 | join(friend, (_, (rid, who), (g, _)) -> (g, (rid, who)));
 let circle_rows = hop1 + hop2;
 let circle_rows2 = circle_rows | filter((node, (_, who)) -> (node, who) ne) | map((node, (rid, _)) -> ((rid, node), ()));
 let circle_idx = circle_rows2 | arrange;
 let circle = circle_idx | reduce((_, vals) -> vals map (((), _) -> ((), 1)));
 let with_it_map = request | map(((rid, _, name), ()) -> (name, rid));
 let with_it_idx = with_it_map | arrange;
-let by_name_idx = by_name | arrange;
-let with_it_join = with_it_idx | join(by_name_idx, (_, rid, t) -> (t, rid));
+let with_it_join = with_it_idx | join(by_name, (_, rid, t) -> (t, rid));
 let with_it_idx2 = with_it_join | arrange;
-let tagged_idx = tagged | arrange;
-let with_it_join2 = with_it_idx2 | join(tagged_idx, (t, rid, m) -> (m, (rid, t)));
+let with_it_join2 = with_it_idx2 | join(tagged, (t, rid, m) -> (m, (rid, t)));
 let with_it_idx3 = with_it_join2 | arrange;
-let message_idx = message | arrange;
-let with_it_join3 = with_it_idx3 | join(message_idx, (m, (rid, t), (kind, _, author, _, _, _, _, _, _, _, _, _, _)) -> ((rid, author), (kind, m, t)));
+let with_it_join3 = with_it_idx3 | join(message, (m, (rid, t), (kind, _, author, _, _, _, _, _, _, _, _, _, _)) -> ((rid, author), (kind, m, t)));
 let with_it_filter = with_it_join3 | filter((_, (kind, _, _)) -> (kind, 0) eq);
 let with_it_idx4 = with_it_filter | arrange;
 let with_it = with_it_idx4 | join(circle, ((rid, _), (_, m, t), ()) -> (m, (rid, t)));
 let with_it_idx5 = with_it | arrange;
-let tags_of_idx = tags_of | arrange;
-let others_join = with_it_idx5 | join(tags_of_idx, (_, (rid, t), other) -> ((rid, t, other), ()));
+let others_join = with_it_idx5 | join(tags_of, (_, (rid, t), other) -> ((rid, t, other), ()));
 let others_rows = others_join | filter(((_, t, other), ()) -> (t, other) ne) | map(((rid, _, other), ()) -> ((rid, other), ()));
 let others_idx = others_rows | arrange;
 let others = others_idx | reduce((_, vals) -> let diffs = vals map ((_, d) -> d) in let n = diffs fold_add in (n, (n, 1)) enlist filter);
 let ranked_map = others | map(((rid, other), n) -> (other, (rid, n)));
 let ranked_idx = ranked_map | arrange;
-let tag_idx = tag | arrange;
-let ranked_join = ranked_idx | join(tag_idx, (_, (rid, n), (name, _)) -> (rid, (n neg, name)));
+let ranked_join = ranked_idx | join(tag, (_, (rid, n), (name, _)) -> (rid, (n neg, name)));
 let ranked_idx2 = ranked_join | arrange;
 let ranked = ranked_idx2 | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 10) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 10) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 10) min in let before = (end, count) sub in let keep = (((10, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
 let answer = ranked | map((rid, (rank, (neg, other))) -> ((rid, rank), (other, neg neg)));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic06_oneoff.lowered--optimized.diff b/interactive/tests/plan_pairs/expected/ldbc_ic06_oneoff.lowered--optimized.diff
index 2bdd24233..4ec44743e 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic06_oneoff.lowered--optimized.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic06_oneoff.lowered--optimized.diff
@@ -1,12 +1,8 @@
 --- lowered
 +++ optimized
-@@ -16,12 +16,10 @@
- let friend_idx = friend | arrange;
- let hop1 = hop1_idx2 | join(friend_idx, (_, (rid, who), (f, _)) -> (f, (rid, who)));
+@@ -16,9 +16,8 @@
  let hop1_idx3 = hop1 | arrange;
--let friend_idx2 = friend | arrange;
--let hop2 = hop1_idx3 | join(friend_idx2, (_, (rid, who), (g, _)) -> (g, (rid, who)));
-+let hop2 = hop1_idx3 | join(friend_idx, (_, (rid, who), (g, _)) -> (g, (rid, who)));
+ let hop2 = hop1_idx3 | join(friend, (_, (rid, who), (g, _)) -> (g, (rid, who)));
  let circle_rows = hop1 + hop2;
 -let circle_filter = circle_rows | filter((node, (_, who)) -> (node, who) ne);
 -let circle_map = circle_filter | map((node, (rid, _)) -> ((rid, node), ()));
@@ -16,10 +12,10 @@
  let circle = circle_idx | reduce((_, vals) -> vals map (((), _) -> ((), 1)));
  let with_it_map = request | map(((rid, _, name), ()) -> (name, rid));
  let with_it_idx = with_it_map | arrange;
-@@ -39,9 +37,8 @@
+@@ -32,9 +31,8 @@
+ let with_it = with_it_idx4 | join(circle, ((rid, _), (_, m, t), ()) -> (m, (rid, t)));
  let with_it_idx5 = with_it | arrange;
- let tags_of_idx = tags_of | arrange;
- let others_join = with_it_idx5 | join(tags_of_idx, (_, (rid, t), other) -> ((rid, t, other), ()));
+ let others_join = with_it_idx5 | join(tags_of, (_, (rid, t), other) -> ((rid, t, other), ()));
 -let others_filter = others_join | filter(((_, t, other), ()) -> (t, other) ne);
 -let others_map = others_filter | map(((rid, _, other), ()) -> ((rid, other), ()));
 -let others_idx = others_map | arrange;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic06_oneoff.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/ldbc_ic06_oneoff.parsed--lowered.diff
index 68527476c..94fdb6ceb 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic06_oneoff.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic06_oneoff.parsed--lowered.diff
@@ -6,7 +6,7 @@
  let request = input 0 : ((int, int, List(int)), ());
  let person = import "graph::person" : (int, (List(int), List(int), List(int), int, int, List(int), List(int), int, int, int, int));
  let message = import "graph::message" : (int, (int, int, int, int, List(int), List(int), int, List(int), int, int, int, int, int));
-@@ -6,11 +8,48 @@
+@@ -6,11 +8,40 @@
  let by_name = import "graph::tag.by_name" : (List(int), int);
  let tagged = import "graph::mtag.by_tag" : (int, int);
  let tags_of = import "graph::mtag.by_message" : (int, int);
@@ -18,14 +18,11 @@
 -let ranked = others | map(((rid, other), n) -> (other, (rid, n))) | join(tag, (_, (rid, n), (name, _)) -> (rid, (n neg, name))) | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 10) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 10) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 10) min in let before = (end, count) sub in let keep = (((10, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
 +let hop1_map = request | map(((rid, who, _), ()) -> (who, (rid, who)));
 +let hop1_idx = hop1_map | arrange;
-+let person_idx = person | arrange;
-+let hop1_join = hop1_idx | join(person_idx, (who, req, _) -> (who, req));
++let hop1_join = hop1_idx | join(person, (who, req, _) -> (who, req));
 +let hop1_idx2 = hop1_join | arrange;
-+let friend_idx = friend | arrange;
-+let hop1 = hop1_idx2 | join(friend_idx, (_, (rid, who), (f, _)) -> (f, (rid, who)));
++let hop1 = hop1_idx2 | join(friend, (_, (rid, who), (f, _)) -> (f, (rid, who)));
 +let hop1_idx3 = hop1 | arrange;
-+let friend_idx2 = friend | arrange;
-+let hop2 = hop1_idx3 | join(friend_idx2, (_, (rid, who), (g, _)) -> (g, (rid, who)));
++let hop2 = hop1_idx3 | join(friend, (_, (rid, who), (g, _)) -> (g, (rid, who)));
 +let circle_rows = hop1 + hop2;
 +let circle_filter = circle_rows | filter((node, (_, who)) -> (node, who) ne);
 +let circle_map = circle_filter | map((node, (rid, _)) -> ((rid, node), ()));
@@ -33,28 +30,23 @@
 +let circle = circle_idx | reduce((_, vals) -> vals map (((), _) -> ((), 1)));
 +let with_it_map = request | map(((rid, _, name), ()) -> (name, rid));
 +let with_it_idx = with_it_map | arrange;
-+let by_name_idx = by_name | arrange;
-+let with_it_join = with_it_idx | join(by_name_idx, (_, rid, t) -> (t, rid));
++let with_it_join = with_it_idx | join(by_name, (_, rid, t) -> (t, rid));
 +let with_it_idx2 = with_it_join | arrange;
-+let tagged_idx = tagged | arrange;
-+let with_it_join2 = with_it_idx2 | join(tagged_idx, (t, rid, m) -> (m, (rid, t)));
++let with_it_join2 = with_it_idx2 | join(tagged, (t, rid, m) -> (m, (rid, t)));
 +let with_it_idx3 = with_it_join2 | arrange;
-+let message_idx = message | arrange;
-+let with_it_join3 = with_it_idx3 | join(message_idx, (m, (rid, t), (kind, _, author, _, _, _, _, _, _, _, _, _, _)) -> ((rid, author), (kind, m, t)));
++let with_it_join3 = with_it_idx3 | join(message, (m, (rid, t), (kind, _, author, _, _, _, _, _, _, _, _, _, _)) -> ((rid, author), (kind, m, t)));
 +let with_it_filter = with_it_join3 | filter((_, (kind, _, _)) -> (kind, 0) eq);
 +let with_it_idx4 = with_it_filter | arrange;
 +let with_it = with_it_idx4 | join(circle, ((rid, _), (_, m, t), ()) -> (m, (rid, t)));
 +let with_it_idx5 = with_it | arrange;
-+let tags_of_idx = tags_of | arrange;
-+let others_join = with_it_idx5 | join(tags_of_idx, (_, (rid, t), other) -> ((rid, t, other), ()));
++let others_join = with_it_idx5 | join(tags_of, (_, (rid, t), other) -> ((rid, t, other), ()));
 +let others_filter = others_join | filter(((_, t, other), ()) -> (t, other) ne);
 +let others_map = others_filter | map(((rid, _, other), ()) -> ((rid, other), ()));
 +let others_idx = others_map | arrange;
 +let others = others_idx | reduce((_, vals) -> let diffs = vals map ((_, d) -> d) in let n = diffs fold_add in (n, (n, 1)) enlist filter);
 +let ranked_map = others | map(((rid, other), n) -> (other, (rid, n)));
 +let ranked_idx = ranked_map | arrange;
-+let tag_idx = tag | arrange;
-+let ranked_join = ranked_idx | join(tag_idx, (_, (rid, n), (name, _)) -> (rid, (n neg, name)));
++let ranked_join = ranked_idx | join(tag, (_, (rid, n), (name, _)) -> (rid, (n neg, name)));
 +let ranked_idx2 = ranked_join | arrange;
 +let ranked = ranked_idx2 | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 10) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 10) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 10) min in let before = (end, count) sub in let keep = (((10, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
  let answer = ranked | map((rid, (rank, (neg, other))) -> ((rid, rank), (other, neg neg)));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic07_oneoff.ddp b/interactive/tests/plan_pairs/expected/ldbc_ic07_oneoff.ddp
index 904a8f252..abfdd26e7 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic07_oneoff.ddp
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic07_oneoff.ddp
@@ -8,20 +8,16 @@ let likes = import "graph::likes.by_message" : (int, (int, int));
 let pals = import "graph::friend.pair" : ((int, int), ());
 let latest_map = request | map(((rid, who), ()) -> (who, rid));
 let latest_idx = latest_map | arrange;
-let wrote_idx = wrote | arrange;
-let latest_join = latest_idx | join(wrote_idx, (who, rid, m) -> (m, (rid, who)));
+let latest_join = latest_idx | join(wrote, (who, rid, m) -> (m, (rid, who)));
 let latest_idx2 = latest_join | arrange;
-let likes_idx = likes | arrange;
-let latest_join2 = latest_idx2 | join(likes_idx, (m, (rid, who), (liker, when)) -> ((rid, who, liker), (when neg, m)));
+let latest_join2 = latest_idx2 | join(likes, (m, (rid, who), (liker, when)) -> ((rid, who, liker), (when neg, m)));
 let latest_idx3 = latest_join2 | arrange;
 let latest = latest_idx3 | reduce(limit 1, (_, vals) -> let first = vals head in (first.0, 1) enlist);
 let rows_map = latest | map(((rid, who, liker), (neg, m)) -> (m, (rid, who, liker, neg neg)));
 let rows_idx = rows_map | arrange;
-let message_idx = message | arrange;
-let rows = rows_idx | join(message_idx, (m, (rid, who, liker, when), (_, created, _, _, text, image, _, _, _, _, _, _, _)) -> ((who, liker), (rid, liker, when, m, ((text len, 0) gt, text, image) select, (when, created) sub)));
+let rows = rows_idx | join(message, (m, (rid, who, liker, when), (_, created, _, _, text, image, _, _, _, _, _, _, _)) -> ((who, liker), (rid, liker, when, m, ((text len, 0) gt, text, image) select, (when, created) sub)));
 let rows_idx2 = rows | arrange;
-let pals_idx = pals | arrange;
-let known = rows_idx2 | join(pals_idx, arg -> let _call0 = let input = arg in let (pair, row, ()) = input in (pair, row) in (((), ()), (_call0.1.0, _call0.1.1, _call0.1.2, _call0.1.3, _call0.1.4, _call0.1.5)));
+let known = rows_idx2 | join(pals, arg -> let _call0 = let input = arg in let (pair, row, ()) = input in (pair, row) in (((), ()), (_call0.1.0, _call0.1.1, _call0.1.2, _call0.1.3, _call0.1.4, _call0.1.5)));
 let marked_map = known | map((_, row) -> (row, 0));
 let marked_map2 = rows | map(arg -> let _call0 = let input = arg in input in (((), ()), (_call0.1.0, _call0.1.1, _call0.1.2, _call0.1.3, _call0.1.4, _call0.1.5)));
 let marked_neg = known | negate;
@@ -30,8 +26,7 @@ let marked_map3 = marked_rows | map((_, row) -> (row, 1));
 let marked = marked_map + marked_map3;
 let ranked_map = marked | map(((rid, liker, when, m, body, age), fresh) -> (liker, (rid, when, m, body, age, fresh)));
 let ranked_idx = ranked_map | arrange;
-let person_idx = person | arrange;
-let ranked_join = ranked_idx | join(person_idx, (liker, (rid, when, m, body, age, fresh), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((when neg, liker), (first, last, m, body, (age, 60000) div, fresh))));
+let ranked_join = ranked_idx | join(person, (liker, (rid, when, m, body, age, fresh), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((when neg, liker), (first, last, m, body, (age, 60000) div, fresh))));
 let ranked_idx2 = ranked_join | arrange;
 let ranked = ranked_idx2 | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 20) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 20) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 20) min in let before = (end, count) sub in let keep = (((20, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
 let answer = ranked | map((rid, (rank, ((neg, liker), (first, last, m, body, minutes, fresh)))) -> ((rid, rank), (liker, first, last, neg neg, m, body, minutes, fresh)));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic07_oneoff.optimized--projected.diff b/interactive/tests/plan_pairs/expected/ldbc_ic07_oneoff.optimized--projected.diff
index c90d26d3c..88dbedff2 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic07_oneoff.optimized--projected.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic07_oneoff.optimized--projected.diff
@@ -1,11 +1,11 @@
 --- optimized
 +++ projected
-@@ -21,12 +21,13 @@
- let rows = rows_idx | join(message_idx, (m, (rid, who, liker, when), (_, created, _, _, text, image, _, _, _, _, _, _, _)) -> ((who, liker), (rid, liker, when, m, ((text len, 0) gt, text, image) select, (when, created) sub)));
+@@ -17,12 +17,13 @@
+ let rows_idx = rows_map | arrange;
+ let rows = rows_idx | join(message, (m, (rid, who, liker, when), (_, created, _, _, text, image, _, _, _, _, _, _, _)) -> ((who, liker), (rid, liker, when, m, ((text len, 0) gt, text, image) select, (when, created) sub)));
  let rows_idx2 = rows | arrange;
- let pals_idx = pals | arrange;
--let known = rows_idx2 | join(pals_idx, (pair, row, ()) -> (pair, row));
-+let known = rows_idx2 | join(pals_idx, arg -> let _call0 = let input = arg in let (pair, row, ()) = input in (pair, row) in (((), ()), (_call0.1.0, _call0.1.1, _call0.1.2, _call0.1.3, _call0.1.4, _call0.1.5)));
+-let known = rows_idx2 | join(pals, (pair, row, ()) -> (pair, row));
++let known = rows_idx2 | join(pals, arg -> let _call0 = let input = arg in let (pair, row, ()) = input in (pair, row) in (((), ()), (_call0.1.0, _call0.1.1, _call0.1.2, _call0.1.3, _call0.1.4, _call0.1.5)));
  let marked_map = known | map((_, row) -> (row, 0));
 +let marked_map2 = rows | map(arg -> let _call0 = let input = arg in input in (((), ()), (_call0.1.0, _call0.1.1, _call0.1.2, _call0.1.3, _call0.1.4, _call0.1.5)));
  let marked_neg = known | negate;
@@ -17,4 +17,4 @@
 +let marked = marked_map + marked_map3;
  let ranked_map = marked | map(((rid, liker, when, m, body, age), fresh) -> (liker, (rid, when, m, body, age, fresh)));
  let ranked_idx = ranked_map | arrange;
- let person_idx = person | arrange;
+ let ranked_join = ranked_idx | join(person, (liker, (rid, when, m, body, age, fresh), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((when neg, liker), (first, last, m, body, (age, 60000) div, fresh))));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic07_oneoff.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/ldbc_ic07_oneoff.parsed--lowered.diff
index bba8ee0f9..d4a8bf2b7 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic07_oneoff.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic07_oneoff.parsed--lowered.diff
@@ -1,6 +1,6 @@
 --- parsed
 +++ lowered
-@@ -1,13 +1,39 @@
+@@ -1,13 +1,34 @@
 +-- Time lanes: epoch.
 +-- Trace imports use provider arrangements; history advances to G = (0, []).
  let request = input 0 : ((int, int), ());
@@ -16,20 +16,16 @@
 -let ranked = marked | map(((rid, liker, when, m, body, age), fresh) -> (liker, (rid, when, m, body, age, fresh))) | join(person, (liker, (rid, when, m, body, age, fresh), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((when neg, liker), (first, last, m, body, (age, 60000) div, fresh)))) | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 20) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 20) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 20) min in let before = (end, count) sub in let keep = (((20, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
 +let latest_map = request | map(((rid, who), ()) -> (who, rid));
 +let latest_idx = latest_map | arrange;
-+let wrote_idx = wrote | arrange;
-+let latest_join = latest_idx | join(wrote_idx, (who, rid, m) -> (m, (rid, who)));
++let latest_join = latest_idx | join(wrote, (who, rid, m) -> (m, (rid, who)));
 +let latest_idx2 = latest_join | arrange;
-+let likes_idx = likes | arrange;
-+let latest_join2 = latest_idx2 | join(likes_idx, (m, (rid, who), (liker, when)) -> ((rid, who, liker), (when neg, m)));
++let latest_join2 = latest_idx2 | join(likes, (m, (rid, who), (liker, when)) -> ((rid, who, liker), (when neg, m)));
 +let latest_idx3 = latest_join2 | arrange;
 +let latest = latest_idx3 | reduce(limit 1, (_, vals) -> let first = vals head in (first.0, 1) enlist);
 +let rows_map = latest | map(((rid, who, liker), (neg, m)) -> (m, (rid, who, liker, neg neg)));
 +let rows_idx = rows_map | arrange;
-+let message_idx = message | arrange;
-+let rows = rows_idx | join(message_idx, (m, (rid, who, liker, when), (_, created, _, _, text, image, _, _, _, _, _, _, _)) -> ((who, liker), (rid, liker, when, m, ((text len, 0) gt, text, image) select, (when, created) sub)));
++let rows = rows_idx | join(message, (m, (rid, who, liker, when), (_, created, _, _, text, image, _, _, _, _, _, _, _)) -> ((who, liker), (rid, liker, when, m, ((text len, 0) gt, text, image) select, (when, created) sub)));
 +let rows_idx2 = rows | arrange;
-+let pals_idx = pals | arrange;
-+let known = rows_idx2 | join(pals_idx, (pair, row, ()) -> (pair, row));
++let known = rows_idx2 | join(pals, (pair, row, ()) -> (pair, row));
 +let marked_map = known | map((_, row) -> (row, 0));
 +let marked_neg = known | negate;
 +let marked_rows = rows + marked_neg;
@@ -37,8 +33,7 @@
 +let marked = marked_map + marked_map2;
 +let ranked_map = marked | map(((rid, liker, when, m, body, age), fresh) -> (liker, (rid, when, m, body, age, fresh)));
 +let ranked_idx = ranked_map | arrange;
-+let person_idx = person | arrange;
-+let ranked_join = ranked_idx | join(person_idx, (liker, (rid, when, m, body, age, fresh), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((when neg, liker), (first, last, m, body, (age, 60000) div, fresh))));
++let ranked_join = ranked_idx | join(person, (liker, (rid, when, m, body, age, fresh), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((when neg, liker), (first, last, m, body, (age, 60000) div, fresh))));
 +let ranked_idx2 = ranked_join | arrange;
 +let ranked = ranked_idx2 | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 20) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 20) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 20) min in let before = (end, count) sub in let keep = (((20, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
  let answer = ranked | map((rid, (rank, ((neg, liker), (first, last, m, body, minutes, fresh)))) -> ((rid, rank), (liker, first, last, neg neg, m, body, minutes, fresh)));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic08_oneoff.ddp b/interactive/tests/plan_pairs/expected/ldbc_ic08_oneoff.ddp
index 96feb7cde..52650d1f1 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic08_oneoff.ddp
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic08_oneoff.ddp
@@ -7,23 +7,19 @@ let wrote = import "graph::message.by_creator" : (int, int);
 let replies = import "graph::message.by_parent" : (int, int);
 let top_map = request | map(((rid, who), ()) -> (who, rid));
 let top_idx = top_map | arrange;
-let wrote_idx = wrote | arrange;
-let top_join = top_idx | join(wrote_idx, (_, rid, op) -> (op, rid));
+let top_join = top_idx | join(wrote, (_, rid, op) -> (op, rid));
 let top_idx2 = top_join | arrange;
-let replies_idx = replies | arrange;
-let top_join2 = top_idx2 | join(replies_idx, (_, rid, id) -> (id, rid));
+let top_join2 = top_idx2 | join(replies, (_, rid, id) -> (id, rid));
 let top_idx3 = top_join2 | arrange;
-let message_idx = message | arrange;
-let top_join3 = top_idx3 | join(message_idx, (id, rid, (kind, created, who, _, _, _, _, _, _, _, _, _, _)) -> (rid, (kind, (created neg, id), who)));
+let top_join3 = top_idx3 | join(message, (id, rid, (kind, created, who, _, _, _, _, _, _, _, _, _, _)) -> (rid, (kind, (created neg, id), who)));
 let top_rows = top_join3 | filter((_, (kind, _, _)) -> (kind, 1) eq) | map((rid, (_, order, who)) -> (rid, (order, who)));
 let top_idx4 = top_rows | arrange;
 let top = top_idx4 | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 20) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 20) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 20) min in let before = (end, count) sub in let keep = (((20, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
 let answer_map = top | map((rid, (rank, ((neg, id), who))) -> (id, (rid, rank, neg neg, who)));
 let answer_idx = answer_map | arrange;
-let answer_join = answer_idx | join(message_idx, (id, (rid, rank, created, who), (_, _, _, _, content, _, _, _, _, _, _, _, _)) -> (who, (rid, rank, id, content, created)));
+let answer_join = answer_idx | join(message, (id, (rid, rank, created, who), (_, _, _, _, content, _, _, _, _, _, _, _, _)) -> (who, (rid, rank, id, content, created)));
 let answer_idx2 = answer_join | arrange;
-let person_idx = person | arrange;
-let answer = answer_idx2 | join(person_idx, (who, (rid, rank, id, content, created), (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, rank), (who, first, last, created, id, content)));
+let answer = answer_idx2 | join(person, (who, (rid, rank, id, content, created), (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, rank), (who, first, last, created, id, content)));
 let answer_idx3 = answer | arrange;
 -- Renderer: publish the existing arrangement.
 output "answer" = answer_idx3;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic08_oneoff.lowered--optimized.diff b/interactive/tests/plan_pairs/expected/ldbc_ic08_oneoff.lowered--optimized.diff
index fbb574474..5f05bfc30 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic08_oneoff.lowered--optimized.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic08_oneoff.lowered--optimized.diff
@@ -1,9 +1,9 @@
 --- lowered
 +++ optimized
-@@ -15,14 +15,12 @@
+@@ -12,9 +12,8 @@
+ let top_join2 = top_idx2 | join(replies, (_, rid, id) -> (id, rid));
  let top_idx3 = top_join2 | arrange;
- let message_idx = message | arrange;
- let top_join3 = top_idx3 | join(message_idx, (id, rid, (kind, created, who, _, _, _, _, _, _, _, _, _, _)) -> (rid, (kind, (created neg, id), who)));
+ let top_join3 = top_idx3 | join(message, (id, rid, (kind, created, who, _, _, _, _, _, _, _, _, _, _)) -> (rid, (kind, (created neg, id), who)));
 -let top_filter = top_join3 | filter((_, (kind, _, _)) -> (kind, 1) eq);
 -let top_map2 = top_filter | map((rid, (_, order, who)) -> (rid, (order, who)));
 -let top_idx4 = top_map2 | arrange;
@@ -12,9 +12,3 @@
  let top = top_idx4 | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 20) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 20) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 20) min in let before = (end, count) sub in let keep = (((20, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
  let answer_map = top | map((rid, (rank, ((neg, id), who))) -> (id, (rid, rank, neg neg, who)));
  let answer_idx = answer_map | arrange;
--let message_idx2 = message | arrange;
--let answer_join = answer_idx | join(message_idx2, (id, (rid, rank, created, who), (_, _, _, _, content, _, _, _, _, _, _, _, _)) -> (who, (rid, rank, id, content, created)));
-+let answer_join = answer_idx | join(message_idx, (id, (rid, rank, created, who), (_, _, _, _, content, _, _, _, _, _, _, _, _)) -> (who, (rid, rank, id, content, created)));
- let answer_idx2 = answer_join | arrange;
- let person_idx = person | arrange;
- let answer = answer_idx2 | join(person_idx, (who, (rid, rank, id, content, created), (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, rank), (who, first, last, created, id, content)));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic08_oneoff.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/ldbc_ic08_oneoff.parsed--lowered.diff
index a5159a60a..1d25d6df4 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic08_oneoff.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic08_oneoff.parsed--lowered.diff
@@ -1,6 +1,6 @@
 --- parsed
 +++ lowered
-@@ -1,8 +1,31 @@
+@@ -1,8 +1,26 @@
 +-- Time lanes: epoch.
 +-- Trace imports use provider arrangements; history advances to G = (0, []).
  let request = input 0 : ((int, int), ());
@@ -13,25 +13,20 @@
 -output "answer" = answer | arrange;
 +let top_map = request | map(((rid, who), ()) -> (who, rid));
 +let top_idx = top_map | arrange;
-+let wrote_idx = wrote | arrange;
-+let top_join = top_idx | join(wrote_idx, (_, rid, op) -> (op, rid));
++let top_join = top_idx | join(wrote, (_, rid, op) -> (op, rid));
 +let top_idx2 = top_join | arrange;
-+let replies_idx = replies | arrange;
-+let top_join2 = top_idx2 | join(replies_idx, (_, rid, id) -> (id, rid));
++let top_join2 = top_idx2 | join(replies, (_, rid, id) -> (id, rid));
 +let top_idx3 = top_join2 | arrange;
-+let message_idx = message | arrange;
-+let top_join3 = top_idx3 | join(message_idx, (id, rid, (kind, created, who, _, _, _, _, _, _, _, _, _, _)) -> (rid, (kind, (created neg, id), who)));
++let top_join3 = top_idx3 | join(message, (id, rid, (kind, created, who, _, _, _, _, _, _, _, _, _, _)) -> (rid, (kind, (created neg, id), who)));
 +let top_filter = top_join3 | filter((_, (kind, _, _)) -> (kind, 1) eq);
 +let top_map2 = top_filter | map((rid, (_, order, who)) -> (rid, (order, who)));
 +let top_idx4 = top_map2 | arrange;
 +let top = top_idx4 | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 20) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 20) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 20) min in let before = (end, count) sub in let keep = (((20, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
 +let answer_map = top | map((rid, (rank, ((neg, id), who))) -> (id, (rid, rank, neg neg, who)));
 +let answer_idx = answer_map | arrange;
-+let message_idx2 = message | arrange;
-+let answer_join = answer_idx | join(message_idx2, (id, (rid, rank, created, who), (_, _, _, _, content, _, _, _, _, _, _, _, _)) -> (who, (rid, rank, id, content, created)));
++let answer_join = answer_idx | join(message, (id, (rid, rank, created, who), (_, _, _, _, content, _, _, _, _, _, _, _, _)) -> (who, (rid, rank, id, content, created)));
 +let answer_idx2 = answer_join | arrange;
-+let person_idx = person | arrange;
-+let answer = answer_idx2 | join(person_idx, (who, (rid, rank, id, content, created), (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, rank), (who, first, last, created, id, content)));
++let answer = answer_idx2 | join(person, (who, (rid, rank, id, content, created), (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, rank), (who, first, last, created, id, content)));
 +let answer_idx3 = answer | arrange;
 +-- Renderer: publish the existing arrangement.
 +output "answer" = answer_idx3;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic09_oneoff.ddp b/interactive/tests/plan_pairs/expected/ldbc_ic09_oneoff.ddp
index 8bd5b1d70..5ed9c406e 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic09_oneoff.ddp
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic09_oneoff.ddp
@@ -9,29 +9,24 @@ let latest = import "ic9s::latest" : (int, (int, int));
 let newest = import "ic9s::newest" : (int, int);
 let hop1_map = request | map(((rid, who, max), ()) -> (who, (rid, who, max)));
 let hop1_idx = hop1_map | arrange;
-let person_idx = person | arrange;
-let hop1_join = hop1_idx | join(person_idx, (who, req, _) -> (who, req));
+let hop1_join = hop1_idx | join(person, (who, req, _) -> (who, req));
 let hop1_idx2 = hop1_join | arrange;
-let friend_idx = friend | arrange;
-let hop1 = hop1_idx2 | join(friend_idx, (_, req, (f, _)) -> (f, req));
+let hop1 = hop1_idx2 | join(friend, (_, req, (f, _)) -> (f, req));
 let hop1_idx3 = hop1 | arrange;
-let hop2 = hop1_idx3 | join(friend_idx, (_, req, (g, _)) -> (g, req));
+let hop2 = hop1_idx3 | join(friend, (_, req, (g, _)) -> (g, req));
 let friends_rows = hop1 + hop2;
 let friends_rows2 = friends_rows | filter((node, (_, who, _)) -> (node, who) ne) | map((node, (rid, _, max)) -> ((node, rid, max), ()));
 let friends_idx = friends_rows2 | arrange;
 let friends_reduce = friends_idx | reduce((_, vals) -> vals map (((), _) -> ((), 1)));
 let friends = friends_reduce | map(((node, rid, max), ()) -> (node, (rid, max)));
 let friends_idx2 = friends | arrange;
-let newest_idx = newest | arrange;
-let ahead = friends_idx2 | join(newest_idx, (f, (rid, max), neg) -> (f, (rid, max, neg neg)));
+let ahead = friends_idx2 | join(newest, (f, (rid, max), neg) -> (f, (rid, max, neg neg)));
 let fast_filter = ahead | filter((_, (_, max, last)) -> (last, max) lt);
 let fast_idx = fast_filter | arrange;
-let latest_idx = latest | arrange;
-let fast = fast_idx | join(latest_idx, (f, (rid, _, _), (neg, id)) -> (rid, ((neg, id), f)));
+let fast = fast_idx | join(latest, (f, (rid, _, _), (neg, id)) -> (rid, ((neg, id), f)));
 let slow_filter = ahead | filter((_, (_, max, last)) -> (last, max) ge);
 let slow_idx = slow_filter | arrange;
-let by_author_idx = by_author | arrange;
-let slow_join = slow_idx | join(by_author_idx, (f, (rid, max, _), (neg, id)) -> ((rid, f), ((neg, id), max)));
+let slow_join = slow_idx | join(by_author, (f, (rid, max, _), (neg, id)) -> ((rid, f), ((neg, id), max)));
 let slow_rows = slow_join | filter((_, ((neg, _), max)) -> (neg neg, max) lt) | map((key, (order, _)) -> (key, order));
 let slow_idx2 = slow_rows | arrange;
 let slow_reduce = slow_idx2 | reduce((_, a) -> let v0 = (a map ((_, a) -> (a, 0) gt), (0, a len) range) zip filter in let v1 = (((0, (v0 len, 20) min) range, v0) gather, a) gather in let v2 = (v1, v1 map ((_, a) -> (a, 20) min) scan_add) zip map ((a, b) -> let v0 = (a.1, 20) min in let v1 = (((20, (b, v0) sub) sub, 0) max, v0) min in ((v1, 0) gt, (a.0, v1))) filter in (v2, v2 map ((_, a) -> a) scan_add) zip map ((a, b) -> (a.0, ((b, a.1) sub, b) range) cap_list map ((a, b) -> ((b, a), 1))) flatten.1 map ((a, b) -> (((), a.1), b)));
@@ -41,10 +36,9 @@ let top_idx = top_rows | arrange;
 let top = top_idx | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 20) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 20) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 20) min in let before = (end, count) sub in let keep = (((20, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
 let answer_map = top | map((rid, (rank, ((neg, id), f))) -> (id, (rid, rank, neg neg, f)));
 let answer_idx = answer_map | arrange;
-let message_idx = message | arrange;
-let answer_join = answer_idx | join(message_idx, (id, (rid, rank, created, f), (_, _, _, _, content, image, _, _, _, _, _, _, _)) -> (f, (rid, rank, id, ((content len, 0) gt, content, image) select, created)));
+let answer_join = answer_idx | join(message, (id, (rid, rank, created, f), (_, _, _, _, content, image, _, _, _, _, _, _, _)) -> (f, (rid, rank, id, ((content len, 0) gt, content, image) select, created)));
 let answer_idx2 = answer_join | arrange;
-let answer = answer_idx2 | join(person_idx, (f, (rid, rank, id, body, created), (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, rank), (f, first, last, id, body, created)));
+let answer = answer_idx2 | join(person, (f, (rid, rank, id, body, created), (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, rank), (f, first, last, id, body, created)));
 let answer_idx3 = answer | arrange;
 -- Renderer: publish the existing arrangement.
 output "answer" = answer_idx3;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic09_oneoff.lowered--optimized.diff b/interactive/tests/plan_pairs/expected/ldbc_ic09_oneoff.lowered--optimized.diff
index 89e924cae..d974a727f 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic09_oneoff.lowered--optimized.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic09_oneoff.lowered--optimized.diff
@@ -1,12 +1,8 @@
 --- lowered
 +++ optimized
-@@ -15,12 +15,10 @@
- let friend_idx = friend | arrange;
- let hop1 = hop1_idx2 | join(friend_idx, (_, req, (f, _)) -> (f, req));
+@@ -15,9 +15,8 @@
  let hop1_idx3 = hop1 | arrange;
--let friend_idx2 = friend | arrange;
--let hop2 = hop1_idx3 | join(friend_idx2, (_, req, (g, _)) -> (g, req));
-+let hop2 = hop1_idx3 | join(friend_idx, (_, req, (g, _)) -> (g, req));
+ let hop2 = hop1_idx3 | join(friend, (_, req, (g, _)) -> (g, req));
  let friends_rows = hop1 + hop2;
 -let friends_filter = friends_rows | filter((node, (_, who, _)) -> (node, who) ne);
 -let friends_map = friends_filter | map((node, (rid, _, max)) -> ((node, rid, max), ()));
@@ -16,10 +12,10 @@
  let friends_reduce = friends_idx | reduce((_, vals) -> vals map (((), _) -> ((), 1)));
  let friends = friends_reduce | map(((node, rid, max), ()) -> (node, (rid, max)));
  let friends_idx2 = friends | arrange;
-@@ -34,9 +32,8 @@
+@@ -28,9 +27,8 @@
+ let slow_filter = ahead | filter((_, (_, max, last)) -> (last, max) ge);
  let slow_idx = slow_filter | arrange;
- let by_author_idx = by_author | arrange;
- let slow_join = slow_idx | join(by_author_idx, (f, (rid, max, _), (neg, id)) -> ((rid, f), ((neg, id), max)));
+ let slow_join = slow_idx | join(by_author, (f, (rid, max, _), (neg, id)) -> ((rid, f), ((neg, id), max)));
 -let slow_filter2 = slow_join | filter((_, ((neg, _), max)) -> (neg neg, max) lt);
 -let slow_map = slow_filter2 | map((key, (order, _)) -> (key, order));
 -let slow_idx2 = slow_map | arrange;
@@ -28,13 +24,3 @@
  let slow_reduce = slow_idx2 | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 20) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 20) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 20) min in let before = (end, count) sub in let keep = (((20, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
  let slow = slow_reduce | map(((rid, f), (_, order)) -> (rid, (order, f)));
  let top_rows = fast + slow;
-@@ -47,8 +44,7 @@
- let message_idx = message | arrange;
- let answer_join = answer_idx | join(message_idx, (id, (rid, rank, created, f), (_, _, _, _, content, image, _, _, _, _, _, _, _)) -> (f, (rid, rank, id, ((content len, 0) gt, content, image) select, created)));
- let answer_idx2 = answer_join | arrange;
--let person_idx2 = person | arrange;
--let answer = answer_idx2 | join(person_idx2, (f, (rid, rank, id, body, created), (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, rank), (f, first, last, id, body, created)));
-+let answer = answer_idx2 | join(person_idx, (f, (rid, rank, id, body, created), (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, rank), (f, first, last, id, body, created)));
- let answer_idx3 = answer | arrange;
- -- Renderer: publish the existing arrangement.
- output "answer" = answer_idx3;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic09_oneoff.optimized--projected.diff b/interactive/tests/plan_pairs/expected/ldbc_ic09_oneoff.optimized--projected.diff
index c6d3255eb..0b7f8becb 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic09_oneoff.optimized--projected.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic09_oneoff.optimized--projected.diff
@@ -1,7 +1,7 @@
 --- optimized
 +++ projected
-@@ -34,7 +34,7 @@
- let slow_join = slow_idx | join(by_author_idx, (f, (rid, max, _), (neg, id)) -> ((rid, f), ((neg, id), max)));
+@@ -29,7 +29,7 @@
+ let slow_join = slow_idx | join(by_author, (f, (rid, max, _), (neg, id)) -> ((rid, f), ((neg, id), max)));
  let slow_rows = slow_join | filter((_, ((neg, _), max)) -> (neg neg, max) lt) | map((key, (order, _)) -> (key, order));
  let slow_idx2 = slow_rows | arrange;
 -let slow_reduce = slow_idx2 | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 20) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 20) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 20) min in let before = (end, count) sub in let keep = (((20, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic09_oneoff.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/ldbc_ic09_oneoff.parsed--lowered.diff
index 066fd252c..fc557ee77 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic09_oneoff.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic09_oneoff.parsed--lowered.diff
@@ -6,7 +6,7 @@
  let request = input 0 : ((int, int, int), ());
  let person = import "graph::person" : (int, (List(int), List(int), List(int), int, int, List(int), List(int), int, int, int, int));
  let message = import "graph::message" : (int, (int, int, int, int, List(int), List(int), int, List(int), int, int, int, int, int));
-@@ -5,12 +7,48 @@
+@@ -5,12 +7,40 @@
  let by_author = import "ic9s::by_author" : (int, (int, int));
  let latest = import "ic9s::latest" : (int, (int, int));
  let newest = import "ic9s::newest" : (int, int);
@@ -21,14 +21,11 @@
 -output "answer" = answer | arrange;
 +let hop1_map = request | map(((rid, who, max), ()) -> (who, (rid, who, max)));
 +let hop1_idx = hop1_map | arrange;
-+let person_idx = person | arrange;
-+let hop1_join = hop1_idx | join(person_idx, (who, req, _) -> (who, req));
++let hop1_join = hop1_idx | join(person, (who, req, _) -> (who, req));
 +let hop1_idx2 = hop1_join | arrange;
-+let friend_idx = friend | arrange;
-+let hop1 = hop1_idx2 | join(friend_idx, (_, req, (f, _)) -> (f, req));
++let hop1 = hop1_idx2 | join(friend, (_, req, (f, _)) -> (f, req));
 +let hop1_idx3 = hop1 | arrange;
-+let friend_idx2 = friend | arrange;
-+let hop2 = hop1_idx3 | join(friend_idx2, (_, req, (g, _)) -> (g, req));
++let hop2 = hop1_idx3 | join(friend, (_, req, (g, _)) -> (g, req));
 +let friends_rows = hop1 + hop2;
 +let friends_filter = friends_rows | filter((node, (_, who, _)) -> (node, who) ne);
 +let friends_map = friends_filter | map((node, (rid, _, max)) -> ((node, rid, max), ()));
@@ -36,16 +33,13 @@
 +let friends_reduce = friends_idx | reduce((_, vals) -> vals map (((), _) -> ((), 1)));
 +let friends = friends_reduce | map(((node, rid, max), ()) -> (node, (rid, max)));
 +let friends_idx2 = friends | arrange;
-+let newest_idx = newest | arrange;
-+let ahead = friends_idx2 | join(newest_idx, (f, (rid, max), neg) -> (f, (rid, max, neg neg)));
++let ahead = friends_idx2 | join(newest, (f, (rid, max), neg) -> (f, (rid, max, neg neg)));
 +let fast_filter = ahead | filter((_, (_, max, last)) -> (last, max) lt);
 +let fast_idx = fast_filter | arrange;
-+let latest_idx = latest | arrange;
-+let fast = fast_idx | join(latest_idx, (f, (rid, _, _), (neg, id)) -> (rid, ((neg, id), f)));
++let fast = fast_idx | join(latest, (f, (rid, _, _), (neg, id)) -> (rid, ((neg, id), f)));
 +let slow_filter = ahead | filter((_, (_, max, last)) -> (last, max) ge);
 +let slow_idx = slow_filter | arrange;
-+let by_author_idx = by_author | arrange;
-+let slow_join = slow_idx | join(by_author_idx, (f, (rid, max, _), (neg, id)) -> ((rid, f), ((neg, id), max)));
++let slow_join = slow_idx | join(by_author, (f, (rid, max, _), (neg, id)) -> ((rid, f), ((neg, id), max)));
 +let slow_filter2 = slow_join | filter((_, ((neg, _), max)) -> (neg neg, max) lt);
 +let slow_map = slow_filter2 | map((key, (order, _)) -> (key, order));
 +let slow_idx2 = slow_map | arrange;
@@ -56,11 +50,9 @@
 +let top = top_idx | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 20) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 20) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 20) min in let before = (end, count) sub in let keep = (((20, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
 +let answer_map = top | map((rid, (rank, ((neg, id), f))) -> (id, (rid, rank, neg neg, f)));
 +let answer_idx = answer_map | arrange;
-+let message_idx = message | arrange;
-+let answer_join = answer_idx | join(message_idx, (id, (rid, rank, created, f), (_, _, _, _, content, image, _, _, _, _, _, _, _)) -> (f, (rid, rank, id, ((content len, 0) gt, content, image) select, created)));
++let answer_join = answer_idx | join(message, (id, (rid, rank, created, f), (_, _, _, _, content, image, _, _, _, _, _, _, _)) -> (f, (rid, rank, id, ((content len, 0) gt, content, image) select, created)));
 +let answer_idx2 = answer_join | arrange;
-+let person_idx2 = person | arrange;
-+let answer = answer_idx2 | join(person_idx2, (f, (rid, rank, id, body, created), (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, rank), (f, first, last, id, body, created)));
++let answer = answer_idx2 | join(person, (f, (rid, rank, id, body, created), (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, rank), (f, first, last, id, body, created)));
 +let answer_idx3 = answer | arrange;
 +-- Renderer: publish the existing arrangement.
 +output "answer" = answer_idx3;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic10_oneoff.ddp b/interactive/tests/plan_pairs/expected/ldbc_ic10_oneoff.ddp
index 60e95c218..d192f292e 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic10_oneoff.ddp
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic10_oneoff.ddp
@@ -8,30 +8,25 @@ let posts = import "ic10s::posts" : (int, int);
 let likes = import "ic10s::likes" : ((int, int), ());
 let hop1_map = request | map(((rid, who, month), ()) -> (who, (rid, who, month)));
 let hop1_idx = hop1_map | arrange;
-let friend_idx = friend | arrange;
-let hop1 = hop1_idx | join(friend_idx, (_, req, (f, _)) -> (f, (req, 1)));
+let hop1 = hop1_idx | join(friend, (_, req, (f, _)) -> (f, (req, 1)));
 let hop1_idx2 = hop1 | arrange;
-let hop2 = hop1_idx2 | join(friend_idx, (_, (req, _), (g, _)) -> (g, (req, 2)));
+let hop2 = hop1_idx2 | join(friend, (_, (req, _), (g, _)) -> (g, (req, 2)));
 let twohop_rows = hop1 + hop2;
 let twohop_rows2 = twohop_rows | filter((node, ((_, who, _), _)) -> (node, who) ne) | map((node, ((rid, who, month), d)) -> ((rid, who, month, node), d));
 let twohop_idx = twohop_rows2 | arrange;
 let twohop_reduce = twohop_idx | reduce(limit 1, (_, vals) -> let first = vals head in (first.0, 1) enlist);
 let cands_rows = twohop_reduce | filter((_, d) -> (d, 2) eq) | map(((rid, who, month, node), _) -> (node, (rid, who, month)));
 let cands_idx = cands_rows | arrange;
-let people_idx = people | arrange;
-let cands_join = cands_idx | join(people_idx, (node, (rid, who, month), (first, last, gender, town, bmonth, bday)) -> ((rid, who, node), (first, last, gender, town, month, bmonth, bday)));
+let cands_join = cands_idx | join(people, (node, (rid, who, month), (first, last, gender, town, bmonth, bday)) -> ((rid, who, node), (first, last, gender, town, month, bmonth, bday)));
 let cands = cands_join | filter((_, (_, _, _, _, month, bmonth, bday)) -> (((bmonth, month) eq, (bday, 21) ge) all, ((bmonth, ((month, 12) eq, 1, (month, 1) add) select) eq, (bday, 22) lt) all) any) | map((key, (first, last, gender, town, _, _, _)) -> (key, (first, last, gender, town)));
 let wrote_map = cands | map(((rid, who, node), _) -> (node, (rid, who)));
 let wrote_idx = wrote_map | arrange;
-let posts_idx = posts | arrange;
-let wrote = wrote_idx | join(posts_idx, (node, (rid, who), m) -> ((rid, who, node, m), ()));
+let wrote = wrote_idx | join(posts, (node, (rid, who), m) -> ((rid, who, node, m), ()));
 let liked_map = wrote | map(((rid, who, node, m), ()) -> (m, (rid, who, node)));
 let liked_idx = liked_map | arrange;
-let tags_of_idx = tags_of | arrange;
-let liked_join = liked_idx | join(tags_of_idx, (m, (rid, who, node), t) -> ((who, t), (rid, node, m)));
+let liked_join = liked_idx | join(tags_of, (m, (rid, who, node), t) -> ((who, t), (rid, node, m)));
 let liked_idx2 = liked_join | arrange;
-let likes_idx = likes | arrange;
-let liked_join2 = liked_idx2 | join(likes_idx, ((who, _), (rid, node, m), ()) -> ((rid, who, node, m), ()));
+let liked_join2 = liked_idx2 | join(likes, ((who, _), (rid, node, m), ()) -> ((rid, who, node, m), ()));
 let liked_idx3 = liked_join2 | arrange;
 let liked = liked_idx3 | reduce((_, vals) -> vals map (((), _) -> ((), 1)));
 let points_map = liked | map(((rid, who, node, _), ()) -> ((rid, who, node), 1));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic10_oneoff.lowered--optimized.diff b/interactive/tests/plan_pairs/expected/ldbc_ic10_oneoff.lowered--optimized.diff
index 39451088a..f5e5a2205 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic10_oneoff.lowered--optimized.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic10_oneoff.lowered--optimized.diff
@@ -13,13 +13,9 @@
  let people = import "ic10s::people" : (int, (List(int), List(int), List(int), List(int), int, int));
  let posts = import "ic10s::posts" : (int, int);
  let likes = import "ic10s::likes" : ((int, int), ());
-@@ -15,20 +11,16 @@
- let friend_idx = friend | arrange;
- let hop1 = hop1_idx | join(friend_idx, (_, req, (f, _)) -> (f, (req, 1)));
+@@ -16,16 +12,13 @@
  let hop1_idx2 = hop1 | arrange;
--let friend_idx2 = friend | arrange;
--let hop2 = hop1_idx2 | join(friend_idx2, (_, (req, _), (g, _)) -> (g, (req, 2)));
-+let hop2 = hop1_idx2 | join(friend_idx, (_, (req, _), (g, _)) -> (g, (req, 2)));
+ let hop2 = hop1_idx2 | join(friend, (_, (req, _), (g, _)) -> (g, (req, 2)));
  let twohop_rows = hop1 + hop2;
 -let twohop_filter = twohop_rows | filter((node, ((_, who, _), _)) -> (node, who) ne);
 -let twohop_map = twohop_filter | map((node, ((rid, who, month), d)) -> ((rid, who, month, node), d));
@@ -32,11 +28,10 @@
 -let cands_idx = cands_map | arrange;
 +let cands_rows = twohop_reduce | filter((_, d) -> (d, 2) eq) | map(((rid, who, month, node), _) -> (node, (rid, who, month)));
 +let cands_idx = cands_rows | arrange;
- let people_idx = people | arrange;
- let cands_join = cands_idx | join(people_idx, (node, (rid, who, month), (first, last, gender, town, bmonth, bday)) -> ((rid, who, node), (first, last, gender, town, month, bmonth, bday)));
+ let cands_join = cands_idx | join(people, (node, (rid, who, month), (first, last, gender, town, bmonth, bday)) -> ((rid, who, node), (first, last, gender, town, month, bmonth, bday)));
 -let cands_filter = cands_join | filter((_, (_, _, _, _, month, bmonth, bday)) -> (((bmonth, month) eq, (bday, 21) ge) all, ((bmonth, ((month, 12) eq, 1, (month, 1) add) select) eq, (bday, 22) lt) all) any);
 -let cands = cands_filter | map((key, (first, last, gender, town, _, _, _)) -> (key, (first, last, gender, town)));
 +let cands = cands_join | filter((_, (_, _, _, _, month, bmonth, bday)) -> (((bmonth, month) eq, (bday, 21) ge) all, ((bmonth, ((month, 12) eq, 1, (month, 1) add) select) eq, (bday, 22) lt) all) any) | map((key, (first, last, gender, town, _, _, _)) -> (key, (first, last, gender, town)));
  let wrote_map = cands | map(((rid, who, node), _) -> (node, (rid, who)));
  let wrote_idx = wrote_map | arrange;
- let posts_idx = posts | arrange;
+ let wrote = wrote_idx | join(posts, (node, (rid, who), m) -> ((rid, who, node, m), ()));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic10_oneoff.optimized--projected.diff b/interactive/tests/plan_pairs/expected/ldbc_ic10_oneoff.optimized--projected.diff
index a28c9a1c0..3acdc458a 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic10_oneoff.optimized--projected.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic10_oneoff.optimized--projected.diff
@@ -1,6 +1,6 @@
 --- optimized
 +++ projected
-@@ -35,10 +35,11 @@
+@@ -30,10 +30,11 @@
  let liked_idx3 = liked_join2 | arrange;
  let liked = liked_idx3 | reduce((_, vals) -> vals map (((), _) -> ((), 1)));
  let points_map = liked | map(((rid, who, node, _), ()) -> ((rid, who, node), 1));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic10_oneoff.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/ldbc_ic10_oneoff.parsed--lowered.diff
index 583b2db0b..876f96438 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic10_oneoff.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic10_oneoff.parsed--lowered.diff
@@ -6,7 +6,7 @@
  let request = input 0 : ((int, int, int), ());
  let person = import "graph::person" : (int, (List(int), List(int), List(int), int, int, List(int), List(int), int, int, int, int));
  let message = import "graph::message" : (int, (int, int, int, int, List(int), List(int), int, List(int), int, int, int, int, int));
-@@ -8,16 +10,59 @@
+@@ -8,16 +10,53 @@
  let people = import "ic10s::people" : (int, (List(int), List(int), List(int), List(int), int, int));
  let posts = import "ic10s::posts" : (int, int);
  let likes = import "ic10s::likes" : ((int, int), ());
@@ -20,11 +20,9 @@
 -let summed = points | join_function((key, p) -> ((key, ()), (0), p) enlist) | reduce((_, vals) -> let diffs = vals map ((_, d) -> d) in let n = diffs fold_add in (n, (n, 1)) enlist filter);
 +let hop1_map = request | map(((rid, who, month), ()) -> (who, (rid, who, month)));
 +let hop1_idx = hop1_map | arrange;
-+let friend_idx = friend | arrange;
-+let hop1 = hop1_idx | join(friend_idx, (_, req, (f, _)) -> (f, (req, 1)));
++let hop1 = hop1_idx | join(friend, (_, req, (f, _)) -> (f, (req, 1)));
 +let hop1_idx2 = hop1 | arrange;
-+let friend_idx2 = friend | arrange;
-+let hop2 = hop1_idx2 | join(friend_idx2, (_, (req, _), (g, _)) -> (g, (req, 2)));
++let hop2 = hop1_idx2 | join(friend, (_, (req, _), (g, _)) -> (g, (req, 2)));
 +let twohop_rows = hop1 + hop2;
 +let twohop_filter = twohop_rows | filter((node, ((_, who, _), _)) -> (node, who) ne);
 +let twohop_map = twohop_filter | map((node, ((rid, who, month), d)) -> ((rid, who, month, node), d));
@@ -33,21 +31,17 @@
 +let twohop = twohop_reduce | filter((_, d) -> (d, 2) eq);
 +let cands_map = twohop | map(((rid, who, month, node), _) -> (node, (rid, who, month)));
 +let cands_idx = cands_map | arrange;
-+let people_idx = people | arrange;
-+let cands_join = cands_idx | join(people_idx, (node, (rid, who, month), (first, last, gender, town, bmonth, bday)) -> ((rid, who, node), (first, last, gender, town, month, bmonth, bday)));
++let cands_join = cands_idx | join(people, (node, (rid, who, month), (first, last, gender, town, bmonth, bday)) -> ((rid, who, node), (first, last, gender, town, month, bmonth, bday)));
 +let cands_filter = cands_join | filter((_, (_, _, _, _, month, bmonth, bday)) -> (((bmonth, month) eq, (bday, 21) ge) all, ((bmonth, ((month, 12) eq, 1, (month, 1) add) select) eq, (bday, 22) lt) all) any);
 +let cands = cands_filter | map((key, (first, last, gender, town, _, _, _)) -> (key, (first, last, gender, town)));
 +let wrote_map = cands | map(((rid, who, node), _) -> (node, (rid, who)));
 +let wrote_idx = wrote_map | arrange;
-+let posts_idx = posts | arrange;
-+let wrote = wrote_idx | join(posts_idx, (node, (rid, who), m) -> ((rid, who, node, m), ()));
++let wrote = wrote_idx | join(posts, (node, (rid, who), m) -> ((rid, who, node, m), ()));
 +let liked_map = wrote | map(((rid, who, node, m), ()) -> (m, (rid, who, node)));
 +let liked_idx = liked_map | arrange;
-+let tags_of_idx = tags_of | arrange;
-+let liked_join = liked_idx | join(tags_of_idx, (m, (rid, who, node), t) -> ((who, t), (rid, node, m)));
++let liked_join = liked_idx | join(tags_of, (m, (rid, who, node), t) -> ((who, t), (rid, node, m)));
 +let liked_idx2 = liked_join | arrange;
-+let likes_idx = likes | arrange;
-+let liked_join2 = liked_idx2 | join(likes_idx, ((who, _), (rid, node, m), ()) -> ((rid, who, node, m), ()));
++let liked_join2 = liked_idx2 | join(likes, ((who, _), (rid, node, m), ()) -> ((rid, who, node, m), ()));
 +let liked_idx3 = liked_join2 | arrange;
 +let liked = liked_idx3 | reduce((_, vals) -> vals map (((), _) -> ((), 1)));
 +let points_map = liked | map(((rid, who, node, _), ()) -> ((rid, who, node), 1));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic10_standing.ddp b/interactive/tests/plan_pairs/expected/ldbc_ic10_standing.ddp
index 697d6ee13..ddde2b17e 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic10_standing.ddp
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic10_standing.ddp
@@ -6,8 +6,7 @@ let place = import "graph::place" : (int, (List(int), List(int), int));
 let interest = import "graph::interest.by_person" : (int, int);
 let people_map = person | map((id, (first, last, gender, _, _, _, _, home, bmonth, bday, _)) -> (home, (id, first, last, gender, bmonth, bday)));
 let people_idx = people_map | arrange;
-let place_idx = place | arrange;
-let people = people_idx | join(place_idx, (_, (id, first, last, gender, bmonth, bday), (town, _, _)) -> (id, (first, last, gender, town, bmonth, bday)));
+let people = people_idx | join(place, (_, (id, first, last, gender, bmonth, bday), (town, _, _)) -> (id, (first, last, gender, town, bmonth, bday)));
 let posts = message | filter((_, (kind, _, _, _, _, _, _, _, _, _, _, _, _)) -> (kind, 0) eq) | map((id, (_, _, who, _, _, _, _, _, _, _, _, _, _)) -> (who, id));
 let likes = interest | map((p, t) -> ((p, t), ()));
 let people_idx2 = people | arrange;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic10_standing.lowered--optimized.diff b/interactive/tests/plan_pairs/expected/ldbc_ic10_standing.lowered--optimized.diff
index a30233b3a..40d9b5b61 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic10_standing.lowered--optimized.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic10_standing.lowered--optimized.diff
@@ -1,6 +1,6 @@
 --- lowered
 +++ optimized
-@@ -2,16 +2,13 @@
+@@ -2,15 +2,12 @@
  -- Trace imports use provider arrangements; history advances to G = (0, []).
  let person = import "graph::person" : (int, (List(int), List(int), List(int), int, int, List(int), List(int), int, int, int, int));
  let message = import "graph::message" : (int, (int, int, int, int, List(int), List(int), int, List(int), int, int, int, int, int));
@@ -10,8 +10,7 @@
  let interest = import "graph::interest.by_person" : (int, int);
  let people_map = person | map((id, (first, last, gender, _, _, _, _, home, bmonth, bday, _)) -> (home, (id, first, last, gender, bmonth, bday)));
  let people_idx = people_map | arrange;
- let place_idx = place | arrange;
- let people = people_idx | join(place_idx, (_, (id, first, last, gender, bmonth, bday), (town, _, _)) -> (id, (first, last, gender, town, bmonth, bday)));
+ let people = people_idx | join(place, (_, (id, first, last, gender, bmonth, bday), (town, _, _)) -> (id, (first, last, gender, town, bmonth, bday)));
 -let posts_filter = message | filter((_, (kind, _, _, _, _, _, _, _, _, _, _, _, _)) -> (kind, 0) eq);
 -let posts = posts_filter | map((id, (_, _, who, _, _, _, _, _, _, _, _, _, _)) -> (who, id));
 +let posts = message | filter((_, (kind, _, _, _, _, _, _, _, _, _, _, _, _)) -> (kind, 0) eq) | map((id, (_, _, who, _, _, _, _, _, _, _, _, _, _)) -> (who, id));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic10_standing.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/ldbc_ic10_standing.parsed--lowered.diff
index 0c15102e6..049bb3d1f 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic10_standing.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic10_standing.parsed--lowered.diff
@@ -1,6 +1,6 @@
 --- parsed
 +++ lowered
-@@ -1,12 +1,24 @@
+@@ -1,12 +1,23 @@
 +-- Time lanes: epoch.
 +-- Trace imports use provider arrangements; history advances to G = (0, []).
  let person = import "graph::person" : (int, (List(int), List(int), List(int), int, int, List(int), List(int), int, int, int, int));
@@ -13,8 +13,7 @@
 -let posts = message | filter((_, (kind, _, _, _, _, _, _, _, _, _, _, _, _)) -> (kind, 0) eq) | map((id, (_, _, who, _, _, _, _, _, _, _, _, _, _)) -> (who, id));
 +let people_map = person | map((id, (first, last, gender, _, _, _, _, home, bmonth, bday, _)) -> (home, (id, first, last, gender, bmonth, bday)));
 +let people_idx = people_map | arrange;
-+let place_idx = place | arrange;
-+let people = people_idx | join(place_idx, (_, (id, first, last, gender, bmonth, bday), (town, _, _)) -> (id, (first, last, gender, town, bmonth, bday)));
++let people = people_idx | join(place, (_, (id, first, last, gender, bmonth, bday), (town, _, _)) -> (id, (first, last, gender, town, bmonth, bday)));
 +let posts_filter = message | filter((_, (kind, _, _, _, _, _, _, _, _, _, _, _, _)) -> (kind, 0) eq);
 +let posts = posts_filter | map((id, (_, _, who, _, _, _, _, _, _, _, _, _, _)) -> (who, id));
  let likes = interest | map((p, t) -> ((p, t), ()));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic11_oneoff.ddp b/interactive/tests/plan_pairs/expected/ldbc_ic11_oneoff.ddp
index 8e51eb164..1692d8b32 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic11_oneoff.ddp
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic11_oneoff.ddp
@@ -8,34 +8,29 @@ let org = import "graph::org" : (int, (List(int), List(int), int));
 let place = import "graph::place" : (int, (List(int), List(int), int));
 let hop1_map = request | map(((rid, who, country, year), ()) -> (who, (rid, who, country, year)));
 let hop1_idx = hop1_map | arrange;
-let person_idx = person | arrange;
-let hop1_join = hop1_idx | join(person_idx, (who, req, _) -> (who, req));
+let hop1_join = hop1_idx | join(person, (who, req, _) -> (who, req));
 let hop1_idx2 = hop1_join | arrange;
-let friend_idx = friend | arrange;
-let hop1 = hop1_idx2 | join(friend_idx, (_, req, (f, _)) -> (f, req));
+let hop1 = hop1_idx2 | join(friend, (_, req, (f, _)) -> (f, req));
 let hop1_idx3 = hop1 | arrange;
-let hop2 = hop1_idx3 | join(friend_idx, (_, req, (g, _)) -> (g, req));
+let hop2 = hop1_idx3 | join(friend, (_, req, (g, _)) -> (g, req));
 let circle_rows = hop1 + hop2;
 let circle_rows2 = circle_rows | filter((node, (_, who, _, _)) -> (node, who) ne) | map((node, (rid, _, country, year)) -> ((node, rid, country, year), ()));
 let circle_idx = circle_rows2 | arrange;
 let circle = circle_idx | reduce((_, vals) -> vals map (((), _) -> ((), 1)));
 let jobs_map = circle | map(((node, rid, country, year), ()) -> (node, (rid, country, year)));
 let jobs_idx = jobs_map | arrange;
-let work_idx = work | arrange;
-let jobs_join = jobs_idx | join(work_idx, (node, (rid, country, year), (at, since)) -> (at, (rid, node, country, year, since)));
+let jobs_join = jobs_idx | join(work, (node, (rid, country, year), (at, since)) -> (at, (rid, node, country, year, since)));
 let jobs_filter = jobs_join | filter((_, (_, _, _, year, since)) -> (since, year) lt);
 let jobs_idx2 = jobs_filter | arrange;
-let org_idx = org | arrange;
-let jobs_join2 = jobs_idx2 | join(org_idx, (_, (rid, node, country, _, since), (company, _, located)) -> (located, ((rid, since, node), (company, country))));
+let jobs_join2 = jobs_idx2 | join(org, (_, (rid, node, country, _, since), (company, _, located)) -> (located, ((rid, since, node), (company, country))));
 let jobs_idx3 = jobs_join2 | arrange;
-let place_idx = place | arrange;
-let jobs_join3 = jobs_idx3 | join(place_idx, (_, (key, (company, country)), (there, _, _)) -> (key, (company, country, there)));
+let jobs_join3 = jobs_idx3 | join(place, (_, (key, (company, country)), (there, _, _)) -> (key, (company, country, there)));
 let jobs = jobs_join3 | filter((_, (_, country, there)) -> (country, there) eq) | map((key, (company, _, _)) -> (key, company));
 let jobs_idx4 = jobs | arrange;
 let named_reduce = jobs_idx4 | reduce((_, vals) -> let lists = vals map ((v, d) -> (v, (0, d) range) cap_list map ((v, _) -> v)) in let flat = lists flatten in (flat.1, 1) enlist);
 let ranked_rows = named_reduce | flatmap((_, entries) -> entries) | map(((rid, since, node), (pos, company)) -> (node, (rid, since, pos, company)));
 let ranked_idx = ranked_rows | arrange;
-let ranked_join = ranked_idx | join(person_idx, (node, (rid, since, pos, company), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((since, node, pos neg), (first, last, company))));
+let ranked_join = ranked_idx | join(person, (node, (rid, since, pos, company), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((since, node, pos neg), (first, last, company))));
 let ranked_idx2 = ranked_join | arrange;
 let ranked = ranked_idx2 | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 10) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 10) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 10) min in let before = (end, count) sub in let keep = (((10, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
 let answer = ranked | map((rid, (rank, ((since, node, _), (first, last, company)))) -> ((rid, rank), (node, first, last, company, since)));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic11_oneoff.lowered--optimized.diff b/interactive/tests/plan_pairs/expected/ldbc_ic11_oneoff.lowered--optimized.diff
index 4812e9483..09078cb78 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic11_oneoff.lowered--optimized.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic11_oneoff.lowered--optimized.diff
@@ -1,12 +1,8 @@
 --- lowered
 +++ optimized
-@@ -14,12 +14,10 @@
- let friend_idx = friend | arrange;
- let hop1 = hop1_idx2 | join(friend_idx, (_, req, (f, _)) -> (f, req));
+@@ -14,9 +14,8 @@
  let hop1_idx3 = hop1 | arrange;
--let friend_idx2 = friend | arrange;
--let hop2 = hop1_idx3 | join(friend_idx2, (_, req, (g, _)) -> (g, req));
-+let hop2 = hop1_idx3 | join(friend_idx, (_, req, (g, _)) -> (g, req));
+ let hop2 = hop1_idx3 | join(friend, (_, req, (g, _)) -> (g, req));
  let circle_rows = hop1 + hop2;
 -let circle_filter = circle_rows | filter((node, (_, who, _, _)) -> (node, who) ne);
 -let circle_map = circle_filter | map((node, (rid, _, country, year)) -> ((node, rid, country, year), ()));
@@ -16,10 +12,10 @@
  let circle = circle_idx | reduce((_, vals) -> vals map (((), _) -> ((), 1)));
  let jobs_map = circle | map(((node, rid, country, year), ()) -> (node, (rid, country, year)));
  let jobs_idx = jobs_map | arrange;
-@@ -32,15 +30,12 @@
+@@ -26,13 +25,11 @@
+ let jobs_join2 = jobs_idx2 | join(org, (_, (rid, node, country, _, since), (company, _, located)) -> (located, ((rid, since, node), (company, country))));
  let jobs_idx3 = jobs_join2 | arrange;
- let place_idx = place | arrange;
- let jobs_join3 = jobs_idx3 | join(place_idx, (_, (key, (company, country)), (there, _, _)) -> (key, (company, country, there)));
+ let jobs_join3 = jobs_idx3 | join(place, (_, (key, (company, country)), (there, _, _)) -> (key, (company, country, there)));
 -let jobs_filter2 = jobs_join3 | filter((_, (_, country, there)) -> (country, there) eq);
 -let jobs = jobs_filter2 | map((key, (company, _, _)) -> (key, company));
 +let jobs = jobs_join3 | filter((_, (_, country, there)) -> (country, there) eq) | map((key, (company, _, _)) -> (key, company));
@@ -28,11 +24,8 @@
 -let named = named_reduce | flatmap((_, entries) -> entries);
 -let ranked_map = named | map(((rid, since, node), (pos, company)) -> (node, (rid, since, pos, company)));
 -let ranked_idx = ranked_map | arrange;
--let person_idx2 = person | arrange;
--let ranked_join = ranked_idx | join(person_idx2, (node, (rid, since, pos, company), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((since, node, pos neg), (first, last, company))));
 +let ranked_rows = named_reduce | flatmap((_, entries) -> entries) | map(((rid, since, node), (pos, company)) -> (node, (rid, since, pos, company)));
 +let ranked_idx = ranked_rows | arrange;
-+let ranked_join = ranked_idx | join(person_idx, (node, (rid, since, pos, company), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((since, node, pos neg), (first, last, company))));
+ let ranked_join = ranked_idx | join(person, (node, (rid, since, pos, company), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((since, node, pos neg), (first, last, company))));
  let ranked_idx2 = ranked_join | arrange;
  let ranked = ranked_idx2 | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 10) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 10) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 10) min in let before = (end, count) sub in let keep = (((10, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
- let answer = ranked | map((rid, (rank, ((since, node, _), (first, last, company)))) -> ((rid, rank), (node, first, last, company, since)));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic11_oneoff.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/ldbc_ic11_oneoff.parsed--lowered.diff
index 1ff2a9cf0..818eec877 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic11_oneoff.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic11_oneoff.parsed--lowered.diff
@@ -1,6 +1,6 @@
 --- parsed
 +++ lowered
-@@ -1,14 +1,49 @@
+@@ -1,14 +1,42 @@
 +-- Time lanes: epoch.
 +-- Trace imports use provider arrangements; history advances to G = (0, []).
  let request = input 0 : ((int, int, List(int), int), ());
@@ -17,14 +17,11 @@
 -let ranked = named | map(((rid, since, node), (pos, company)) -> (node, (rid, since, pos, company))) | join(person, (node, (rid, since, pos, company), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((since, node, pos neg), (first, last, company)))) | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 10) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 10) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 10) min in let before = (end, count) sub in let keep = (((10, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
 +let hop1_map = request | map(((rid, who, country, year), ()) -> (who, (rid, who, country, year)));
 +let hop1_idx = hop1_map | arrange;
-+let person_idx = person | arrange;
-+let hop1_join = hop1_idx | join(person_idx, (who, req, _) -> (who, req));
++let hop1_join = hop1_idx | join(person, (who, req, _) -> (who, req));
 +let hop1_idx2 = hop1_join | arrange;
-+let friend_idx = friend | arrange;
-+let hop1 = hop1_idx2 | join(friend_idx, (_, req, (f, _)) -> (f, req));
++let hop1 = hop1_idx2 | join(friend, (_, req, (f, _)) -> (f, req));
 +let hop1_idx3 = hop1 | arrange;
-+let friend_idx2 = friend | arrange;
-+let hop2 = hop1_idx3 | join(friend_idx2, (_, req, (g, _)) -> (g, req));
++let hop2 = hop1_idx3 | join(friend, (_, req, (g, _)) -> (g, req));
 +let circle_rows = hop1 + hop2;
 +let circle_filter = circle_rows | filter((node, (_, who, _, _)) -> (node, who) ne);
 +let circle_map = circle_filter | map((node, (rid, _, country, year)) -> ((node, rid, country, year), ()));
@@ -32,15 +29,12 @@
 +let circle = circle_idx | reduce((_, vals) -> vals map (((), _) -> ((), 1)));
 +let jobs_map = circle | map(((node, rid, country, year), ()) -> (node, (rid, country, year)));
 +let jobs_idx = jobs_map | arrange;
-+let work_idx = work | arrange;
-+let jobs_join = jobs_idx | join(work_idx, (node, (rid, country, year), (at, since)) -> (at, (rid, node, country, year, since)));
++let jobs_join = jobs_idx | join(work, (node, (rid, country, year), (at, since)) -> (at, (rid, node, country, year, since)));
 +let jobs_filter = jobs_join | filter((_, (_, _, _, year, since)) -> (since, year) lt);
 +let jobs_idx2 = jobs_filter | arrange;
-+let org_idx = org | arrange;
-+let jobs_join2 = jobs_idx2 | join(org_idx, (_, (rid, node, country, _, since), (company, _, located)) -> (located, ((rid, since, node), (company, country))));
++let jobs_join2 = jobs_idx2 | join(org, (_, (rid, node, country, _, since), (company, _, located)) -> (located, ((rid, since, node), (company, country))));
 +let jobs_idx3 = jobs_join2 | arrange;
-+let place_idx = place | arrange;
-+let jobs_join3 = jobs_idx3 | join(place_idx, (_, (key, (company, country)), (there, _, _)) -> (key, (company, country, there)));
++let jobs_join3 = jobs_idx3 | join(place, (_, (key, (company, country)), (there, _, _)) -> (key, (company, country, there)));
 +let jobs_filter2 = jobs_join3 | filter((_, (_, country, there)) -> (country, there) eq);
 +let jobs = jobs_filter2 | map((key, (company, _, _)) -> (key, company));
 +let jobs_idx4 = jobs | arrange;
@@ -48,8 +42,7 @@
 +let named = named_reduce | flatmap((_, entries) -> entries);
 +let ranked_map = named | map(((rid, since, node), (pos, company)) -> (node, (rid, since, pos, company)));
 +let ranked_idx = ranked_map | arrange;
-+let person_idx2 = person | arrange;
-+let ranked_join = ranked_idx | join(person_idx2, (node, (rid, since, pos, company), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((since, node, pos neg), (first, last, company))));
++let ranked_join = ranked_idx | join(person, (node, (rid, since, pos, company), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((since, node, pos neg), (first, last, company))));
 +let ranked_idx2 = ranked_join | arrange;
 +let ranked = ranked_idx2 | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 10) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 10) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 10) min in let before = (end, count) sub in let keep = (((10, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
  let answer = ranked | map((rid, (rank, ((since, node, _), (first, last, company)))) -> ((rid, rank), (node, first, last, company, since)));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic12_oneoff.ddp b/interactive/tests/plan_pairs/expected/ldbc_ic12_oneoff.ddp
index 87b54fff3..97d524fff 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic12_oneoff.ddp
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic12_oneoff.ddp
@@ -12,30 +12,22 @@ let below_hl = import "ic12s::below_hl" : (int, int);
 let reply = import "ic12s::reply" : (int, (int, int));
 let intag_map = request | map(((rid, _, name), ()) -> (name, rid));
 let intag_idx = intag_map | arrange;
-let classes_idx = classes | arrange;
-let intag_join = intag_idx | join(classes_idx, (_, rid, high) -> (high, rid));
+let intag_join = intag_idx | join(classes, (_, rid, high) -> (high, rid));
 let intag_idx2 = intag_join | arrange;
-let below_hl_idx = below_hl | arrange;
-let intag_join2 = intag_idx2 | join(below_hl_idx, (_, rid, low) -> (low, rid));
+let intag_join2 = intag_idx2 | join(below_hl, (_, rid, low) -> (low, rid));
 let intag_idx3 = intag_join2 | arrange;
-let by_class_idx = by_class | arrange;
-let intag_join3 = intag_idx3 | join(by_class_idx, (_, rid, t) -> (t, rid));
+let intag_join3 = intag_idx3 | join(by_class, (_, rid, t) -> (t, rid));
 let intag_idx4 = intag_join3 | arrange;
-let tag_idx = tag | arrange;
-let intag_join4 = intag_idx4 | join(tag_idx, (t, rid, (name, _)) -> (t, (rid, name)));
+let intag_join4 = intag_idx4 | join(tag, (t, rid, (name, _)) -> (t, (rid, name)));
 let intag_idx5 = intag_join4 | arrange;
-let mtag_idx = mtag | arrange;
-let intag_join5 = intag_idx5 | join(mtag_idx, (_, (rid, name), m) -> (m, (rid, name)));
+let intag_join5 = intag_idx5 | join(mtag, (_, (rid, name), m) -> (m, (rid, name)));
 let intag_idx6 = intag_join5 | arrange;
-let message_idx = message | arrange;
-let intag_join6 = intag_idx6 | join(message_idx, (m, (rid, name), (kind, _, _, _, _, _, _, _, _, _, _, _, _)) -> ((rid, m, name), kind));
+let intag_join6 = intag_idx6 | join(message, (m, (rid, name), (kind, _, _, _, _, _, _, _, _, _, _, _, _)) -> ((rid, m, name), kind));
 let hits_map = request | map(((rid, who, _), ()) -> (who, rid));
 let hits_idx = hits_map | arrange;
-let friend_idx = friend | arrange;
-let hits_join = hits_idx | join(friend_idx, (_, rid, (f, _)) -> (f, rid));
+let hits_join = hits_idx | join(friend, (_, rid, (f, _)) -> (f, rid));
 let hits_idx2 = hits_join | arrange;
-let reply_idx = reply | arrange;
-let hits_join2 = hits_idx2 | join(reply_idx, (f, rid, (id, parent)) -> ((rid, parent), (f, id)));
+let hits_join2 = hits_idx2 | join(reply, (f, rid, (id, parent)) -> ((rid, parent), (f, id)));
 let hits_idx3 = hits_join2 | arrange;
 let hits_rows = intag_join6 | filter((_, kind) -> (kind, 0) eq) | map(((a, b, c), _) -> ((a, b), c));
 let hits_idx4 = hits_rows | arrange;
@@ -54,8 +46,7 @@ let tagset_idx2 = tagset_map2 | arrange;
 let tagset = tagset_idx2 | reduce((_, vals) -> let lists = vals map ((v, d) -> (v, (0, d) range) cap_list map ((v, _) -> v)) in let flat = lists flatten in (flat.1, 1) enlist);
 let ranked_join = counts | join(tagset, ((rid, f), n, list) -> (f, (rid, n, list)));
 let ranked_idx = ranked_join | arrange;
-let person_idx = person | arrange;
-let ranked_join2 = ranked_idx | join(person_idx, (f, (rid, n, list), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((n neg, f), (first, last, list))));
+let ranked_join2 = ranked_idx | join(person, (f, (rid, n, list), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((n neg, f), (first, last, list))));
 let ranked_idx2 = ranked_join2 | arrange;
 let ranked = ranked_idx2 | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 20) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 20) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 20) min in let before = (end, count) sub in let keep = (((20, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
 let answer = ranked | map((rid, (rank, ((neg, f), (first, last, list)))) -> ((rid, rank), (f, first, last, list, neg neg)));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic12_oneoff.lowered--optimized.diff b/interactive/tests/plan_pairs/expected/ldbc_ic12_oneoff.lowered--optimized.diff
index 45a66d793..a3f132768 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic12_oneoff.lowered--optimized.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic12_oneoff.lowered--optimized.diff
@@ -8,18 +8,17 @@
  let classes = import "graph::tagclass.by_name" : (List(int), int);
  let mtag = import "graph::mtag.by_tag" : (int, int);
  let below_hl = import "ic12s::below_hl" : (int, int);
-@@ -30,8 +29,6 @@
+@@ -24,16 +23,14 @@
+ let intag_join5 = intag_idx5 | join(mtag, (_, (rid, name), m) -> (m, (rid, name)));
  let intag_idx6 = intag_join5 | arrange;
- let message_idx = message | arrange;
- let intag_join6 = intag_idx6 | join(message_idx, (m, (rid, name), (kind, _, _, _, _, _, _, _, _, _, _, _, _)) -> ((rid, m, name), kind));
+ let intag_join6 = intag_idx6 | join(message, (m, (rid, name), (kind, _, _, _, _, _, _, _, _, _, _, _, _)) -> ((rid, m, name), kind));
 -let intag_filter = intag_join6 | filter((_, kind) -> (kind, 0) eq);
 -let intag = intag_filter | map((key, _) -> (key, ()));
  let hits_map = request | map(((rid, who, _), ()) -> (who, rid));
  let hits_idx = hits_map | arrange;
- let friend_idx = friend | arrange;
-@@ -40,8 +37,8 @@
- let reply_idx = reply | arrange;
- let hits_join2 = hits_idx2 | join(reply_idx, (f, rid, (id, parent)) -> ((rid, parent), (f, id)));
+ let hits_join = hits_idx | join(friend, (_, rid, (f, _)) -> (f, rid));
+ let hits_idx2 = hits_join | arrange;
+ let hits_join2 = hits_idx2 | join(reply, (f, rid, (id, parent)) -> ((rid, parent), (f, id)));
  let hits_idx3 = hits_join2 | arrange;
 -let hits_map2 = intag | map(((rid, m, name), ()) -> ((rid, m), name));
 -let hits_idx4 = hits_map2 | arrange;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic12_oneoff.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/ldbc_ic12_oneoff.parsed--lowered.diff
index 0fa297913..4eac7d0de 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic12_oneoff.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic12_oneoff.parsed--lowered.diff
@@ -6,7 +6,7 @@
  let request = input 0 : ((int, int, List(int)), ());
  let person = import "graph::person" : (int, (List(int), List(int), List(int), int, int, List(int), List(int), int, int, int, int));
  let message = import "graph::message" : (int, (int, int, int, int, List(int), List(int), int, List(int), int, int, int, int, int));
-@@ -9,10 +11,57 @@
+@@ -9,10 +11,48 @@
  let mtag = import "graph::mtag.by_tag" : (int, int);
  let below_hl = import "ic12s::below_hl" : (int, int);
  let reply = import "ic12s::reply" : (int, (int, int));
@@ -17,32 +17,24 @@
 -let ranked = counts | join(tagset, ((rid, f), n, list) -> (f, (rid, n, list))) | join(person, (f, (rid, n, list), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((n neg, f), (first, last, list)))) | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 20) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 20) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 20) min in let before = (end, count) sub in let keep = (((20, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
 +let intag_map = request | map(((rid, _, name), ()) -> (name, rid));
 +let intag_idx = intag_map | arrange;
-+let classes_idx = classes | arrange;
-+let intag_join = intag_idx | join(classes_idx, (_, rid, high) -> (high, rid));
++let intag_join = intag_idx | join(classes, (_, rid, high) -> (high, rid));
 +let intag_idx2 = intag_join | arrange;
-+let below_hl_idx = below_hl | arrange;
-+let intag_join2 = intag_idx2 | join(below_hl_idx, (_, rid, low) -> (low, rid));
++let intag_join2 = intag_idx2 | join(below_hl, (_, rid, low) -> (low, rid));
 +let intag_idx3 = intag_join2 | arrange;
-+let by_class_idx = by_class | arrange;
-+let intag_join3 = intag_idx3 | join(by_class_idx, (_, rid, t) -> (t, rid));
++let intag_join3 = intag_idx3 | join(by_class, (_, rid, t) -> (t, rid));
 +let intag_idx4 = intag_join3 | arrange;
-+let tag_idx = tag | arrange;
-+let intag_join4 = intag_idx4 | join(tag_idx, (t, rid, (name, _)) -> (t, (rid, name)));
++let intag_join4 = intag_idx4 | join(tag, (t, rid, (name, _)) -> (t, (rid, name)));
 +let intag_idx5 = intag_join4 | arrange;
-+let mtag_idx = mtag | arrange;
-+let intag_join5 = intag_idx5 | join(mtag_idx, (_, (rid, name), m) -> (m, (rid, name)));
++let intag_join5 = intag_idx5 | join(mtag, (_, (rid, name), m) -> (m, (rid, name)));
 +let intag_idx6 = intag_join5 | arrange;
-+let message_idx = message | arrange;
-+let intag_join6 = intag_idx6 | join(message_idx, (m, (rid, name), (kind, _, _, _, _, _, _, _, _, _, _, _, _)) -> ((rid, m, name), kind));
++let intag_join6 = intag_idx6 | join(message, (m, (rid, name), (kind, _, _, _, _, _, _, _, _, _, _, _, _)) -> ((rid, m, name), kind));
 +let intag_filter = intag_join6 | filter((_, kind) -> (kind, 0) eq);
 +let intag = intag_filter | map((key, _) -> (key, ()));
 +let hits_map = request | map(((rid, who, _), ()) -> (who, rid));
 +let hits_idx = hits_map | arrange;
-+let friend_idx = friend | arrange;
-+let hits_join = hits_idx | join(friend_idx, (_, rid, (f, _)) -> (f, rid));
++let hits_join = hits_idx | join(friend, (_, rid, (f, _)) -> (f, rid));
 +let hits_idx2 = hits_join | arrange;
-+let reply_idx = reply | arrange;
-+let hits_join2 = hits_idx2 | join(reply_idx, (f, rid, (id, parent)) -> ((rid, parent), (f, id)));
++let hits_join2 = hits_idx2 | join(reply, (f, rid, (id, parent)) -> ((rid, parent), (f, id)));
 +let hits_idx3 = hits_join2 | arrange;
 +let hits_map2 = intag | map(((rid, m, name), ()) -> ((rid, m), name));
 +let hits_idx4 = hits_map2 | arrange;
@@ -61,8 +53,7 @@
 +let tagset = tagset_idx2 | reduce((_, vals) -> let lists = vals map ((v, d) -> (v, (0, d) range) cap_list map ((v, _) -> v)) in let flat = lists flatten in (flat.1, 1) enlist);
 +let ranked_join = counts | join(tagset, ((rid, f), n, list) -> (f, (rid, n, list)));
 +let ranked_idx = ranked_join | arrange;
-+let person_idx = person | arrange;
-+let ranked_join2 = ranked_idx | join(person_idx, (f, (rid, n, list), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((n neg, f), (first, last, list))));
++let ranked_join2 = ranked_idx | join(person, (f, (rid, n, list), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((n neg, f), (first, last, list))));
 +let ranked_idx2 = ranked_join2 | arrange;
 +let ranked = ranked_idx2 | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 20) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 20) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 20) min in let before = (end, count) sub in let keep = (((20, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
  let answer = ranked | map((rid, (rank, ((neg, f), (first, last, list)))) -> ((rid, rank), (f, first, last, list, neg neg)));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic12_standing.lowered--optimized.diff b/interactive/tests/plan_pairs/expected/ldbc_ic12_standing.lowered--optimized.diff
index fcae73f9d..c8499e64f 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic12_standing.lowered--optimized.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic12_standing.lowered--optimized.diff
@@ -1,6 +1,6 @@
 --- lowered
 +++ optimized
-@@ -1,31 +1,22 @@
+@@ -1,13 +1,7 @@
  -- Time lanes: epoch.
  -- Trace imports use provider arrangements; history advances to G = (0, []).
 -let person = import "graph::person" : (int, (List(int), List(int), List(int), int, int, List(int), List(int), int, int, int, int));
@@ -14,14 +14,12 @@
  let selves = tagclass | map((id, _) -> ((id, id), ()));
  below: {
      -- Time lanes: epoch, then 1 scope coordinates; this scope enters at zero.
-     var below;
+@@ -15,16 +9,14 @@
      let step_map = below | map(((low, high), ()) -> (high, low));
      let step_idx = step_map | arrange;
--    let tagclass_idx = ::tagclass | arrange;
--    let step_join = step_idx | join(tagclass_idx, (_, low, (_, parent)) -> (low, parent));
+     let step_join = step_idx | join(::tagclass, (_, low, (_, parent)) -> (low, parent));
 -    let step_filter = step_join | filter((_, parent) -> (parent, 0) ge);
 -    let step = step_filter | map((low, higher) -> ((low, higher), ()));
-+    let step_join = step_idx | join(::tagclass, (_, low, (_, parent)) -> (low, parent));
 +    let step = step_join | filter((_, parent) -> (parent, 0) ge) | map((low, higher) -> ((low, higher), ()));
      let below_rows = ::selves + step;
      let below_idx = below_rows | arrange;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic12_standing.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/ldbc_ic12_standing.parsed--lowered.diff
index 9b0d44260..393fc2b43 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic12_standing.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic12_standing.parsed--lowered.diff
@@ -6,7 +6,7 @@
  let person = import "graph::person" : (int, (List(int), List(int), List(int), int, int, List(int), List(int), int, int, int, int));
  let message = import "graph::message" : (int, (int, int, int, int, List(int), List(int), int, List(int), int, int, int, int, int));
  let friend = import "graph::friend" : (int, (int, int));
-@@ -8,10 +10,25 @@
+@@ -8,10 +10,24 @@
  let mtag = import "graph::mtag.by_tag" : (int, int);
  let selves = tagclass | map((id, _) -> ((id, id), ()));
  below: {
@@ -16,8 +16,7 @@
 +    var below;
 +    let step_map = below | map(((low, high), ()) -> (high, low));
 +    let step_idx = step_map | arrange;
-+    let tagclass_idx = ::tagclass | arrange;
-+    let step_join = step_idx | join(tagclass_idx, (_, low, (_, parent)) -> (low, parent));
++    let step_join = step_idx | join(::tagclass, (_, low, (_, parent)) -> (low, parent));
 +    let step_filter = step_join | filter((_, parent) -> (parent, 0) ge);
 +    let step = step_filter | map((low, higher) -> ((low, higher), ()));
 +    let below_rows = ::selves + step;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic13_oneoff.lowered--optimized.diff b/interactive/tests/plan_pairs/expected/ldbc_ic13_oneoff.lowered--optimized.diff
index 0c55c2117..714c0dd13 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic13_oneoff.lowered--optimized.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic13_oneoff.lowered--optimized.diff
@@ -13,7 +13,7 @@
      let side0_idx = side0 | arrange;
      let side1_idx = side1 | arrange;
      let best_join = side0_idx | join(side1_idx, ((rid, _), d0, d1) -> (rid, (d0, d1) add));
-@@ -24,15 +22,12 @@
+@@ -24,10 +22,8 @@
      let open_join = by_rid_idx | join(met_idx, (rid, row, ()) -> (rid, row));
      let open_neg = open_join | negate;
      let open = by_rid + open_neg;
@@ -26,13 +26,7 @@
      let grow_rows = open + near;
      let grow_map = grow_rows | map((rid, (side, node, d)) -> (node, (rid, side, d)));
      let grow_idx = grow_map | arrange;
--    let friend_idx = ::friend | arrange;
--    let grow = grow_idx | join(friend_idx, (_, (rid, side, d), (next, _)) -> ((rid, side, next, (d, 1) add), ()));
-+    let grow = grow_idx | join(::friend, (_, (rid, side, d), (next, _)) -> ((rid, side, next, (d, 1) add), ()));
-     let search_rows = ::starts + search + grow;
-     let search_map = search_rows | map(((rid, side, node, d), ()) -> ((rid, side, node), d));
-     let search_idx = search_map | arrange;
-@@ -40,10 +35,8 @@
+@@ -39,10 +35,8 @@
      let search_map2 = search_reduce | map(((rid, side, node), d) -> ((rid, side, node, d), ()));
      set search = search_map2;
  }
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic13_oneoff.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/ldbc_ic13_oneoff.parsed--lowered.diff
index c506c1ed9..2cee3bf61 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic13_oneoff.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic13_oneoff.parsed--lowered.diff
@@ -1,6 +1,6 @@
 --- parsed
 +++ lowered
-@@ -1,21 +1,62 @@
+@@ -1,21 +1,61 @@
 +-- Time lanes: epoch.
 +-- Trace imports use provider arrangements; history advances to G = (0, []).
  let request = input 0 : ((int, int, int), ());
@@ -42,8 +42,7 @@
 +    let grow_rows = open + near;
 +    let grow_map = grow_rows | map((rid, (side, node, d)) -> (node, (rid, side, d)));
 +    let grow_idx = grow_map | arrange;
-+    let friend_idx = ::friend | arrange;
-+    let grow = grow_idx | join(friend_idx, (_, (rid, side, d), (next, _)) -> ((rid, side, next, (d, 1) add), ()));
++    let grow = grow_idx | join(::friend, (_, (rid, side, d), (next, _)) -> ((rid, side, next, (d, 1) add), ()));
 +    let search_rows = ::starts + search + grow;
 +    let search_map = search_rows | map(((rid, side, node, d), ()) -> ((rid, side, node), d));
 +    let search_idx = search_map | arrange;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic14_oneoff.ddp b/interactive/tests/plan_pairs/expected/ldbc_ic14_oneoff.ddp
index 55d86150c..8e446dd96 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic14_oneoff.ddp
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic14_oneoff.ddp
@@ -18,8 +18,7 @@ dist: {
 let best = dist::dist | map(((rid, node, cost), ()) -> ((rid, node), cost));
 let pred_map = dist::dist | map(((rid, u, cost), ()) -> (u, (rid, cost)));
 let pred_idx = pred_map | arrange;
-let weighted_idx = weighted | arrange;
-let pred_join = pred_idx | join(weighted_idx, (u, (rid, cost), (v, w)) -> ((rid, v), (u, (cost, w) add)));
+let pred_join = pred_idx | join(weighted, (u, (rid, cost), (v, w)) -> ((rid, v), (u, (cost, w) add)));
 let pred_idx2 = pred_join | arrange;
 let best_idx = best | arrange;
 let pred_join2 = pred_idx2 | join(best_idx, ((rid, v), (u, via), least) -> ((rid, v), (u, via, least)));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic14_oneoff.lowered--optimized.diff b/interactive/tests/plan_pairs/expected/ldbc_ic14_oneoff.lowered--optimized.diff
index bd7f36fca..4aab3c07d 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic14_oneoff.lowered--optimized.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic14_oneoff.lowered--optimized.diff
@@ -9,17 +9,7 @@
  let weighted = import "ic14s::weighted" : (int, (int, int));
  let starts = request | map(((rid, from, _), ()) -> ((rid, from), 0));
  dist: {
-@@ -10,8 +8,7 @@
-     var dist;
-     let grow_map = dist | map(((rid, node, cost), ()) -> (node, (rid, cost)));
-     let grow_idx = grow_map | arrange;
--    let weighted_idx = ::weighted | arrange;
--    let grow = grow_idx | join(weighted_idx, (_, (rid, cost), (next, w)) -> ((rid, next), (cost, w) add));
-+    let grow = grow_idx | join(::weighted, (_, (rid, cost), (next, w)) -> ((rid, next), (cost, w) add));
-     let dist_rows = ::starts + grow;
-     let dist_idx = dist_rows | arrange;
-     let dist_reduce = dist_idx | reduce(limit 1, (_, vals) -> let first = vals head in (first.0, 1) enlist);
-@@ -26,39 +23,34 @@
+@@ -24,32 +22,28 @@
  let pred_idx2 = pred_join | arrange;
  let best_idx = best | arrange;
  let pred_join2 = pred_idx2 | join(best_idx, ((rid, v), (u, via), least) -> ((rid, v), (u, via, least)));
@@ -57,15 +47,7 @@
  walk: {
      -- Time lanes: epoch, then 1 scope coordinates; this scope enters at zero.
      var walk;
-     let step_map = walk | map(((rid, node, path), ()) -> ((rid, node), path));
-     let step_idx = step_map | arrange;
--    let next_idx = ::next | arrange;
--    let step = step_idx | join(next_idx, ((rid, _), path, v) -> ((rid, v, (path, v enlist) append), ()));
-+    let step = step_idx | join(::next, ((rid, _), path, v) -> ((rid, v, (path, v enlist) append), ()));
-     let walk_rows = ::first + step;
-     set walk = walk_rows;
- }
-@@ -67,8 +59,7 @@
+@@ -64,8 +58,7 @@
  let targets_idx2 = targets | arrange;
  let answer_join = answer_idx | join(targets_idx2, ((rid, node), path, ()) -> ((rid, node), path));
  let answer_idx2 = answer_join | arrange;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic14_oneoff.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/ldbc_ic14_oneoff.parsed--lowered.diff
index d5d7d4e92..5bf9c15db 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic14_oneoff.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic14_oneoff.parsed--lowered.diff
@@ -1,6 +1,6 @@
 --- parsed
 +++ lowered
-@@ -1,24 +1,74 @@
+@@ -1,24 +1,71 @@
 +-- Time lanes: epoch.
 +-- Trace imports use provider arrangements; history advances to G = (0, []).
  let request = input 0 : ((int, int, int), ());
@@ -15,8 +15,7 @@
 +    var dist;
 +    let grow_map = dist | map(((rid, node, cost), ()) -> (node, (rid, cost)));
 +    let grow_idx = grow_map | arrange;
-+    let weighted_idx = ::weighted | arrange;
-+    let grow = grow_idx | join(weighted_idx, (_, (rid, cost), (next, w)) -> ((rid, next), (cost, w) add));
++    let grow = grow_idx | join(::weighted, (_, (rid, cost), (next, w)) -> ((rid, next), (cost, w) add));
 +    let dist_rows = ::starts + grow;
 +    let dist_idx = dist_rows | arrange;
 +    let dist_reduce = dist_idx | reduce(limit 1, (_, vals) -> let first = vals head in (first.0, 1) enlist);
@@ -28,8 +27,7 @@
 -let targets = request | map(((rid, _, to), ()) -> ((rid, to), ())) | join(best, (key, (), _) -> (key, ()));
 +let pred_map = dist::dist | map(((rid, u, cost), ()) -> (u, (rid, cost)));
 +let pred_idx = pred_map | arrange;
-+let weighted_idx = weighted | arrange;
-+let pred_join = pred_idx | join(weighted_idx, (u, (rid, cost), (v, w)) -> ((rid, v), (u, (cost, w) add)));
++let pred_join = pred_idx | join(weighted, (u, (rid, cost), (v, w)) -> ((rid, v), (u, (cost, w) add)));
 +let pred_idx2 = pred_join | arrange;
 +let best_idx = best | arrange;
 +let pred_join2 = pred_idx2 | join(best_idx, ((rid, v), (u, via), least) -> ((rid, v), (u, via, least)));
@@ -70,8 +68,7 @@
 +    var walk;
 +    let step_map = walk | map(((rid, node, path), ()) -> ((rid, node), path));
 +    let step_idx = step_map | arrange;
-+    let next_idx = ::next | arrange;
-+    let step = step_idx | join(next_idx, ((rid, _), path, v) -> ((rid, v, (path, v enlist) append), ()));
++    let step = step_idx | join(::next, ((rid, _), path, v) -> ((rid, v, (path, v enlist) append), ()));
 +    let walk_rows = ::first + step;
 +    set walk = walk_rows;
  }
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic14_standing.ddp b/interactive/tests/plan_pairs/expected/ldbc_ic14_standing.ddp
index 7ea9f852a..544b8d7e6 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic14_standing.ddp
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic14_standing.ddp
@@ -4,16 +4,14 @@ let message = import "graph::message" : (int, (int, int, int, int, List(int), Li
 let pals = import "graph::friend.pair" : ((int, int), ());
 let answered_rows = message | filter((_, (kind, _, _, _, _, _, _, _, _, _, _, _, _)) -> (kind, 1) eq) | map((_, (_, _, who, _, _, _, _, _, _, parent, _, _, _)) -> (parent, who));
 let answered_idx = answered_rows | arrange;
-let message_idx = message | arrange;
-let answered_join = answered_idx | join(message_idx, (_, who, (_, _, to, _, _, _, _, _, _, _, _, _, _)) -> (who, to));
+let answered_join = answered_idx | join(message, (_, who, (_, _, to, _, _, _, _, _, _, _, _, _, _)) -> (who, to));
 let answered = answered_join | filter((who, to) -> (who, to) ne);
 let talks_map = answered | map((a, b) -> ((a, b), ()));
 let talks_map2 = answered | map((a, b) -> ((b, a), ()));
 let talks = talks_map + talks_map2;
 let talks_idx = talks | arrange;
 let weighted_reduce = talks_idx | reduce((_, vals) -> let diffs = vals map ((_, d) -> d) in let n = diffs fold_add in (n, (n, 1)) enlist filter);
-let pals_idx = pals | arrange;
-let weighted_join = weighted_reduce | join(pals_idx, (pair, n, ()) -> (pair, n));
+let weighted_join = weighted_reduce | join(pals, (pair, n, ()) -> (pair, n));
 let weighted = weighted_join | map(((a, b), n) -> (a, (b, (((0, n), (1, 40) range) fold (((acc, n), k) ->
                            ((acc, ((((k, (k, 1) sub) mul, 1) add, n) gt, 1, 0) select) add, n)) .0, 1) add)));
 let weighted_idx = weighted | arrange;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic14_standing.lowered--optimized.diff b/interactive/tests/plan_pairs/expected/ldbc_ic14_standing.lowered--optimized.diff
index b63f2011e..10eb25131 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic14_standing.lowered--optimized.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic14_standing.lowered--optimized.diff
@@ -9,6 +9,6 @@
 -let answered_idx = answered_map | arrange;
 +let answered_rows = message | filter((_, (kind, _, _, _, _, _, _, _, _, _, _, _, _)) -> (kind, 1) eq) | map((_, (_, _, who, _, _, _, _, _, _, parent, _, _, _)) -> (parent, who));
 +let answered_idx = answered_rows | arrange;
- let message_idx = message | arrange;
- let answered_join = answered_idx | join(message_idx, (_, who, (_, _, to, _, _, _, _, _, _, _, _, _, _)) -> (who, to));
+ let answered_join = answered_idx | join(message, (_, who, (_, _, to, _, _, _, _, _, _, _, _, _, _)) -> (who, to));
  let answered = answered_join | filter((who, to) -> (who, to) ne);
+ let talks_map = answered | map((a, b) -> ((a, b), ()));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_ic14_standing.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/ldbc_ic14_standing.parsed--lowered.diff
index 926ece7ae..c5a71a3ae 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_ic14_standing.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_ic14_standing.parsed--lowered.diff
@@ -1,6 +1,6 @@
 --- parsed
 +++ lowered
-@@ -1,7 +1,22 @@
+@@ -1,7 +1,20 @@
 +-- Time lanes: epoch.
 +-- Trace imports use provider arrangements; history advances to G = (0, []).
  let message = import "graph::message" : (int, (int, int, int, int, List(int), List(int), int, List(int), int, int, int, int, int));
@@ -11,16 +11,14 @@
 +let answered_filter = message | filter((_, (kind, _, _, _, _, _, _, _, _, _, _, _, _)) -> (kind, 1) eq);
 +let answered_map = answered_filter | map((_, (_, _, who, _, _, _, _, _, _, parent, _, _, _)) -> (parent, who));
 +let answered_idx = answered_map | arrange;
-+let message_idx = message | arrange;
-+let answered_join = answered_idx | join(message_idx, (_, who, (_, _, to, _, _, _, _, _, _, _, _, _, _)) -> (who, to));
++let answered_join = answered_idx | join(message, (_, who, (_, _, to, _, _, _, _, _, _, _, _, _, _)) -> (who, to));
 +let answered = answered_join | filter((who, to) -> (who, to) ne);
 +let talks_map = answered | map((a, b) -> ((a, b), ()));
 +let talks_map2 = answered | map((a, b) -> ((b, a), ()));
 +let talks = talks_map + talks_map2;
 +let talks_idx = talks | arrange;
 +let weighted_reduce = talks_idx | reduce((_, vals) -> let diffs = vals map ((_, d) -> d) in let n = diffs fold_add in (n, (n, 1)) enlist filter);
-+let pals_idx = pals | arrange;
-+let weighted_join = weighted_reduce | join(pals_idx, (pair, n, ()) -> (pair, n));
++let weighted_join = weighted_reduce | join(pals, (pair, n, ()) -> (pair, n));
 +let weighted = weighted_join | map(((a, b), n) -> (a, (b, (((0, n), (1, 40) range) fold (((acc, n), k) ->
                             ((acc, ((((k, (k, 1) sub) mul, 1) add, n) gt, 1, 0) select) add, n)) .0, 1) add)));
 -output "weighted" = weighted | arrange;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_is01.ddp b/interactive/tests/plan_pairs/expected/ldbc_is01.ddp
index c4de7b330..f52857605 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_is01.ddp
+++ b/interactive/tests/plan_pairs/expected/ldbc_is01.ddp
@@ -4,8 +4,7 @@ let request = input 0 : ((int, int), ());
 let person = import "graph::person" : (int, (List(int), List(int), List(int), int, int, List(int), List(int), int, int, int, int));
 let answer_map = request | map(((rid, who), ()) -> (who, rid));
 let answer_idx = answer_map | arrange;
-let person_idx = person | arrange;
-let answer = answer_idx | join(person_idx, (_, rid, (first, last, gender, birthday, created, ip, browser, city, _, _, _)) -> ((rid, 0), (first, last, birthday, ip, browser, city, gender, created)));
+let answer = answer_idx | join(person, (_, rid, (first, last, gender, birthday, created, ip, browser, city, _, _, _)) -> ((rid, 0), (first, last, birthday, ip, browser, city, gender, created)));
 let answer_idx2 = answer | arrange;
 -- Renderer: publish the existing arrangement.
 output "answer" = answer_idx2;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_is01.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/ldbc_is01.parsed--lowered.diff
index 884638de4..9553afaad 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_is01.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_is01.parsed--lowered.diff
@@ -1,6 +1,6 @@
 --- parsed
 +++ lowered
-@@ -1,4 +1,11 @@
+@@ -1,4 +1,10 @@
 +-- Time lanes: epoch.
 +-- Trace imports use provider arrangements; history advances to G = (0, []).
  let request = input 0 : ((int, int), ());
@@ -9,8 +9,7 @@
 -output "answer" = answer | arrange;
 +let answer_map = request | map(((rid, who), ()) -> (who, rid));
 +let answer_idx = answer_map | arrange;
-+let person_idx = person | arrange;
-+let answer = answer_idx | join(person_idx, (_, rid, (first, last, gender, birthday, created, ip, browser, city, _, _, _)) -> ((rid, 0), (first, last, birthday, ip, browser, city, gender, created)));
++let answer = answer_idx | join(person, (_, rid, (first, last, gender, birthday, created, ip, browser, city, _, _, _)) -> ((rid, 0), (first, last, birthday, ip, browser, city, gender, created)));
 +let answer_idx2 = answer | arrange;
 +-- Renderer: publish the existing arrangement.
 +output "answer" = answer_idx2;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_is02.ddp b/interactive/tests/plan_pairs/expected/ldbc_is02.ddp
index 6a52ec2c1..d452231b2 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_is02.ddp
+++ b/interactive/tests/plan_pairs/expected/ldbc_is02.ddp
@@ -7,24 +7,20 @@ let by_creator = import "graph::message.by_creator" : (int, int);
 let root_of = import "graph::message.root" : (int, int);
 let mine_map = request | map(((rid, who), ()) -> (who, rid));
 let mine_idx = mine_map | arrange;
-let by_creator_idx = by_creator | arrange;
-let mine_join = mine_idx | join(by_creator_idx, (_, rid, id) -> (id, rid));
+let mine_join = mine_idx | join(by_creator, (_, rid, id) -> (id, rid));
 let mine_idx2 = mine_join | arrange;
-let message_idx = message | arrange;
-let mine_join2 = mine_idx2 | join(message_idx, (id, rid, (_, created, _, _, _, _, _, _, _, _, _, _, _)) -> (id, (rid, created)));
+let mine_join2 = mine_idx2 | join(message, (id, rid, (_, created, _, _, _, _, _, _, _, _, _, _, _)) -> (id, (rid, created)));
 let mine_idx3 = mine_join2 | arrange;
-let root_of_idx = root_of | arrange;
-let mine = mine_idx3 | join(root_of_idx, (id, (rid, created), root) -> (rid, ((created neg, id neg), (id, created, root))));
+let mine = mine_idx3 | join(root_of, (id, (rid, created), root) -> (rid, ((created neg, id neg), (id, created, root))));
 let mine_idx4 = mine | arrange;
 let top = mine_idx4 | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 10) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 10) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 10) min in let before = (end, count) sub in let keep = (((10, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
 let answer_map = top | map((rid, (rank, (_, (id, created, root)))) -> (id, (rid, rank, created, root)));
 let answer_idx = answer_map | arrange;
-let answer_join = answer_idx | join(message_idx, (id, (rid, rank, created, root), (_, _, _, _, content, image, _, _, _, _, _, _, _)) -> (root, (rid, rank, id, ((content len, 0) gt, content, image) select, created)));
+let answer_join = answer_idx | join(message, (id, (rid, rank, created, root), (_, _, _, _, content, image, _, _, _, _, _, _, _)) -> (root, (rid, rank, id, ((content len, 0) gt, content, image) select, created)));
 let answer_idx2 = answer_join | arrange;
-let answer_join2 = answer_idx2 | join(message_idx, (root, (rid, rank, id, body, created), (_, _, op, _, _, _, _, _, _, _, _, _, _)) -> (op, (rid, rank, id, body, created, root)));
+let answer_join2 = answer_idx2 | join(message, (root, (rid, rank, id, body, created), (_, _, op, _, _, _, _, _, _, _, _, _, _)) -> (op, (rid, rank, id, body, created, root)));
 let answer_idx3 = answer_join2 | arrange;
-let person_idx = person | arrange;
-let answer = answer_idx3 | join(person_idx, (op, (rid, rank, id, body, created, root), (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, rank), (id, body, created, root, op, first, last)));
+let answer = answer_idx3 | join(person, (op, (rid, rank, id, body, created, root), (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, rank), (id, body, created, root, op, first, last)));
 let answer_idx4 = answer | arrange;
 -- Renderer: publish the existing arrangement.
 output "answer" = answer_idx4;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_is02.lowered--optimized.diff b/interactive/tests/plan_pairs/expected/ldbc_is02.lowered--optimized.diff
index fff47f866..e69de29bb 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_is02.lowered--optimized.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_is02.lowered--optimized.diff
@@ -1,16 +0,0 @@
---- lowered
-+++ optimized
-@@ -19,11 +19,9 @@
- let top = mine_idx4 | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 10) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 10) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 10) min in let before = (end, count) sub in let keep = (((10, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
- let answer_map = top | map((rid, (rank, (_, (id, created, root)))) -> (id, (rid, rank, created, root)));
- let answer_idx = answer_map | arrange;
--let message_idx2 = message | arrange;
--let answer_join = answer_idx | join(message_idx2, (id, (rid, rank, created, root), (_, _, _, _, content, image, _, _, _, _, _, _, _)) -> (root, (rid, rank, id, ((content len, 0) gt, content, image) select, created)));
-+let answer_join = answer_idx | join(message_idx, (id, (rid, rank, created, root), (_, _, _, _, content, image, _, _, _, _, _, _, _)) -> (root, (rid, rank, id, ((content len, 0) gt, content, image) select, created)));
- let answer_idx2 = answer_join | arrange;
--let message_idx3 = message | arrange;
--let answer_join2 = answer_idx2 | join(message_idx3, (root, (rid, rank, id, body, created), (_, _, op, _, _, _, _, _, _, _, _, _, _)) -> (op, (rid, rank, id, body, created, root)));
-+let answer_join2 = answer_idx2 | join(message_idx, (root, (rid, rank, id, body, created), (_, _, op, _, _, _, _, _, _, _, _, _, _)) -> (op, (rid, rank, id, body, created, root)));
- let answer_idx3 = answer_join2 | arrange;
- let person_idx = person | arrange;
- let answer = answer_idx3 | join(person_idx, (op, (rid, rank, id, body, created, root), (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, rank), (id, body, created, root, op, first, last)));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_is02.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/ldbc_is02.parsed--lowered.diff
index 67b0104cc..7801a80ec 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_is02.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_is02.parsed--lowered.diff
@@ -1,6 +1,6 @@
 --- parsed
 +++ lowered
-@@ -1,9 +1,32 @@
+@@ -1,9 +1,26 @@
 +-- Time lanes: epoch.
 +-- Trace imports use provider arrangements; history advances to G = (0, []).
  let request = input 0 : ((int, int), ());
@@ -14,26 +14,20 @@
 -output "answer" = answer | arrange;
 +let mine_map = request | map(((rid, who), ()) -> (who, rid));
 +let mine_idx = mine_map | arrange;
-+let by_creator_idx = by_creator | arrange;
-+let mine_join = mine_idx | join(by_creator_idx, (_, rid, id) -> (id, rid));
++let mine_join = mine_idx | join(by_creator, (_, rid, id) -> (id, rid));
 +let mine_idx2 = mine_join | arrange;
-+let message_idx = message | arrange;
-+let mine_join2 = mine_idx2 | join(message_idx, (id, rid, (_, created, _, _, _, _, _, _, _, _, _, _, _)) -> (id, (rid, created)));
++let mine_join2 = mine_idx2 | join(message, (id, rid, (_, created, _, _, _, _, _, _, _, _, _, _, _)) -> (id, (rid, created)));
 +let mine_idx3 = mine_join2 | arrange;
-+let root_of_idx = root_of | arrange;
-+let mine = mine_idx3 | join(root_of_idx, (id, (rid, created), root) -> (rid, ((created neg, id neg), (id, created, root))));
++let mine = mine_idx3 | join(root_of, (id, (rid, created), root) -> (rid, ((created neg, id neg), (id, created, root))));
 +let mine_idx4 = mine | arrange;
 +let top = mine_idx4 | reduce((_, vals) -> let positive = (vals map ((_, d) -> (d, 0) gt), (0, vals len) range) zip filter in let indices = ((0, (positive len, 10) min) range, positive) gather in let prefix = (indices, vals) gather in let ends = prefix map ((_, d) -> (d, 10) min) scan_add in let chosen = (prefix, ends) zip map (((item, d), end) -> let count = (d, 10) min in let before = (end, count) sub in let keep = (((10, before) sub, 0) max, count) min in ((keep, 0) gt, (item, keep))) filter in let ends = chosen map ((_, d) -> d) scan_add in (chosen, ends) zip map (((item, d), end) -> (item, ((end, d) sub, end) range) cap_list map ((item, rank) -> ((rank, item), 1))) flatten .1);
 +let answer_map = top | map((rid, (rank, (_, (id, created, root)))) -> (id, (rid, rank, created, root)));
 +let answer_idx = answer_map | arrange;
-+let message_idx2 = message | arrange;
-+let answer_join = answer_idx | join(message_idx2, (id, (rid, rank, created, root), (_, _, _, _, content, image, _, _, _, _, _, _, _)) -> (root, (rid, rank, id, ((content len, 0) gt, content, image) select, created)));
++let answer_join = answer_idx | join(message, (id, (rid, rank, created, root), (_, _, _, _, content, image, _, _, _, _, _, _, _)) -> (root, (rid, rank, id, ((content len, 0) gt, content, image) select, created)));
 +let answer_idx2 = answer_join | arrange;
-+let message_idx3 = message | arrange;
-+let answer_join2 = answer_idx2 | join(message_idx3, (root, (rid, rank, id, body, created), (_, _, op, _, _, _, _, _, _, _, _, _, _)) -> (op, (rid, rank, id, body, created, root)));
++let answer_join2 = answer_idx2 | join(message, (root, (rid, rank, id, body, created), (_, _, op, _, _, _, _, _, _, _, _, _, _)) -> (op, (rid, rank, id, body, created, root)));
 +let answer_idx3 = answer_join2 | arrange;
-+let person_idx = person | arrange;
-+let answer = answer_idx3 | join(person_idx, (op, (rid, rank, id, body, created, root), (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, rank), (id, body, created, root, op, first, last)));
++let answer = answer_idx3 | join(person, (op, (rid, rank, id, body, created, root), (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, rank), (id, body, created, root, op, first, last)));
 +let answer_idx4 = answer | arrange;
 +-- Renderer: publish the existing arrangement.
 +output "answer" = answer_idx4;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_is03.ddp b/interactive/tests/plan_pairs/expected/ldbc_is03.ddp
index 0d5b730db..dd6987550 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_is03.ddp
+++ b/interactive/tests/plan_pairs/expected/ldbc_is03.ddp
@@ -5,11 +5,9 @@ let person = import "graph::person" : (int, (List(int), List(int), List(int), in
 let friend = import "graph::friend" : (int, (int, int));
 let ranked_map = request | map(((rid, who), ()) -> (who, rid));
 let ranked_idx = ranked_map | arrange;
-let friend_idx = friend | arrange;
-let ranked_join = ranked_idx | join(friend_idx, (_, rid, (f, since)) -> (f, (rid, since)));
+let ranked_join = ranked_idx | join(friend, (_, rid, (f, since)) -> (f, (rid, since)));
 let ranked_idx2 = ranked_join | arrange;
-let person_idx = person | arrange;
-let ranked_join2 = ranked_idx2 | join(person_idx, (f, (rid, since), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((since neg, f), (first, last))));
+let ranked_join2 = ranked_idx2 | join(person, (f, (rid, since), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((since neg, f), (first, last))));
 let ranked_idx3 = ranked_join2 | arrange;
 let ranked_reduce = ranked_idx3 | reduce((_, vals) -> let lists = vals map ((v, d) -> (v, (0, d) range) cap_list map ((v, _) -> v)) in let flat = lists flatten in (flat.1, 1) enlist);
 let answer = ranked_reduce | flatmap((_, entries) -> entries) | map((rid, (rank, ((neg, f), (first, last)))) -> ((rid, rank), (f, first, last, neg neg)));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_is03.lowered--optimized.diff b/interactive/tests/plan_pairs/expected/ldbc_is03.lowered--optimized.diff
index e85652ae2..6d133257c 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_is03.lowered--optimized.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_is03.lowered--optimized.diff
@@ -1,7 +1,7 @@
 --- lowered
 +++ optimized
-@@ -12,8 +12,7 @@
- let ranked_join2 = ranked_idx2 | join(person_idx, (f, (rid, since), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((since neg, f), (first, last))));
+@@ -10,8 +10,7 @@
+ let ranked_join2 = ranked_idx2 | join(person, (f, (rid, since), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((since neg, f), (first, last))));
  let ranked_idx3 = ranked_join2 | arrange;
  let ranked_reduce = ranked_idx3 | reduce((_, vals) -> let lists = vals map ((v, d) -> (v, (0, d) range) cap_list map ((v, _) -> v)) in let flat = lists flatten in (flat.1, 1) enlist);
 -let ranked = ranked_reduce | flatmap((_, entries) -> entries);
diff --git a/interactive/tests/plan_pairs/expected/ldbc_is03.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/ldbc_is03.parsed--lowered.diff
index c849e10e7..024b0d199 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_is03.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_is03.parsed--lowered.diff
@@ -1,6 +1,6 @@
 --- parsed
 +++ lowered
-@@ -1,6 +1,19 @@
+@@ -1,6 +1,17 @@
 +-- Time lanes: epoch.
 +-- Trace imports use provider arrangements; history advances to G = (0, []).
  let request = input 0 : ((int, int), ());
@@ -9,11 +9,9 @@
 -let ranked = request | map(((rid, who), ()) -> (who, rid)) | join(friend, (_, rid, (f, since)) -> (f, (rid, since))) | join(person, (f, (rid, since), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((since neg, f), (first, last)))) | reduce((_, vals) -> let lists = vals map ((v, d) -> (v, (0, d) range) cap_list map ((v, _) -> v)) in let flat = lists flatten in (flat.1, 1) enlist) | flatmap((_, entries) -> entries);
 +let ranked_map = request | map(((rid, who), ()) -> (who, rid));
 +let ranked_idx = ranked_map | arrange;
-+let friend_idx = friend | arrange;
-+let ranked_join = ranked_idx | join(friend_idx, (_, rid, (f, since)) -> (f, (rid, since)));
++let ranked_join = ranked_idx | join(friend, (_, rid, (f, since)) -> (f, (rid, since)));
 +let ranked_idx2 = ranked_join | arrange;
-+let person_idx = person | arrange;
-+let ranked_join2 = ranked_idx2 | join(person_idx, (f, (rid, since), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((since neg, f), (first, last))));
++let ranked_join2 = ranked_idx2 | join(person, (f, (rid, since), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((since neg, f), (first, last))));
 +let ranked_idx3 = ranked_join2 | arrange;
 +let ranked_reduce = ranked_idx3 | reduce((_, vals) -> let lists = vals map ((v, d) -> (v, (0, d) range) cap_list map ((v, _) -> v)) in let flat = lists flatten in (flat.1, 1) enlist);
 +let ranked = ranked_reduce | flatmap((_, entries) -> entries);
diff --git a/interactive/tests/plan_pairs/expected/ldbc_is04.ddp b/interactive/tests/plan_pairs/expected/ldbc_is04.ddp
index c17e1ad19..95ca1f865 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_is04.ddp
+++ b/interactive/tests/plan_pairs/expected/ldbc_is04.ddp
@@ -4,8 +4,7 @@ let request = input 0 : ((int, int), ());
 let message = import "graph::message" : (int, (int, int, int, int, List(int), List(int), int, List(int), int, int, int, int, int));
 let answer_map = request | map(((rid, m), ()) -> (m, rid));
 let answer_idx = answer_map | arrange;
-let message_idx = message | arrange;
-let answer = answer_idx | join(message_idx, (_, rid, (_, created, _, _, text, image, _, _, _, _, _, _, _)) -> ((rid, 0), (created, ((text len, 0) gt, text, image) select)));
+let answer = answer_idx | join(message, (_, rid, (_, created, _, _, text, image, _, _, _, _, _, _, _)) -> ((rid, 0), (created, ((text len, 0) gt, text, image) select)));
 let answer_idx2 = answer | arrange;
 -- Renderer: publish the existing arrangement.
 output "answer" = answer_idx2;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_is04.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/ldbc_is04.parsed--lowered.diff
index ff621ea75..43f9c0701 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_is04.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_is04.parsed--lowered.diff
@@ -1,6 +1,6 @@
 --- parsed
 +++ lowered
-@@ -1,4 +1,11 @@
+@@ -1,4 +1,10 @@
 +-- Time lanes: epoch.
 +-- Trace imports use provider arrangements; history advances to G = (0, []).
  let request = input 0 : ((int, int), ());
@@ -9,8 +9,7 @@
 -output "answer" = answer | arrange;
 +let answer_map = request | map(((rid, m), ()) -> (m, rid));
 +let answer_idx = answer_map | arrange;
-+let message_idx = message | arrange;
-+let answer = answer_idx | join(message_idx, (_, rid, (_, created, _, _, text, image, _, _, _, _, _, _, _)) -> ((rid, 0), (created, ((text len, 0) gt, text, image) select)));
++let answer = answer_idx | join(message, (_, rid, (_, created, _, _, text, image, _, _, _, _, _, _, _)) -> ((rid, 0), (created, ((text len, 0) gt, text, image) select)));
 +let answer_idx2 = answer | arrange;
 +-- Renderer: publish the existing arrangement.
 +output "answer" = answer_idx2;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_is05.ddp b/interactive/tests/plan_pairs/expected/ldbc_is05.ddp
index 9172fc792..0ab419ad7 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_is05.ddp
+++ b/interactive/tests/plan_pairs/expected/ldbc_is05.ddp
@@ -5,11 +5,9 @@ let person = import "graph::person" : (int, (List(int), List(int), List(int), in
 let message = import "graph::message" : (int, (int, int, int, int, List(int), List(int), int, List(int), int, int, int, int, int));
 let answer_map = request | map(((rid, m), ()) -> (m, rid));
 let answer_idx = answer_map | arrange;
-let message_idx = message | arrange;
-let answer_join = answer_idx | join(message_idx, (_, rid, (_, _, who, _, _, _, _, _, _, _, _, _, _)) -> (who, rid));
+let answer_join = answer_idx | join(message, (_, rid, (_, _, who, _, _, _, _, _, _, _, _, _, _)) -> (who, rid));
 let answer_idx2 = answer_join | arrange;
-let person_idx = person | arrange;
-let answer = answer_idx2 | join(person_idx, (who, rid, (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, 0), (who, first, last)));
+let answer = answer_idx2 | join(person, (who, rid, (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, 0), (who, first, last)));
 let answer_idx3 = answer | arrange;
 -- Renderer: publish the existing arrangement.
 output "answer" = answer_idx3;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_is05.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/ldbc_is05.parsed--lowered.diff
index a91541d9f..44db594d6 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_is05.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_is05.parsed--lowered.diff
@@ -1,6 +1,6 @@
 --- parsed
 +++ lowered
-@@ -1,5 +1,15 @@
+@@ -1,5 +1,13 @@
 +-- Time lanes: epoch.
 +-- Trace imports use provider arrangements; history advances to G = (0, []).
  let request = input 0 : ((int, int), ());
@@ -10,11 +10,9 @@
 -output "answer" = answer | arrange;
 +let answer_map = request | map(((rid, m), ()) -> (m, rid));
 +let answer_idx = answer_map | arrange;
-+let message_idx = message | arrange;
-+let answer_join = answer_idx | join(message_idx, (_, rid, (_, _, who, _, _, _, _, _, _, _, _, _, _)) -> (who, rid));
++let answer_join = answer_idx | join(message, (_, rid, (_, _, who, _, _, _, _, _, _, _, _, _, _)) -> (who, rid));
 +let answer_idx2 = answer_join | arrange;
-+let person_idx = person | arrange;
-+let answer = answer_idx2 | join(person_idx, (who, rid, (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, 0), (who, first, last)));
++let answer = answer_idx2 | join(person, (who, rid, (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, 0), (who, first, last)));
 +let answer_idx3 = answer | arrange;
 +-- Renderer: publish the existing arrangement.
 +output "answer" = answer_idx3;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_is06.ddp b/interactive/tests/plan_pairs/expected/ldbc_is06.ddp
index 1e8a40034..360b1601c 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_is06.ddp
+++ b/interactive/tests/plan_pairs/expected/ldbc_is06.ddp
@@ -7,17 +7,13 @@ let forum = import "graph::forum" : (int, (List(int), int, int));
 let root_of = import "graph::message.root" : (int, int);
 let answer_map = request | map(((rid, m), ()) -> (m, rid));
 let answer_idx = answer_map | arrange;
-let root_of_idx = root_of | arrange;
-let answer_join = answer_idx | join(root_of_idx, (_, rid, root) -> (root, rid));
+let answer_join = answer_idx | join(root_of, (_, rid, root) -> (root, rid));
 let answer_idx2 = answer_join | arrange;
-let message_idx = message | arrange;
-let answer_join2 = answer_idx2 | join(message_idx, (_, rid, (_, _, _, _, _, _, _, _, f, _, _, _, _)) -> (f, rid));
+let answer_join2 = answer_idx2 | join(message, (_, rid, (_, _, _, _, _, _, _, _, f, _, _, _, _)) -> (f, rid));
 let answer_idx3 = answer_join2 | arrange;
-let forum_idx = forum | arrange;
-let answer_join3 = answer_idx3 | join(forum_idx, (f, rid, (title, _, moderator)) -> (moderator, (rid, f, title)));
+let answer_join3 = answer_idx3 | join(forum, (f, rid, (title, _, moderator)) -> (moderator, (rid, f, title)));
 let answer_idx4 = answer_join3 | arrange;
-let person_idx = person | arrange;
-let answer = answer_idx4 | join(person_idx, (moderator, (rid, f, title), (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, 0), (f, title, moderator, first, last)));
+let answer = answer_idx4 | join(person, (moderator, (rid, f, title), (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, 0), (f, title, moderator, first, last)));
 let answer_idx5 = answer | arrange;
 -- Renderer: publish the existing arrangement.
 output "answer" = answer_idx5;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_is06.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/ldbc_is06.parsed--lowered.diff
index 37aefc16c..b029bfbe8 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_is06.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_is06.parsed--lowered.diff
@@ -1,6 +1,6 @@
 --- parsed
 +++ lowered
-@@ -1,7 +1,23 @@
+@@ -1,7 +1,19 @@
 +-- Time lanes: epoch.
 +-- Trace imports use provider arrangements; history advances to G = (0, []).
  let request = input 0 : ((int, int), ());
@@ -12,17 +12,13 @@
 -output "answer" = answer | arrange;
 +let answer_map = request | map(((rid, m), ()) -> (m, rid));
 +let answer_idx = answer_map | arrange;
-+let root_of_idx = root_of | arrange;
-+let answer_join = answer_idx | join(root_of_idx, (_, rid, root) -> (root, rid));
++let answer_join = answer_idx | join(root_of, (_, rid, root) -> (root, rid));
 +let answer_idx2 = answer_join | arrange;
-+let message_idx = message | arrange;
-+let answer_join2 = answer_idx2 | join(message_idx, (_, rid, (_, _, _, _, _, _, _, _, f, _, _, _, _)) -> (f, rid));
++let answer_join2 = answer_idx2 | join(message, (_, rid, (_, _, _, _, _, _, _, _, f, _, _, _, _)) -> (f, rid));
 +let answer_idx3 = answer_join2 | arrange;
-+let forum_idx = forum | arrange;
-+let answer_join3 = answer_idx3 | join(forum_idx, (f, rid, (title, _, moderator)) -> (moderator, (rid, f, title)));
++let answer_join3 = answer_idx3 | join(forum, (f, rid, (title, _, moderator)) -> (moderator, (rid, f, title)));
 +let answer_idx4 = answer_join3 | arrange;
-+let person_idx = person | arrange;
-+let answer = answer_idx4 | join(person_idx, (moderator, (rid, f, title), (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, 0), (f, title, moderator, first, last)));
++let answer = answer_idx4 | join(person, (moderator, (rid, f, title), (first, last, _, _, _, _, _, _, _, _, _)) -> ((rid, 0), (f, title, moderator, first, last)));
 +let answer_idx5 = answer | arrange;
 +-- Renderer: publish the existing arrangement.
 +output "answer" = answer_idx5;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_is07.ddp b/interactive/tests/plan_pairs/expected/ldbc_is07.ddp
index c1d6c532a..5492ea3a4 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_is07.ddp
+++ b/interactive/tests/plan_pairs/expected/ldbc_is07.ddp
@@ -7,18 +7,15 @@ let by_parent = import "graph::message.by_parent" : (int, int);
 let friend = import "graph::friend" : (int, (int, int));
 let reply_map = request | map(((rid, m), ()) -> (m, rid));
 let reply_idx = reply_map | arrange;
-let message_idx = message | arrange;
-let reply_join = reply_idx | join(message_idx, (m, rid, (_, _, op, _, _, _, _, _, _, _, _, _, _)) -> (m, (rid, op)));
+let reply_join = reply_idx | join(message, (m, rid, (_, _, op, _, _, _, _, _, _, _, _, _, _)) -> (m, (rid, op)));
 let reply_idx2 = reply_join | arrange;
-let by_parent_idx = by_parent | arrange;
-let reply_join2 = reply_idx2 | join(by_parent_idx, (_, (rid, op), id) -> (id, (rid, op)));
+let reply_join2 = reply_idx2 | join(by_parent, (_, (rid, op), id) -> (id, (rid, op)));
 let reply_idx3 = reply_join2 | arrange;
-let reply_join3 = reply_idx3 | join(message_idx, (id, (rid, op), (kind, created, who, _, text, _, _, _, _, _, _, _, _)) -> (kind, ((who, op), (rid, id, text, created))));
+let reply_join3 = reply_idx3 | join(message, (id, (rid, op), (kind, created, who, _, text, _, _, _, _, _, _, _, _)) -> (kind, ((who, op), (rid, id, text, created))));
 let reply = reply_join3 | filter((kind, _) -> (kind, 1) eq) | map((_, row) -> row);
 let known_map = reply | map(((who, op), row) -> (who, (op, row)));
 let known_idx = known_map | arrange;
-let friend_idx = friend | arrange;
-let known_join = known_idx | join(friend_idx, (who, (op, row), (f, _)) -> ((f, op) eq, ((who, op), row)));
+let known_join = known_idx | join(friend, (who, (op, row), (f, _)) -> ((f, op) eq, ((who, op), row)));
 let known_rows = known_join | filter((same, _) -> same) | map((_, (pair, row)) -> ((pair, row), ()));
 let known_idx2 = known_rows | arrange;
 let known_reduce = known_idx2 | reduce((_, vals) -> vals map (((), _) -> ((), 1)));
@@ -30,8 +27,7 @@ let marked_rows = marked_map2 + marked_neg;
 let marked_map3 = marked_rows | map(((who, _), row) -> (who, (row, 0)));
 let marked = marked_map + marked_map3;
 let marked_idx = marked | arrange;
-let person_idx = person | arrange;
-let ranked_join = marked_idx | join(person_idx, (who, ((rid, id, text, created), k), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((created neg, who), (id, text, first, last, k))));
+let ranked_join = marked_idx | join(person, (who, ((rid, id, text, created), k), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((created neg, who), (id, text, first, last, k))));
 let ranked_idx = ranked_join | arrange;
 let ranked_reduce = ranked_idx | reduce((_, vals) -> let lists = vals map ((v, d) -> (v, (0, d) range) cap_list map ((v, _) -> v)) in let flat = lists flatten in (flat.1, 1) enlist);
 let answer = ranked_reduce | flatmap((_, entries) -> entries) | map((rid, (rank, ((neg, who), (id, text, first, last, k)))) -> ((rid, rank), (id, text, neg neg, who, first, last, k)));
diff --git a/interactive/tests/plan_pairs/expected/ldbc_is07.lowered--optimized.diff b/interactive/tests/plan_pairs/expected/ldbc_is07.lowered--optimized.diff
index 1019d56ba..be24587d3 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_is07.lowered--optimized.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_is07.lowered--optimized.diff
@@ -1,19 +1,15 @@
 --- lowered
 +++ optimized
-@@ -13,17 +13,14 @@
- let by_parent_idx = by_parent | arrange;
- let reply_join2 = reply_idx2 | join(by_parent_idx, (_, (rid, op), id) -> (id, (rid, op)));
+@@ -12,14 +12,12 @@
+ let reply_join2 = reply_idx2 | join(by_parent, (_, (rid, op), id) -> (id, (rid, op)));
  let reply_idx3 = reply_join2 | arrange;
--let message_idx2 = message | arrange;
--let reply_join3 = reply_idx3 | join(message_idx2, (id, (rid, op), (kind, created, who, _, text, _, _, _, _, _, _, _, _)) -> (kind, ((who, op), (rid, id, text, created))));
+ let reply_join3 = reply_idx3 | join(message, (id, (rid, op), (kind, created, who, _, text, _, _, _, _, _, _, _, _)) -> (kind, ((who, op), (rid, id, text, created))));
 -let reply_filter = reply_join3 | filter((kind, _) -> (kind, 1) eq);
 -let reply = reply_filter | map((_, row) -> row);
-+let reply_join3 = reply_idx3 | join(message_idx, (id, (rid, op), (kind, created, who, _, text, _, _, _, _, _, _, _, _)) -> (kind, ((who, op), (rid, id, text, created))));
 +let reply = reply_join3 | filter((kind, _) -> (kind, 1) eq) | map((_, row) -> row);
  let known_map = reply | map(((who, op), row) -> (who, (op, row)));
  let known_idx = known_map | arrange;
- let friend_idx = friend | arrange;
- let known_join = known_idx | join(friend_idx, (who, (op, row), (f, _)) -> ((f, op) eq, ((who, op), row)));
+ let known_join = known_idx | join(friend, (who, (op, row), (f, _)) -> ((f, op) eq, ((who, op), row)));
 -let known_filter = known_join | filter((same, _) -> same);
 -let known_map2 = known_filter | map((_, (pair, row)) -> ((pair, row), ()));
 -let known_idx2 = known_map2 | arrange;
@@ -22,8 +18,8 @@
  let known_reduce = known_idx2 | reduce((_, vals) -> vals map (((), _) -> ((), 1)));
  let known = known_reduce | map(((pair, row), ()) -> (pair, row));
  let marked_map = known | map(((who, _), row) -> (who, (row, 1)));
-@@ -36,8 +33,7 @@
- let ranked_join = marked_idx | join(person_idx, (who, ((rid, id, text, created), k), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((created neg, who), (id, text, first, last, k))));
+@@ -31,8 +29,7 @@
+ let ranked_join = marked_idx | join(person, (who, ((rid, id, text, created), k), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((created neg, who), (id, text, first, last, k))));
  let ranked_idx = ranked_join | arrange;
  let ranked_reduce = ranked_idx | reduce((_, vals) -> let lists = vals map ((v, d) -> (v, (0, d) range) cap_list map ((v, _) -> v)) in let flat = lists flatten in (flat.1, 1) enlist);
 -let ranked = ranked_reduce | flatmap((_, entries) -> entries);
diff --git a/interactive/tests/plan_pairs/expected/ldbc_is07.optimized--projected.diff b/interactive/tests/plan_pairs/expected/ldbc_is07.optimized--projected.diff
index 0891b264a..34d002a79 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_is07.optimized--projected.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_is07.optimized--projected.diff
@@ -1,6 +1,6 @@
 --- optimized
 +++ projected
-@@ -22,12 +22,13 @@
+@@ -19,12 +19,13 @@
  let known_rows = known_join | filter((same, _) -> same) | map((_, (pair, row)) -> ((pair, row), ()));
  let known_idx2 = known_rows | arrange;
  let known_reduce = known_idx2 | reduce((_, vals) -> vals map (((), _) -> ((), 1)));
@@ -16,5 +16,5 @@
 +let marked_map3 = marked_rows | map(((who, _), row) -> (who, (row, 0)));
 +let marked = marked_map + marked_map3;
  let marked_idx = marked | arrange;
- let person_idx = person | arrange;
- let ranked_join = marked_idx | join(person_idx, (who, ((rid, id, text, created), k), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((created neg, who), (id, text, first, last, k))));
+ let ranked_join = marked_idx | join(person, (who, ((rid, id, text, created), k), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((created neg, who), (id, text, first, last, k))));
+ let ranked_idx = ranked_join | arrange;
diff --git a/interactive/tests/plan_pairs/expected/ldbc_is07.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/ldbc_is07.parsed--lowered.diff
index 344585511..9bb0a064c 100644
--- a/interactive/tests/plan_pairs/expected/ldbc_is07.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/ldbc_is07.parsed--lowered.diff
@@ -1,6 +1,6 @@
 --- parsed
 +++ lowered
-@@ -1,11 +1,43 @@
+@@ -1,11 +1,38 @@
 +-- Time lanes: epoch.
 +-- Trace imports use provider arrangements; history advances to G = (0, []).
  let request = input 0 : ((int, int), ());
@@ -14,20 +14,16 @@
 -let ranked = marked | join(person, (who, ((rid, id, text, created), k), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((created neg, who), (id, text, first, last, k)))) | reduce((_, vals) -> let lists = vals map ((v, d) -> (v, (0, d) range) cap_list map ((v, _) -> v)) in let flat = lists flatten in (flat.1, 1) enlist) | flatmap((_, entries) -> entries);
 +let reply_map = request | map(((rid, m), ()) -> (m, rid));
 +let reply_idx = reply_map | arrange;
-+let message_idx = message | arrange;
-+let reply_join = reply_idx | join(message_idx, (m, rid, (_, _, op, _, _, _, _, _, _, _, _, _, _)) -> (m, (rid, op)));
++let reply_join = reply_idx | join(message, (m, rid, (_, _, op, _, _, _, _, _, _, _, _, _, _)) -> (m, (rid, op)));
 +let reply_idx2 = reply_join | arrange;
-+let by_parent_idx = by_parent | arrange;
-+let reply_join2 = reply_idx2 | join(by_parent_idx, (_, (rid, op), id) -> (id, (rid, op)));
++let reply_join2 = reply_idx2 | join(by_parent, (_, (rid, op), id) -> (id, (rid, op)));
 +let reply_idx3 = reply_join2 | arrange;
-+let message_idx2 = message | arrange;
-+let reply_join3 = reply_idx3 | join(message_idx2, (id, (rid, op), (kind, created, who, _, text, _, _, _, _, _, _, _, _)) -> (kind, ((who, op), (rid, id, text, created))));
++let reply_join3 = reply_idx3 | join(message, (id, (rid, op), (kind, created, who, _, text, _, _, _, _, _, _, _, _)) -> (kind, ((who, op), (rid, id, text, created))));
 +let reply_filter = reply_join3 | filter((kind, _) -> (kind, 1) eq);
 +let reply = reply_filter | map((_, row) -> row);
 +let known_map = reply | map(((who, op), row) -> (who, (op, row)));
 +let known_idx = known_map | arrange;
-+let friend_idx = friend | arrange;
-+let known_join = known_idx | join(friend_idx, (who, (op, row), (f, _)) -> ((f, op) eq, ((who, op), row)));
++let known_join = known_idx | join(friend, (who, (op, row), (f, _)) -> ((f, op) eq, ((who, op), row)));
 +let known_filter = known_join | filter((same, _) -> same);
 +let known_map2 = known_filter | map((_, (pair, row)) -> ((pair, row), ()));
 +let known_idx2 = known_map2 | arrange;
@@ -39,8 +35,7 @@
 +let marked_map2 = marked_rows | map(((who, _), row) -> (who, (row, 0)));
 +let marked = marked_map + marked_map2;
 +let marked_idx = marked | arrange;
-+let person_idx = person | arrange;
-+let ranked_join = marked_idx | join(person_idx, (who, ((rid, id, text, created), k), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((created neg, who), (id, text, first, last, k))));
++let ranked_join = marked_idx | join(person, (who, ((rid, id, text, created), k), (first, last, _, _, _, _, _, _, _, _, _)) -> (rid, ((created neg, who), (id, text, first, last, k))));
 +let ranked_idx = ranked_join | arrange;
 +let ranked_reduce = ranked_idx | reduce((_, vals) -> let lists = vals map ((v, d) -> (v, (0, d) range) cap_list map ((v, _) -> v)) in let flat = lists flatten in (flat.1, 1) enlist);
 +let ranked = ranked_reduce | flatmap((_, entries) -> entries);
diff --git a/interactive/tests/plan_pairs/expected/txn_resolve.ddp b/interactive/tests/plan_pairs/expected/txn_resolve.ddp
index 9d268242c..2748050c1 100644
--- a/interactive/tests/plan_pairs/expected/txn_resolve.ddp
+++ b/interactive/tests/plan_pairs/expected/txn_resolve.ddp
@@ -9,8 +9,7 @@ let wid = intents | filter(((_, r, _), _) -> (r, 0) eq) | map(((a, _, b), (c)) -
 let wid_idx = wid | arrange;
 let rk = reads | map(((rid, k), (e)) -> ((k), (rid, e)));
 let rk_idx = rk | arrange;
-let store_idx = store | arrange;
-let base = rk_idx | join(store_idx, ((k), (rid, e), (sw, v)) -> ((k, rid, e), (sw neg, v)));
+let base = rk_idx | join(store, ((k), (rid, e), (sw, v)) -> ((k, rid, e), (sw neg, v)));
 res: {
     -- Time lanes: epoch, then 1 scope coordinates; this scope enters at zero.
     var rollback;
@@ -45,7 +44,7 @@ let latest_map = committed | map(((wid), (k, v)) -> ((k), (wid neg, v)));
 let latest_idx = latest_map | arrange;
 let latest = latest_idx | reduce(limit 1, (_, vals) -> let first = vals head in (first.0, 1) enlist);
 let new_rows = latest | map(((k), (nw, v)) -> ((k), (nw neg, v)));
-let old_rows = latest | join(store_idx, ((k), _, (sw, sv)) -> ((k), (sw, sv)));
+let old_rows = latest | join(store, ((k), _, (sw, sv)) -> ((k), (sw, sv)));
 let delta_neg = old_rows | negate;
 let delta_rows = new_rows + delta_neg;
 -- Renderer: build an export arrangement.
diff --git a/interactive/tests/plan_pairs/expected/txn_resolve.lowered--optimized.diff b/interactive/tests/plan_pairs/expected/txn_resolve.lowered--optimized.diff
index 3e3d17c25..62feeceef 100644
--- a/interactive/tests/plan_pairs/expected/txn_resolve.lowered--optimized.diff
+++ b/interactive/tests/plan_pairs/expected/txn_resolve.lowered--optimized.diff
@@ -1,6 +1,6 @@
 --- lowered
 +++ optimized
-@@ -2,11 +2,11 @@
+@@ -2,48 +2,40 @@
  -- Trace imports use provider arrangements; history advances to G = (0, []).
  let store = import "store::store" : ((int), (int, int));
  let intents = input 0 : ((int, int, int), (int));
@@ -16,8 +16,7 @@
 +let wid_idx = wid | arrange;
  let rk = reads | map(((rid, k), (e)) -> ((k), (rid, e)));
  let rk_idx = rk | arrange;
- let store_idx = store | arrange;
-@@ -14,37 +14,29 @@
+ let base = rk_idx | join(store, ((k), (rid, e), (sw, v)) -> ((k, rid, e), (sw neg, v)));
  res: {
      -- Time lanes: epoch, then 1 scope coordinates; this scope enters at zero.
      var rollback;
@@ -62,13 +61,3 @@
  let rb_idx = rb | arrange;
  let wbad = wid_idx | join(rb_idx, (wid, kv, ()) -> (wid, kv));
  let committed_neg = wbad | negate;
-@@ -53,8 +45,7 @@
- let latest_idx = latest_map | arrange;
- let latest = latest_idx | reduce(limit 1, (_, vals) -> let first = vals head in (first.0, 1) enlist);
- let new_rows = latest | map(((k), (nw, v)) -> ((k), (nw neg, v)));
--let store_idx2 = store | arrange;
--let old_rows = latest | join(store_idx2, ((k), _, (sw, sv)) -> ((k), (sw, sv)));
-+let old_rows = latest | join(store_idx, ((k), _, (sw, sv)) -> ((k), (sw, sv)));
- let delta_neg = old_rows | negate;
- let delta_rows = new_rows + delta_neg;
- -- Renderer: build an export arrangement.
diff --git a/interactive/tests/plan_pairs/expected/txn_resolve.optimized--projected.diff b/interactive/tests/plan_pairs/expected/txn_resolve.optimized--projected.diff
index 90d27e57f..c3cfe7a50 100644
--- a/interactive/tests/plan_pairs/expected/txn_resolve.optimized--projected.diff
+++ b/interactive/tests/plan_pairs/expected/txn_resolve.optimized--projected.diff
@@ -1,6 +1,6 @@
 --- optimized
 +++ projected
-@@ -24,7 +24,7 @@
+@@ -23,7 +23,7 @@
      let pairs = pairs_join | filter(((_, rid, _), (nw, _)) -> (nw neg, rid) lt);
      let best_rows = pairs + ::base;
      let best_idx = best_rows | arrange;
diff --git a/interactive/tests/plan_pairs/expected/txn_resolve.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/txn_resolve.parsed--lowered.diff
index 588a41e1d..d66f7345f 100644
--- a/interactive/tests/plan_pairs/expected/txn_resolve.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/txn_resolve.parsed--lowered.diff
@@ -1,6 +1,6 @@
 --- parsed
 +++ lowered
-@@ -1,28 +1,63 @@
+@@ -1,28 +1,61 @@
 +-- Time lanes: epoch.
 +-- Trace imports use provider arrangements; history advances to G = (0, []).
  let store = import "store::store" : ((int), (int, int));
@@ -15,8 +15,7 @@
  let rk = reads | map(((rid, k), (e)) -> ((k), (rid, e)));
 -let base = rk | join(store, ((k), (rid, e), (sw, v)) -> ((k, rid, e), (sw neg, v)));
 +let rk_idx = rk | arrange;
-+let store_idx = store | arrange;
-+let base = rk_idx | join(store_idx, ((k), (rid, e), (sw, v)) -> ((k, rid, e), (sw neg, v)));
++let base = rk_idx | join(store, ((k), (rid, e), (sw, v)) -> ((k, rid, e), (sw neg, v)));
  res: {
 -    let wr_bad = wid | join(rollback, (wid, kv, ()) -> (wid, kv));
 -    let writes = wid + (wr_bad | negate);
@@ -71,9 +70,7 @@
 +let latest_idx = latest_map | arrange;
 +let latest = latest_idx | reduce(limit 1, (_, vals) -> let first = vals head in (first.0, 1) enlist);
  let new_rows = latest | map(((k), (nw, v)) -> ((k), (nw neg, v)));
--let old_rows = latest | join(store, ((k), _, (sw, sv)) -> ((k), (sw, sv)));
-+let store_idx2 = store | arrange;
-+let old_rows = latest | join(store_idx2, ((k), _, (sw, sv)) -> ((k), (sw, sv)));
+ let old_rows = latest | join(store, ((k), _, (sw, sv)) -> ((k), (sw, sv)));
 +let delta_neg = old_rows | negate;
 +let delta_rows = new_rows + delta_neg;
 +-- Renderer: build an export arrangement.
diff --git a/interactive/tests/plan_pairs/expected/txn_resolve_by_key.ddp b/interactive/tests/plan_pairs/expected/txn_resolve_by_key.ddp
index 34d8e7e37..0fc33cfa8 100644
--- a/interactive/tests/plan_pairs/expected/txn_resolve_by_key.ddp
+++ b/interactive/tests/plan_pairs/expected/txn_resolve_by_key.ddp
@@ -6,8 +6,7 @@ let wid = intents | filter(((_, r, _), _) -> (r, 0) eq) | map(((a, _, b), (c)) -
 let wid_idx = wid | arrange;
 let read_entries = intents | filter(((_, r, _), _) -> (r, 1) eq) | map(((a, _, b), (c)) -> ((b), (1, a, c)));
 let read_entries_idx = read_entries | arrange;
-let store_idx = store | arrange;
-let store_entries = read_entries_idx | join(store_idx, ((k), _, (sw, v)) -> ((k), (0, sw, v)));
+let store_entries = read_entries_idx | join(store, ((k), _, (sw, v)) -> ((k), (0, sw, v)));
 res: {
     -- Time lanes: epoch, then 1 scope coordinates; this scope enters at zero.
     var rollback;
@@ -41,7 +40,7 @@ let latest_map = committed | map(((wid), (k, v)) -> ((k), (wid neg, v)));
 let latest_idx = latest_map | arrange;
 let latest = latest_idx | reduce(limit 1, (_, vals) -> let first = vals head in (first.0, 1) enlist);
 let new_rows = latest | map(((k), (nw, v)) -> ((k), (nw neg, v)));
-let old_rows = latest | join(store_idx, ((k), _, (sw, sv)) -> ((k), (sw, sv)));
+let old_rows = latest | join(store, ((k), _, (sw, sv)) -> ((k), (sw, sv)));
 let delta_neg = old_rows | negate;
 let delta_rows = new_rows + delta_neg;
 -- Renderer: build an export arrangement.
diff --git a/interactive/tests/plan_pairs/expected/txn_resolve_by_key.lowered--optimized.diff b/interactive/tests/plan_pairs/expected/txn_resolve_by_key.lowered--optimized.diff
index 6955d416d..729238fc9 100644
--- a/interactive/tests/plan_pairs/expected/txn_resolve_by_key.lowered--optimized.diff
+++ b/interactive/tests/plan_pairs/expected/txn_resolve_by_key.lowered--optimized.diff
@@ -1,6 +1,6 @@
 --- lowered
 +++ optimized
-@@ -2,21 +2,17 @@
+@@ -2,20 +2,16 @@
  -- Trace imports use provider arrangements; history advances to G = (0, []).
  let store = import "store::store" : ((int), (int, int));
  let intents = input 0 : ((int, int, int), (int));
@@ -14,8 +14,7 @@
 +let wid_idx = wid | arrange;
 +let read_entries = intents | filter(((_, r, _), _) -> (r, 1) eq) | map(((a, _, b), (c)) -> ((b), (1, a, c)));
  let read_entries_idx = read_entries | arrange;
- let store_idx = store | arrange;
- let store_entries = read_entries_idx | join(store_idx, ((k), _, (sw, v)) -> ((k), (0, sw, v)));
+ let store_entries = read_entries_idx | join(store, ((k), _, (sw, v)) -> ((k), (0, sw, v)));
  res: {
      -- Time lanes: epoch, then 1 scope coordinates; this scope enters at zero.
      var rollback;
@@ -26,7 +25,7 @@
      let writes_neg = wr_bad | negate;
      let writes = ::wid + writes_neg;
      let write_entries = writes | map(((wid), (k, v)) -> ((k), (0, wid, v)));
-@@ -37,7 +33,6 @@
+@@ -36,7 +32,6 @@
      set rollback = rollback_reduce;
  }
  let rb = res::rollback;
@@ -34,13 +33,3 @@
  let rb_idx = rb | arrange;
  let wbad = wid_idx | join(rb_idx, (wid, kv, ()) -> (wid, kv));
  let committed_neg = wbad | negate;
-@@ -46,8 +41,7 @@
- let latest_idx = latest_map | arrange;
- let latest = latest_idx | reduce(limit 1, (_, vals) -> let first = vals head in (first.0, 1) enlist);
- let new_rows = latest | map(((k), (nw, v)) -> ((k), (nw neg, v)));
--let store_idx2 = store | arrange;
--let old_rows = latest | join(store_idx2, ((k), _, (sw, sv)) -> ((k), (sw, sv)));
-+let old_rows = latest | join(store_idx, ((k), _, (sw, sv)) -> ((k), (sw, sv)));
- let delta_neg = old_rows | negate;
- let delta_rows = new_rows + delta_neg;
- -- Renderer: build an export arrangement.
diff --git a/interactive/tests/plan_pairs/expected/txn_resolve_by_key.parsed--lowered.diff b/interactive/tests/plan_pairs/expected/txn_resolve_by_key.parsed--lowered.diff
index 1a339c191..08225ff3a 100644
--- a/interactive/tests/plan_pairs/expected/txn_resolve_by_key.parsed--lowered.diff
+++ b/interactive/tests/plan_pairs/expected/txn_resolve_by_key.parsed--lowered.diff
@@ -1,6 +1,6 @@
 --- parsed
 +++ lowered
-@@ -1,15 +1,28 @@
+@@ -1,15 +1,27 @@
 +-- Time lanes: epoch.
 +-- Trace imports use provider arrangements; history advances to G = (0, []).
  let store = import "store::store" : ((int), (int, int));
@@ -15,8 +15,7 @@
  let read_entries = reads | map(((rid, k), (e)) -> ((k), (1, rid, e)));
 -let store_entries = read_entries | join(store, ((k), _, (sw, v)) -> ((k), (0, sw, v)));
 +let read_entries_idx = read_entries | arrange;
-+let store_idx = store | arrange;
-+let store_entries = read_entries_idx | join(store_idx, ((k), _, (sw, v)) -> ((k), (0, sw, v)));
++let store_entries = read_entries_idx | join(store, ((k), _, (sw, v)) -> ((k), (0, sw, v)));
  res: {
 -    let wr_bad = wid | join(rollback, (wid, kv, ()) -> (wid, kv));
 -    let writes = wid + (wr_bad | negate);
@@ -35,7 +34,7 @@
          let ws = (entries map ((t, _, _) -> (t, 0) eq), entries) zip filter in
          let rs = (entries map ((t, _, _) -> (t, 1) eq), entries) zip filter in
          let judged = (ws, rs) cap_list map ((ws, (_, i, x)) ->
-@@ -18,13 +31,26 @@
+@@ -18,13 +30,25 @@
              let (bid, bv) = best in
              (((bid, -1) eq, (x, -1) ne, (bv, x) ne) select, ((i), 1))) in
          (judged map ((b, _) -> b), judged map ((_, o) -> o)) zip filter);
@@ -58,9 +57,7 @@
 +let latest_idx = latest_map | arrange;
 +let latest = latest_idx | reduce(limit 1, (_, vals) -> let first = vals head in (first.0, 1) enlist);
  let new_rows = latest | map(((k), (nw, v)) -> ((k), (nw neg, v)));
--let old_rows = latest | join(store, ((k), _, (sw, sv)) -> ((k), (sw, sv)));
-+let store_idx2 = store | arrange;
-+let old_rows = latest | join(store_idx2, ((k), _, (sw, sv)) -> ((k), (sw, sv)));
+ let old_rows = latest | join(store, ((k), _, (sw, sv)) -> ((k), (sw, sv)));
 +let delta_neg = old_rows | negate;
 +let delta_rows = new_rows + delta_neg;
 +-- Renderer: build an export arrangement.
diff --git a/interactive/tests/server_arranged_imports.rs b/interactive/tests/server_arranged_imports.rs
index 4f1d92818..8cfe485a8 100644
--- a/interactive/tests/server_arranged_imports.rs
+++ b/interactive/tests/server_arranged_imports.rs
@@ -99,3 +99,43 @@ fn scenario(arranged: bool) -> Vec<Snapshot> {
 fn arranged_imports_answer_as_unarranged_imports_do() {
     assert_eq!(scenario(true), scenario(false));
 }
+
+/// How many arrange operators installing a consumer whose two joins read one trace import builds,
+/// with arranged imports `arranged`.
+fn import_arranges(arranged: bool) -> usize {
+    use std::cell::RefCell;
+    use std::rc::Rc;
+    use timely::logging::{TimelyEvent, TimelyEventBuilder};
+    const READER: &str = r#"
+        let edges = import "prod::edges";
+        let roots = input 0 : ((int), ()) | map(((n), ()) -> (n, ()));
+        output "out" = roots | join(edges, (n, _, dst) -> (dst, n));
+        output "in" = roots | join(edges, (n, _, dst) -> (n, dst));
+    "#;
+    timely::execute_directly(move |worker| {
+        let mut server = Server::new();
+        server.set_arranged_imports(arranged);
+        install(&mut server, worker, "prod", PRODUCER);
+        server.tick(worker);
+        let names: Rc<RefCell<Vec<String>>> = Rc::default();
+        let sink = Rc::clone(&names);
+        worker.log_register().unwrap().insert::<TimelyEventBuilder, _>("timely", move |_, data| {
+            if let Some(data) = data {
+                for (_, event) in data.iter() {
+                    if let TimelyEvent::Operates(op) = event { sink.borrow_mut().push(op.name.clone()); }
+                }
+            }
+        });
+        install(&mut server, worker, "reader", READER);
+        server.tick(worker);
+        worker.log_register().unwrap().remove("timely");
+        let count = names.borrow().iter().filter(|n| *n == "CorgiArrange").count();
+        count
+    })
+}
+
+/// A trace import that arrives as rows is arranged once, and both joins read that arrangement.
+#[test]
+fn unarranged_import_is_arranged_once() {
+    assert_eq!(import_arranges(false), import_arranges(true) + 1);
+}
diff --git a/interactive/tests/variadic_reduce.rs b/interactive/tests/variadic_reduce.rs
new file mode 100644
index 000000000..b6fadcec1
--- /dev/null
+++ b/interactive/tests/variadic_reduce.rs
@@ -0,0 +1,658 @@
+//! Bracket lists: `[a, -b] | reduce` reduces the signed sum of its elements as one merged reduce.
+//! Extra inputs: `a | reduce(b, (k, la, lb) -> ..)` is a grouped reduce, one value list per input.
+//!
+//! The tests check lowering, the answers against the same programs written as concatenations,
+//! shape inference in loops, and the parse errors.
+
+use std::collections::BTreeMap;
+
+use interactive::scope_ir::{Item, Node, ReduceInput, Ref};
+use interactive::server::Server;
+
+type Rows = Vec<(String, String, i64)>;
+
+/// Run `src` on `epochs`, each a list of feed lines per input, through `workers` workers, ticking
+/// after each epoch. Returns, per epoch, each output's sorted rows.
+fn run(workers: usize, src: &str, passes: Option<&str>, epochs: Vec<Vec<Vec<String>>>) -> Vec<BTreeMap<String, Rows>> {
+    let program = interactive::lower::lower_tree(interactive::parse::pipe::parse(src));
+    let passes = passes.map(|p| interactive::passes::Config::parse(p).unwrap());
+    let guards = timely::execute(timely::Config::process(workers), move |worker| {
+        let mut server = Server::new();
+        if let Some(passes) = passes { server.set_passes(passes); }
+        server.install(worker, "p", &program).expect("install");
+        let mut out = Vec::new();
+        for epoch in &epochs {
+            for (input, rows) in epoch.iter().enumerate() {
+                let shard: Vec<&str> = rows.iter().skip(worker.index()).step_by(worker.peers()).map(String::as_str).collect();
+                server.feed("p", input, &shard.join("\n"), None).expect("feed");
+            }
+            server.tick(worker);
+            let snapshots = program.root.exports.iter().map(|e| {
+                let mut rows = server.snapshot(worker, &format!("p::{}", e.name)).expect("snapshot").rows();
+                rows.sort();
+                (e.name.clone(), rows)
+            }).collect();
+            out.push(snapshots);
+        }
+        out
+    }).expect("workers");
+    guards.join().into_iter().next().unwrap().unwrap()
+}
+
+fn lines(rows: &[(i64, i64, i64)]) -> Vec<String> {
+    rows.iter().map(|(k, v, d)| format!("{k} val={v} diff={d}")).collect()
+}
+
+/// The panic text of parsing `src`.
+fn parse_error(src: &str) -> String {
+    let src = src.to_string();
+    let payload = std::panic::catch_unwind(move || { interactive::parse::pipe::parse(&src); }).expect_err("the program parses");
+    payload.downcast_ref::<String>().cloned().or_else(|| payload.downcast_ref::<&str>().map(|s| s.to_string())).expect("a text panic")
+}
+
+const LIST_MISUSE: &str = "a list of collections is the input of a reduce";
+
+#[test]
+fn list_lowers_to_merged() {
+    let src = r#"
+        let a = input 0 : (int, int) | arrange;
+        let b = input 1 : (int, int) | arrange;
+        output "o" = [a, -b] | count;
+    "#;
+    let program = interactive::lower::lower_tree(interactive::parse::pipe::parse(src));
+    let items = &program.root.items;
+    let arranges: Vec<usize> = (0..items.len()).filter(|i| matches!(&items[*i], Item::Op(Node::Arrange(_)))).collect();
+    assert_eq!(arranges.len(), 2, "{items:?}");
+    let reduces: Vec<&ReduceInput> = items.iter().filter_map(|i| match i { Item::Op(Node::Reduce { input, .. }) => Some(input), _ => None }).collect();
+    assert_eq!(reduces.len(), 1);
+    assert_eq!(*reduces[0], ReduceInput::Merged(vec![(Ref::Local(arranges[0]), 1), (Ref::Local(arranges[1]), -1)]));
+}
+
+#[test]
+fn list_answers_match_concat() {
+    let epochs = vec![
+        vec![lines(&[(1, 5, 1), (1, 7, 2), (2, 3, 1), (3, 1, 1)]), lines(&[(1, 5, 1), (3, 9, 1), (1, 6, 1)]), lines(&[(1, 7, 1), (2, 3, 1)])],
+        vec![lines(&[(1, 5, -1), (4, 4, 1)]), lines(&[(3, 9, -1), (2, 3, 1), (4, 4, 1)]), lines(&[(1, 7, -1), (3, 1, 1)])],
+        vec![lines(&[(1, 7, -2), (2, 3, -1)]), lines(&[(1, 5, -1), (1, 6, 1), (2, 3, -1)]), lines(&[(4, 4, 1), (1, 6, 1)])],
+    ];
+    // The list, then the concatenation it denotes. A lambda inside an element must still lex.
+    let cases = [
+        ("[a, -b] | count", "a - b | count"),
+        ("[a, -b] | min", "a - b | min"),
+        ("[a, -b] | collect", "a - b | collect"),
+        ("[a, -b] | reduce((k, vals) -> vals)", "a - b | reduce((k, vals) -> vals)"),
+        ("[a, -b] | reduce(limit 1, (k, vals) -> vals)", "a - b | reduce(limit 1, (k, vals) -> vals)"),
+        ("[-a] | count", "a | negate | count"),
+        ("[a, b - c] | distinct", "a + b - c | distinct"),
+        ("[a | map((k, v) -> (k, v)), -b] | distinct", "a | map((k, v) -> (k, v)) - b | distinct"),
+        ("[a, -b | filter((k, v) -> v)] | distinct", "a - (b | filter((k, v) -> v)) | distinct"),
+        ("[a] | distinct", "a | distinct"),
+    ];
+    let program = |expr: &str| format!("let a = input 0 : (int, int); let b = input 1 : (int, int); let c = input 2 : (int, int); output \"o\" = {expr};");
+    for workers in [1, 3] {
+        for passes in [None, Some("none")] {
+            for (list, concat) in cases {
+                let expected = run(workers, &program(concat), passes, epochs.clone());
+                assert_eq!(run(workers, &program(list), passes, epochs.clone()), expected, "{list} on {workers} workers, passes {passes:?}");
+            }
+        }
+    }
+    // `-b` exceeds `a` at keys 8 and 9, so their counts are negative. Key 8's value 1 nets to -2
+    // and then to 0, and key 9 holds only `b`.
+    let negative = vec![
+        vec![lines(&[(8, 1, 1), (8, 2, 1), (7, 1, 1)]), lines(&[(8, 1, 3), (9, 4, 2), (7, 1, 1)]), vec![]],
+        vec![lines(&[(8, 1, 2), (9, 4, 1)]), lines(&[(8, 2, 2), (7, 1, -1)]), vec![]],
+        vec![lines(&[(8, 2, -1)]), lines(&[(9, 4, -3), (8, 1, 1)]), vec![]],
+    ];
+    for workers in [1, 3] {
+        for passes in [None, Some("none")] {
+            for (list, concat) in [("[a, -b] | count", "a - b | count"), ("[a, -b] | distinct", "a - b | distinct")] {
+                let expected = run(workers, &program(concat), passes, negative.clone());
+                assert_eq!(run(workers, &program(list), passes, negative.clone()), expected, "{list} on {workers} workers, passes {passes:?}");
+            }
+        }
+    }
+}
+
+/// A merged reduce in a loop, against the same program written as a concatenation, with every pass
+/// off. Input 0 holds blocked nodes, input 1 roots, and the loop reaches `n -> n+1` and `n -> n+3`
+/// below 200 avoiding blocked nodes. The reduce reads an arrangement built in the loop and one
+/// entered from outside, once added and once negated.
+#[test]
+fn merged_loop_matches_concat() {
+    // `cand` and `blocked` are arranged, and a key of `reach` survives when `cand` holds it and
+    // `blocked` does not.
+    let added = |reach: &str| format!(r#"
+        let blocked = input 0 : ((int), ()) | reduce((_, vals) -> ((1), 1) enlist);
+        let roots = input 1 : ((int), ()) | distinct;
+        r: {{
+            let step = (reach | map(((n), ()) -> (((n, 1) add), ()))) + (reach | map(((n), ()) -> (((n, 3) add), ()))) | filter(((m), ()) -> (m, 200) lt);
+            let cand = roots + step | reduce((_, vals) -> ((0), 1) enlist);
+            set reach = {reach} | reduce((_, vals) -> let h = vals head in (((vals len, 1) eq, (h.0.0, 0) eq) mul, ((), 1)) enlist filter);
+        }}
+        output "reach" = r::reach;
+        output "count" = r::reach | map(((n), ()) -> ((), ())) | count;
+    "#);
+    let negated = |reach: &str| format!(r#"
+        let blocked = input 0 : ((int), ()) | distinct;
+        let roots = input 1 : ((int), ()) | distinct;
+        r: {{
+            let step = (reach | map(((n), ()) -> (((n, 1) add), ()))) + (reach | map(((n), ()) -> (((n, 3) add), ()))) | filter(((m), ()) -> (m, 200) lt);
+            let cand = roots + step | distinct;
+            set reach = {reach} | reduce((_, vals) -> (((0, vals) fold ((acc, (_, d)) -> (acc, d) add), 0) gt, ((), 1)) enlist filter);
+        }}
+        output "reach" = r::reach;
+        output "count" = r::reach | map(((n), ()) -> ((), ())) | count;
+    "#);
+    // 25 ticks. Each blocks six nodes and unblocks two blocked earlier. Roots 0 and 50 come first,
+    // root 50 is retracted at tick 10 and root 7 added at tick 15.
+    let mut state = 0x2545_F491_4F6C_DD1Du64;
+    let mut next = move |bound: u64| { state ^= state << 13; state ^= state >> 7; state ^= state << 17; state % bound };
+    let mut blocked: Vec<u64> = Vec::new();
+    let mut epochs = Vec::new();
+    for tick in 0..25 {
+        let mut feed = Vec::new();
+        for _ in 0..6 {
+            let n = next(200);
+            blocked.push(n);
+            feed.push(format!("{n}"));
+        }
+        for _ in 0..2 {
+            let n = blocked.swap_remove(usize::try_from(next(u64::try_from(blocked.len()).unwrap())).unwrap());
+            feed.push(format!("{n} diff=-1"));
+        }
+        let roots = match tick {
+            0 => vec!["0".to_string(), "50".to_string()],
+            10 => vec!["50 diff=-1".to_string()],
+            15 => vec!["7".to_string()],
+            _ => vec![],
+        };
+        epochs.push(vec![feed, roots]);
+    }
+    for workers in [1, 4] {
+        for (program, list, concat) in [(added as fn(&str) -> String, "[cand, blocked]", "cand + blocked"), (negated, "[cand, -blocked]", "cand - blocked")] {
+            let expected = run(workers, &program(concat), Some("none"), epochs.clone());
+            assert!(expected.iter().any(|epoch| !epoch["reach"].is_empty()), "the loop reaches nodes");
+            assert!(expected.windows(2).filter(|w| w[0]["reach"] != w[1]["reach"]).count() > 10, "the reached nodes change");
+            // The merge-reduce pass also merges `cand`'s concatenation of an arranged `roots`, so
+            // the list's reduce is one of two. The concatenation form fuses the same way.
+            let many = |src: &str| operator_names(src).iter().filter(|n| *n == "CorgiReduceMany").count();
+            assert_eq!(many(&program(list)), 2, "{list}: {:?}", operator_names(&program(list)));
+            assert_eq!(many(&program(concat)), 2, "{concat}: {:?}", operator_names(&program(concat)));
+            assert_eq!(run(workers, &program(list), Some("none"), epochs.clone()), expected, "{list} on {workers} workers");
+            // The concatenation with default passes, merging on, answers as the unmerged form does.
+            assert_eq!(run(workers, &program(concat), None, epochs.clone()), expected, "{concat} with default passes on {workers} workers");
+        }
+    }
+}
+
+#[test]
+fn list_in_loop_infers_shape() {
+    // The list's reduce is the left operand of `+`, which pins stage precedence.
+    let src = r#"
+        let seed = input 0 : (int, int);
+        let blocked = input 1 : (int, int);
+        s: { set x = [::seed, -::blocked] | distinct + (x | map((k, v) -> (k, v))) | distinct; }
+        output "o" = s::x;
+    "#;
+    let epochs = vec![
+        vec![lines(&[(1, 1, 1), (2, 2, 1), (3, 3, 1)]), lines(&[(2, 2, 1)])],
+        vec![lines(&[(4, 4, 1)]), lines(&[(1, 1, 1), (2, 2, -1)])],
+    ];
+    let plain = r#"
+        let seed = input 0 : (int, int);
+        let blocked = input 1 : (int, int);
+        s: { set x = (::seed - ::blocked | distinct) + (x | map((k, v) -> (k, v))) | distinct; }
+        output "o" = s::x;
+    "#;
+    for workers in [1, 2] {
+        assert_eq!(run(workers, src, None, epochs.clone()), run(workers, plain, None, epochs.clone()));
+    }
+    // No `var` declares x's shape: it comes from the list's elements.
+    let looped = r#"
+        let seed = input 0 : (int, int);
+        s: { set x = [::seed, -x] | distinct; }
+        output "o" = s::x;
+    "#;
+    let mut program = interactive::lower::lower_tree(interactive::parse::pipe::parse(looped));
+    interactive::passes::optimize(&mut program);
+    let (_, problems) = interactive::shapes::infer(&program, &|_| None, 1);
+    assert!(problems.conflicts.is_empty(), "{:?}", problems.conflicts);
+}
+
+#[test]
+fn by_record_distinct_element_is_arranged() {
+    let src = r#"
+        let a = input 0 : (int, int);
+        let b = input 1 : (int, int);
+        output "o" = [a | distinct, -b] | distinct;
+    "#;
+    let lowered = interactive::lower::lower_tree(interactive::parse::pipe::parse(src));
+    let items = &lowered.root.items;
+    let mut merged = 0;
+    for item in items {
+        let Item::Op(Node::Reduce { input: ReduceInput::Merged(inputs), .. }) = item else { continue };
+        if inputs.len() < 2 { continue }
+        merged += 1;
+        for (r, _) in inputs {
+            let Ref::Local(i) = r else { panic!("{r:?}") };
+            assert!(matches!(&items[*i], Item::Op(Node::Arrange(_) | Node::Reduce { .. })), "{:?}", items[*i]);
+        }
+    }
+    assert_eq!(merged, 1);
+    let epochs = vec![
+        vec![lines(&[(1, 5, 2), (2, 3, 1), (3, 1, 1)]), lines(&[(1, 5, 1), (3, 9, 1)])],
+        vec![lines(&[(1, 5, -1), (4, 4, 1)]), lines(&[(2, 3, 1), (4, 4, 1)])],
+        vec![lines(&[(1, 5, -1), (2, 3, -1)]), lines(&[(1, 5, -1), (2, 3, -1)])],
+    ];
+    let program = |expr: &str| format!("let a = input 0 : (int, int); let b = input 1 : (int, int); output \"o\" = {expr};");
+    for workers in [1, 3] {
+        assert_eq!(
+            run(workers, &program("[a | distinct, -b] | distinct"), None, epochs.clone()),
+            run(workers, &program("(a | distinct) - b | distinct"), None, epochs.clone()),
+        );
+    }
+}
+
+#[test]
+fn list_misuse_is_rejected() {
+    for src in [
+        "let a = input 0 : (int, int); let b = input 1 : (int, int); let p = [a, -b];",
+        "let a = input 0 : (int, int); output \"o\" = [a];",
+        "let a = input 0 : (int, int); let b = input 1 : (int, int); output \"o\" = [a, -b] | map((k, v) -> (k, v));",
+        "let a = input 0 : (int, int); let b = input 1 : (int, int); output \"o\" = [a] + b;",
+        "let a = input 0 : (int, int); let b = input 1 : (int, int); output \"o\" = a + [b];",
+    ] {
+        assert_eq!(parse_error(src), LIST_MISUSE, "{src}");
+    }
+}
+
+/// The names of the operators installing `src` builds on one worker, with default passes.
+fn operator_names(src: &str) -> Vec<String> { operator_names_with(src, None) }
+
+/// The names of the operators installing `src` builds on one worker, with the passes `passes` names.
+fn operator_names_with(src: &str, passes: Option<&str>) -> Vec<String> {
+    use std::cell::RefCell;
+    use std::rc::Rc;
+    use timely::logging::{TimelyEvent, TimelyEventBuilder};
+    let program = interactive::lower::lower_tree(interactive::parse::pipe::parse(src));
+    let passes = passes.map(|p| interactive::passes::Config::parse(p).unwrap());
+    timely::execute_directly(move |worker| {
+        let names: Rc<RefCell<Vec<String>>> = Rc::default();
+        let sink = Rc::clone(&names);
+        worker.log_register().unwrap().insert::<TimelyEventBuilder, _>("timely", move |_, data| {
+            if let Some(data) = data {
+                for (_, event) in data.iter() {
+                    if let TimelyEvent::Operates(op) = event { sink.borrow_mut().push(op.name.clone()); }
+                }
+            }
+        });
+        let mut server = Server::new();
+        if let Some(passes) = passes { server.set_passes(passes); }
+        server.install(worker, "p", &program).expect("install");
+        server.tick(worker);
+        worker.log_register().unwrap().remove("timely");
+        let names = names.borrow().clone();
+        names
+    })
+}
+
+#[test]
+fn merged_reduce_reads_input_arrangements() {
+    let names = operator_names(r#"
+        let a = input 0 : (int, int) | arrange;
+        let b = input 1 : (int, int) | arrange;
+        output "o" = [a, -b] | count;
+    "#);
+    let count = |name: &str| names.iter().filter(|n| *n == name).count();
+    assert_eq!(count("CorgiReduceMany"), 1, "{names:?}");
+    assert_eq!(count("CorgiReduce"), 0, "{names:?}");
+    // The arrangements of `a` and `b`, and no arrangement of their concatenation.
+    assert_eq!(count("CorgiArrange"), 2, "{names:?}");
+    assert_eq!(count("Concatenate"), 0, "{names:?}");
+}
+
+/// Each key's lists, as the lambda is handed them: retractions, values in one input only, equal
+/// values in both inputs (which must not cancel), and keys in some inputs only.
+#[test]
+fn grouped_hands_one_list_per_input() {
+    let src = r#"
+        let a = input 0 : (int, int);
+        let b = input 1 : (int, int);
+        output "co" = a | reduce(b, (_, va, vb) -> ((va, vb), 1) enlist);
+    "#;
+    let epochs = vec![
+        vec![lines(&[(1, 5, 1), (1, 7, 2), (2, 3, 1)]), lines(&[(1, 5, 1), (3, 9, 1), (1, 6, -1)])],
+        vec![lines(&[(1, 5, -1)]), lines(&[(3, 9, -1), (2, 3, 1)])],
+        vec![lines(&[(1, 7, -2), (2, 3, -1)]), lines(&[(1, 5, -1), (1, 6, 1), (2, 3, -1)])],
+    ];
+    let want = |rows: &[(&str, &str)]| -> Rows { rows.iter().map(|(k, v)| (k.to_string(), v.to_string(), 1)).collect() };
+    let expected = [
+        want(&[
+            ("1", "tuple(list(tuple(5,1),tuple(7,2)),list(tuple(5,1),tuple(6,-1)))"),
+            ("2", "tuple(list(tuple(3,1)),list())"),
+            ("3", "tuple(list(),list(tuple(9,1)))"),
+        ]),
+        want(&[
+            ("1", "tuple(list(tuple(7,2)),list(tuple(5,1),tuple(6,-1)))"),
+            ("2", "tuple(list(tuple(3,1)),list(tuple(3,1)))"),
+        ]),
+        want(&[]),
+    ];
+    for workers in [1, 3] {
+        for passes in [None, Some("none")] {
+            let got = run(workers, src, passes, epochs.clone());
+            for (epoch, want_rows) in expected.iter().enumerate() {
+                assert_eq!(&got[epoch]["co"], want_rows, "workers={workers}, passes {passes:?}, epoch={epoch}");
+            }
+        }
+    }
+    // Every input is arranged, and the reduce reads the arrangements.
+    let program = interactive::lower::lower_tree(interactive::parse::pipe::parse(src));
+    let items = &program.root.items;
+    let grouped: Vec<&Vec<Ref>> = items.iter().filter_map(|i| match i { Item::Op(Node::Reduce { input: ReduceInput::Grouped(v), limit: None, .. }) => Some(v), _ => None }).collect();
+    assert_eq!(grouped.len(), 1, "{items:?}");
+    assert_eq!(grouped[0].len(), 2);
+    for r in grouped[0] {
+        let Ref::Local(i) = r else { panic!("{r:?}") };
+        assert!(matches!(&items[*i], Item::Op(Node::Arrange(_))), "{:?}", items[*i]);
+    }
+    let names = operator_names(src);
+    assert_eq!(names.iter().filter(|n| *n == "CorgiReduceMany").count(), 1, "{names:?}");
+}
+
+/// A small deterministic generator.
+struct Rng(u64);
+impl Rng {
+    fn next(&mut self, n: u64) -> i64 {
+        self.0 = self.0.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
+        i64::try_from((self.0 >> 33) % n).unwrap()
+    }
+}
+
+/// A grouped reduce over three inputs, one of them pair-valued, keyed by a hashed compound key,
+/// agrees with a tagged concatenation reduced by a plain `reduce`, whose sorted values are the
+/// lists one after the other.
+#[test]
+fn grouped_matches_tagged_concat() {
+    let src = r#"
+        let a = input 0 : (int, int) | map((k, v) -> ((k, (k, 3) mul), v));
+        let b = input 1 : (int, int) | map((k, v) -> ((k, (k, 3) mul), v));
+        let c = input 2 : (int, (int, int)) | map((k, v) -> ((k, (k, 3) mul), v));
+        output "co" = a | reduce(b, c, (_, va, vb, vc) ->
+            (((va map ((v, d) -> ((0, (v, 0)), d)), vb map ((v, d) -> ((1, (v, 0)), d))) append,
+              vc map ((v, d) -> ((2, v), d))) append, 1) enlist);
+        output "ref" = (a | map((k, v) -> (k, (0, (v, 0)))))
+            + (b | map((k, v) -> (k, (1, (v, 0)))))
+            + (c | map((k, v) -> (k, (2, v))))
+            | reduce((_, vals) -> (vals, 1) enlist);
+    "#;
+    let mut rng = Rng(0x5EED);
+    let mut held: [Vec<(i64, String)>; 3] = Default::default();
+    let mut epochs = Vec::new();
+    for _ in 0..3 {
+        let mut epoch = Vec::new();
+        for (input, pool) in held.iter_mut().enumerate() {
+            let mut rows = Vec::new();
+            for _ in 0..40 {
+                // Retract a held row, or add a new one.
+                if !pool.is_empty() && rng.next(3) == 0 {
+                    let (k, v) = pool.swap_remove(usize::try_from(rng.next(u64::try_from(pool.len()).unwrap())).unwrap());
+                    rows.push(format!("{k} val={v} diff=-1"));
+                } else {
+                    let k = rng.next(12);
+                    let v = if input == 2 { format!("tuple({},{})", rng.next(3), rng.next(3)) } else { rng.next(4).to_string() };
+                    let d = [1, 1, 2, -1][usize::try_from(rng.next(4)).unwrap()];
+                    for _ in 0..d.max(0) { pool.push((k, v.clone())); }
+                    rows.push(format!("{k} val={v} diff={d}"));
+                }
+            }
+            epoch.push(rows);
+        }
+        epochs.push(epoch);
+    }
+    for workers in [1, 3] {
+        for passes in [None, Some("none")] {
+            let got = run(workers, src, passes, epochs.clone());
+            for (epoch, outputs) in got.iter().enumerate() {
+                assert!(!outputs["ref"].is_empty());
+                assert_eq!(outputs["co"], outputs["ref"], "workers={workers}, passes {passes:?}, epoch={epoch}");
+            }
+        }
+    }
+}
+
+/// A grouped reduce reads a feedback variable that declares no shape: the variable's shape comes
+/// from `seed`, and the reduce's once it is known. Each key's `x` holds its `seed` value and the
+/// count of its `x` values plus its `other` values, iterated to a fixed point.
+#[test]
+fn grouped_in_loop_without_var() {
+    let src = r#"
+        let seed = input 0 : (int, int);
+        let other = input 1 : (int, int);
+        s: {
+            let g = x | reduce(::other, (_, lx, lo) -> ((lx len, lo len) add, 1) enlist);
+            set x = ::seed + g | distinct;
+        }
+        output "o" = s::x;
+    "#;
+    let mut program = interactive::lower::lower_tree(interactive::parse::pipe::parse(src));
+    interactive::passes::optimize(&mut program);
+    let (_, problems) = interactive::shapes::infer(&program, &|_| None, 1);
+    assert!(problems.conflicts.is_empty() && problems.unknown.is_empty(), "{problems:?}");
+    // Key 1: seed 5 and two others give {2, 5}, then {4, 5}. Key 2: seed 1 and no others give {1}.
+    // Key 3: no seed and one other give {1}, then {2}. Retracting an other of key 1 gives {3, 5}.
+    let epochs = vec![
+        vec![lines(&[(1, 5, 1), (2, 1, 1)]), lines(&[(1, 7, 1), (1, 8, 1), (3, 4, 1)])],
+        vec![vec![], lines(&[(1, 8, -1)])],
+    ];
+    let want = |rows: &[(i64, i64)]| -> Rows { rows.iter().map(|(k, v)| (k.to_string(), v.to_string(), 1)).collect() };
+    for workers in [1, 2] {
+        for passes in [None, Some("none")] {
+            let got = run(workers, src, passes, epochs.clone());
+            assert_eq!(got[0]["o"], want(&[(1, 4), (1, 5), (2, 1), (3, 2)]), "workers={workers}, passes {passes:?}");
+            assert_eq!(got[1]["o"], want(&[(1, 3), (1, 5), (2, 1), (3, 2)]), "workers={workers}, passes {passes:?}");
+        }
+    }
+}
+
+/// A grouped reduce whose other input never gets a shape fails inference, naming that input.
+#[test]
+fn grouped_unknown_input_is_named() {
+    let src = r#"
+        let a = input 0 : (int, int);
+        let b = input 1;
+        output "o" = a | reduce(b, (_, la, lb) -> (la len, 1) enlist);
+    "#;
+    let mut program = interactive::lower::lower_tree(interactive::parse::pipe::parse(src));
+    interactive::passes::optimize(&mut program);
+    let (_, problems) = interactive::shapes::infer(&program, &|_| None, 1);
+    assert!(problems.conflicts.is_empty(), "{problems:?}");
+    assert!(problems.unknown.iter().any(|e| e.contains("reduce input 1") && e.contains("has no shape")), "{problems:?}");
+}
+
+#[test]
+fn grouped_rejects_limit() {
+    let src = "let a = input 0 : (int, int); let b = input 1 : (int, int); output \"o\" = a | reduce(limit 2, b, (k, la, lb) -> la);";
+    assert_eq!(parse_error(src), "a reduce over several inputs takes no limit");
+    // `limit` is the keyword only before an integer, so a collection may be named `limit`.
+    let limit_src = "let a = input 0 : (int, int); let limit = input 1 : (int, int); output \"o\" = a | reduce(limit, (k, la, lb) -> la);";
+    let program = interactive::lower::lower_tree(interactive::parse::pipe::parse(limit_src));
+    assert!(program.root.items.iter().any(|i| matches!(i, Item::Op(Node::Reduce { input: ReduceInput::Grouped(v), .. }) if v.len() == 2)), "{:?}", program.root.items);
+    // A list is a merged reduce's input, and takes no further inputs.
+    let list_src = "let a = input 0 : (int, int); let b = input 1 : (int, int); let c = input 2 : (int, int); output \"o\" = [a, -b] | reduce(c, (k, la, lb) -> la);";
+    assert_eq!(parse_error(list_src), "a list of collections cannot take extra reduce inputs");
+}
+
+/// The shapes of the imports a printed program names: `p::x` is `(int, int)`.
+fn import_source(name: &str) -> Option<interactive::scope_ir::RowShape> {
+    (name == "p::x").then_some((corgi::Shape::Int, corgi::Shape::Int))
+}
+
+/// Plans `src` with the passes `config`, prints the optimized stage, replans the text with no
+/// passes, and checks the two plans compare equal and the second print equals the first.
+fn assert_printed_replans(src: &str, config: &interactive::passes::Config, expect: &str) {
+    use interactive::plan::{self, ddp::DdpStage};
+    let first = plan::report(src, &import_source, config).unwrap_or_else(|e| panic!("{src}: {e}"));
+    let text = first.emit_ddp_at(DdpStage::Optimized).unwrap_or_else(|e| panic!("{src}: {e}")).text;
+    assert!(text.contains(expect), "{src}: expected `{expect}` in\n{text}");
+    let second = plan::report(&text, &import_source, &interactive::passes::Config::none()).unwrap_or_else(|e| panic!("{src}: printed text does not replan: {e}\n{text}"));
+    assert!(second.stages.iter().all(|s| s.problems.is_empty()), "{src}: {text}");
+    assert_eq!(first.compare_final(&second), Vec::<String>::new(), "{src}: {text}");
+    assert_eq!(second.emit_ddp_at(DdpStage::Optimized).unwrap().text, text, "{src}");
+}
+
+#[test]
+fn printed_reduces_replan_identically() {
+    let header = r#"
+        let a = input 0 : (int, int) | arrange;
+        let b = input 1 : (int, int) | arrange;
+        let c = input 2 : (int, int) | arrange;
+        let imp = import "p::x" : (int, int);
+    "#;
+    let cases = [
+        ("output \"o\" = [a, -b] | count;", "[a, -b] | reduce("),
+        ("output \"o\" = [-a] | count;", "[-a] | reduce("),
+        ("output \"o\" = [imp, -b] | min;", "[imp, -b] | reduce("),
+        ("output \"o\" = [a, b - c] | distinct;", "] | reduce("),
+        ("output \"o\" = [a, -b] | reduce(limit 1, (k, vals) -> vals);", "reduce(limit 1, "),
+        ("output \"o\" = a | reduce(b, c, (k, la, lb, lc) -> la);", "a | reduce(b, c, "),
+        ("output \"o\" = a | reduce(b | filter((k, v) -> (k, 0) gt), (k, la, lb) -> la);", "reduce("),
+    ];
+    for (body, expect) in cases { assert_printed_replans(&format!("{header}{body}"), &interactive::passes::Config::none(), expect); }
+}
+
+/// The merge-reduce pass's output prints and replans: each program is planned with the default
+/// passes, so the pass fires, and its optimized text replans with none to the same plan.
+#[test]
+fn merged_by_the_pass_replans_identically() {
+    let header = r#"
+        let a = input 0 : (int, int) | arrange;
+        let b = input 1 : (int, int) | arrange;
+        let d = input 2 : (int, int);
+        let e = input 3 : (int, int);
+        let f = input 4 : (int, int);
+    "#;
+    let cases = [
+        // One arranged leaf, and the unarranged ones share one arrangement of their signed concat.
+        ("output \"o\" = a + d + e - f | count;", "let o_idx = o_rows | arrange;\nlet o_reduce = [a, o_idx] | reduce("),
+        // A single negated unarranged leaf keeps its sign.
+        ("output \"o\" = a - d | count;", "[a, -d_idx] | reduce("),
+        ("output \"o\" = a | negate | count;", "[-a] | reduce("),
+        ("output \"o\" = a + a | count;", "[a, a] | reduce("),
+    ];
+    for (body, expect) in cases { assert_printed_replans(&format!("{header}{body}"), &interactive::passes::Config::default(), expect); }
+    // A merged reduce in a loop, of two outer arrangements and the loop's own arrangement.
+    let looped = r#"
+        let seed = input 0 : (int, ()) | arrange;
+        let blocked = input 1 : (int, ()) | arrange;
+        s: { set x = (::seed - ::blocked + x) | distinct; }
+        output "o" = s::x;
+    "#;
+    assert_printed_replans(looped, &interactive::passes::Config::default(), "[::seed, -::blocked, ");
+    // A merged reduce of a child scope that hoisting moves out of it.
+    let hoisted = r#"
+        let a = input 0 : (int, int) | arrange;
+        let d = input 1 : (int, int);
+        let roots = input 2 : (int, int);
+        s: {
+            let c = ::a - ::d | count;
+            set x = (roots + (x | join(c, (k, v, n) -> (k, v)))) | distinct;
+        }
+        output "o" = s::x;
+    "#;
+    assert_printed_replans(hoisted, &interactive::passes::Config::default(), "\nlet c = [a, -d_idx] | reduce(");
+}
+
+/// `[e]` is `e`, so `[a] | distinct` prints with the same by-record re-key as `a | distinct`.
+#[test]
+fn single_list_distinct_keys_by_record() {
+    use interactive::plan::{self, ddp::DdpStage};
+    let src = "let a = input 0 : (int, int); output \"o\" = [a] | distinct;";
+    let report = plan::report(src, &import_source, &interactive::passes::Config::none()).unwrap();
+    let text = report.emit_ddp_at(DdpStage::Parsed).unwrap().text;
+    assert!(text.contains("map((k, v) -> ((k, v), ()))"), "{text}");
+}
+
+/// With projection on, merged and grouped reduces plan without panicking and answer as with it
+/// off. A merged reduce's output is masked into its reducer, a grouped one is left whole.
+#[test]
+fn projection_keeps_variadic_reduce_answers() {
+    let src = r#"
+        let a = input 0 : (int, (int, int));
+        let b = input 1 : (int, (int, int));
+        let c = input 2 : (int, int);
+        output "merged" = [a, -b] | reduce((k, vals) -> vals) | map((k, v) -> (k, v .0));
+        output "grouped" = a | reduce(b, c, (k, la, lb, lc) -> (la, lb) append) | map((k, v) -> (k, 0));
+    "#;
+    let row = |k: i64, x: i64, y: i64, d: i64| format!("{k} val=tuple({x},{y}) diff={d}");
+    let epochs = vec![
+        vec![vec![row(1, 1, 2, 1), row(1, 3, 4, 1), row(2, 5, 6, 2)], vec![row(1, 1, 2, 1), row(3, 7, 8, 1)], lines(&[(1, 9, 1), (2, 8, 1)])],
+        vec![vec![row(1, 1, 2, -1), row(3, 1, 1, 1)], vec![row(2, 5, 6, 1)], lines(&[(1, 9, -1)])],
+    ];
+    for workers in [1, 2] {
+        let off = run(workers, src, Some("none"), epochs.clone());
+        let on = run(workers, src, Some("projection"), epochs.clone());
+        assert_eq!(off, on, "workers={workers}");
+    }
+    // Planning with projection on does not panic either.
+    let config = interactive::passes::Config { projection: true, ..interactive::passes::Config::none() };
+    interactive::plan::report(src, &|_| None, &config).expect("plans");
+}
+
+/// The merge-reduce pass changes the plan and not the answers: concats with arranged leaves, run
+/// with the pass off and on, on one and several workers.
+#[test]
+fn merge_reduce_pass_on_off_agree() {
+    let epochs = vec![
+        vec![lines(&[(1, 5, 1), (1, 7, 2), (2, 3, 1), (3, 1, 1)]), lines(&[(1, 5, 1), (3, 9, 1), (1, 6, 1)]), lines(&[(1, 7, 1), (2, 3, 1)])],
+        vec![lines(&[(1, 5, -1), (4, 4, 1)]), lines(&[(3, 9, -1), (2, 3, 1), (4, 4, 1)]), lines(&[(1, 7, -1), (3, 1, 1)])],
+        vec![lines(&[(1, 7, -2), (2, 3, -1)]), lines(&[(1, 5, -1), (1, 6, 1), (2, 3, -1)]), lines(&[(4, 4, 1), (1, 6, 1)])],
+    ];
+    // `a` and `b` are arranged, `c` is not.
+    let cases = [
+        "a - b | count", "a - b | min", "a - b | collect", "a - b | reduce((k, vals) -> vals)",
+        "a - b | reduce(limit 1, (k, vals) -> vals)", "a | negate | count", "a + b - c | distinct",
+        "a + c | count", "a - (b - c) | count", "a + (c | negate) | collect", "c - a | count",
+        "a | map((k, v) -> (k, v)) - b | distinct", "a - (b | filter((k, v) -> v)) | distinct",
+    ];
+    // The same arranged leaf twice.
+    let repeated = ["a + a | count", "a - a | count", "a + a - b | count"];
+    let program = |expr: &str| format!("let a = input 0 : (int, int) | arrange; let b = input 1 : (int, int) | arrange; let c = input 2 : (int, int); output \"o\" = {expr};");
+    for workers in [1, 3] {
+        for expr in cases.into_iter().chain(repeated) {
+            let off = run(workers, &program(expr), Some("-merge-reduce"), epochs.clone());
+            assert_eq!(run(workers, &program(expr), None, epochs.clone()), off, "{expr} on {workers} workers");
+        }
+    }
+    // The pass fires on every case that reduces an arranged leaf: the reduce is a merged one with it
+    // on and a plain one with it off. A `distinct` of `(int, int)` rows rekeys each leaf by its
+    // whole record first, and a rekeyed leaf is not arranged, so those cases stay plain.
+    let many = |expr: &str, passes: Option<&str>| operator_names_with(&program(expr), passes).iter().filter(|n| *n == "CorgiReduceMany").count();
+    for expr in cases.into_iter().chain(repeated).filter(|expr| !expr.contains("distinct")) {
+        assert_eq!(many(expr, None), 1, "{expr} merges");
+        assert_eq!(many(expr, Some("-merge-reduce")), 0, "{expr} stays plain with the pass off");
+    }
+}
+
+/// A negation read elsewhere is not absorbed into the merged reduce's signs: the reduce still
+/// merges the arranged leaf, and the other reader sees the negation.
+#[test]
+fn shared_negation_answers_match() {
+    let epochs = vec![
+        vec![lines(&[(1, 5, 1), (1, 7, 2), (2, 3, 1)]), lines(&[(1, 5, 1), (3, 9, 1), (2, 3, 2)])],
+        vec![lines(&[(1, 5, -1), (4, 4, 1)]), lines(&[(3, 9, -1), (4, 4, 1)])],
+    ];
+    let src = r#"
+        let a = input 0 : (int, int) | arrange;
+        let b = input 1 : (int, int) | arrange;
+        let nb = b | negate;
+        output "o" = a + nb | count;
+        output "nb" = nb;
+    "#;
+    for workers in [1, 3] {
+        let off = run(workers, src, Some("-merge-reduce"), epochs.clone());
+        assert!(off.iter().any(|e| !e["nb"].is_empty()));
+        assert_eq!(run(workers, src, None, epochs.clone()), off, "{workers} workers");
+    }
+}