From 008f6d40d8837cb376cf76bfa46bf1ea70ae282b Mon Sep 17 00:00:00 2001
From: Moritz Hoffmann <antiguru@gmail.com>
Date: Tue, 10 Nov 2026 10:41:42 +0100
Subject: [PATCH 01/19] DDIR: lowering treats arranged imports as arranged

Trace imports, and parent imports of arranged parent items, are no longer
wrapped in another Arrange, so printed plans replan identically with passes off.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 interactive/src/lower.rs                      | 58 ++++++++++++++++---
 interactive/src/reducers.rs                   | 15 +++--
 .../access_shared.lowered--optimized.diff     | 12 ++--
 .../access_shared.parsed--lowered.diff        |  8 +--
 .../plan_pairs/expected/as_of_shared.ddp      |  5 +-
 .../as_of_shared.lowered--optimized.diff      | 12 ----
 .../as_of_shared.parsed--lowered.diff         |  8 +--
 .../as_of_shared.projected--as-of.diff        |  9 ++-
 .../plan_pairs/expected/as_of_strict.ddp      |  3 +-
 .../as_of_strict.parsed--lowered.diff         |  5 +-
 .../as_of_strict.projected--as-of.diff        |  4 +-
 .../plan_pairs/expected/ldbc_ic01_oneoff.ddp  | 34 +++++------
 .../ldbc_ic01_oneoff.lowered--optimized.diff  | 53 +++++------------
 .../ldbc_ic01_oneoff.parsed--lowered.diff     | 41 +++++--------
 .../plan_pairs/expected/ldbc_ic02_oneoff.ddp  | 18 ++----
 .../ldbc_ic02_oneoff.lowered--optimized.diff  |  6 +-
 .../ldbc_ic02_oneoff.parsed--lowered.diff     | 20 +++----
 .../plan_pairs/expected/ldbc_ic03_oneoff.ddp  | 25 ++++----
 .../ldbc_ic03_oneoff.lowered--optimized.diff  | 42 ++++----------
 .../ldbc_ic03_oneoff.parsed--lowered.diff     | 32 ++++------
 .../plan_pairs/expected/ldbc_ic04_oneoff.ddp  |  9 +--
 .../ldbc_ic04_oneoff.lowered--optimized.diff  |  6 +-
 ...ldbc_ic04_oneoff.optimized--projected.diff |  2 +-
 .../ldbc_ic04_oneoff.parsed--lowered.diff     | 11 ++--
 .../expected/ldbc_ic04_standing.ddp           |  4 +-
 ...ldbc_ic04_standing.lowered--optimized.diff |  6 +-
 .../ldbc_ic04_standing.parsed--lowered.diff   | 11 ++--
 .../plan_pairs/expected/ldbc_ic05_oneoff.ddp  | 23 +++-----
 .../ldbc_ic05_oneoff.lowered--optimized.diff  | 22 +++----
 .../ldbc_ic05_oneoff.parsed--lowered.diff     | 26 +++------
 .../plan_pairs/expected/ldbc_ic06_oneoff.ddp  | 23 +++-----
 .../ldbc_ic06_oneoff.lowered--optimized.diff  | 14 ++---
 .../ldbc_ic06_oneoff.parsed--lowered.diff     | 26 +++------
 .../plan_pairs/expected/ldbc_ic07_oneoff.ddp  | 15 ++---
 ...ldbc_ic07_oneoff.optimized--projected.diff | 12 ++--
 .../ldbc_ic07_oneoff.parsed--lowered.diff     | 17 ++----
 .../plan_pairs/expected/ldbc_ic08_oneoff.ddp  | 14 ++---
 .../ldbc_ic08_oneoff.lowered--optimized.diff  | 12 +---
 .../ldbc_ic08_oneoff.parsed--lowered.diff     | 17 ++----
 .../plan_pairs/expected/ldbc_ic09_oneoff.ddp  | 22 +++----
 .../ldbc_ic09_oneoff.lowered--optimized.diff  | 24 ++------
 ...ldbc_ic09_oneoff.optimized--projected.diff |  4 +-
 .../ldbc_ic09_oneoff.parsed--lowered.diff     | 26 +++------
 .../plan_pairs/expected/ldbc_ic10_oneoff.ddp  | 17 ++----
 .../ldbc_ic10_oneoff.lowered--optimized.diff  | 13 ++---
 ...ldbc_ic10_oneoff.optimized--projected.diff |  2 +-
 .../ldbc_ic10_oneoff.parsed--lowered.diff     | 20 +++----
 .../expected/ldbc_ic10_standing.ddp           |  3 +-
 ...ldbc_ic10_standing.lowered--optimized.diff |  5 +-
 .../ldbc_ic10_standing.parsed--lowered.diff   |  5 +-
 .../plan_pairs/expected/ldbc_ic11_oneoff.ddp  | 19 +++---
 .../ldbc_ic11_oneoff.lowered--optimized.diff  | 19 ++----
 .../ldbc_ic11_oneoff.parsed--lowered.diff     | 23 +++-----
 .../plan_pairs/expected/ldbc_ic12_oneoff.ddp  | 27 +++------
 .../ldbc_ic12_oneoff.lowered--optimized.diff  | 13 ++---
 .../ldbc_ic12_oneoff.parsed--lowered.diff     | 29 ++++------
 ...ldbc_ic12_standing.lowered--optimized.diff |  8 +--
 .../ldbc_ic12_standing.parsed--lowered.diff   |  5 +-
 .../ldbc_ic13_oneoff.lowered--optimized.diff  | 10 +---
 .../ldbc_ic13_oneoff.parsed--lowered.diff     |  5 +-
 .../plan_pairs/expected/ldbc_ic14_oneoff.ddp  |  3 +-
 .../ldbc_ic14_oneoff.lowered--optimized.diff  | 22 +------
 .../ldbc_ic14_oneoff.parsed--lowered.diff     | 11 ++--
 .../expected/ldbc_ic14_standing.ddp           |  6 +-
 ...ldbc_ic14_standing.lowered--optimized.diff |  4 +-
 .../ldbc_ic14_standing.parsed--lowered.diff   |  8 +--
 .../tests/plan_pairs/expected/ldbc_is01.ddp   |  3 +-
 .../expected/ldbc_is01.parsed--lowered.diff   |  5 +-
 .../tests/plan_pairs/expected/ldbc_is02.ddp   | 16 ++---
 .../ldbc_is02.lowered--optimized.diff         | 16 -----
 .../expected/ldbc_is02.parsed--lowered.diff   | 20 +++----
 .../tests/plan_pairs/expected/ldbc_is03.ddp   |  6 +-
 .../ldbc_is03.lowered--optimized.diff         |  4 +-
 .../expected/ldbc_is03.parsed--lowered.diff   |  8 +--
 .../tests/plan_pairs/expected/ldbc_is04.ddp   |  3 +-
 .../expected/ldbc_is04.parsed--lowered.diff   |  5 +-
 .../tests/plan_pairs/expected/ldbc_is05.ddp   |  6 +-
 .../expected/ldbc_is05.parsed--lowered.diff   |  8 +--
 .../tests/plan_pairs/expected/ldbc_is06.ddp   | 12 ++--
 .../expected/ldbc_is06.parsed--lowered.diff   | 14 ++---
 .../tests/plan_pairs/expected/ldbc_is07.ddp   | 14 ++---
 .../ldbc_is07.lowered--optimized.diff         | 16 ++---
 .../ldbc_is07.optimized--projected.diff       |  6 +-
 .../expected/ldbc_is07.parsed--lowered.diff   | 17 ++----
 .../tests/plan_pairs/expected/txn_resolve.ddp |  5 +-
 .../txn_resolve.lowered--optimized.diff       | 15 +----
 .../txn_resolve.optimized--projected.diff     |  2 +-
 .../expected/txn_resolve.parsed--lowered.diff |  9 +--
 .../expected/txn_resolve_by_key.ddp           |  5 +-
 ...txn_resolve_by_key.lowered--optimized.diff | 17 +-----
 .../txn_resolve_by_key.parsed--lowered.diff   | 11 ++--
 91 files changed, 461 insertions(+), 815 deletions(-)

diff --git a/interactive/src/lower.rs b/interactive/src/lower.rs
index 7ff7c21def..f83f8148a2 100644
--- a/interactive/src/lower.rs
+++ b/interactive/src/lower.rs
@@ -298,8 +298,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 +323,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 +340,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 +355,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 +365,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 +374,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)
     }
@@ -424,6 +440,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 +451,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 +471,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 +577,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));
@@ -665,10 +684,31 @@ mod tree_tests {
                 st::Item::Op(st::Node::Reduce { input, .. }) => vec![input],
                 _ => 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: 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 keeps_explicit_arranges_and_scope_boundaries() {
         let program = lower_tree(parse(r#"
@@ -684,7 +724,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: Ref::Import(_), .. })));
+        assert!(!inner.items.iter().any(|item| matches!(item, st::Item::Op(st::Node::Arrange(_)))));
     }
 
     #[test]
diff --git a/interactive/src/reducers.rs b/interactive/src/reducers.rs
index f33f27921b..f71e79a018 100644
--- a/interactive/src/reducers.rs
+++ b/interactive/src/reducers.rs
@@ -16,6 +16,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};
@@ -39,19 +40,25 @@ pub(crate) fn expand_distinct(
             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());
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 d31a8e1101..4fd700f6b7 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 ecce6a3d21..e1deac20af 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 58f316f05a..559f3e2862 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 ce2169f66c..e69de29bb2 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 bc62f12101..396cae967d 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 0176e83bcf..3608be2a8a 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 d658ee19ad..4e2403862e 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 eaa3a8aca0..23ce5459ef 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 c581670014..561be9e94d 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 caeff6f00a..9001b1aa70 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 3d9dea0c40..07feccb259 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 ae8295b3c9..717218d8ec 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 28571e75b3..16293a0226 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 720d756252..65ca7ed81d 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 e9a8173acb..05f5711569 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 6c59ef1542..4954350bb5 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 d76be3a0f2..6888d9a8b8 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 5da749f991..8cc9c43271 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 24b9114151..762269a709 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 34b756169a..77f833e40a 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 8f7c454e03..8cb00be837 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 2adc6878ed..6082d787ae 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 6439534ce2..6ea21adad1 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 4d697215a9..56a49aab21 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 b6a53a5073..f7fa5abf5e 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 9c4fe9ccf8..c278ba2036 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 3d777b080c..7f44a87265 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 33d36ad7d7..fd8b9eb594 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 e9e5f8a342..f4bd79293d 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 2bdd24233a..4ec44743eb 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 68527476c2..94fdb6ceb5 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 904a8f2524..abfdd26e7c 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 c90d26d3c9..88dbedff29 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 bba8ee0f95..d4a8bf2b72 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 96feb7cdee..52650d1f1b 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 fbb5744742..5f05bfc30f 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 a5159a60a7..1d25d6df44 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 8bd5b1d70c..5ed9c406e7 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 89e924cae7..d974a727fa 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 c6d3255ebc..0b7f8becb4 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 066fd252cf..fc557ee777 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 60e95c218d..d192f292ec 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 39451088ad..f5e5a2205b 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 a28c9a1c02..3acdc458a8 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 583b2db0b0..876f964380 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 697d6ee130..ddde2b17e8 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 a30233b3aa..40d9b5b615 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 0c15102e61..049bb3d1f9 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 8e51eb1649..1692d8b32e 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 4812e94835..09078cb78a 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 1ff2a9cf0e..818eec8772 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 87b54fff31..97d524fff3 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 45a66d7934..a3f1327684 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 0fa2979137..4eac7d0dee 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 fcae73f9d5..c8499e64fa 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 9b0d442607..393fc2b43d 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 0c55c21175..714c0dd13f 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 c506c1ed96..2cee3bf616 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 55d86150c4..8e446dd962 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 bd7f36fcaa..4aab3c07d6 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 d5d7d4e92f..5bf9c15db1 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 7ea9f852a1..544b8d7e63 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 b63f2011ea..10eb251314 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 926ece7aef..c5a71a3ae1 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 c4de7b330d..f528576057 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 884638de4e..9553afaadc 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 6a52ec2c1a..d452231b28 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 fff47f8666..e69de29bb2 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 67b0104cc8..7801a80ec0 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 0d5b730dba..dd69875507 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 e85652ae2c..6d133257c9 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 c849e10e7a..024b0d199e 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 c17e1ad197..95ca1f865a 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 ff621ea755..43f9c07011 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 9172fc792c..0ab419ad70 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 a91541d9f2..44db594d6f 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 1e8a400345..360b1601c4 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 37aefc16c6..b029bfbe89 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 c1d6c532a9..5492ea3a49 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 1019d56bae..be24587d34 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 0891b264a7..34d002a79a 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 3445855110..9bb0a064c1 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 9d268242ce..2748050c13 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 3e3d17c25b..62feeceef5 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 90d27e57fc..c3cfe7a50e 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 588a41e1de..d66f7345f2 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 34d8e7e377..0fc33cfa80 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 6955d416d0..729238fc9e 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 1a339c1914..08225ff3ab 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.

From cb969f7c46e5363827694c7ef9cd3400052414c3 Mon Sep 17 00:00:00 2001
From: Moritz Hoffmann <antiguru@gmail.com>
Date: Tue, 10 Nov 2026 10:44:03 +0100
Subject: [PATCH 02/19] DDIR: test arranged parents rewritten by distinct

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 interactive/src/lower.rs | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/interactive/src/lower.rs b/interactive/src/lower.rs
index f83f8148a2..e1e142da19 100644
--- a/interactive/src/lower.rs
+++ b/interactive/src/lower.rs
@@ -709,6 +709,19 @@ mod tree_tests {
         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#"

From 72908a911d922f52d82bf27a3ed82ea06b999277 Mon Sep 17 00:00:00 2001
From: Moritz Hoffmann <antiguru@gmail.com>
Date: Tue, 10 Nov 2026 10:47:19 +0100
Subject: [PATCH 03/19] DDIR: Reduce takes a ReduceInput

Node::Reduce names its inputs with a ReduceInput, either a signed merge
or a cogroup. Nothing builds a non-single input yet. Ref walkers handle
every input, consumers that need one input call unimplemented!.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 interactive/src/backend/mod.rs       |  1 +
 interactive/src/explain/mod.rs       | 12 ++--
 interactive/src/lower.rs             |  8 +--
 interactive/src/passes/as_of.rs      |  3 +-
 interactive/src/passes/dead_code.rs  |  3 +-
 interactive/src/passes/projection.rs | 10 ++--
 interactive/src/passes/structural.rs |  3 +-
 interactive/src/plan.rs              |  8 +--
 interactive/src/plan/compare.rs      | 13 ++++-
 interactive/src/plan/ddp.rs          |  4 +-
 interactive/src/reducers.rs          | 11 +++-
 interactive/src/scope_ir.rs          | 85 ++++++++++++++++++++++++----
 interactive/src/shapes.rs            |  2 +-
 interactive/tests/plan_pairs.rs      |  3 +-
 14 files changed, 124 insertions(+), 42 deletions(-)

diff --git a/interactive/src/backend/mod.rs b/interactive/src/backend/mod.rs
index e431679d95..a739e83d56 100644
--- a/interactive/src/backend/mod.rs
+++ b/interactive/src/backend/mod.rs
@@ -259,6 +259,7 @@ pub(crate) fn render_scope<'s, B: Backend>(
                         Rendered::Collection(B::half_join(c, a, *strict, projection, level, (shape_of(stream), shape_of(arrangement))))
                     },
                     st::Node::Reduce { input, reducer, limit } => {
+                        let input = input.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs"));
                         let a = resolve(&items, &imports, &var_cols, input).arrange();
                         Rendered::Arrangement(B::reduce(a, reducer, *limit, shape_of(input)))
                     },
diff --git a/interactive/src/explain/mod.rs b/interactive/src/explain/mod.rs
index 353203755c..068924c984 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() },
     }
 }
@@ -140,7 +140,7 @@ fn clone_rec(orig: &Scope, out: &mut Scope, import_map: &[Ref], path: &[usize],
                 // 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 {
                     let presented = Node::Reduce {
-                        input: map_ref(input, &locals, &subs, import_map, var_base),
+                        input: ReduceInput::single(map_ref(input.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs")), &locals, &subs, import_map, var_base)),
                         reducer: Reducer::Expr(crate::parse::Reducer::Distinct.lambda()),
                         limit: Some(*k),
                     };
@@ -373,7 +373,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();
@@ -1024,7 +1024,7 @@ impl<'a> Reverse<'a> {
                 self.push(ex, path, input, dep_this);
             }
             Node::Reduce { input, limit: None, .. } => {
-                let target = resolve(self.orig, path, input);
+                let target = resolve(self.orig, path, input.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs")));
                 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);
@@ -1035,7 +1035,7 @@ impl<'a> Reverse<'a> {
             // 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 target = resolve(self.orig, path, input.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs")));
                 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());
diff --git a/interactive/src/lower.rs b/interactive/src/lower.rs
index e1e142da19..85a47f89f4 100644
--- a/interactive/src/lower.rs
+++ b/interactive/src/lower.rs
@@ -425,7 +425,7 @@ impl ScopeLower {
                     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() })
             },
             Expr::Inspect(e, l) => { let r = self.lower_expr(e); self.push(st::Node::Inspect { input: r, label: l.clone() }) },
             Expr::Concat(es)    => { let rs: Vec<st::Ref> = es.iter().map(|e| self.lower_expr(e)).collect(); self.push(st::Node::Concat(rs)) },
@@ -681,7 +681,7 @@ 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, &program.root.imports, &[]), "{item:?}"); }
@@ -695,7 +695,7 @@ mod tree_tests {
             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: Ref::Import(_), .. }))));
+        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]
@@ -738,7 +738,7 @@ mod tree_tests {
         assert!(arranges.iter().any(|input| matches!(input, Ref::ChildExport(..))));
         let inner = child(&program.root, "inner");
         // 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: Ref::Import(_), .. })));
+        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(_)))));
     }
 
diff --git a/interactive/src/passes/as_of.rs b/interactive/src/passes/as_of.rs
index 4cdbe55cd4..280bf27e0a 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 130d206312..6f63eeb1b5 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/projection.rs b/interactive/src/passes/projection.rs
index 807122bc53..a8b6783759 100644
--- a/interactive/src/passes/projection.rs
+++ b/interactive/src/passes/projection.rs
@@ -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
@@ -764,7 +764,7 @@ fn rewrite_scope(scope: &mut st::Scope, plan: &PlannedScope, live: &[bool]) -> u
             (Item::Op(Node::Reduce { input, reducer, .. }), PlannedItem::Op { output, .. }) => {
                 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;
+                    let shape = &plan.at(input.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs"))).expect("reduce input").shape;
                     *reducer = reducer.project(&Projection::parse(&value).expect("a value mask"), &shape.0, &shape.1);
                     masked += output.val.iter().filter(|&&id| !live[id]).count();
                 }
@@ -778,8 +778,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 +882,7 @@ 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 };
+        let Some(shape) = shapes.of(input.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs"))) 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 48d49bc604..fee852a485 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/plan.rs b/interactive/src/plan.rs
index 84d02a4dbf..2e5b7055c8 100644
--- a/interactive/src/plan.rs
+++ b/interactive/src/plan.rs
@@ -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: r, limit } => format!("{} | {}", names.of(input.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs"))), reducer(r, *limit)),
         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.of(input.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs"))).map(|s| Shape::Prod(vec![s.key, Shape::List(Box::new(Shape::Prod(vec![s.val, Shape::Int])))]));
+            format!("{} | reduce({}{})", names.of(input.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs"))), 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 af1d094784..d41f429e5e 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,7 +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)?;
+            let shape = shapes.of(input.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs")))?;
             vec![Shape::Prod(vec![shape.key, Shape::List(Box::new(Shape::Prod(vec![shape.val, Shape::Int])))])]
         }
         _ => Vec::new(),
@@ -98,7 +105,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 789cb6f2b9..ddc6d08f22 100644
--- a/interactive/src/plan/ddp.rs
+++ b/interactive/src/plan/ddp.rs
@@ -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])))]));
+                        let input = shapes.of(input.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs"))).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)?)
                     }
                 };
-                format!("{} | {word}", names.of(input))
+                format!("{} | {word}", names.of(input.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs"))))
             }
             Node::Inspect { input, label } => {
                 if identifier(label) != *label { return Err(format!("inspect label {label:?} is not a DDP identifier")); }
diff --git a/interactive/src/reducers.rs b/interactive/src/reducers.rs
index f71e79a018..394c8dc75f 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.
@@ -33,7 +34,10 @@ 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, .. }) => {
+                let input = input.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs"));
+                !shapes.of(input).is_some_and(|s| s.val == corgi::Shape::Unit)
+            }
             _ => false,
         };
         match &mut item {
@@ -68,7 +72,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());
@@ -78,13 +82,14 @@ pub(crate) fn expand_distinct(
         };
         if distinct {
             let Item::Op(Node::Reduce { input, .. }) = item else { unreachable!() };
+            let input = input.as_single().cloned().unwrap_or_else(|| unimplemented!("reduce over several inputs"));
             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/scope_ir.rs b/interactive/src/scope_ir.rs
index ea47e6ed98..6d341fbbf2 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)>),
+    /// Cogroup: 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,13 @@ 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 } => {
+                        let inputs = match input {
+                            ReduceInput::Merged(v) => v.iter().map(|(r, s)| format!("{}{}", if *s < 0 { "-" } else { "" }, fmt_ref(r))).collect::<Vec<_>>().join(" + "),
+                            ReduceInput::Grouped(v) => format!("cogroup({})", v.iter().map(fmt_ref).collect::<Vec<_>>().join(", ")),
+                        };
+                        format!("{} | {:?} limit={limit:?}", inputs, reducer)
+                    }
                     Node::Inspect { input, label } => format!("{} | inspect({})", fmt_ref(input), label),
                 };
                 println!("{}n{} = {};", pad2, i, desc);
@@ -392,4 +450,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 c54e57f779..07874d9c91 100644
--- a/interactive/src/shapes.rs
+++ b/interactive/src/shapes.rs
@@ -343,7 +343,7 @@ fn infer_node(node: &st::Node, shapes: &ScopeShapes, level: Level, at: &str, pro
             }
         }
         st::Node::Reduce { input, reducer, .. } => {
-            let c = shapes.of(input)?;
+            let c = shapes.of(input.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs")))?;
             let Reducer::Expr(lambda) = reducer;
             let v = match reduce_shape(lambda, &c.key, &c.val) {
                 Ok(v) => v,
diff --git a/interactive/tests/plan_pairs.rs b/interactive/tests/plan_pairs.rs
index 2259e85a7b..239f4dc3ed 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); }

From 55dd5dc7c50a91f7f0812b128e14e31510f6536b Mon Sep 17 00:00:00 2001
From: Moritz Hoffmann <antiguru@gmail.com>
Date: Tue, 10 Nov 2026 10:52:11 +0100
Subject: [PATCH 04/19] DDIR: bracket lists of signed inputs for reduces

A list [a, -b] before min, distinct, count, collect or reduce lowers to
one reduce over Merged inputs, each arranged on its own with its sign.
Shape inference takes the row shape from any known element. The runtime
renders a merged reduce as concat, arrange, then the unary reduce, until
an N-ary operator replaces it.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 interactive/src/backend/mod.rs       |  22 +++-
 interactive/src/lower.rs             |  13 ++
 interactive/src/parse/mod.rs         |   3 +
 interactive/src/parse/pipe.rs        |  44 ++++++-
 interactive/src/plan/ddp/parsed.rs   |  10 +-
 interactive/src/reducers.rs          |   5 +-
 interactive/src/shapes.rs            |   9 +-
 interactive/tests/variadic_reduce.rs | 178 +++++++++++++++++++++++++++
 8 files changed, 273 insertions(+), 11 deletions(-)
 create mode 100644 interactive/tests/variadic_reduce.rs

diff --git a/interactive/src/backend/mod.rs b/interactive/src/backend/mod.rs
index a739e83d56..2239695e52 100644
--- a/interactive/src/backend/mod.rs
+++ b/interactive/src/backend/mod.rs
@@ -258,10 +258,24 @@ pub(crate) fn render_scope<'s, B: Backend>(
                         let a = resolve(&items, &imports, &var_cols, arrangement).arrange();
                         Rendered::Collection(B::half_join(c, a, *strict, projection, level, (shape_of(stream), shape_of(arrangement))))
                     },
-                    st::Node::Reduce { input, reducer, limit } => {
-                        let input = input.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs"));
-                        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(), input) {
+                        (Some(input), _) => {
+                            let a = resolve(&items, &imports, &var_cols, input).arrange();
+                            Rendered::Arrangement(B::reduce(a, reducer, *limit, shape_of(input)))
+                        },
+                        // A merged reduce is the reduce of the signed concatenation of its inputs.
+                        (None, st::ReduceInput::Merged(inputs)) => {
+                            let shape = shape_of(&inputs[0].0);
+                            let mut parts = inputs.iter().map(|(r, sign)| {
+                                let c = resolve(&items, &imports, &var_cols, r).collection();
+                                if *sign < 0 { B::linear(c, vec![LinearOp::Negate], level, shape_of(r)) } else { c }
+                            });
+                            let first = parts.next().expect("a merged reduce has an input");
+                            let union = parts.fold(first, |acc, c| acc.concat(c));
+                            let a = Rendered::<'s, B>::Collection(union).arrange();
+                            Rendered::Arrangement(B::reduce(a, reducer, *limit, shape))
+                        },
+                        (None, st::ReduceInput::Grouped(_)) => unimplemented!("reduce over several inputs"),
                     },
                     st::Node::Inspect { input, label } => {
                         let c = resolve(&items, &imports, &var_cols, input).collection();
diff --git a/interactive/src/lower.rs b/interactive/src/lower.rs
index 85a47f89f4..c97331fcc1 100644
--- a/interactive/src/lower.rs
+++ b/interactive/src/lower.rs
@@ -196,6 +196,7 @@ fn resolve_expr(expr: &mut Expr, here: &[String], item: Option<&str>,
             resolve_expr(r, here, item, scopes, plan);
         }
         Expr::Concat(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 { .. } => {},
     }
 }
@@ -252,6 +253,7 @@ fn expr_free_names(expr: &Expr, out: &mut BTreeSet<RefName>) {
             | 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::List(es) => { for (_, e) in es { expr_free_names(e, out); } },
     }
 }
 
@@ -418,7 +420,17 @@ 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.
@@ -428,6 +440,7 @@ impl ScopeLower {
                 self.push(st::Node::Reduce { input: st::ReduceInput::single(a), reducer: crate::ir::Reducer::Expr(red.lambda()), limit: red.limit() })
             },
             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)) },
         }
     }
diff --git a/interactive/src/parse/mod.rs b/interactive/src/parse/mod.rs
index 06d957a747..fcdf30653d 100644
--- a/interactive/src/parse/mod.rs
+++ b/interactive/src/parse/mod.rs
@@ -79,6 +79,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 fc7540180d..1cfdd82a4c 100644
--- a/interactive/src/parse/pipe.rs
+++ b/interactive/src/parse/pipe.rs
@@ -41,6 +41,11 @@
 //!   `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)`.
+//! - `[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`.
 //! - `| 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)`.
@@ -122,11 +127,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 +260,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 +532,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 +564,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 +617,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),
         }
     }
diff --git a/interactive/src/plan/ddp/parsed.rs b/interactive/src/plan/ddp/parsed.rs
index 23185e9c4a..3a2f9c01e5 100644
--- a/interactive/src/plan/ddp/parsed.rs
+++ b/interactive/src/plan/ddp/parsed.rs
@@ -72,11 +72,13 @@ 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 is no collection to key by its records, and `distinct` handles any values.
+                let by_record = matches!(reducer, crate::parse::Reducer::Distinct) && !matches!(**input, Expr::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)")
@@ -90,6 +92,10 @@ impl Printer<'_> {
             }
             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 394c8dc75f..1e70e979ba 100644
--- a/interactive/src/reducers.rs
+++ b/interactive/src/reducers.rs
@@ -35,7 +35,8 @@ pub(crate) fn expand_distinct(
         if distinct { sites.next(); }
         let by_record = distinct && match &item {
             Item::Op(Node::Reduce { input, .. }) => {
-                let input = input.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs"));
+                // 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,
@@ -82,7 +83,7 @@ pub(crate) fn expand_distinct(
         };
         if distinct {
             let Item::Op(Node::Reduce { input, .. }) = item else { unreachable!() };
-            let input = input.as_single().cloned().unwrap_or_else(|| unimplemented!("reduce over several inputs"));
+            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 };
diff --git a/interactive/src/shapes.rs b/interactive/src/shapes.rs
index 07874d9c91..ad959f2e06 100644
--- a/interactive/src/shapes.rs
+++ b/interactive/src/shapes.rs
@@ -343,7 +343,14 @@ fn infer_node(node: &st::Node, shapes: &ScopeShapes, level: Level, at: &str, pro
             }
         }
         st::Node::Reduce { input, reducer, .. } => {
-            let c = shapes.of(input.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs")))?;
+            let st::ReduceInput::Merged(inputs) = input else { unimplemented!("reduce over several inputs") };
+            // 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) {
                 Ok(v) => v,
diff --git a/interactive/tests/variadic_reduce.rs b/interactive/tests/variadic_reduce.rs
new file mode 100644
index 0000000000..b6cc6ba011
--- /dev/null
+++ b/interactive/tests/variadic_reduce.rs
@@ -0,0 +1,178 @@
+//! Bracket lists: `[a, -b] | reduce` reduces the signed sum of its elements as one merged reduce.
+//!
+//! 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"),
+    ];
+    for workers in [1, 3] {
+        for (list, concat) in cases {
+            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};");
+            let expected = run(workers, &program(concat), None, epochs.clone());
+            assert_eq!(run(workers, &program(list), None, epochs.clone()), expected, "{list} 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 src = 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(src));
+    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 program = interactive::lower::lower_tree(interactive::parse::pipe::parse(src));
+    let items = &program.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}");
+    }
+}

From 1c5fe043f0e9a24f8ac47427e9a72d21d8066a2a Mon Sep 17 00:00:00 2001
From: Moritz Hoffmann <antiguru@gmail.com>
Date: Tue, 10 Nov 2026 10:56:44 +0100
Subject: [PATCH 05/19] differential: co_reduce_with_tactic over several
 arrangements

A reduce driver over several arrangements of one trace type. It mirrors
reduce_with_tactic and hands the tactic batches tagged by input, retiring
the interval bounded by the meet of the inputs' progress.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../src/operators/co_reduce.rs                | 179 ++++++++++++++++++
 differential-dataflow/src/operators/mod.rs    |   1 +
 2 files changed, 180 insertions(+)
 create mode 100644 differential-dataflow/src/operators/co_reduce.rs

diff --git a/differential-dataflow/src/operators/co_reduce.rs b/differential-dataflow/src/operators/co_reduce.rs
new file mode 100644
index 0000000000..53d10d4513
--- /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 7c2f662da4..19067bdef5 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;

From 511b4855e247e8e16335f97b8f633a91efb8a972 Mon Sep 17 00:00:00 2001
From: Moritz Hoffmann <antiguru@gmail.com>
Date: Tue, 10 Nov 2026 10:59:41 +0100
Subject: [PATCH 06/19] DDIR: merged reduces read their inputs' arrangements

A merged reduce over several inputs renders as one co_reduce_with_tactic
over the inputs' arrangements, rather than arranging their signed
concatenation. The corgi reduce backend reads batches tagged by input and
counts each input's diffs times its sign. Grouped reduces remain
unimplemented.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 interactive/src/backend/corgi.rs     |  16 ++++
 interactive/src/backend/mod.rs       |  28 +++---
 interactive/src/runtime/reduce.rs    |  81 +++++++++++++---
 interactive/tests/variadic_reduce.rs | 132 ++++++++++++++++++++++++++-
 4 files changed, 225 insertions(+), 32 deletions(-)

diff --git a/interactive/src/backend/corgi.rs b/interactive/src/backend/corgi.rs
index c79baebd70..ddb733a34b 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,21 @@ 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.
+        let backend = match signs {
+            Some(signs) => CorgiReduceBackend::new(reducer.clone(), limit, shapes[0].clone()).with_signs(signs),
+            None => unimplemented!("a grouped reduce"),
+        };
+        // 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 2239695e52..905c89388c 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>;
 }
 
@@ -258,24 +262,20 @@ pub(crate) fn render_scope<'s, B: Backend>(
                         let a = resolve(&items, &imports, &var_cols, arrangement).arrange();
                         Rendered::Collection(B::half_join(c, a, *strict, projection, level, (shape_of(stream), shape_of(arrangement))))
                     },
-                    st::Node::Reduce { input, reducer, limit } => match (input.as_single(), input) {
-                        (Some(input), _) => {
+                    st::Node::Reduce { input, reducer, limit } => match input.as_single() {
+                        Some(input) => {
                             let a = resolve(&items, &imports, &var_cols, input).arrange();
                             Rendered::Arrangement(B::reduce(a, reducer, *limit, shape_of(input)))
                         },
-                        // A merged reduce is the reduce of the signed concatenation of its inputs.
-                        (None, st::ReduceInput::Merged(inputs)) => {
-                            let shape = shape_of(&inputs[0].0);
-                            let mut parts = inputs.iter().map(|(r, sign)| {
-                                let c = resolve(&items, &imports, &var_cols, r).collection();
-                                if *sign < 0 { B::linear(c, vec![LinearOp::Negate], level, shape_of(r)) } else { c }
-                            });
-                            let first = parts.next().expect("a merged reduce has an input");
-                            let union = parts.fold(first, |acc, c| acc.concat(c));
-                            let a = Rendered::<'s, B>::Collection(union).arrange();
-                            Rendered::Arrangement(B::reduce(a, reducer, *limit, shape))
+                        // Every input is arranged, and the reduce reads the arrangements directly.
+                        None => {
+                            let arrs = input.refs().map(|r| resolve(&items, &imports, &var_cols, r).arrange()).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()))
                         },
-                        (None, st::ReduceInput::Grouped(_)) => unimplemented!("reduce over several inputs"),
                     },
                     st::Node::Inspect { input, label } => {
                         let c = resolve(&items, &imports, &var_cols, input).collection();
diff --git a/interactive/src/runtime/reduce.rs b/interactive/src/runtime/reduce.rs
index e291ef56f6..543b3b7283 100644
--- a/interactive/src/runtime/reduce.rs
+++ b/interactive/src/runtime/reduce.rs
@@ -49,6 +49,37 @@ 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 }
+}
+
+/// The chunks of `batches`, and each chunk's input.
+fn tagged_chunks_of<T: ColTime, B: InBatch<T>>(batches: &[B]) -> (Vec<&CorgiChunk<T, Diff>>, Vec<usize>) {
+    let mut chunks = Vec::new();
+    let mut tags = Vec::new();
+    for b in batches {
+        for chunk in b.batch().chunks.iter() {
+            chunks.push(chunk);
+            tags.push(b.tag());
+        }
+    }
+    (chunks, tags)
+}
+
 /// Values named by id: id `i` is row `refs[i].1` of `columns[refs[i].0]`.
 #[derive(Default)]
 struct Pool {
@@ -158,6 +189,8 @@ 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>,
 }
 
 /// A retire's keys and where its input chunks hold them, found once by its first window.
@@ -234,8 +267,16 @@ 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],
         }
     }
+
+    /// 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 {
+        self.signs = signs;
+        self
+    }
 }
 
 /// Where `chunks` hold the ascending `keys`.
@@ -259,9 +300,10 @@ 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.
 fn present<T: ColTime + Ord>(
     chunks: &[&CorgiChunk<T, Diff>],
+    signs: Option<&[Diff]>,
     keys: &[i64],
     matches: &Matches,
     colliding: &[bool],
@@ -295,7 +337,8 @@ fn present<T: ColTime + Ord>(
         &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]);
+    // 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()];
@@ -423,7 +466,7 @@ where
     }
 }
 
-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,14 +480,18 @@ 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;
         }
-        let novel_chunks = chunks_of(instance.input_batches);
-        let mut in_chunks = chunks_of(instance.source_batches);
+        let (novel_chunks, novel_tags) = tagged_chunks_of(instance.input_batches);
+        let (mut in_chunks, mut in_tags) = tagged_chunks_of(instance.source_batches);
         let prior = in_chunks.len();
         in_chunks.extend(novel_chunks.iter().copied());
+        in_tags.extend(novel_tags);
+        // Each input chunk's sign, unless every one is positive.
+        let in_signs: Vec<Diff> = in_tags.iter().map(|tag| self.signs[*tag]).collect();
+        let in_signs = in_signs.iter().any(|sign| *sign != 1).then_some(&in_signs[..]);
         let out_chunks = chunks_of(instance.output_batches);
 
         // The first window finds the retire's keys, where the input holds them, and the columns
@@ -498,11 +545,11 @@ 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);
+        present(&in_chunks, in_signs, keys, &matches, colliding, projected, &mut self.input.refs, &mut window.input);
         // 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, &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));
@@ -734,6 +781,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 +858,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, &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 +885,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 +901,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 +965,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 {
diff --git a/interactive/tests/variadic_reduce.rs b/interactive/tests/variadic_reduce.rs
index b6cc6ba011..b1b84b51ca 100644
--- a/interactive/tests/variadic_reduce.rs
+++ b/interactive/tests/variadic_reduce.rs
@@ -87,11 +87,95 @@ fn list_answers_match_concat() {
         ("[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 (list, concat) in cases {
-            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};");
-            let expected = run(workers, &program(concat), None, epochs.clone());
-            assert_eq!(run(workers, &program(list), None, epochs.clone()), expected, "{list} on {workers} workers");
+        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");
+            let names = operator_names(&program(list));
+            assert_eq!(names.iter().filter(|n| *n == "CorgiReduceMany").count(), 1, "{list}: {names:?}");
+            assert_eq!(run(workers, &program(list), Some("none"), epochs.clone()), expected, "{list} on {workers} workers");
         }
     }
 }
@@ -176,3 +260,43 @@ fn list_misuse_is_rejected() {
         assert_eq!(parse_error(src), LIST_MISUSE, "{src}");
     }
 }
+
+/// The names of the operators installing `src` builds on one worker.
+fn operator_names(src: &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));
+    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();
+        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:?}");
+}

From b25fe2131f21a3a40603b1f9fd49d4ef6e6b734c Mon Sep 17 00:00:00 2001
From: Moritz Hoffmann <antiguru@gmail.com>
Date: Tue, 10 Nov 2026 11:08:59 +0100
Subject: [PATCH 07/19] differential: test co_reduce with one input ahead of
 another

One input runs twenty ticks ahead of the other, so the driver hands over
batches holding times beyond the interval it retires. The test counts
those batches and checks the output against the reduce of the
concatenation.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 differential-dataflow/tests/co_reduce.rs | 151 +++++++++++++++++++++++
 1 file changed, 151 insertions(+)
 create mode 100644 differential-dataflow/tests/co_reduce.rs

diff --git a/differential-dataflow/tests/co_reduce.rs b/differential-dataflow/tests/co_reduce.rs
new file mode 100644
index 0000000000..e993bc821f
--- /dev/null
+++ b/differential-dataflow/tests/co_reduce.rs
@@ -0,0 +1,151 @@
+//! 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::progress::Antichain;
+
+use differential_dataflow::VecCollection;
+use differential_dataflow::hashable::Hashable;
+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::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 = Rc<ChunkBatch<VecChunk<u64, (u64, u64), u64, i64>>>;
+type Spine = VChunkSpine<u64, (u64, u64), u64, 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<Tac: ReduceTactic<u64, Batch, Batch>> ReduceTactic<u64, (usize, Batch), Batch> for Untag<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 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)>| 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>(c: VecCollection<'s, u64, (u64, u64), i64>) -> Arranged<'s, TraceAgent<Spine>> {
+    let hashed = c.map(|(k, v)| (k.hashed(), (k, v)));
+    arrange_core::<Pipeline, Vec<((u64, (u64, u64)), u64, i64)>, _, Spine>(hashed.inner, Pipeline, "Arrange", VChunkBatcher::new)
+}
+
+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) = (got.clone(), want.clone(), ahead.clone());
+    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) = (g.clone(), w.clone(), seen.clone());
+        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);
+}

From 9d5ec961e45b351e337c62bec78cf957699b6486 Mon Sep 17 00:00:00 2001
From: Moritz Hoffmann <antiguru@gmail.com>
Date: Tue, 10 Nov 2026 11:08:59 +0100
Subject: [PATCH 08/19] DDIR: check merged reduce signs and shapes, keep the
 unary read

reduce_many checks that it has one sign and one shape per input, and
that a merged reduce's inputs share a shape. The backend builds per-chunk
signs only when some input is negated, so a unary reduce reads its
chunks as before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 interactive/src/backend/corgi.rs  |  8 ++++++-
 interactive/src/runtime/reduce.rs | 35 +++++++++++++------------------
 2 files changed, 21 insertions(+), 22 deletions(-)

diff --git a/interactive/src/backend/corgi.rs b/interactive/src/backend/corgi.rs
index ddb733a34b..d7597912cc 100644
--- a/interactive/src/backend/corgi.rs
+++ b/interactive/src/backend/corgi.rs
@@ -392,8 +392,14 @@ impl Backend for CorgiBackend {
     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) => CorgiReduceBackend::new(reducer.clone(), limit, shapes[0].clone()).with_signs(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 => unimplemented!("a grouped reduce"),
         };
         // As for the join, the inputs are read as of the join of their times. Every program time
diff --git a/interactive/src/runtime/reduce.rs b/interactive/src/runtime/reduce.rs
index 543b3b7283..4fab3bf414 100644
--- a/interactive/src/runtime/reduce.rs
+++ b/interactive/src/runtime/reduce.rs
@@ -67,19 +67,6 @@ impl<T: ColTime> InBatch<T> for (usize, CBatch<T>) {
     fn batch(&self) -> &CBatch<T> { &self.1 }
 }
 
-/// The chunks of `batches`, and each chunk's input.
-fn tagged_chunks_of<T: ColTime, B: InBatch<T>>(batches: &[B]) -> (Vec<&CorgiChunk<T, Diff>>, Vec<usize>) {
-    let mut chunks = Vec::new();
-    let mut tags = Vec::new();
-    for b in batches {
-        for chunk in b.batch().chunks.iter() {
-            chunks.push(chunk);
-            tags.push(b.tag());
-        }
-    }
-    (chunks, tags)
-}
-
 /// Values named by id: id `i` is row `refs[i].1` of `columns[refs[i].0]`.
 #[derive(Default)]
 struct Pool {
@@ -274,6 +261,7 @@ impl<T> CorgiReduceBackend<T> {
     /// 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
     }
@@ -384,11 +372,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
@@ -484,14 +473,18 @@ where
         if *from == KeyPosition::End {
             return;
         }
-        let (novel_chunks, novel_tags) = tagged_chunks_of(instance.input_batches);
-        let (mut in_chunks, mut in_tags) = tagged_chunks_of(instance.source_batches);
+        let novel_chunks = chunks_of(instance.input_batches);
+        let mut in_chunks = chunks_of(instance.source_batches);
         let prior = in_chunks.len();
         in_chunks.extend(novel_chunks.iter().copied());
-        in_tags.extend(novel_tags);
-        // Each input chunk's sign, unless every one is positive.
-        let in_signs: Vec<Diff> = in_tags.iter().map(|tag| self.signs[*tag]).collect();
-        let in_signs = in_signs.iter().any(|sign| *sign != 1).then_some(&in_signs[..]);
+        // Each input chunk's sign, in the order of `in_chunks`. Only a reduce with a negated input
+        // builds it, so a unary reduce reads its chunks as before.
+        let in_signs: Option<Vec<Diff>> = self.signs.iter().any(|sign| *sign != 1).then(|| {
+            instance.source_batches.iter().chain(instance.input_batches)
+                .flat_map(|b| std::iter::repeat_n(self.signs[b.tag()], b.batch().chunks.len()))
+                .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

From 306f9e523c72158590fdbe09d88a175bb91f82fa Mon Sep 17 00:00:00 2001
From: Moritz Hoffmann <antiguru@gmail.com>
Date: Tue, 10 Nov 2026 11:18:07 +0100
Subject: [PATCH 09/19] DDIR: grouped reduce over several inputs

`a | reduce(b, c, (k, la, lb, lc) -> ..)` lowers to a Grouped reduce over
every input's arrangement. The lambda takes the key and one (val, diff)
list per input. Shape inference revisits the reduce until every input's
shape is known, and the corgi backend presents each input on its own,
ordered by real key and then input.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 interactive/src/backend/corgi.rs     |   9 +-
 interactive/src/lambda.rs            |  17 +-
 interactive/src/lower.rs             |   9 +-
 interactive/src/parse/mod.rs         |   4 +
 interactive/src/parse/pipe.rs        |  30 +++-
 interactive/src/plan/ddp/parsed.rs   |   4 +
 interactive/src/runtime/reduce.rs    | 235 +++++++++++++++++++++++----
 interactive/src/scope_ir.rs          |   4 +-
 interactive/src/shapes.rs            |  41 ++++-
 interactive/tests/variadic_reduce.rs | 173 ++++++++++++++++++++
 10 files changed, 474 insertions(+), 52 deletions(-)

diff --git a/interactive/src/backend/corgi.rs b/interactive/src/backend/corgi.rs
index d7597912cc..8955d34169 100644
--- a/interactive/src/backend/corgi.rs
+++ b/interactive/src/backend/corgi.rs
@@ -400,7 +400,14 @@ impl Backend for CorgiBackend {
                 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 => unimplemented!("a grouped reduce"),
+            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.
diff --git a/interactive/src/lambda.rs b/interactive/src/lambda.rs
index 4e1aaca359..f4ece4b1b0 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 c97331fcc1..54fc70cf62 100644
--- a/interactive/src/lower.rs
+++ b/interactive/src/lower.rs
@@ -195,7 +195,7 @@ 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 { .. } => {},
     }
@@ -252,7 +252,7 @@ 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); } },
     }
 }
@@ -439,6 +439,11 @@ impl ScopeLower {
                 } else { self.arrange(r) };
                 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(|e| { let r = self.lower_expr(e); 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)) },
diff --git a/interactive/src/parse/mod.rs b/interactive/src/parse/mod.rs
index fcdf30653d..8ec4eea81a 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)
diff --git a/interactive/src/parse/pipe.rs b/interactive/src/parse/pipe.rs
index 1cfdd82a4c..a2504520d4 100644
--- a/interactive/src/parse/pipe.rs
+++ b/interactive/src/parse/pipe.rs
@@ -40,7 +40,13 @@
 //!   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
@@ -89,9 +95,9 @@
 //! # 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`,
+//! 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`).
@@ -664,7 +670,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,
@@ -673,9 +680,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/plan/ddp/parsed.rs b/interactive/src/plan/ddp/parsed.rs
index 3a2f9c01e5..b9eb69b187 100644
--- a/interactive/src/plan/ddp/parsed.rs
+++ b/interactive/src/plan/ddp/parsed.rs
@@ -86,6 +86,10 @@ 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)?)
diff --git a/interactive/src/runtime/reduce.rs b/interactive/src/runtime/reduce.rs
index 4fab3bf414..ed51a117a0 100644
--- a/interactive/src/runtime/reduce.rs
+++ b/interactive/src/runtime/reduce.rs
@@ -83,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)
 }
@@ -178,6 +184,11 @@ pub(crate) struct CorgiReduceBackend<T> {
     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.
@@ -242,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(),
@@ -255,6 +289,8 @@ impl<T> CorgiReduceBackend<T> {
             window_size: window_size.max(1),
             retire: Retire::default(),
             signs: vec![1],
+            grouped: None,
+            input_tags: Vec::new(),
         }
     }
 
@@ -288,7 +324,9 @@ 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. With `signs`, chunk `i`'s diffs count `signs[i]` times.
+/// 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.
 fn present<T: ColTime + Ord>(
     chunks: &[&CorgiChunk<T, Diff>],
     signs: Option<&[Diff]>,
@@ -296,11 +334,12 @@ fn present<T: ColTime + Ord>(
     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);
@@ -324,7 +363,7 @@ 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 (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());
@@ -418,6 +457,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<_>>()),
@@ -426,7 +490,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");
                 }
@@ -434,24 +498,45 @@ 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)
     }
 }
 
@@ -477,13 +562,16 @@ 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 sign, in the order of `in_chunks`. Only a reduce with a negated input
-        // builds it, so a unary reduce reads its chunks as before.
-        let in_signs: Option<Vec<Diff>> = self.signs.iter().any(|sign| *sign != 1).then(|| {
+        // 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(self.signs[b.tag()], b.batch().chunks.len()))
+                .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);
 
@@ -500,6 +588,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.
@@ -538,11 +627,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, in_signs, 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, None, 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));
@@ -567,6 +669,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); }
@@ -851,7 +963,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, None, &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<_>>()));
@@ -1057,4 +1169,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 batch in first.iter().chain(second.and_then(|span| span.inner).as_ref()) {
+                for chunk in batch.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 6d341fbbf2..e38667b34a 100644
--- a/interactive/src/scope_ir.rs
+++ b/interactive/src/scope_ir.rs
@@ -142,8 +142,8 @@ pub enum ReduceInput {
     /// 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)>),
-    /// Cogroup: 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,
+    /// 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>),
diff --git a/interactive/src/shapes.rs b/interactive/src/shapes.rs
index ad959f2e06..d5a8dfabde 100644
--- a/interactive/src/shapes.rs
+++ b/interactive/src/shapes.rs
@@ -275,11 +275,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,8 +342,7 @@ 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 st::ReduceInput::Merged(inputs) = input else { unimplemented!("reduce over several inputs") };
+        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();
@@ -352,12 +351,38 @@ fn infer_node(node: &st::Node, shapes: &ScopeShapes, level: Level, at: &str, pro
                 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/variadic_reduce.rs b/interactive/tests/variadic_reduce.rs
index b1b84b51ca..c200180b4b 100644
--- a/interactive/tests/variadic_reduce.rs
+++ b/interactive/tests/variadic_reduce.rs
@@ -1,4 +1,5 @@
 //! 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.
@@ -300,3 +301,175 @@ fn merged_reduce_reads_input_arrangements() {
     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, expected) in expected.iter().enumerate() {
+                assert_eq!(&got[epoch]["co"], expected, "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, held) in held.iter_mut().enumerate() {
+            let mut rows = Vec::new();
+            for _ in 0..40 {
+                // Retract a held row, or add a new one.
+                if !held.is_empty() && rng.next(3) == 0 {
+                    let (k, v) = held.swap_remove(usize::try_from(rng.next(u64::try_from(held.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) { held.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 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(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 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(src), "a list of collections cannot take extra reduce inputs");
+}

From 09546311d274dd7b0a961c3adac44d3da7815239 Mon Sep 17 00:00:00 2001
From: Moritz Hoffmann <antiguru@gmail.com>
Date: Tue, 10 Nov 2026 11:24:45 +0100
Subject: [PATCH 10/19] DDIR: print merged and grouped reduces

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 interactive/src/explain/mod.rs       | 31 ++++++++-----
 interactive/src/passes/projection.rs | 13 ++++--
 interactive/src/plan.rs              | 10 ++---
 interactive/src/plan/compare.rs      |  3 +-
 interactive/src/plan/ddp.rs          | 29 +++++++++++--
 interactive/src/scope_ir.rs          | 11 ++---
 interactive/src/shapes.rs            | 16 +++++++
 interactive/tests/variadic_reduce.rs | 65 ++++++++++++++++++++++++++++
 8 files changed, 147 insertions(+), 31 deletions(-)

diff --git a/interactive/src/explain/mod.rs b/interactive/src/explain/mod.rs
index 068924c984..85894aa214 100644
--- a/interactive/src/explain/mod.rs
+++ b/interactive/src/explain/mod.rs
@@ -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: ReduceInput::single(map_ref(input.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs")), &locals, &subs, import_map, var_base)),
+                        input: mapped,
                         reducer: Reducer::Expr(crate::parse::Reducer::Distinct.lambda()),
                         limit: Some(*k),
                     };
@@ -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.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs")));
-                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.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs")));
-                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/passes/projection.rs b/interactive/src/passes/projection.rs
index a8b6783759..a78e1cdb19 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)]
@@ -761,10 +761,13 @@ 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.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs"))).expect("reduce input").shape;
+                    let shape = &plan.at(input).expect("reduce input").shape;
                     *reducer = reducer.project(&Projection::parse(&value).expect("a value mask"), &shape.0, &shape.1);
                     masked += output.val.iter().filter(|&&id| !live[id]).count();
                 }
@@ -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.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs"))) 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/plan.rs b/interactive/src/plan.rs
index 2e5b7055c8..1bce83a62b 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.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs"))), reducer(r, *limit)),
+        Node::Reduce { input, reducer: r, limit } => format!("{} | {}", ddp::reduce_head(input, |r| names.of(r)), reducer(r, *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.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs"))).map(|s| Shape::Prod(vec![s.key, Shape::List(Box::new(Shape::Prod(vec![s.val, Shape::Int])))]));
-            format!("{} | reduce({}{})", names.of(input.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs"))), 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)
     }
diff --git a/interactive/src/plan/compare.rs b/interactive/src/plan/compare.rs
index d41f429e5e..72dbcb6545 100644
--- a/interactive/src/plan/compare.rs
+++ b/interactive/src/plan/compare.rs
@@ -75,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.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs")))?;
-            vec![Shape::Prod(vec![shape.key, Shape::List(Box::new(Shape::Prod(vec![shape.val, Shape::Int])))])]
+            vec![shapes.reduce_input(input)?]
         }
         _ => Vec::new(),
     })
diff --git a/interactive/src/plan/ddp.rs b/interactive/src/plan/ddp.rs
index ddc6d08f22..3d4e0b82e7 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.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs"))).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.as_single().unwrap_or_else(|| unimplemented!("reduce over several inputs"))))
+                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/scope_ir.rs b/interactive/src/scope_ir.rs
index e38667b34a..da4d627cc4 100644
--- a/interactive/src/scope_ir.rs
+++ b/interactive/src/scope_ir.rs
@@ -378,11 +378,12 @@ fn dump_scope_body(s: &Scope, indent: usize) {
                     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 } => {
-                        let inputs = match input {
-                            ReduceInput::Merged(v) => v.iter().map(|(r, s)| format!("{}{}", if *s < 0 { "-" } else { "" }, fmt_ref(r))).collect::<Vec<_>>().join(" + "),
-                            ReduceInput::Grouped(v) => format!("cogroup({})", v.iter().map(fmt_ref).collect::<Vec<_>>().join(", ")),
-                        };
-                        format!("{} | {:?} limit={limit:?}", inputs, reducer)
+                        // 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(|(r, s)| format!("{}{}", if *s < 0 { "-" } else { "" }, fmt_ref(r))).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),
                 };
diff --git a/interactive/src/shapes.rs b/interactive/src/shapes.rs
index d5a8dfabde..4f97d8440b 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() {
diff --git a/interactive/tests/variadic_reduce.rs b/interactive/tests/variadic_reduce.rs
index c200180b4b..c47589fcbe 100644
--- a/interactive/tests/variadic_reduce.rs
+++ b/interactive/tests/variadic_reduce.rs
@@ -473,3 +473,68 @@ fn grouped_rejects_limit() {
     let 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(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(|| (corgi::Shape::Int, corgi::Shape::Int))
+}
+
+/// Plans `src` with no passes, prints the optimized stage, replans the text, and checks the two
+/// plans compare equal and the second print equals the first.
+fn assert_printed_replans(src: &str, expect: &str) {
+    use interactive::plan::{self, ddp::DdpStage};
+    let config = interactive::passes::Config::none();
+    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, &config).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}"), expect); }
+}
+
+/// 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");
+}

From daba32a32023ce524cbe27571973f3db693a9a3f Mon Sep 17 00:00:00 2001
From: Moritz Hoffmann <antiguru@gmail.com>
Date: Tue, 10 Nov 2026 11:29:45 +0100
Subject: [PATCH 11/19] DDIR: merge-reduce pass reads a concat's arranged
 leaves

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 interactive/src/passes/merge_reduce.rs | 234 +++++++++++++++++++++++++
 interactive/src/passes/mod.rs          |  24 ++-
 interactive/src/passes/timing.rs       |   7 +-
 interactive/tests/difftest.rs          |   4 +-
 interactive/tests/variadic_reduce.rs   |  32 +++-
 5 files changed, 289 insertions(+), 12 deletions(-)
 create mode 100644 interactive/src/passes/merge_reduce.rs

diff --git a/interactive/src/passes/merge_reduce.rs b/interactive/src/passes/merge_reduce.rs
new file mode 100644
index 0000000000..fbbb5cae75
--- /dev/null
+++ b/interactive/src/passes/merge_reduce.rs
@@ -0,0 +1,234 @@
+//! 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, Source};
+use crate::ir::{Diff, LinearOp};
+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 child_imports: Vec<bool> = child.imports.iter().map(|import| match &import.from {
+            Source::Parent(r) => arranged(scope, imports, r),
+            _ => false,
+        }).collect();
+        let Item::Sub(child) = &mut scope.items[i] else { unreachable!() };
+        count += run(child, &child_imports);
+    }
+    count
+}
+
+/// Whether `r` is statically arranged in `scope`.
+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],
+        // Leaving a child flattens its exports. Feedback is also a collection.
+        Ref::Var(_) | Ref::ChildExport(_, _) => false,
+    }
+}
+
+/// 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 r in refs { leaves(scope, uses, r, 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));
+}
+
+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 = |scope: &mut Scope, node: Node| {
+            let at = scope.items.len();
+            scope.items.push(Item::Op(node));
+            if scope.labels.len() == at { scope.labels.push(scope.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, .. }) = &mut scope.items[i] else { unreachable!() };
+        *input = 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(_)))));
+    }
+
+    #[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));
+    }
+}
diff --git a/interactive/src/passes/mod.rs b/interactive/src/passes/mod.rs
index c5ce065c6c..13c8e49b4b 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 = |program: &mut Program, timings: &mut Timings| {
+        let imports: Vec<bool> = program.root.imports.iter().map(|i| matches!(i.from, Source::Trace(_))).collect();
+        timings.pass_mut(Pass::MergeReduce).rewrites(|| merge_reduce::run(&mut program.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/timing.rs b/interactive/src/passes/timing.rs
index 7879f7a994..fb269552ae 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/tests/difftest.rs b/interactive/tests/difftest.rs
index fd81f16cef..734d7d8e73 100644
--- a/interactive/tests/difftest.rs
+++ b/interactive/tests/difftest.rs
@@ -1390,7 +1390,9 @@ fn subset(seed: u64) -> Config {
     let bits = Rng(seed ^ 0x7061_7373_6573).below(128);
     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,
+        // Drawn by bit in the oracle task.
+        merge_reduce: true }
 }
 
 fn pass_names(config: Config) -> String {
diff --git a/interactive/tests/variadic_reduce.rs b/interactive/tests/variadic_reduce.rs
index c47589fcbe..11109b6698 100644
--- a/interactive/tests/variadic_reduce.rs
+++ b/interactive/tests/variadic_reduce.rs
@@ -174,8 +174,11 @@ fn merged_loop_matches_concat() {
             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");
-            let names = operator_names(&program(list));
-            assert_eq!(names.iter().filter(|n| *n == "CorgiReduceMany").count(), 1, "{list}: {names:?}");
+            // 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");
         }
     }
@@ -538,3 +541,28 @@ fn projection_keeps_variadic_reduce_answers() {
     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",
+    ];
+    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 {
+            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");
+        }
+    }
+}

From f9512f6272407879115d7812ad43096dd5989cc2 Mon Sep 17 00:00:00 2001
From: Moritz Hoffmann <antiguru@gmail.com>
Date: Tue, 10 Nov 2026 11:38:44 +0100
Subject: [PATCH 12/19] DDIR: difftest generates variadic reduces

The generator emits bracket lists before a reduce and grouped reduces over inputs of
different value shapes, and the pass-subset oracle draws merge-reduce as a bit. Close the
Task 7 test gaps: the concat form with default passes, the pass firing on and off, a
shared negation left alone, and a repeated arranged leaf.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 interactive/src/passes/merge_reduce.rs | 18 ++++++++
 interactive/tests/difftest.rs          | 63 ++++++++++++++++++++++++--
 interactive/tests/variadic_reduce.rs   | 45 ++++++++++++++++--
 3 files changed, 119 insertions(+), 7 deletions(-)

diff --git a/interactive/src/passes/merge_reduce.rs b/interactive/src/passes/merge_reduce.rs
index fbbb5cae75..24393e00d7 100644
--- a/interactive/src/passes/merge_reduce.rs
+++ b/interactive/src/passes/merge_reduce.rs
@@ -231,4 +231,22 @@ mod tests {
         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/tests/difftest.rs b/interactive/tests/difftest.rs
index 734d7d8e73..f885d4f587 100644
--- a/interactive/tests/difftest.rs
+++ b/interactive/tests/difftest.rs
@@ -529,6 +529,52 @@ 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 others: Vec<Coll> = self.colls.iter().filter(|c| c.key == key).cloned().collect();
+                    if others.is_empty() { continue; }
+                    let others: Vec<Coll> = (0..1 + self.rng.below(3)).map(|_| self.rng.pick(&others).clone()).collect();
+                    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 (body, v2) = match self.rng.below(3) {
+                        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()])),
+                        _ => ("l0 map ((v, _) -> (v, 1))".to_string(), val.clone()),
+                    };
+                    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 +596,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 +642,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,12 +1443,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,
-        // Drawn by bit in the oracle task.
-        merge_reduce: true }
+        merge_reduce: bits & 128 != 0 }
 }
 
 fn pass_names(config: Config) -> String {
diff --git a/interactive/tests/variadic_reduce.rs b/interactive/tests/variadic_reduce.rs
index 11109b6698..4ba74cab84 100644
--- a/interactive/tests/variadic_reduce.rs
+++ b/interactive/tests/variadic_reduce.rs
@@ -180,6 +180,8 @@ fn merged_loop_matches_concat() {
             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");
         }
     }
 }
@@ -265,12 +267,16 @@ fn list_misuse_is_rejected() {
     }
 }
 
-/// The names of the operators installing `src` builds on one worker.
-fn operator_names(src: &str) -> Vec<String> {
+/// 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);
@@ -282,6 +288,7 @@ fn operator_names(src: &str) -> Vec<String> {
             }
         });
         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");
@@ -558,11 +565,43 @@ fn merge_reduce_pass_on_off_agree() {
         "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 {
+        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");
+    }
 }

From 89c1f34fd44f703c98a403e102c869fc089f42d1 Mon Sep 17 00:00:00 2001
From: Moritz Hoffmann <antiguru@gmail.com>
Date: Tue, 10 Nov 2026 12:03:35 +0100
Subject: [PATCH 13/19] DDIR: clear clippy warnings the variadic reduce
 introduced

The difftest grouped arm also picks a first extra input of another value shape when one
exists, and a lambda body reads the contents of the last list.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 differential-dataflow/tests/co_reduce.rs |  5 ++--
 interactive/src/lower.rs                 |  3 ++-
 interactive/src/passes/merge_reduce.rs   | 19 +++++++-------
 interactive/src/passes/mod.rs            |  6 ++---
 interactive/src/plan.rs                  |  2 +-
 interactive/src/runtime/reduce.rs        |  5 ++--
 interactive/src/scope_ir.rs              |  2 +-
 interactive/tests/difftest.rs            | 18 +++++++++----
 interactive/tests/variadic_reduce.rs     | 32 ++++++++++++------------
 9 files changed, 52 insertions(+), 40 deletions(-)

diff --git a/differential-dataflow/tests/co_reduce.rs b/differential-dataflow/tests/co_reduce.rs
index e993bc821f..135a082bbf 100644
--- a/differential-dataflow/tests/co_reduce.rs
+++ b/differential-dataflow/tests/co_reduce.rs
@@ -66,6 +66,7 @@ fn arrange<'s>(c: VecCollection<'s, u64, (u64, u64), i64>) -> Arranged<'s, Trace
     arrange_core::<Pipeline, Vec<((u64, (u64, u64)), u64, i64)>, _, Spine>(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));
@@ -83,11 +84,11 @@ 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) = (got.clone(), want.clone(), ahead.clone());
+    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) = (g.clone(), w.clone(), seen.clone());
+        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 };
diff --git a/interactive/src/lower.rs b/interactive/src/lower.rs
index 54fc70cf62..6f9dcb1b7c 100644
--- a/interactive/src/lower.rs
+++ b/interactive/src/lower.rs
@@ -441,7 +441,7 @@ impl ScopeLower {
             },
             // A grouped reduce reads every input arranged, as a join does.
             Expr::GroupedReduce(es, lambda) => {
-                let inputs = es.iter().map(|e| { let r = self.lower_expr(e); self.arrange(r) }).collect();
+                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() }) },
@@ -451,6 +451,7 @@ impl ScopeLower {
     }
 }
 
+#[expect(clippy::too_many_arguments, reason = "the scope tree walk threads its environment through parameters")]
 fn lower_scope_tree(
     address: &[String],
     body: &[Stmt],
diff --git a/interactive/src/passes/merge_reduce.rs b/interactive/src/passes/merge_reduce.rs
index 24393e00d7..4b28887c36 100644
--- a/interactive/src/passes/merge_reduce.rs
+++ b/interactive/src/passes/merge_reduce.rs
@@ -26,8 +26,8 @@ pub(super) fn run(scope: &mut Scope, imports: &[bool]) -> usize {
             Source::Parent(r) => arranged(scope, imports, r),
             _ => false,
         }).collect();
-        let Item::Sub(child) = &mut scope.items[i] else { unreachable!() };
-        count += run(child, &child_imports);
+        let Item::Sub(sub) = &mut scope.items[i] else { unreachable!() };
+        count += run(sub, &child_imports);
     }
     count
 }
@@ -50,7 +50,7 @@ fn leaves(scope: &Scope, uses: &[usize], r: &Ref, sign: Diff, absorbed: &mut Vec
             match &scope.items[*n] {
                 Item::Op(Node::Concat(refs)) => {
                     absorbed.push(*n);
-                    for r in refs { leaves(scope, uses, r, sign, absorbed, out); }
+                    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)) => {
@@ -66,6 +66,7 @@ fn leaves(scope: &Scope, uses: &[usize], r: &Ref, sign: Diff, absorbed: &mut Vec
     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]);
@@ -88,10 +89,10 @@ fn rewrite_scope(scope: &mut Scope, imports: &[bool]) -> usize {
         for (leaf, sign) in found {
             if arranged(scope, imports, &leaf) { merged.push((leaf, sign)); } else { rest.push((leaf, sign)); }
         }
-        let mut add = |scope: &mut Scope, node: Node| {
-            let at = scope.items.len();
-            scope.items.push(Item::Op(node));
-            if scope.labels.len() == at { scope.labels.push(scope.labels[i].clone()); }
+        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)
         };
@@ -110,8 +111,8 @@ fn rewrite_scope(scope: &mut Scope, imports: &[bool]) -> usize {
             merged.push((arr, 1));
         }
         for n in absorbed { dead[n] = true; }
-        let Item::Op(Node::Reduce { input, .. }) = &mut scope.items[i] else { unreachable!() };
-        *input = ReduceInput::Merged(merged);
+        let Item::Op(Node::Reduce { input: rewritten, .. }) = &mut scope.items[i] else { unreachable!() };
+        *rewritten = ReduceInput::Merged(merged);
         rewrites += 1;
     }
     if rewrites == 0 { return 0; }
diff --git a/interactive/src/passes/mod.rs b/interactive/src/passes/mod.rs
index 13c8e49b4b..2ef7e31467 100644
--- a/interactive/src/passes/mod.rs
+++ b/interactive/src/passes/mod.rs
@@ -246,9 +246,9 @@ 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 = |program: &mut Program, timings: &mut Timings| {
-        let imports: Vec<bool> = program.root.imports.iter().map(|i| matches!(i.from, Source::Trace(_))).collect();
-        timings.pass_mut(Pass::MergeReduce).rewrites(|| merge_reduce::run(&mut program.root, &imports))
+    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.
diff --git a/interactive/src/plan.rs b/interactive/src/plan.rs
index 1bce83a62b..0f2556f2f2 100644
--- a/interactive/src/plan.rs
+++ b/interactive/src/plan.rs
@@ -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!("{} | {}", ddp::reduce_head(input, |r| names.of(r)), reducer(r, *limit, ddp::grouped_rest(input, |r| names.of(r)))),
+        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)),
     }
 }
diff --git a/interactive/src/runtime/reduce.rs b/interactive/src/runtime/reduce.rs
index ed51a117a0..2c17dfb283 100644
--- a/interactive/src/runtime/reduce.rs
+++ b/interactive/src/runtime/reduce.rs
@@ -327,6 +327,7 @@ fn search<T: ColTime>(chunks: &[&CorgiChunk<T, Diff>], keys: &[i64]) -> Matches
 /// 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]>,
@@ -1213,8 +1214,8 @@ mod tests {
             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 batch in first.iter().chain(second.and_then(|span| span.inner).as_ref()) {
-                for chunk in batch.chunks.iter() {
+            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];
diff --git a/interactive/src/scope_ir.rs b/interactive/src/scope_ir.rs
index da4d627cc4..bf63b152e0 100644
--- a/interactive/src/scope_ir.rs
+++ b/interactive/src/scope_ir.rs
@@ -381,7 +381,7 @@ fn dump_scope_body(s: &Scope, indent: usize) {
                         // 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(|(r, s)| format!("{}{}", if *s < 0 { "-" } else { "" }, fmt_ref(r))).collect::<Vec<_>>().join(", "), 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),
                         }
                     }
diff --git a/interactive/tests/difftest.rs b/interactive/tests/difftest.rs
index f885d4f587..e812005bdc 100644
--- a/interactive/tests/difftest.rs
+++ b/interactive/tests/difftest.rs
@@ -556,20 +556,28 @@ impl Gen {
                 // A grouped reduce over the stream and 1 to 3 collections of its key, whose values
                 // may have other shapes.
                 93..=95 => {
-                    let others: Vec<Coll> = self.colls.iter().filter(|c| c.key == key).cloned().collect();
-                    if others.is_empty() { continue; }
-                    let others: Vec<Coll> = (0..1 + self.rng.below(3)).map(|_| self.rng.pick(&others).clone()).collect();
+                    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 (body, v2) = match self.rng.below(3) {
+                    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()])),
-                        _ => ("l0 map ((v, _) -> (v, 1))".to_string(), val.clone()),
+                        // 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;
diff --git a/interactive/tests/variadic_reduce.rs b/interactive/tests/variadic_reduce.rs
index 4ba74cab84..bf844def64 100644
--- a/interactive/tests/variadic_reduce.rs
+++ b/interactive/tests/variadic_reduce.rs
@@ -206,15 +206,15 @@ fn list_in_loop_infers_shape() {
         output "o" = s::x;
     "#;
     for workers in [1, 2] {
-        assert_eq!(run(workers, src, None, epochs.clone()), run(workers, &plain, None, epochs.clone()));
+        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 src = r#"
+    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(src));
+    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);
@@ -227,8 +227,8 @@ fn by_record_distinct_element_is_arranged() {
         let b = input 1 : (int, int);
         output "o" = [a | distinct, -b] | distinct;
     "#;
-    let program = interactive::lower::lower_tree(interactive::parse::pipe::parse(src));
-    let items = &program.root.items;
+    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 };
@@ -342,8 +342,8 @@ fn grouped_hands_one_list_per_input() {
     for workers in [1, 3] {
         for passes in [None, Some("none")] {
             let got = run(workers, src, passes, epochs.clone());
-            for (epoch, expected) in expected.iter().enumerate() {
-                assert_eq!(&got[epoch]["co"], expected, "workers={workers}, passes {passes:?}, epoch={epoch}");
+            for (epoch, want_rows) in expected.iter().enumerate() {
+                assert_eq!(&got[epoch]["co"], want_rows, "workers={workers}, passes {passes:?}, epoch={epoch}");
             }
         }
     }
@@ -392,18 +392,18 @@ fn grouped_matches_tagged_concat() {
     let mut epochs = Vec::new();
     for _ in 0..3 {
         let mut epoch = Vec::new();
-        for (input, held) in held.iter_mut().enumerate() {
+        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 !held.is_empty() && rng.next(3) == 0 {
-                    let (k, v) = held.swap_remove(usize::try_from(rng.next(u64::try_from(held.len()).unwrap())).unwrap());
+                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) { held.push((k, v.clone())); }
+                    for _ in 0..d.max(0) { pool.push((k, v.clone())); }
                     rows.push(format!("{k} val={v} diff={d}"));
                 }
             }
@@ -476,17 +476,17 @@ 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 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(src));
+    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 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(src), "a list of collections cannot take extra reduce 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(|| (corgi::Shape::Int, corgi::Shape::Int))
+    (name == "p::x").then_some((corgi::Shape::Int, corgi::Shape::Int))
 }
 
 /// Plans `src` with no passes, prints the optimized stage, replans the text, and checks the two

From d4f78e1ca7cb17f5b59e073ab9f27839742f2d91 Mon Sep 17 00:00:00 2001
From: Moritz Hoffmann <antiguru@gmail.com>
Date: Tue, 10 Nov 2026 12:18:24 +0100
Subject: [PATCH 14/19] DDIR: arrange a trace import read as rows once per
 scope

With arranged imports off, a trace import renders as rows. Lowering treats
it as arranged and inserts no arrange, so each index reader arranged it
again. The first index reader now arranges it, and the import keeps both
forms for every later reader.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 interactive/src/backend/mod.rs               | 36 ++++++++++++++----
 interactive/tests/server_arranged_imports.rs | 40 ++++++++++++++++++++
 2 files changed, 68 insertions(+), 8 deletions(-)

diff --git a/interactive/src/backend/mod.rs b/interactive/src/backend/mod.rs
index 905c89388c..b17a2fe35e 100644
--- a/interactive/src/backend/mod.rs
+++ b/interactive/src/backend/mod.rs
@@ -110,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>),
 }
 
@@ -175,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 {
@@ -218,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)
@@ -251,25 +271,25 @@ 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 } => match input.as_single() {
                         Some(input) => {
-                            let a = resolve(&items, &imports, &var_cols, input).arrange();
+                            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| resolve(&items, &imports, &var_cols, r).arrange()).collect();
+                            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,
diff --git a/interactive/tests/server_arranged_imports.rs b/interactive/tests/server_arranged_imports.rs
index 4f1d928186..8cfe485a82 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);
+}

From 76d06262e01bd65f04a9094242b2c487257dab05 Mon Sep 17 00:00:00 2001
From: Moritz Hoffmann <antiguru@gmail.com>
Date: Tue, 10 Nov 2026 12:18:24 +0100
Subject: [PATCH 15/19] DDIR: variadic reduce review minors

Print a one-element positive list's distinct with the by-record re-key,
reuse the arrangement helpers in merge-reduce, list merge-reduce in the
README, and tidy the pipe syntax docs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 interactive/README.md                  |  5 +++--
 interactive/src/parse/pipe.rs          | 17 +++++++++--------
 interactive/src/passes/arrangements.rs |  6 ++++--
 interactive/src/passes/merge_reduce.rs | 21 +++++----------------
 interactive/src/plan/ddp/parsed.rs     |  6 ++++--
 5 files changed, 25 insertions(+), 30 deletions(-)

diff --git a/interactive/README.md b/interactive/README.md
index a47ee9f073..43366a0316 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/parse/pipe.rs b/interactive/src/parse/pipe.rs
index a2504520d4..f74b1181a3 100644
--- a/interactive/src/parse/pipe.rs
+++ b/interactive/src/parse/pipe.rs
@@ -42,16 +42,17 @@
 //!   key's first `n` values (`n` at least one), whatever their diffs; `min` is
 //!   `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
+//! - `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
+//! - `[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`.
+//!   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)`.
@@ -97,10 +98,10 @@
 //! 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,
 //! `(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`).
+//! 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:
 //!
diff --git a/interactive/src/passes/arrangements.rs b/interactive/src/passes/arrangements.rs
index 8d533836fc..cc1bc5b615 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/merge_reduce.rs b/interactive/src/passes/merge_reduce.rs
index 4b28887c36..d8c242f3a0 100644
--- a/interactive/src/passes/merge_reduce.rs
+++ b/interactive/src/passes/merge_reduce.rs
@@ -12,8 +12,9 @@
 //! 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, Source};
+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`
@@ -22,26 +23,13 @@ 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 child_imports: Vec<bool> = child.imports.iter().map(|import| match &import.from {
-            Source::Parent(r) => arranged(scope, imports, r),
-            _ => false,
-        }).collect();
+        let arranged_imports = child_imports(scope, imports, child);
         let Item::Sub(sub) = &mut scope.items[i] else { unreachable!() };
-        count += run(sub, &child_imports);
+        count += run(sub, &arranged_imports);
     }
     count
 }
 
-/// Whether `r` is statically arranged in `scope`.
-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],
-        // Leaving a child flattens its exports. Feedback is also a collection.
-        Ref::Var(_) | Ref::ChildExport(_, _) => false,
-    }
-}
-
 /// 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)>) {
@@ -204,6 +192,7 @@ mod tests {
         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#"
diff --git a/interactive/src/plan/ddp/parsed.rs b/interactive/src/plan/ddp/parsed.rs
index b9eb69b187..9740c24992 100644
--- a/interactive/src/plan/ddp/parsed.rs
+++ b/interactive/src/plan/ddp/parsed.rs
@@ -72,8 +72,10 @@ 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) => {
-                // A list is no collection to key by its records, and `distinct` handles any values.
-                let by_record = matches!(reducer, crate::parse::Reducer::Distinct) && !matches!(**input, Expr::List(_));
+                // 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())? };

From 86fd1e1d964af87d9a876fa2ba109e5f967eb449 Mon Sep 17 00:00:00 2001
From: Moritz Hoffmann <antiguru@gmail.com>
Date: Tue, 10 Nov 2026 12:20:08 +0100
Subject: [PATCH 16/19] DDIR: test that merge-reduce's printed output replans

Plan with the default passes, print the optimized stage, and replan the
text with none: shared and single unarranged leaves, a negated and a
repeated arranged leaf, a merged reduce in a loop, and one hoisted out of
a child scope. Also check that a one-element list's distinct prints keyed
by record.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 interactive/tests/variadic_reduce.rs | 64 +++++++++++++++++++++++++---
 1 file changed, 58 insertions(+), 6 deletions(-)

diff --git a/interactive/tests/variadic_reduce.rs b/interactive/tests/variadic_reduce.rs
index bf844def64..0eb1f36bc0 100644
--- a/interactive/tests/variadic_reduce.rs
+++ b/interactive/tests/variadic_reduce.rs
@@ -489,14 +489,14 @@ fn import_source(name: &str) -> Option<interactive::scope_ir::RowShape> {
     (name == "p::x").then_some((corgi::Shape::Int, corgi::Shape::Int))
 }
 
-/// Plans `src` with no passes, prints the optimized stage, replans the text, and checks the two
-/// plans compare equal and the second print equals the first.
-fn assert_printed_replans(src: &str, expect: &str) {
+/// 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 config = interactive::passes::Config::none();
-    let first = plan::report(src, &import_source, &config).unwrap_or_else(|e| panic!("{src}: {e}"));
+    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 config = interactive::passes::Config::none();
     let second = plan::report(&text, &import_source, &config).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}");
@@ -520,7 +520,59 @@ fn printed_reduces_replan_identically() {
         ("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}"), expect); }
+    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

From b1a7156432ccf9871cbb67be5e7239568e2873ab Mon Sep 17 00:00:00 2001
From: Moritz Hoffmann <antiguru@gmail.com>
Date: Tue, 10 Nov 2026 12:28:34 +0100
Subject: [PATCH 17/19] differential: test co_reduce with an input ahead inside
 a loop

An input entered into an iterative scope and arranged there runs several
outer epochs ahead of the loop's feedback. The driver hands over its
batches beyond the retired interval, and the reduce's output at every
iteration matches the reduce of the concatenation.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 differential-dataflow/tests/co_reduce.rs | 125 ++++++++++++++++++++---
 1 file changed, 111 insertions(+), 14 deletions(-)

diff --git a/differential-dataflow/tests/co_reduce.rs b/differential-dataflow/tests/co_reduce.rs
index 135a082bbf..348312b588 100644
--- a/differential-dataflow/tests/co_reduce.rs
+++ b/differential-dataflow/tests/co_reduce.rs
@@ -5,14 +5,17 @@ use std::sync::{Arc, Mutex};
 use std::sync::atomic::{AtomicUsize, Ordering};
 
 use timely::dataflow::channels::pact::Pipeline;
-use timely::progress::Antichain;
+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;
@@ -21,8 +24,8 @@ use differential_dataflow::trace::chunk::vec::{ChunkBatcher as VChunkBatcher, Ch
 use differential_dataflow::trace::cursor::Cursor;
 use differential_dataflow::trace::{Navigable, Span};
 
-type Batch = Rc<ChunkBatch<VecChunk<u64, (u64, u64), u64, i64>>>;
-type Spine = VChunkSpine<u64, (u64, u64), u64, i64>;
+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`.
@@ -31,16 +34,16 @@ struct Untag<Tac> {
     ahead: Arc<AtomicUsize>,
 }
 
-impl<Tac: ReduceTactic<u64, Batch, Batch>> ReduceTactic<u64, (usize, Batch), Batch> for Untag<Tac> {
+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)>,
-        output_batches: Vec<Batch>,
-        input_batches: Vec<(usize, Batch)>,
-        lower: &Antichain<u64>,
-        upper: &Antichain<u64>,
-        held: &Antichain<u64>,
-    ) -> (Option<Span<u64, Batch>>, Antichain<u64>) {
+        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 {
@@ -55,15 +58,15 @@ impl<Tac: ReduceTactic<u64, Batch, Batch>> ReduceTactic<u64, (usize, Batch), Bat
             }
             if beyond { self.ahead.fetch_add(1, Ordering::Relaxed); }
         }
-        let untag = |batches: Vec<(usize, Batch)>| batches.into_iter().map(|(_, b)| b).collect();
+        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>(c: VecCollection<'s, u64, (u64, u64), i64>) -> Arranged<'s, TraceAgent<Spine>> {
+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)), u64, i64)>, _, Spine>(hashed.inner, Pipeline, "Arrange", VChunkBatcher::new)
+    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")]
@@ -150,3 +153,97 @@ fn input_ahead_matches_concat() {
     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);
+}

From aed70ff488e2d2649eb203929c3c62a88071215e Mon Sep 17 00:00:00 2001
From: Moritz Hoffmann <antiguru@gmail.com>
Date: Tue, 10 Nov 2026 12:42:53 +0100
Subject: [PATCH 18/19] DDIR: replan printed reduces without shadowing the
 config

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 interactive/tests/variadic_reduce.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/interactive/tests/variadic_reduce.rs b/interactive/tests/variadic_reduce.rs
index 0eb1f36bc0..b6fadcec16 100644
--- a/interactive/tests/variadic_reduce.rs
+++ b/interactive/tests/variadic_reduce.rs
@@ -496,8 +496,7 @@ fn assert_printed_replans(src: &str, config: &interactive::passes::Config, expec
     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 config = interactive::passes::Config::none();
-    let second = plan::report(&text, &import_source, &config).unwrap_or_else(|e| panic!("{src}: printed text does not replan: {e}\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}");

From 0a5e9647d52e410967e5e2bf8b0fbde799dfab41 Mon Sep 17 00:00:00 2001
From: Moritz Hoffmann <antiguru@gmail.com>
Date: Tue, 10 Nov 2026 13:38:00 +0100
Subject: [PATCH 19/19] differential: test co_reduce holding back batches
 beyond the interval

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 differential-dataflow/tests/co_reduce.rs | 116 +++++++++++++++++++++++
 1 file changed, 116 insertions(+)

diff --git a/differential-dataflow/tests/co_reduce.rs b/differential-dataflow/tests/co_reduce.rs
index 348312b588..4878ea0909 100644
--- a/differential-dataflow/tests/co_reduce.rs
+++ b/differential-dataflow/tests/co_reduce.rs
@@ -247,3 +247,119 @@ fn input_ahead_in_loop_matches_concat() {
     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:?}");
+}