@@ -121,7 +121,7 @@ pub(crate) struct VortexOpener {
     /// shared layout reader.
     pub segment_sources: Arc<DashMap<Path, Weak<dyn SegmentSource>>>,
     /// The V2 scan cache each open file's partitions share: its lowered layout, filter and
-    /// projection plans, proved zones and dictionary values, built once per file.
+    /// projection plans, pruned zones and dictionary values, built once per file.
     pub scan_caches: Arc<DashMap<Path, WeakScanCache>>,
     /// Shared full-file natural splits keyed by file path.
     pub natural_splits: Arc<DashMap<Path, Arc<NaturalSplits>>>,
@@ -553,7 +553,7 @@ impl FileOpener for VortexOpener {
                     .map_err(|e| exec_datafusion_err!("Failed to plan Vortex scan: {e}"))?;
                 let scan = Arc::new(scan);
 
-                // The planners, composed: with a filter, its zone proofs first over the whole
+                // The planners, composed: with a filter, its pruning plans first over the whole
                 // partition, continuing into the chunks of the rows they keep; without a
                 // filter, the chunks directly. A chunk plans its conjuncts, then its
                 // projection.
 
@@ -4,7 +4,7 @@
 //! Drives a V2 scan of a file for callers without an engine of their own.
 //!
 //! A planner says what it needs: compute, or reads. This driver decides where each runs. It
-//! composes the planners over a [`PreparedScan`], the zone proofs first when the scan has a
+//! composes the planners over a [`PreparedScan`], the pruning plans first when the scan has a
 //! filter and the chunks of the rows they keep after, and runs them on planning runs it owns:
 //! the root run stepped on `spawn_cpu` tasks as the stream is polled, each spawned chunk on a
 //! task of its own, up to the concurrency, or on the root run at a concurrency of one. Every
@@ -112,7 +112,7 @@ impl ScanDriver {
     }
 }
 
-/// The planners of a scan, composed: with a filter, its proofs first over the whole scan,
+/// The planners of a scan, composed: with a filter, its pruning plans first over the whole scan,
 /// continuing into the chunks of the rows they keep; without, the chunks directly.
 fn compose(scan: &Arc<PreparedScan>) -> Box<dyn Planner> {
     let rows = scan.rows().clone();
 
@@ -30,7 +30,7 @@ use crate::plan::physical::optimizer::PlanParentReduceRule;
 use crate::plan::physical::optimizer::PlanReduceRule;
 use crate::plan::physical::pipeline::Chain;
 use crate::plan::physical::pipeline::Compiler;
-use crate::plan::physical::plans::zoned::is_zone_proof;
+use crate::plan::physical::plans::zoned::is_zone_pruning;
 
 const DATA: usize = 0;
 const ZONES: usize = 1;
@@ -176,7 +176,7 @@ impl PlanReduceRule<LegacyStats> for LegacyStatsRule {
     }
 }
 
-/// Converts the legacy stats beneath a zone proof in place, so the proof meets a [`Zoned`] plan
+/// Converts the legacy stats beneath a zone pruning plan in place, so the plan meets a [`Zoned`] plan
 /// before the data path optimizes the stats away.
 #[derive(Debug)]
 pub(crate) struct ExpressionLegacyStatsRule;
@@ -190,7 +190,7 @@ impl PlanParentReduceRule<LegacyStats> for ExpressionLegacyStatsRule {
         parent: &Plan<Eval>,
         _child_idx: usize,
     ) -> VortexResult<Option<PlanRef>> {
-        if !is_zone_proof(parent)? {
+        if !is_zone_pruning(parent)? {
             return Ok(None);
         }
         let Some(converted) = LegacyStatsRule.reduce(child)? else {
 
@@ -455,7 +455,7 @@ impl PlanParentReduceRule<Zoned> for ExpressionZonedRule {
         parent: &Plan<Eval>,
         _child_idx: usize,
     ) -> VortexResult<Option<PlanRef>> {
-        if !is_zone_proof(parent)? {
+        if !is_zone_pruning(parent)? {
             return Ok(None);
         }
         Ok(child
@@ -465,8 +465,8 @@ impl PlanParentReduceRule<Zoned> for ExpressionZonedRule {
 }
 
 /// Whether `eval` is a boolean expression over abstract statistics alone, which a zone table can
-/// prove without reading the data it summarises.
-pub(crate) fn is_zone_proof(eval: &Plan<Eval>) -> VortexResult<bool> {
+/// prune without reading the data it summarises.
+pub(crate) fn is_zone_pruning(eval: &Plan<Eval>) -> VortexResult<bool> {
     let mut contains_stat = false;
     let mut contains_root = false;
     eval.expression().clone().transform_down(|expression| {
@@ -488,8 +488,8 @@ pub(crate) fn is_zone_proof(eval: &Plan<Eval>) -> VortexResult<bool> {
 }
 
 /// Replaces a zoned data plan by its data: a scan reads the data through it and never its zone
-/// table. Pruning proofs are derived from the filter over the lowered plan before this runs, so
-/// an optimized plan carries a zone table only where a proof reads it.
+/// table. Pruning plans are derived from the filter over the lowered plan before this runs, so
+/// an optimized plan carries a zone table only where a pruning plan reads it.
 #[derive(Debug)]
 pub(crate) struct ZonedDataRule;
 
 
@@ -1589,7 +1589,7 @@ fn zoned_over_legacy_stats_read_as_data_keeps_only_the_data() -> VortexResult<()
 }
 
 /// Legacy stats over a zoned plan are dropped: read as data only the data remains, and a zone
-/// proof is proved over the aggregate zones, never the legacy table.
+/// pruning plan is evaluated over the aggregate zones, never the legacy table.
 #[test]
 fn legacy_stats_over_zoned_are_dropped() -> VortexResult<()> {
     let dtype = primitive(PType::I32, Nullability::NonNullable);
 
@@ -66,7 +66,7 @@ pub struct ChunkPlanner {
     rows: Range<u64>,
     chunks: IntoIter<Range<u64>>,
     selection: Selection,
-    /// The rows zone pruning kept, over `rows`, or `None` when nothing was proved.
+    /// The rows zone pruning kept, over `rows`, or `None` when nothing was pruned.
     kept: Option<Mask>,
 }
 
 
@@ -47,7 +47,7 @@ use crate::segments::SegmentId;
 pub struct FilterPlans {
     expression: FilterExpr,
     predicates: Vec<PlanRef>,
-    /// A metadata-only proof per conjunct, where the conjunct has one.
+    /// A metadata-only pruning plan per conjunct, where the conjunct has one.
     pruning: Vec<Option<PlanRef>>,
 }
 
@@ -71,7 +71,7 @@ impl FilterPlans {
             .iter()
             .map(|expr| {
                 expr.falsify(session)?
-                    .map(|proof| optimize(plan_row_idx_expression(proof, root.clone())?))
+                    .map(|pruning| optimize(plan_row_idx_expression(pruning, root.clone())?))
                     .transpose()
             })
             .map(|plan| {
@@ -89,13 +89,13 @@ impl FilterPlans {
         })
     }
 
-    /// The pruning proofs, run once over a scan's rows before its chunks are planned.
-    pub(crate) fn proofs(&self) -> impl Iterator<Item = &PlanRef> {
+    /// The pruning plans, run once over a scan's rows before its chunks are planned.
+    pub(crate) fn pruning(&self) -> impl Iterator<Item = &PlanRef> {
         self.pruning.iter().flatten()
     }
 }
 
-/// A pruning proof must not fetch data when its requested statistics are unavailable.
+/// A pruning plan must not fetch data when its requested statistics are unavailable.
 fn metadata_only(plan: &PlanRef) -> VortexResult<bool> {
     if plan
         .as_opt::<Zoned>()
 
@@ -4,7 +4,7 @@
 //! The planners of a V2 scan, and the prepared plans they run.
 //!
 //! A [`PreparedScan`] holds a scan's plans over one file. An engine composes the planners over it
-//! and drives them: a [`PrunePlanner`] proves the filter's zone maps over the scan's rows and
+//! and drives them: a [`PrunePlanner`] evaluates the filter's pruning plans over the scan's rows and
 //! emits the planner it was built to continue into, with the rows they keep; a [`ChunkPlanner`]
 //! cuts those rows into chunks and spawns a [`FilterPlanner`] or a [`ProjectionPlanner`] per
 //! chunk; a filter planner runs its chunk's conjuncts and emits a projection planner for the rows
@@ -91,7 +91,7 @@ pub struct PreparedScan {
     pub(super) locations: Arc<[SegmentLocation]>,
     /// The optimized projection plan, over the scan's root row domain.
     pub(super) projection: PlanRef,
-    /// The filter's conjuncts, their plans and their proofs.
+    /// The filter's conjuncts, their plans and their pruning plans.
     pub(super) filter: Option<Arc<FilterPlans>>,
     /// The global row index of the root row domain's first row.
     pub(super) row_offset: u64,
 
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-//! Proves a filter's zone maps once over a scan's rows, before any chunk is planned.
+//! Evaluates a filter's pruning plans once over a scan's rows, before any chunk is planned.
 
 use std::ops::Range;
 use std::sync::Arc;
@@ -31,24 +31,24 @@ use crate::plan::physical::PlanRef;
 use crate::plan::physical::pipeline::Scan;
 use crate::plan::physical::pipeline::Split;
 
-/// The planner a prune planner continues into, given the rows the proofs kept, or `None` when
-/// no proof ran.
+/// The planner a prune planner continues into, given the rows pruning kept, or `None` when
+/// no pruning plan ran.
 pub type PruneNext = Box<dyn FnOnce(Option<Mask>) -> Box<dyn Planner> + Send>;
 
-/// Runs the filter's zone-map proofs over the scan's rows and emits the planner it was built
-/// to continue into, with the rows no proof excludes. The zone maps are the only reads,
-/// started together. Rows every proof excludes end the scan here: nothing is emitted. A filter
-/// without proofs emits the next planner at once.
+/// Evaluates the filter's pruning plans over the scan's rows and emits the planner it was
+/// built to continue into, with the rows no plan pruned. The zone maps are the only reads,
+/// started together. Rows every plan prunes end the scan here: nothing is emitted. A filter
+/// without pruning plans emits the next planner at once.
 pub struct PrunePlanner {
     scan: Arc<PreparedScan>,
     rows: Range<u64>,
-    /// What to emit once every proof has run, taken when it is.
+    /// What to emit once every pruning plan has run, taken when it is.
     next: Option<PruneNext>,
-    /// Whether any proof ran, so the kept rows mean something.
-    proved: bool,
-    /// The rows no proof has excluded yet, over `rows`.
+    /// Whether any pruning plan ran, so the kept rows mean something.
+    pruned: bool,
+    /// The rows no pruning plan has excluded yet, over `rows`.
     mask: Mask,
-    proofs: IntoIter<PlanRef>,
+    pruning: IntoIter<PlanRef>,
     active: Option<ScanAdaptor>,
     pieces: Vec<Mask>,
     announced: bool,
@@ -58,21 +58,21 @@ pub struct PrunePlanner {
 }
 
 impl PrunePlanner {
-    /// The planner of the proofs of `scan`'s filter over `rows`, continuing into `next`.
+    /// The planner of `scan`'s filter's pruning plans over `rows`, continuing into `next`.
     pub fn new(scan: Arc<PreparedScan>, rows: Range<u64>, next: PruneNext) -> Self {
-        let proofs: Vec<_> = scan
+        let pruning: Vec<_> = scan
             .filter
             .iter()
-            .flat_map(|filter| filter.proofs().cloned())
+            .flat_map(|filter| filter.pruning().cloned())
             .collect();
         let len = usize::try_from(rows.end - rows.start).unwrap_or(usize::MAX);
         Self {
             scan,
             rows,
             next: Some(next),
-            proved: false,
+            pruned: false,
             mask: Mask::new_true(len),
-            proofs: proofs.into_iter(),
+            pruning: pruning.into_iter(),
             active: None,
             pieces: Vec::new(),
             announced: false,
@@ -107,11 +107,11 @@ impl Planner for PrunePlanner {
         }
         if !self.announced {
             self.announced = true;
-            // A proof whose zones an earlier scan of the file proved compiles to its kept
-            // result and lists no segment, so only unproved proofs prefetch their zone maps.
+            // A pruning plan whose zones an earlier scan of the file pruned compiles to its kept
+            // result and lists no segment, so only unpruned plans prefetch their zone maps.
             let segments = segments_read(
                 &self.scan.session,
-                self.proofs.as_slice().iter(),
+                self.pruning.as_slice().iter(),
                 self.rows.clone(),
                 &self.mask,
             )?;
@@ -149,20 +149,20 @@ impl Planner for PrunePlanner {
                 row_end = self.rows.end,
                 input_rows = input,
                 output_rows = self.mask.true_count(),
-                "v2 zone proof evaluated"
+                "v2 pruning plan evaluated"
             );
             self.active = None;
             self.pieces.clear();
-            self.proved = true;
+            self.pruned = true;
         }
         if self.mask.all_false() {
             self.done = true;
             return Ok(PlannerOutput::Done);
         }
-        if let Some(proof) = self.proofs.next() {
+        if let Some(plan) = self.pruning.next() {
             let scan = Scan::try_new(
                 self.scan.session.clone(),
-                proof,
+                plan,
                 vec![Split {
                     rows: self.rows.clone(),
                     mask: self.mask.clone(),
@@ -173,20 +173,20 @@ impl Planner for PrunePlanner {
             self.active = Some(ScanAdaptor::new(scan, Arc::clone(&self.scan.locations)));
             return Ok(PlannerOutput::Continue);
         }
-        // Every proof has run: the planner this one continues into gets the kept rows.
+        // Every pruning plan has run: the planner this one continues into gets the kept rows.
         self.done = true;
         tracing::debug!(
             row_start = self.rows.start,
             row_end = self.rows.end,
             kept_rows = self.mask.true_count(),
-            "v2 zone proofs finished"
+            "v2 pruning finished"
         );
         let next = self
             .next
             .take()
             .ok_or_else(|| vortex_err!("the prune planner has nothing to continue into"))?;
         let kept = self
-            .proved
+            .pruned
             .then(|| std::mem::replace(&mut self.mask, Mask::new_true(0)));
         Ok(PlannerOutput::Planner(
             WorkScope {
 
@@ -23,8 +23,8 @@ use crate::scan::execution::FilterPlans;
 /// over it, indexes every segment's byte range, and decodes the dictionary values it needs. A scan
 /// that finds an entry here reuses it, and one that misses builds the entry and keeps it for later
 /// scans. The lowered plan keeps the children it has initialized, each distinct projection keeps
-/// its optimized plan, each distinct filter keeps its conjunct and zone-proof plans along with the
-/// zones those proofs have already excluded, and dictionary values stay keyed by the cached plan
+/// its optimized plan, each distinct filter keeps its conjunct and pruning plans along with the
+/// zones those plans have already excluded, and dictionary values stay keyed by the cached plan
 /// that produced them.
 ///
 /// A cache describes one file's layout, segment locations, and segment source. Use a new cache
@@ -40,8 +40,8 @@ struct Inner {
     /// them, so a projection must reuse its plan for its values to be found again.
     projections: Mutex<FxHashMap<ExactBoundExpr, PlanRef>>,
     ranges: Mutex<Option<SegmentRanges>>,
-    /// Plans of filters, keyed by the exact filter expression. A proof plan remembers the zones it
-    /// excluded, so sharing the plans proves a file's zones once for every scan of that filter.
+    /// Plans of filters, keyed by the exact filter expression. A pruning plan remembers the zones it
+    /// excluded, so sharing the plans prunes a file's zones once for every scan of that filter.
     filters: Mutex<FxHashMap<ExactBoundExpr, Arc<FilterPlans>>>,
     values: ValueCache,
 }
Original file line number	Diff line number	Diff line change
`@@ -1589,7 +1589,7 @@ fn zoned_over_legacy_stats_read_as_data_keeps_only_the_data() -> VortexResult<()`
`1589`	`1589`	`}`
`1590`	`1590`
`1591`	`1591`	`/// Legacy stats over a zoned plan are dropped: read as data only the data remains, and a zone`
`1592`		`-/// proof is proved over the aggregate zones, never the legacy table.`
	`1592`	`+/// pruning plan is evaluated over the aggregate zones, never the legacy table.`
`1593`	`1593`	`#[test]`
`1594`	`1594`	`fn legacy_stats_over_zoned_are_dropped() -> VortexResult<()> {`
`1595`	`1595`	`let dtype = primitive(PType::I32, Nullability::NonNullable);`
Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ pub struct ChunkPlanner {`
`66`	`66`	`rows: Range<u64>,`
`67`	`67`	`chunks: IntoIter<Range<u64>>,`
`68`	`68`	`selection: Selection,`
`69`		- /// The rows zone pruning kept, over `rows`, or `None` when nothing was proved.
	`69`	+ /// The rows zone pruning kept, over `rows`, or `None` when nothing was pruned.
`70`	`70`	`kept: Option<Mask>,`
`71`	`71`	`}`
`72`	`72`