From 213574efdf9435842ec227bf8ea7f39b7483b55e Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 16 Oct 2026 00:29:47 +0000 Subject: [PATCH 1/7] D-HOLO H14d: pre-registration (C only, four stages) Logic reduces the set expression (relalg), the address mask R is materialized over presence planes, Lance 13 reads only R's survivors, terminals count from R or compute on the survivors' operands. Checks, disable runs and predictions are fixed before any timing. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011BMJnDBAfzcuQh5HeT39Rh --- .claude/board/INTEGRATION_PLANS.md | 7 + .claude/board/STATUS_BOARD.md | 1 + .../plans/d-holo-h14d-logic-mask-read-v1.md | 121 ++++++++++++++++++ 3 files changed, 129 insertions(+) create mode 100644 .claude/plans/d-holo-h14d-logic-mask-read-v1.md diff --git a/.claude/board/INTEGRATION_PLANS.md b/.claude/board/INTEGRATION_PLANS.md index 7b846772e..e470fa9ae 100644 --- a/.claude/board/INTEGRATION_PLANS.md +++ b/.claude/board/INTEGRATION_PLANS.md @@ -1,3 +1,10 @@ +## 2026-10-16 — d-holo-h14d-logic-mask-read-v1 — C's own operation: logic → address mask → masked read → terminal → `.claude/plans/d-holo-h14d-logic-mask-read-v1.md` + +**Status:** PRE-REGISTERED; not run. + +- Four stages in order, each shrinking the next: relalg symbolic reduction (no data), address materialization over presence planes (64 per word), Lance 13 read pruned by `R`, terminals. +- C only. No B, S or M arm: the row-first comparisons of H14/H14b are withdrawn (#1569). + ## 2026-10-14 (2) — metta-polyfill-v1 — Hyperon/MeTTa as a front end over the masking-algebra polyfill → `.claude/plans/metta-polyfill-v1.md` **Status:** PROPOSAL; D-MTP-0 (map + measurements), D-MTP-1 (join probe, measured), D-MTP-1b (range hop, measured) and D-MTP-6 (datafrog oracle) done; D-MTP-2..5 not authorized. diff --git a/.claude/board/STATUS_BOARD.md b/.claude/board/STATUS_BOARD.md index 2b3c9299d..117b7d947 100644 --- a/.claude/board/STATUS_BOARD.md +++ b/.claude/board/STATUS_BOARD.md @@ -44,6 +44,7 @@ Plan: `.claude/plans/relalg-v1.md`. Crate: `crates/lance-graph-relalg` (own work | **D-HOLO-H12** | Semantic map of inference functions across OpenNARS, ONA, the NAL polyfill (and a MeTTa NAL if pinnable) | Queued (pre-registered, not run) | last system adds zero nodes in both orders; polyfill gaps named; differences classified as distinction or defect | | **D-HOLO-H14** | Per classid x thought x 64k tile: full 512-byte row writes vs a connected lane delta (row key + lane mask + changed lanes in one record), and per-(thought, lane) tables indexed directly by the row address (`Lane_l[index]`, no traversal; presence masks folded, materialization charged only at a terminal); session thought masks and thought lane masks kept as separate levels | Measured 2026-10-15 (v4, one class): C folds 10–256× faster than B on F1/F2; C merge-on-read 2.8–6.1× slower than B; C default and B default both not met; returned to the operator with the crossover; H14b measured (row D-HOLO-H14b) | == dense reference; C default iff at k <= 4 its fold queries are >= 2x faster than B, its reads with terminal materialization <= 1.25x B and bytes <= B; else B default iff read and session read <= 1.25x A and bytes <= 0.5x A; mixed result returns to the operator | | **D-HOLO-H14b** | C plus one positional u32 lane mask per row per thought (`Mask[i]`), so merge-on-read reads only the tables the mask names; folds unchanged | Measured 2026-10-15 (v4, one class, entry 2026-10-15-d-holo-h14b-lane-mask): prediction falsified in 9 of 18 cells at k <= 4 (all 1 % cells pass, failures at 10 % and 100 % dirty); bytes <= B everywhere; M faster than C on full-row read in 35 of 36 cells; M beats B on F3 in all 12 cells at 1 % dirty; M default not met. WITHDRAWN 2026-10-15 as a layout candidate (category error: M transposes C's presence planes into a row index; H14/H14b measured row reconstruction, not C's primary operation); numbers kept; follow-up D-HOLO-H14c | M default iff at k <= 4 on every cell its full-row and session read <= 1.25x B and bytes <= B; folds equal C (tested) | +| **D-HOLO-H14d** | C's own operation in four stages, C only: (1) relalg symbolic reduction of the thought's set expression, (2) materialize `R = P_a ∧ P_b ∧ A` (or `∨`) over presence planes, (3) Lance 13 read pruned by `R`, (4) COUNT/EXISTS from `R` or the operation on `T_a[i], T_b[i]` for survivors; sub-ids -1 … -5 | Pre-registered 2026-10-16 (plan d-holo-h14d-logic-mask-read-v1); not run | `R` == per-address reference; rewritten == as written on 2,000 programs; payload reads == |R| × k; Lance rows == |R| with reference values; five disable runs red | | **D-RA-1** | `Rel` + `normalize` + `symbolic` + R2IL lowering | Shipped #1546 `c21bd165` (11 tests, 11 disable runs red; four comparisons on one lane 8 → 2 ops; 70/2,000 small descriptions refused as written, all run rewritten) | == row oracle over 400 generated descriptions × 5 measures | | **D-RA-2** | Rules into the contract set IR (D-CMR-1/-6); relalg keeps only lowering or is deleted | Queued (maintainer decision) | relalg tests pass unchanged against the contract IR | | **D-RA-3** | Datalog rules as algebra values; names are labels resolved through the label codebook, never strings in a rule | Queued (after D-RA-2) | codebook-built rules == hand-written `Rel`; unknown label refused at resolution | diff --git a/.claude/plans/d-holo-h14d-logic-mask-read-v1.md b/.claude/plans/d-holo-h14d-logic-mask-read-v1.md new file mode 100644 index 000000000..ca8711968 --- /dev/null +++ b/.claude/plans/d-holo-h14d-logic-mask-read-v1.md @@ -0,0 +1,121 @@ +# D-HOLO-H14d — logic → address mask → masked read → terminal (C only) + +**Status:** PRE-REGISTERED 2026-10-16. Nothing below has been run. +**Follows:** D-HOLO-H14c (#1573). H14, H14b and part of H14c measured C by +rebuilding rows or against row-first layouts (B, M); that framing is withdrawn +(#1569). This probe measures C's own operation and nothing else. + +## Overview + +A thought `t` selects lanes `a, b, …`. Its operation is + +``` +Thought(t)[T_a[i] : T_b[i]] for every i the logic admits +``` + +and it runs in four stages, in this order, each only shrinking what the next +one touches: + +| stage | what runs | touches | existing code | +|---|---|---|---| +| 1. logic | the set expression is reduced symbolically (Prolog reduces the set theory): intersection, union, difference, contradiction, absorption | no data | `lance-graph-relalg::normalize` + `symbolic` (#1546) | +| 2. address materialization | the reduced expression becomes the concrete address set `R` over the thought's presence planes `P_l` and the aperture `A`, e.g. `R = P_a ∧ P_b ∧ A` or `(P_a ∨ P_b) ∧ A` | presence planes only, 64 addresses per word | `relalg::run` → R2IL → one mask-risc program (`Measure::Keep` writes `R`, `Measure::Count` is the mask terminal) | +| 3. masked read | `R` prunes the read at the source | payload of survivors only | Lance 13 `with_row_addr_prefilter(RowAddrMask)` (as D-TELEPORT-2) | +| 4. terminal | COUNT / EXISTS from `R`; or per survivor `i`, read `T_a[i], T_b[i]` positionally and run the operation | nothing more | positional lanes (H14c read path) | + +The only thing materialized before a terminal is addresses. A per-address +read is the payload terminal's correct primitive: it runs only at addresses +whose presence bits the mask has already proved. No arm B, S or M. + +## Checklist + +- [ ] Pre-registration committed before any timing (this file) +- [ ] Probe crate `crates/holo-h14d-probe` (excluded from the workspace, like the relalg crate; path deps: relalg, mask-risc; registry: lance 13, arrow 58, tokio) +- [ ] Oracles (§ Checks) written first and red against a stub +- [ ] Disable runs (§ Disable runs) red, files restored +- [ ] v4 run, tier printed by the program +- [ ] Results section, board entry with raw CSV, STATUS row, AGENT_LOG +- [ ] Draft PR; no merge + +## Sub-ids + +| id | stage | measures | +|---|---|---| +| D-HOLO-H14d-1 | 1 | fraction of a generated program corpus decided symbolically (`Empty`/`All`, zero programs run); mask-risc passes rewritten vs as written | +| D-HOLO-H14d-2 | 2 | ns per 64-address word to materialize `R`; ns per word for the COUNT terminal | +| D-HOLO-H14d-3 | 3 | Lance rows scanned and `bytes_read` with `R` vs without it, same projection | +| D-HOLO-H14d-4 | 4 | ns per survivor for the resident payload terminal; ns per word for the fused Σ terminal (`Measure::Sum`) | +| D-HOLO-H14d-5 | 4 | ns for a single-address query: presence bits, then the loads | + +## Fixture + +- One tile, `N = 65,536` addresses. One thought; up to 8 lanes. +- Presence planes `P_l`: patterns uniform (independent per address), clustered + (runs of 64), at densities 0.1 %, 1 %, 10 %, 50 %. +- Aperture `A`: a contiguous window of 1,024, 8,192 or 65,536 addresses. +- Value lanes `T_l`: positional `i32`, `T_l[i] = f(l, i)` where present and + `POISON = i32::MIN` where absent. A read at an absent address therefore + breaks every sum and every comparison, so the reference tests catch it. +- Program forms: `∧` over k presence planes and `A` (k = 1, 2, 4, 8); `∨` over + k planes, then `∧ A`. +- Stage-1 corpus: seeded generator over the same planes adding duplicates, + `x ∧ ¬x`, `x ∨ ¬x`, nested absorption (`x ∧ (x ∨ y)`), `∧ All`, `∨ Empty`; + 2,000 programs. + +## Predictions (stated before the run) + +1. Stage 1 decides every program containing `x ∧ ¬x` (or reduced to it) as + `Empty` with 0 programs run, and every `x ∨ ¬x` COUNT as `All`. +2. Stage 2 cost per word is flat in density (within 1.25× between 0.1 % and + 50 %) and grows with the number of operands, not with `|R|`. +3. Stage 3: `rows_scanned == |R|` in every cell. `bytes_read` with `R` is below + the unmasked read only where survivors are page-local (clustered, or a + narrow aperture); at uniform 1 % it equals the unmasked bytes (H14c). +4. Stage 4: payload reads == `|R| × k` exactly; ns per survivor flat in density + within 1.5×. +5. A single-address query costs one presence test per requested lane plus k + loads, with no search. + +No layout decision depends on these numbers. The result returns to the +operator. + +## Checks (written first) + +1. `R` from stage 2 equals a per-address reference for every fixture cell. +2. Stage 1 (`run`) and the unrewritten program (`run_as_written`) give the + same answer on all 2,000 programs; the reference agrees with both. +3. COUNT terminal == `popcount(R)` == reference. +4. Resident payload terminal: Σ and the comparison count equal the reference; + payload reads == `|R| × k` (counted). +5. Fused Σ (`Measure::Sum`) equals the explicit payload terminal. +6. Lance payload terminal: returned rows == `|R|`, values equal the reference. +7. Single-address query equals the reference at every address of a sample, + absent included. +8. Fixture shape: the poison value really sits at every absent address, and + each density cell has the stated `|P_l|` within 10 %. + +## Disable runs (each must turn its check red; files restored after) + +1. Skip stage 1 (`run_as_written` everywhere): check 2's "0 programs run" for + contradictions must fail. +2. Read payload outside `R` (iterate the aperture, not `R`): checks 4 and 6 + must fail on the read count and on the poison. +3. Treat absent as a value (drop the presence test in the single-address + query): check 7 must fail. +4. Hand Lance a mask that is not `R` (the aperture alone): check 6 must fail. +5. Drop `A` from the expression: check 1 must fail. + +## Timing protocol + +v4 only, tier printed by the program; release, debug 0. Medians of 7 batches; +hot (repeated) and cold (cache flushed between batches) reported apart. ns per +word, per survivor, per query; never whole-call milliseconds. About 40 % +run-to-run noise was measured on this VM in H14c; differences below that are +not read as results. + +## Not measured + +Hardware counters (none on this VM). Lance decoded bytes, pages and +allocations (not exposed). More than one tile. Quack's `lower_fused` path +(another front end over the same mask-risc programs; relalg is used here +because it carries the stage-1 reduction). From e433e1296ecdadaabf25da3cf80d8e858784a318 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 16 Oct 2026 00:30:28 +0000 Subject: [PATCH 2/7] D-HOLO H14d: amendment A1 (payload read count in the OR form), before any code or timing Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011BMJnDBAfzcuQh5HeT39Rh --- .claude/plans/d-holo-h14d-logic-mask-read-v1.md | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/.claude/plans/d-holo-h14d-logic-mask-read-v1.md b/.claude/plans/d-holo-h14d-logic-mask-read-v1.md index ca8711968..ff21aebae 100644 --- a/.claude/plans/d-holo-h14d-logic-mask-read-v1.md +++ b/.claude/plans/d-holo-h14d-logic-mask-read-v1.md @@ -86,7 +86,8 @@ operator. same answer on all 2,000 programs; the reference agrees with both. 3. COUNT terminal == `popcount(R)` == reference. 4. Resident payload terminal: Σ and the comparison count equal the reference; - payload reads == `|R| × k` (counted). + payload reads == `Σ_l popcount(R ∧ P_l)` (counted), which is `|R| × k` for + the `∧` form. 5. Fused Σ (`Measure::Sum`) equals the explicit payload terminal. 6. Lance payload terminal: returned rows == `|R|`, values equal the reference. 7. Single-address query equals the reference at every address of a sample, @@ -105,6 +106,14 @@ operator. 4. Hand Lance a mask that is not `R` (the aperture alone): check 6 must fail. 5. Drop `A` from the expression: check 1 must fail. +## Amendment A1 (2026-10-16, before any code or timing) + +In the `∨` form a survivor of `R` need not hold every requested lane, so the +payload terminal tests lane `l`'s presence bit at `i` before loading `T_l[i]`. +The exact read count is `Σ_l popcount(R ∧ P_l)`; for the `∧` form every +survivor holds every lane and the count is `|R| × k`, as first stated. +Prediction 4 and check 4 read with this count. + ## Timing protocol v4 only, tier printed by the program; release, debug 0. Medians of 7 batches; From ac849a64c667ddbc0361cdff156972d8545b70a4 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 16 Oct 2026 00:44:03 +0000 Subject: [PATCH 3/7] D-HOLO-H14d: probe crate (stages 1-4, checks 1-8); not yet built or run The probe measures C's own operation: symbolic reduction, the address mask R over presence planes and aperture, the Lance 13 prefilter with R, and the presence-gated positional payload terminal. Checks are written; they have not run yet. Excluded from the workspace. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011BMJnDBAfzcuQh5HeT39Rh --- Cargo.toml | 4 + crates/holo-h14d-probe/Cargo.toml | 26 + crates/holo-h14d-probe/build.rs | 27 + crates/holo-h14d-probe/src/main.rs | 789 +++++++++++++++++++++++++++++ 4 files changed, 846 insertions(+) create mode 100644 crates/holo-h14d-probe/Cargo.toml create mode 100644 crates/holo-h14d-probe/build.rs create mode 100644 crates/holo-h14d-probe/src/main.rs diff --git a/Cargo.toml b/Cargo.toml index 22d085929..4cec7b27a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -115,6 +115,10 @@ exclude = [ # lance-graph-r2il like lance-graph-nal. Own workspace root; verify via # `cargo test --manifest-path crates/lance-graph-relalg/Cargo.toml`. "crates/lance-graph-relalg", + # D-HOLO-H14d probe (plan d-holo-h14d-logic-mask-read-v1): its own workspace + # root; path-deps relalg and pulls lance 13. Excluded so no workspace crate + # gains a dependency. + "crates/holo-h14d-probe", # D-MTP-1: its own workspace root (datafrog oracle is a git dev-dependency). # `cargo test --manifest-path crates/lance-graph-metta/Cargo.toml`. "crates/lance-graph-metta", diff --git a/crates/holo-h14d-probe/Cargo.toml b/crates/holo-h14d-probe/Cargo.toml new file mode 100644 index 000000000..6534ae7d1 --- /dev/null +++ b/crates/holo-h14d-probe/Cargo.toml @@ -0,0 +1,26 @@ +[package] +name = "holo-h14d-probe" +version = "0.1.0" +edition = "2021" +publish = false +description = "D-HOLO-H14d: C's own operation in four stages: logic, address mask, masked read, terminal (plan d-holo-h14d-logic-mask-read-v1)" + +# Its own workspace root and excluded from the workspace: it path-deps +# lance-graph-relalg (which git-deps OGAR through lance-graph-r2il) and pulls +# lance 13, so it changes no dependency of any workspace crate. Run with +# cargo run --release --manifest-path crates/holo-h14d-probe/Cargo.toml +# cargo test --release --manifest-path crates/holo-h14d-probe/Cargo.toml +[workspace] + +[dependencies] +lance-graph-relalg = { path = "../lance-graph-relalg" } +lance-graph-mask-risc = { path = "../lance-graph-mask-risc" } +lance = { version = "13.*", default-features = false } +arrow-array = "58" +arrow-schema = "58" +futures = "0.3" +tokio = { version = "1.37", features = ["macros", "rt-multi-thread"] } +tempfile = "3" + +[patch."https://github.com/AdaWorldAPI/lance-graph"] +lance-graph-contract = { path = "../lance-graph-contract" } diff --git a/crates/holo-h14d-probe/build.rs b/crates/holo-h14d-probe/build.rs new file mode 100644 index 000000000..14630b0ee --- /dev/null +++ b/crates/holo-h14d-probe/build.rs @@ -0,0 +1,27 @@ +//! Records the `lance` version this build resolved, so the probe prints what +//! it was built against. The repository tracks no `Cargo.lock`; cargo writes +//! one next to this excluded crate's manifest before running this script. + +use std::path::Path; + +fn main() { + let dir = std::env::var("CARGO_MANIFEST_DIR").unwrap(); + let lock = Path::new(&dir).join("Cargo.lock"); + println!("cargo:rerun-if-changed={}", lock.display()); + let text = std::fs::read_to_string(&lock).unwrap_or_default(); + let mut version = "unknown".to_string(); + let mut in_lance = false; + for line in text.lines() { + if line == "[[package]]" { + in_lance = false; + } else if line == "name = \"lance\"" { + in_lance = true; + } else if in_lance { + if let Some(v) = line.strip_prefix("version = \"") { + version = v.trim_end_matches('"').to_string(); + break; + } + } + } + println!("cargo:rustc-env=PROBE_LANCE_VERSION={version}"); +} diff --git a/crates/holo-h14d-probe/src/main.rs b/crates/holo-h14d-probe/src/main.rs new file mode 100644 index 000000000..c0cca314c --- /dev/null +++ b/crates/holo-h14d-probe/src/main.rs @@ -0,0 +1,789 @@ +//! D-HOLO-H14d: C's own operation, in four stages, C only +//! (plan `.claude/plans/d-holo-h14d-logic-mask-read-v1.md`). +//! +//! 1. logic: the thought's set expression is reduced symbolically +//! (`lance_graph_relalg::normalize` / `symbolic`); no data is touched. +//! 2. address materialization: the reduced expression becomes the address set +//! `R` over the thought's presence planes `P_l` and the aperture `A`, as one +//! mask-risc program (`relalg::run`, `Measure::Keep`); the COUNT terminal is +//! `Measure::Count`. +//! 3. masked read: `R` prunes a Lance 13 read at the source +//! (`with_row_addr_prefilter`). +//! 4. terminal: per survivor `i` of `R`, the presence bit of each requested +//! lane gates a positional load of `T_l[i]`, then the operation runs. +//! +//! Only addresses are materialized before a terminal. Absent values hold +//! `POISON`, so a read the presence bits did not admit breaks every result. + +use std::collections::BTreeMap; +use std::sync::{Arc, Mutex}; +use std::time::Instant; + +use arrow_array::{Array, Int32Array, RecordBatch, RecordBatchIterator, UInt32Array, UInt64Array}; +use arrow_schema::{DataType, Field, Schema}; +use lance::dataset::scanner::{RowAddrMask, RowAddrTreeMap}; +use lance::dataset::{Dataset, WriteMode, WriteParams}; +use lance_graph_mask_risc::{words_for, LaneRef, Planes}; +use lance_graph_relalg::{normalize, run, run_as_written, symbolic, Answer, Measure, Query, Rel}; + +/// Addresses in one tile. +const N: usize = 65_536; +/// 64-address words in one tile. +const W: usize = N / 64; +/// Lanes the thought can request. +const LANES: usize = 8; +/// The plane index of the aperture in `Planes::masks`. +const APERTURE: u16 = LANES as u16; +/// The value an absent address holds; reading it breaks every result. +const POISON: i32 = i32::MIN; + +fn tier() -> &'static str { + if cfg!(target_feature = "avx512f") { + "v4 (avx512f)" + } else { + "below v4: timings not reportable" + } +} + +fn mix(mut z: u64) -> u64 { + z = z.wrapping_add(0x9E37_79B9_7F4A_7C15); + z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9); + z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB); + z ^ (z >> 31) +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum Pattern { + /// Each address independently. + Uniform, + /// Runs of 64 addresses: one draw per word. + Clustered, +} + +impl Pattern { + fn name(self) -> &'static str { + match self { + Pattern::Uniform => "uniform", + Pattern::Clustered => "clustered", + } + } +} + +/// Whether lane `l` holds a value at address `i` (closed form; the oracle). +fn present(p: Pattern, d: f64, l: usize, i: usize) -> bool { + let key = match p { + Pattern::Uniform => i as u64, + Pattern::Clustered => (i / 64) as u64, + }; + let h = mix((l as u64) << 40 ^ key ^ 0x5151); + (h >> 11) as f64 / (1u64 << 53) as f64 < d +} + +/// The value lane `l` holds at address `i` when present: small, so sums fit. +fn value(l: usize, i: usize) -> i32 { + (mix((l as u64) << 32 | i as u64) % 2001) as i32 - 1000 +} + +fn in_aperture(width: usize, i: usize) -> bool { + i < width +} + +/// One thought's resident data: presence planes, aperture, positional lanes. +struct Fx { + p: Vec>, + a: Vec, + t: Vec>, + pattern: Pattern, + density: f64, + width: usize, +} + +fn plane(f: impl Fn(usize) -> bool) -> Vec { + let mut w = vec![0u64; words_for(N)]; + for i in (0..N).filter(|&i| f(i)) { + w[i / 64] |= 1 << (i % 64); + } + w +} + +fn fixture(pattern: Pattern, density: f64, width: usize) -> Fx { + let p = (0..LANES) + .map(|l| plane(|i| present(pattern, density, l, i))) + .collect(); + let t = (0..LANES) + .map(|l| { + (0..N) + .map(|i| { + if present(pattern, density, l, i) { + value(l, i) + } else { + POISON + } + }) + .collect() + }) + .collect(); + Fx { + p, + a: plane(|i| in_aperture(width, i)), + t, + pattern, + density, + width, + } +} + +impl Fx { + /// Run `f` with the planes relalg reads: `P_0 … P_7`, then `A`. + fn with_planes(&self, f: impl FnOnce(&Planes<'_>) -> T) -> T { + let lanes: Vec> = self.t.iter().map(|t| LaneRef::I32(t)).collect(); + let mut masks: Vec<&[u64]> = self.p.iter().map(Vec::as_slice).collect(); + masks.push(&self.a); + let planes = Planes { + n_rows: N, + masks: &masks, + lanes: &lanes, + }; + f(&planes) + } + + /// Whether `i` belongs to the form's population (the oracle). + fn member(&self, form: Form, k: usize, i: usize) -> bool { + let lanes = (0..k).map(|l| present(self.pattern, self.density, l, i)); + let hit = match form { + Form::And => lanes.fold(true, |a, b| a && b), + Form::Or => lanes.fold(false, |a, b| a || b), + }; + hit && in_aperture(self.width, i) + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum Form { + /// `P_0 ∧ … ∧ P_{k-1} ∧ A` + And, + /// `(P_0 ∨ … ∨ P_{k-1}) ∧ A` + Or, +} + +impl Form { + fn name(self) -> &'static str { + match self { + Form::And => "and", + Form::Or => "or", + } + } +} + +/// The thought's set expression over its first `k` lanes and the aperture. +fn expr(form: Form, k: usize) -> Rel { + let lanes: Vec = (0..k as u16).map(Rel::Plane).collect(); + match form { + Form::And => Rel::And(lanes.into_iter().chain([Rel::Plane(APERTURE)]).collect()), + Form::Or => Rel::And(vec![Rel::Or(lanes), Rel::Plane(APERTURE)]), + } +} + +// ── stage 2: the address mask ────────────────────────────────────────────── + +/// `R`, materialized by one mask-risc program. +fn materialize(fx: &Fx, rel: &Rel, r: &mut [u64]) { + let q = Query { + rel: rel.clone(), + measure: Measure::Keep, + }; + fx.with_planes(|pl| run(&q, pl, Some(r)).expect("lowering")); +} + +/// The COUNT terminal: no payload is read. +fn count(fx: &Fx, rel: &Rel) -> u64 { + let q = Query { + rel: rel.clone(), + measure: Measure::Count, + }; + match fx.with_planes(|pl| run(&q, pl, None).expect("lowering")).answer { + Answer::Count(c) => c, + a => panic!("count answered {a:?}"), + } +} + +/// Σ of lane `l` over `R`, fused into the mask-risc program. +fn fused_sum(fx: &Fx, rel: &Rel, l: u16) -> i64 { + let q = Query { + rel: rel.clone(), + measure: Measure::Sum(l), + }; + match fx.with_planes(|pl| run(&q, pl, None).expect("lowering")).answer { + Answer::Sum(s) => s, + a => panic!("sum answered {a:?}"), + } +} + +// ── stage 4: the payload terminal ────────────────────────────────────────── + +/// What the payload terminal produced, and how many values it loaded. +#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)] +struct Out { + /// Σ over survivors of the present requested values. + sum: i64, + /// Survivors where lanes 0 and 1 are both present and `T_0 > T_1`. + greater: u64, + /// Values loaded. + reads: u64, +} + +/// Per survivor `i` of `R`: lane `l`'s presence bit gates the load of +/// `T_l[i]`, then the operation runs (add, and compare lanes 0 and 1). +fn payload(fx: &Fx, r: &[u64], k: usize) -> Out { + let mut o = Out::default(); + for (w, &bits) in r.iter().enumerate() { + let mut b = bits; + while b != 0 { + let i = w * 64 + b.trailing_zeros() as usize; + b &= b - 1; + let mut v = [None; LANES]; + for l in 0..k { + if fx.p[l][w] >> (i % 64) & 1 == 1 { + v[l] = Some(fx.t[l][i]); + o.reads += 1; + } + } + for x in v.iter().take(k).flatten() { + o.sum += i64::from(*x); + } + if let (Some(a), Some(b)) = (v[0], v[1]) { + o.greater += u64::from(a > b); + } + } + } + o +} + +/// One address: the aperture bit, then each requested lane's presence bit, +/// then the load. `None` = absent; `Some(None)` = outside the aperture. +fn point(fx: &Fx, i: usize, k: usize) -> Option<[Option; LANES]> { + if fx.a[i / 64] >> (i % 64) & 1 == 0 { + return None; + } + let mut v = [None; LANES]; + for (l, slot) in v.iter_mut().enumerate().take(k) { + if fx.p[l][i / 64] >> (i % 64) & 1 == 1 { + *slot = Some(fx.t[l][i]); + } + } + Some(v) +} + +// ── stage 1: the corpus ──────────────────────────────────────────────────── + +struct Rng(u64); + +impl Rng { + fn next(&mut self) -> u64 { + self.0 = mix(self.0); + self.0 + } + fn below(&mut self, n: u64) -> u64 { + self.next() % n + } +} + +/// A random expression over the nine planes, with redundancy and +/// contradiction mixed in. +fn random_rel(rng: &mut Rng, depth: u32) -> Rel { + let leaf = |rng: &mut Rng| Rel::Plane(rng.below(u64::from(APERTURE) + 1) as u16); + if depth == 0 { + return leaf(rng); + } + let a = random_rel(rng, depth - 1); + match rng.below(9) { + 0 => Rel::And(vec![a.clone(), Rel::Not(Box::new(a))]), + 1 => Rel::Or(vec![a.clone(), Rel::Not(Box::new(a))]), + 2 => { + let b = random_rel(rng, depth - 1); + Rel::And(vec![a.clone(), Rel::Or(vec![a, b])]) + } + 3 => Rel::And(vec![a.clone(), a]), + 4 => Rel::Or(vec![a, Rel::Empty]), + 5 => Rel::And(vec![a, Rel::All]), + 6 => Rel::Not(Box::new(a)), + 7 => Rel::Or(vec![a, random_rel(rng, depth - 1)]), + _ => Rel::And(vec![a, random_rel(rng, depth - 1)]), + } +} + +fn corpus(n: usize) -> Vec { + let mut rng = Rng(0x00C0_FFEE); + (0..n) + .map(|_| { + let d = 1 + rng.below(3) as u32; + random_rel(&mut rng, d) + }) + .collect() +} + +/// Evaluate `rel` at address `i` over the fixture's bits (the oracle). +fn holds(fx: &Fx, rel: &Rel, i: usize) -> bool { + match rel { + Rel::All => true, + Rel::Empty => false, + Rel::Plane(p) => { + let w = if *p == APERTURE { &fx.a } else { &fx.p[*p as usize] }; + w[i / 64] >> (i % 64) & 1 == 1 + } + Rel::Not(c) => !holds(fx, c, i), + Rel::And(cs) => cs.iter().all(|c| holds(fx, c, i)), + Rel::Or(cs) => cs.iter().any(|c| holds(fx, c, i)), + Rel::Atom(_) => unreachable!("the corpus holds planes only"), + } +} + +/// Stage 1 for one program: answered without running (`programs == 0`), or run. +fn stage1(fx: &Fx, rel: &Rel) -> (u64, usize, usize) { + let q = Query { + rel: rel.clone(), + measure: Measure::Count, + }; + let r = fx.with_planes(|pl| run(&q, pl, None).expect("lowering")); + match r.answer { + Answer::Count(c) => (c, r.programs, r.passes), + a => panic!("{a:?}"), + } +} + +// ── stage 3: Lance ───────────────────────────────────────────────────────── + +fn lane_name(l: usize) -> String { + format!("lane_{l}") +} + +fn schema() -> Arc { + let mut f = vec![Field::new("coord", DataType::UInt32, false)]; + f.extend((0..LANES).map(|l| Field::new(lane_name(l), DataType::Int32, false))); + Arc::new(Schema::new(f)) +} + +fn batch(fx: &Fx) -> RecordBatch { + let mut cols: Vec> = vec![Arc::new(UInt32Array::from_iter_values(0..N as u32))]; + for l in 0..LANES { + cols.push(Arc::new(Int32Array::from(fx.t[l].clone()))); + } + RecordBatch::try_new(schema(), cols).unwrap() +} + +async fn write(uri: &str, fx: &Fx) -> Dataset { + let reader = RecordBatchIterator::new([Ok(batch(fx))], schema()); + let params = WriteParams { + mode: WriteMode::Create, + max_rows_per_file: N, + ..Default::default() + }; + Dataset::write(reader, uri, Some(params)).await.unwrap() +} + +/// `_rowid` of every stored coordinate, positionally (coordinate `c` at `[c]`). +async fn row_ids(ds: &Dataset) -> Vec { + let mut s = ds.scan(); + s.project(&["coord"]).unwrap(); + s.with_row_id(); + let b = s.try_into_batch().await.unwrap(); + let coord = b.column_by_name("coord").unwrap().as_any().downcast_ref::().unwrap(); + let id = b.column_by_name("_rowid").unwrap().as_any().downcast_ref::().unwrap(); + let mut out = vec![u64::MAX; N]; + for j in 0..b.num_rows() { + out[coord.value(j) as usize] = id.value(j); + } + out +} + +#[derive(Debug, Default, Clone)] +struct Io { + bytes_read: usize, + rows_scanned: usize, + rows: usize, +} + +/// The read of lanes `0..k`; pruned by `mask` when given. Returns +/// `coord → values` and Lance's own statistics. +async fn read( + ds: &Dataset, + mask: Option, + k: usize, +) -> (BTreeMap>, Io) { + let mut names = vec!["coord".to_string()]; + names.extend((0..k).map(lane_name)); + let stats: Arc> = Arc::default(); + let sink = stats.clone(); + let mut s = ds.scan(); + s.project(&names).unwrap(); + if let Some(m) = mask { + s.with_row_addr_prefilter(m); + } + s.scan_stats_callback(Arc::new(move |c| { + let mut io = sink.lock().unwrap(); + io.bytes_read = c.bytes_read; + io.rows_scanned = c.all_counts.get("rows_scanned").copied().unwrap_or(0); + })); + let b = s.try_into_batch().await.unwrap(); + let mut io = stats.lock().unwrap().clone(); + io.rows = b.num_rows(); + let coord = b.column_by_name("coord").unwrap().as_any().downcast_ref::().unwrap(); + let lanes: Vec<&Int32Array> = (0..k) + .map(|l| b.column_by_name(&lane_name(l)).unwrap().as_any().downcast_ref::().unwrap()) + .collect(); + let mut out = BTreeMap::new(); + for j in 0..b.num_rows() { + out.insert(coord.value(j), lanes.iter().map(|a| a.value(j)).collect()); + } + (out, io) +} + +/// `R`'s survivors as Lance row ids. +fn row_mask(r: &[u64], ids: &[u64]) -> RowAddrMask { + let mut set = Vec::new(); + for (w, &bits) in r.iter().enumerate() { + let mut b = bits; + while b != 0 { + set.push(ids[w * 64 + b.trailing_zeros() as usize]); + b &= b - 1; + } + } + RowAddrMask::from_allowed(RowAddrTreeMap::from_iter(set)) +} + +// ── timing ───────────────────────────────────────────────────────────────── + +fn median(mut v: Vec) -> f64 { + v.sort_by(|a, b| a.partial_cmp(b).unwrap()); + v[v.len() / 2] +} + +/// Median of 7 batches of `reps` calls, in ns per `units`; `flush` runs +/// before each batch (empty for hot). +fn time(reps: usize, units: f64, mut flush: impl FnMut(), mut f: impl FnMut()) -> f64 { + let mut out = Vec::new(); + for _ in 0..7 { + flush(); + let t = Instant::now(); + for _ in 0..reps { + f(); + } + out.push(t.elapsed().as_nanos() as f64 / reps as f64 / units); + } + median(out) +} + +fn evict(buf: &mut [u64]) { + for (j, x) in buf.iter_mut().enumerate() { + *x = x.wrapping_add(j as u64); + } + std::hint::black_box(&buf); +} + +fn csv(fields: &[String]) { + println!("csv,{}", fields.join(",")); +} + +#[tokio::main(flavor = "multi_thread", worker_threads = 4)] +async fn main() { + println!("lance: {} (resolved at build time; no lockfile is tracked)", env!("PROBE_LANCE_VERSION")); + println!("tier: {}", tier()); + println!("csv,stage,pattern,density,width,form,k,cache,metric,value"); + let mut ev = vec![0u64; 8 << 20]; + + // Stage 1: the corpus over one fixture. + { + let fx = fixture(Pattern::Uniform, 0.1, N); + let progs = corpus(2000); + let mut decided = 0; + let mut passes_rw = 0usize; + let mut passes_as = 0usize; + for rel in &progs { + let (_, programs, passes) = stage1(&fx, rel); + decided += usize::from(programs == 0); + passes_rw += passes; + let q = Query { rel: rel.clone(), measure: Measure::Count }; + passes_as += fx.with_planes(|pl| run_as_written(&q, pl, None).unwrap()).passes; + } + let ns = time(1, progs.len() as f64, || {}, || { + for rel in &progs { + std::hint::black_box(symbolic(&normalize(rel), Measure::Count, N)); + } + }); + let row = |m: &str, v: String| csv(&["1".into(), "uniform".into(), "0.1".into(), N.to_string(), "-".into(), "-".into(), "-".into(), m.into(), v]); + row("programs", progs.len().to_string()); + row("decided_symbolically", decided.to_string()); + row("passes_rewritten", passes_rw.to_string()); + row("passes_as_written", passes_as.to_string()); + row("reduce_ns_per_program", format!("{ns:.1}")); + } + + let dir = tempfile::tempdir().unwrap(); + for pattern in [Pattern::Uniform, Pattern::Clustered] { + for &d in &[0.001, 0.01, 0.1, 0.5] { + for &width in &[1024usize, 8192, N] { + let fx = fixture(pattern, d, width); + let uri = dir.path().join(format!("{}_{d}_{width}", pattern.name())); + let ds = write(uri.to_str().unwrap(), &fx).await; + let ids = row_ids(&ds).await; + for form in [Form::And, Form::Or] { + for &k in &[1usize, 2, 4, 8] { + if form == Form::Or && k == 1 { + continue; + } + let rel = expr(form, k); + let mut r = vec![0u64; W]; + materialize(&fx, &rel, &mut r); + let survivors: u64 = r.iter().map(|w| u64::from(w.count_ones())).sum(); + let row = |cache: &str, m: &str, v: String| { + csv(&["2-4".into(), pattern.name().into(), d.to_string(), width.to_string(), form.name().into(), k.to_string(), cache.into(), m.into(), v]) + }; + row("-", "survivors", survivors.to_string()); + // stage 2 and the COUNT terminal + for (cache, cold) in [("hot", false), ("cold", true)] { + let mut sink = vec![0u64; W]; + let ns = time(if cold { 1 } else { 50 }, W as f64, || if cold { evict(&mut ev) }, || materialize(&fx, &rel, &mut sink)); + row(cache, "materialize_ns_per_word", format!("{ns:.3}")); + let ns = time(if cold { 1 } else { 50 }, W as f64, || if cold { evict(&mut ev) }, || { std::hint::black_box(count(&fx, &rel)); }); + row(cache, "count_ns_per_word", format!("{ns:.3}")); + // stage 4: payload terminal over the survivors + let o = payload(&fx, &r, k); + let ns = time(if cold { 1 } else { 50 }, survivors.max(1) as f64, || if cold { evict(&mut ev) }, || { std::hint::black_box(payload(&fx, &r, k)); }); + row(cache, "payload_ns_per_survivor", format!("{ns:.3}")); + if !cold { + row("-", "payload_reads", o.reads.to_string()); + } + let ns = time(if cold { 1 } else { 50 }, W as f64, || if cold { evict(&mut ev) }, || { std::hint::black_box(fused_sum(&fx, &rel, 0)); }); + row(cache, "fused_sum_ns_per_word", format!("{ns:.3}")); + // a single-address query at 1,024 addresses spread over the tile + let pts: Vec = (0..1024).map(|j| (mix(j as u64) as usize) % N).collect(); + let ns = time(if cold { 1 } else { 20 }, pts.len() as f64, || if cold { evict(&mut ev) }, || { + for &i in &pts { + std::hint::black_box(point(&fx, i, k)); + } + }); + row(cache, "point_ns_per_query", format!("{ns:.3}")); + } + // stage 3: Lance, form ∧ only (the read projection is lanes 0..k) + if form == Form::And { + let (_, plain) = read(&ds, None, k).await; + let mask = row_mask(&r, &ids); + let t = Instant::now(); + let (got, masked) = read(&ds, Some(mask), k).await; + let wall = t.elapsed().as_nanos() as f64; + row("-", "lance_rows_returned", masked.rows.to_string()); + row("-", "lance_rows_scanned_masked", masked.rows_scanned.to_string()); + row("-", "lance_rows_scanned_unmasked", plain.rows_scanned.to_string()); + row("-", "lance_bytes_masked", masked.bytes_read.to_string()); + row("-", "lance_bytes_unmasked", plain.bytes_read.to_string()); + row("-", "lance_ns_per_survivor_wall", format!("{:.1}", wall / survivors.max(1) as f64)); + assert_eq!(got.len() as u64, survivors, "lance returned other rows than R"); + } + } + } + } + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + const CELLS: [(Pattern, f64, usize); 4] = [ + (Pattern::Uniform, 0.5, N), + (Pattern::Uniform, 0.1, 8192), + (Pattern::Clustered, 0.5, 8192), + (Pattern::Clustered, 0.1, N), + ]; + + fn reference_r(fx: &Fx, form: Form, k: usize) -> Vec { + plane(|i| fx.member(form, k, i)) + } + + /// Check 1: `R` equals the per-address reference. + #[test] + fn r_equals_the_reference() { + for (p, d, w) in CELLS { + let fx = fixture(p, d, w); + for form in [Form::And, Form::Or] { + for k in [1, 2, 4, 8] { + let mut r = vec![0u64; W]; + materialize(&fx, &expr(form, k), &mut r); + assert_eq!(r, reference_r(&fx, form, k), "{p:?} {d} {w} {form:?} k {k}"); + } + } + } + } + + /// Check 2: rewritten == as written == reference on the corpus; every + /// program that reduces to `Empty` or to `All` runs no program. + #[test] + fn stage1_answers_agree_and_contradictions_run_nothing() { + let fx = fixture(Pattern::Uniform, 0.1, N); + let progs = corpus(2000); + let mut contradictions = 0; + for rel in &progs { + let (c, programs, _) = stage1(&fx, rel); + let q = Query { rel: rel.clone(), measure: Measure::Count }; + let as_written = fx.with_planes(|pl| run_as_written(&q, pl, None).unwrap()); + assert_eq!(as_written.answer, Answer::Count(c)); + let want = (0..N).filter(|&i| holds(&fx, rel, i)).count() as u64; + assert_eq!(c, want, "{rel:?}"); + let n = normalize(rel); + if n == Rel::Empty || n == Rel::All { + contradictions += 1; + assert_eq!(programs, 0, "{rel:?} reduced to {n:?} but ran"); + } + } + // anti-vacuity: the corpus really contains decidable programs + assert!(contradictions > 100, "only {contradictions} decidable programs"); + // and programs that must run + assert!(contradictions * 2 < progs.len(), "{contradictions} of {}", progs.len()); + } + + /// Check 3: the COUNT terminal == popcount(R) == reference. + #[test] + fn count_terminal_equals_popcount() { + for (p, d, w) in CELLS { + let fx = fixture(p, d, w); + for form in [Form::And, Form::Or] { + for k in [1, 2, 4] { + let r = reference_r(&fx, form, k); + let pop: u64 = r.iter().map(|w| u64::from(w.count_ones())).sum(); + assert_eq!(count(&fx, &expr(form, k)), pop); + } + } + } + } + + fn reference_out(fx: &Fx, form: Form, k: usize) -> Out { + let mut o = Out::default(); + for i in (0..N).filter(|&i| fx.member(form, k, i)) { + let v: Vec> = (0..k) + .map(|l| present(fx.pattern, fx.density, l, i).then(|| value(l, i))) + .collect(); + for x in v.iter().flatten() { + o.sum += i64::from(*x); + o.reads += 1; + } + if k >= 2 { + if let (Some(a), Some(b)) = (v[0], v[1]) { + o.greater += u64::from(a > b); + } + } + } + o + } + + /// Check 4: payload terminal == reference, reads == Σ_l |R ∧ P_l|. + #[test] + fn payload_terminal_reads_exactly_the_present_survivors() { + for (p, d, w) in CELLS { + let fx = fixture(p, d, w); + for form in [Form::And, Form::Or] { + for k in [1, 2, 4, 8] { + let mut r = vec![0u64; W]; + materialize(&fx, &expr(form, k), &mut r); + let got = payload(&fx, &r, k); + assert_eq!(got, reference_out(&fx, form, k), "{p:?} {d} {w} {form:?} k {k}"); + let want: u64 = (0..k) + .map(|l| r.iter().zip(&fx.p[l]).map(|(a, b)| u64::from((a & b).count_ones())).sum::()) + .sum(); + assert_eq!(got.reads, want); + if form == Form::And { + let pop: u64 = r.iter().map(|w| u64::from(w.count_ones())).sum(); + assert_eq!(got.reads, pop * k as u64); + } + } + } + } + } + + /// Check 5: the fused Σ equals the explicit payload terminal (∧ form, + /// lane 0 alone). + #[test] + fn fused_sum_equals_the_payload_terminal() { + for (p, d, w) in CELLS { + let fx = fixture(p, d, w); + for k in [1, 2, 4] { + let rel = expr(Form::And, k); + let mut r = vec![0u64; W]; + materialize(&fx, &rel, &mut r); + let o = payload(&fx, &r, 1); + assert_eq!(fused_sum(&fx, &rel, 0), o.sum); + } + } + } + + /// Check 6: Lance returns exactly `R`'s survivors with reference values. + #[tokio::test(flavor = "multi_thread", worker_threads = 2)] + async fn lance_reads_exactly_the_survivors() { + let dir = tempfile::tempdir().unwrap(); + for (j, (p, d, w)) in CELLS.into_iter().enumerate() { + let fx = fixture(p, d, w); + let uri = dir.path().join(format!("c{j}")); + let ds = write(uri.to_str().unwrap(), &fx).await; + let ids = row_ids(&ds).await; + assert!(ids.iter().all(|&x| x != u64::MAX), "every coordinate stored"); + for k in [1, 2, 4] { + let mut r = vec![0u64; W]; + materialize(&fx, &expr(Form::And, k), &mut r); + let (got, io) = read(&ds, Some(row_mask(&r, &ids)), k).await; + let want: Vec = (0..N).filter(|&i| fx.member(Form::And, k, i)).collect(); + assert_eq!(io.rows, want.len(), "{p:?} {d} {w} k {k}"); + assert_eq!(got.len(), want.len()); + for &i in &want { + let vals = &got[&(i as u32)]; + for (l, &v) in vals.iter().enumerate() { + assert_eq!(v, value(l, i)); + } + } + } + } + } + + /// Check 7: the single-address query equals the reference, absent and + /// outside the aperture included. + #[test] + fn point_query_equals_the_reference() { + for (p, d, w) in CELLS { + let fx = fixture(p, d, w); + let mut absent = 0; + for j in 0..4096u64 { + let i = mix(j) as usize % N; + let got = point(&fx, i, 4); + if !in_aperture(w, i) { + assert_eq!(got, None); + continue; + } + let got = got.unwrap(); + for l in 0..4 { + let want = present(p, d, l, i).then(|| value(l, i)); + absent += usize::from(want.is_none()); + assert_eq!(got[l], want, "{p:?} {d} {w} i {i} l {l}"); + } + } + assert!(absent > 0, "the sample holds absent values"); + } + } + + /// Check 8: the fixture has the stated shape. + #[test] + fn fixture_has_the_stated_shape() { + for (p, d, w) in CELLS { + let fx = fixture(p, d, w); + for l in 0..LANES { + let n = fx.p[l].iter().map(|x| x.count_ones() as f64).sum::(); + let want = d * N as f64; + assert!((n - want).abs() <= 0.1 * want + 64.0, "{p:?} {d} lane {l}: {n}"); + for i in 0..N { + let is_p = fx.p[l][i / 64] >> (i % 64) & 1 == 1; + assert_eq!(is_p, fx.t[l][i] != POISON, "poison exactly at absent"); + } + } + let a: u32 = fx.a.iter().map(|x| x.count_ones()).sum(); + assert_eq!(a as usize, w); + } + } +} From 52731e18e83926cf62162584de5fb8c50236aacd Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 16 Oct 2026 01:01:23 +0000 Subject: [PATCH 4/7] D-HOLO-H14d: checks 1-8 green; amendment A2 (slot refusals, clustered tolerance) Check 2 counts the documented MAX_SLOTS refusal instead of unwrapping it and reports programs widened by the rewrite (2 of 2,000: absorption is missed after De Morgan flattens; a relalg defect recorded for its own fix). Check 8's tolerance is binomial in the pattern's draw unit. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011BMJnDBAfzcuQh5HeT39Rh --- .../plans/d-holo-h14d-logic-mask-read-v1.md | 26 ++ crates/holo-h14d-probe/Cargo.toml | 1 + crates/holo-h14d-probe/src/main.rs | 333 ++++++++++++++---- 3 files changed, 298 insertions(+), 62 deletions(-) diff --git a/.claude/plans/d-holo-h14d-logic-mask-read-v1.md b/.claude/plans/d-holo-h14d-logic-mask-read-v1.md index ff21aebae..ba8d6f954 100644 --- a/.claude/plans/d-holo-h14d-logic-mask-read-v1.md +++ b/.claude/plans/d-holo-h14d-logic-mask-read-v1.md @@ -114,6 +114,32 @@ The exact read count is `Σ_l popcount(R ∧ P_l)`; for the `∧` form every survivor holds every lane and the count is `|R| × k`, as first stated. Prediction 4 and check 4 read with this count. +## Amendment A2 (2026-10-16, after the first test run, before any timing) + +Two corrections, both found by the checks before a single timing ran. + +1. **Check 2, refusals.** `FoldDialect` refuses a fold wider than + `lance_graph_r2il::MAX_SLOTS` (8) scratch slots, by design and never by + truncation. Deep corpus programs hit it as written. Check 2 now compares + answers only where a run answers, and stage 1 additionally reports how many + programs are refused rewritten, refused as written, answered only after the + rewrite, and **widened by the rewrite** (answered as written, refused + rewritten). Only the scratch-slot refusal is accepted; any other error + fails the check. Anti-vacuity: more than half the corpus must be answered + both ways. +2. **Check 8, tolerance.** Clustered presence is drawn per 64-address word, so + its count is a binomial over 1,024 draws scaled by 64, with about 9 % + relative spread at 10 % density; the flat 10 % bound failed on a correct + fixture. The bound is now 5 binomial standard deviations in the pattern's + own draw unit. + +First observation, from the corrected check (not a timing): of 2,000 programs, +1,583 are answered both ways, 396 only after the rewrite, and 2 are widened by +it. The widened case is `¬(x ∧ (x ∨ y))`: `normalize` applies De Morgan before +absorption, flattens, and leaves `¬x ∨ (¬x ∧ ¬y)`, so absorption no longer +matches. A relalg defect, recorded for its own test-first fix; this probe +counts it and does not change relalg. + ## Timing protocol v4 only, tier printed by the program; release, debug 0. Medians of 7 batches; diff --git a/crates/holo-h14d-probe/Cargo.toml b/crates/holo-h14d-probe/Cargo.toml index 6534ae7d1..1e409ee5e 100644 --- a/crates/holo-h14d-probe/Cargo.toml +++ b/crates/holo-h14d-probe/Cargo.toml @@ -15,6 +15,7 @@ description = "D-HOLO-H14d: C's own operation in four stages: logic, address mas [dependencies] lance-graph-relalg = { path = "../lance-graph-relalg" } lance-graph-mask-risc = { path = "../lance-graph-mask-risc" } +lance-graph-r2il = { path = "../lance-graph-r2il" } lance = { version = "13.*", default-features = false } arrow-array = "58" arrow-schema = "58" diff --git a/crates/holo-h14d-probe/src/main.rs b/crates/holo-h14d-probe/src/main.rs index c0cca314c..f8764204e 100644 --- a/crates/holo-h14d-probe/src/main.rs +++ b/crates/holo-h14d-probe/src/main.rs @@ -23,8 +23,11 @@ use arrow_array::{Array, Int32Array, RecordBatch, RecordBatchIterator, UInt32Arr use arrow_schema::{DataType, Field, Schema}; use lance::dataset::scanner::{RowAddrMask, RowAddrTreeMap}; use lance::dataset::{Dataset, WriteMode, WriteParams}; -use lance_graph_mask_risc::{words_for, LaneRef, Planes}; -use lance_graph_relalg::{normalize, run, run_as_written, symbolic, Answer, Measure, Query, Rel}; +use lance_graph_mask_risc::{words_for, ExecError, LaneRef, Planes}; +use lance_graph_r2il::FoldError; +use lance_graph_relalg::{ + normalize, run, run_as_written, symbolic, Answer, Measure, Query, Rel, RelError, +}; /// Addresses in one tile. const N: usize = 65_536; @@ -76,7 +79,7 @@ fn present(p: Pattern, d: f64, l: usize, i: usize) -> bool { Pattern::Clustered => (i / 64) as u64, }; let h = mix((l as u64) << 40 ^ key ^ 0x5151); - (h >> 11) as f64 / (1u64 << 53) as f64 < d + ((h >> 11) as f64 / (1u64 << 53) as f64) < d } /// The value lane `l` holds at address `i` when present: small, so sums fit. @@ -201,7 +204,10 @@ fn count(fx: &Fx, rel: &Rel) -> u64 { rel: rel.clone(), measure: Measure::Count, }; - match fx.with_planes(|pl| run(&q, pl, None).expect("lowering")).answer { + match fx + .with_planes(|pl| run(&q, pl, None).expect("lowering")) + .answer + { Answer::Count(c) => c, a => panic!("count answered {a:?}"), } @@ -213,7 +219,10 @@ fn fused_sum(fx: &Fx, rel: &Rel, l: u16) -> i64 { rel: rel.clone(), measure: Measure::Sum(l), }; - match fx.with_planes(|pl| run(&q, pl, None).expect("lowering")).answer { + match fx + .with_planes(|pl| run(&q, pl, None).expect("lowering")) + .answer + { Answer::Sum(s) => s, a => panic!("sum answered {a:?}"), } @@ -328,7 +337,11 @@ fn holds(fx: &Fx, rel: &Rel, i: usize) -> bool { Rel::All => true, Rel::Empty => false, Rel::Plane(p) => { - let w = if *p == APERTURE { &fx.a } else { &fx.p[*p as usize] }; + let w = if *p == APERTURE { + &fx.a + } else { + &fx.p[*p as usize] + }; w[i / 64] >> (i % 64) & 1 == 1 } Rel::Not(c) => !holds(fx, c, i), @@ -338,19 +351,44 @@ fn holds(fx: &Fx, rel: &Rel, i: usize) -> bool { } } -/// Stage 1 for one program: answered without running (`programs == 0`), or run. -fn stage1(fx: &Fx, rel: &Rel) -> (u64, usize, usize) { +/// One COUNT run of `rel`: the count, programs run, passes. `Err` only for +/// the documented refusal of a fold wider than the dialect's scratch slots +/// (`lance_graph_r2il::MAX_SLOTS`); any other error is a defect and panics. +fn count_run(fx: &Fx, rel: &Rel, rewritten: bool) -> Result<(u64, usize, usize), ()> { let q = Query { rel: rel.clone(), measure: Measure::Count, }; - let r = fx.with_planes(|pl| run(&q, pl, None).expect("lowering")); - match r.answer { - Answer::Count(c) => (c, r.programs, r.passes), - a => panic!("{a:?}"), + let r = fx.with_planes(|pl| { + if rewritten { + run(&q, pl, None) + } else { + run_as_written(&q, pl, None) + } + }); + match r { + Ok(r) => match r.answer { + Answer::Count(c) => Ok((c, r.programs, r.passes)), + a => panic!("{a:?}"), + }, + Err(e) if refused(&e) => Err(()), + Err(e) => panic!("{rel:?}: {e:?}"), } } +fn refused(e: &RelError) -> bool { + matches!( + e, + RelError::Fold(FoldError::Exec(ExecError::ScratchBufferTooSmall { .. })) + ) +} + +/// Stage 1 for one program, rewritten: answered without running +/// (`programs == 0`), run, or refused. +fn stage1(fx: &Fx, rel: &Rel) -> Result<(u64, usize, usize), ()> { + count_run(fx, rel, true) +} + // ── stage 3: Lance ───────────────────────────────────────────────────────── fn lane_name(l: usize) -> String { @@ -387,8 +425,18 @@ async fn row_ids(ds: &Dataset) -> Vec { s.project(&["coord"]).unwrap(); s.with_row_id(); let b = s.try_into_batch().await.unwrap(); - let coord = b.column_by_name("coord").unwrap().as_any().downcast_ref::().unwrap(); - let id = b.column_by_name("_rowid").unwrap().as_any().downcast_ref::().unwrap(); + let coord = b + .column_by_name("coord") + .unwrap() + .as_any() + .downcast_ref::() + .unwrap(); + let id = b + .column_by_name("_rowid") + .unwrap() + .as_any() + .downcast_ref::() + .unwrap(); let mut out = vec![u64::MAX; N]; for j in 0..b.num_rows() { out[coord.value(j) as usize] = id.value(j); @@ -405,11 +453,7 @@ struct Io { /// The read of lanes `0..k`; pruned by `mask` when given. Returns /// `coord → values` and Lance's own statistics. -async fn read( - ds: &Dataset, - mask: Option, - k: usize, -) -> (BTreeMap>, Io) { +async fn read(ds: &Dataset, mask: Option, k: usize) -> (BTreeMap>, Io) { let mut names = vec!["coord".to_string()]; names.extend((0..k).map(lane_name)); let stats: Arc> = Arc::default(); @@ -427,9 +471,20 @@ async fn read( let b = s.try_into_batch().await.unwrap(); let mut io = stats.lock().unwrap().clone(); io.rows = b.num_rows(); - let coord = b.column_by_name("coord").unwrap().as_any().downcast_ref::().unwrap(); + let coord = b + .column_by_name("coord") + .unwrap() + .as_any() + .downcast_ref::() + .unwrap(); let lanes: Vec<&Int32Array> = (0..k) - .map(|l| b.column_by_name(&lane_name(l)).unwrap().as_any().downcast_ref::().unwrap()) + .map(|l| { + b.column_by_name(&lane_name(l)) + .unwrap() + .as_any() + .downcast_ref::() + .unwrap() + }) .collect(); let mut out = BTreeMap::new(); for j in 0..b.num_rows() { @@ -486,7 +541,10 @@ fn csv(fields: &[String]) { #[tokio::main(flavor = "multi_thread", worker_threads = 4)] async fn main() { - println!("lance: {} (resolved at build time; no lockfile is tracked)", env!("PROBE_LANCE_VERSION")); + println!( + "lance: {} (resolved at build time; no lockfile is tracked)", + env!("PROBE_LANCE_VERSION") + ); println!("tier: {}", tier()); println!("csv,stage,pattern,density,width,form,k,cache,metric,value"); let mut ev = vec![0u64; 8 << 20]; @@ -498,23 +556,54 @@ async fn main() { let mut decided = 0; let mut passes_rw = 0usize; let mut passes_as = 0usize; + let (mut refused_rw, mut refused_as, mut both) = (0usize, 0usize, 0usize); + let mut widened = 0usize; for rel in &progs { - let (_, programs, passes) = stage1(&fx, rel); - decided += usize::from(programs == 0); - passes_rw += passes; - let q = Query { rel: rel.clone(), measure: Measure::Count }; - passes_as += fx.with_planes(|pl| run_as_written(&q, pl, None).unwrap()).passes; - } - let ns = time(1, progs.len() as f64, || {}, || { - for rel in &progs { - std::hint::black_box(symbolic(&normalize(rel), Measure::Count, N)); + let rw = stage1(&fx, rel); + let aw = count_run(&fx, rel, false); + match rw { + Ok((_, programs, _)) => decided += usize::from(programs == 0), + Err(()) => refused_rw += 1, } - }); - let row = |m: &str, v: String| csv(&["1".into(), "uniform".into(), "0.1".into(), N.to_string(), "-".into(), "-".into(), "-".into(), m.into(), v]); + refused_as += usize::from(aw.is_err()); + widened += usize::from(rw.is_err() && aw.is_ok()); + if let (Ok((_, _, p1)), Ok((_, _, p2))) = (rw, aw) { + both += 1; + passes_rw += p1; + passes_as += p2; + } + } + let ns = time( + 1, + progs.len() as f64, + || {}, + || { + for rel in &progs { + std::hint::black_box(symbolic(&normalize(rel), Measure::Count, N)); + } + }, + ); + let row = |m: &str, v: String| { + csv(&[ + "1".into(), + "uniform".into(), + "0.1".into(), + N.to_string(), + "-".into(), + "-".into(), + "-".into(), + m.into(), + v, + ]) + }; row("programs", progs.len().to_string()); row("decided_symbolically", decided.to_string()); - row("passes_rewritten", passes_rw.to_string()); - row("passes_as_written", passes_as.to_string()); + row("refused_rewritten", refused_rw.to_string()); + row("refused_as_written", refused_as.to_string()); + row("answered_both", both.to_string()); + row("widened_by_rewrite", widened.to_string()); + row("passes_rewritten_where_both", passes_rw.to_string()); + row("passes_as_written_where_both", passes_as.to_string()); row("reduce_ns_per_program", format!("{ns:.1}")); } @@ -536,32 +625,94 @@ async fn main() { materialize(&fx, &rel, &mut r); let survivors: u64 = r.iter().map(|w| u64::from(w.count_ones())).sum(); let row = |cache: &str, m: &str, v: String| { - csv(&["2-4".into(), pattern.name().into(), d.to_string(), width.to_string(), form.name().into(), k.to_string(), cache.into(), m.into(), v]) + csv(&[ + "2-4".into(), + pattern.name().into(), + d.to_string(), + width.to_string(), + form.name().into(), + k.to_string(), + cache.into(), + m.into(), + v, + ]) }; row("-", "survivors", survivors.to_string()); // stage 2 and the COUNT terminal for (cache, cold) in [("hot", false), ("cold", true)] { let mut sink = vec![0u64; W]; - let ns = time(if cold { 1 } else { 50 }, W as f64, || if cold { evict(&mut ev) }, || materialize(&fx, &rel, &mut sink)); + let ns = time( + if cold { 1 } else { 50 }, + W as f64, + || { + if cold { + evict(&mut ev) + } + }, + || materialize(&fx, &rel, &mut sink), + ); row(cache, "materialize_ns_per_word", format!("{ns:.3}")); - let ns = time(if cold { 1 } else { 50 }, W as f64, || if cold { evict(&mut ev) }, || { std::hint::black_box(count(&fx, &rel)); }); + let ns = time( + if cold { 1 } else { 50 }, + W as f64, + || { + if cold { + evict(&mut ev) + } + }, + || { + std::hint::black_box(count(&fx, &rel)); + }, + ); row(cache, "count_ns_per_word", format!("{ns:.3}")); // stage 4: payload terminal over the survivors let o = payload(&fx, &r, k); - let ns = time(if cold { 1 } else { 50 }, survivors.max(1) as f64, || if cold { evict(&mut ev) }, || { std::hint::black_box(payload(&fx, &r, k)); }); + let ns = time( + if cold { 1 } else { 50 }, + survivors.max(1) as f64, + || { + if cold { + evict(&mut ev) + } + }, + || { + std::hint::black_box(payload(&fx, &r, k)); + }, + ); row(cache, "payload_ns_per_survivor", format!("{ns:.3}")); if !cold { row("-", "payload_reads", o.reads.to_string()); } - let ns = time(if cold { 1 } else { 50 }, W as f64, || if cold { evict(&mut ev) }, || { std::hint::black_box(fused_sum(&fx, &rel, 0)); }); + let ns = time( + if cold { 1 } else { 50 }, + W as f64, + || { + if cold { + evict(&mut ev) + } + }, + || { + std::hint::black_box(fused_sum(&fx, &rel, 0)); + }, + ); row(cache, "fused_sum_ns_per_word", format!("{ns:.3}")); // a single-address query at 1,024 addresses spread over the tile - let pts: Vec = (0..1024).map(|j| (mix(j as u64) as usize) % N).collect(); - let ns = time(if cold { 1 } else { 20 }, pts.len() as f64, || if cold { evict(&mut ev) }, || { - for &i in &pts { - std::hint::black_box(point(&fx, i, k)); - } - }); + let pts: Vec = + (0..1024).map(|j| (mix(j as u64) as usize) % N).collect(); + let ns = time( + if cold { 1 } else { 20 }, + pts.len() as f64, + || { + if cold { + evict(&mut ev) + } + }, + || { + for &i in &pts { + std::hint::black_box(point(&fx, i, k)); + } + }, + ); row(cache, "point_ns_per_query", format!("{ns:.3}")); } // stage 3: Lance, form ∧ only (the read projection is lanes 0..k) @@ -572,12 +723,28 @@ async fn main() { let (got, masked) = read(&ds, Some(mask), k).await; let wall = t.elapsed().as_nanos() as f64; row("-", "lance_rows_returned", masked.rows.to_string()); - row("-", "lance_rows_scanned_masked", masked.rows_scanned.to_string()); - row("-", "lance_rows_scanned_unmasked", plain.rows_scanned.to_string()); + row( + "-", + "lance_rows_scanned_masked", + masked.rows_scanned.to_string(), + ); + row( + "-", + "lance_rows_scanned_unmasked", + plain.rows_scanned.to_string(), + ); row("-", "lance_bytes_masked", masked.bytes_read.to_string()); row("-", "lance_bytes_unmasked", plain.bytes_read.to_string()); - row("-", "lance_ns_per_survivor_wall", format!("{:.1}", wall / survivors.max(1) as f64)); - assert_eq!(got.len() as u64, survivors, "lance returned other rows than R"); + row( + "-", + "lance_ns_per_survivor_wall", + format!("{:.1}", wall / survivors.max(1) as f64), + ); + assert_eq!( + got.len() as u64, + survivors, + "lance returned other rows than R" + ); } } } @@ -623,23 +790,42 @@ mod tests { let fx = fixture(Pattern::Uniform, 0.1, N); let progs = corpus(2000); let mut contradictions = 0; + let (mut both, mut only_rewritten, mut widened) = (0, 0, 0); for rel in &progs { - let (c, programs, _) = stage1(&fx, rel); - let q = Query { rel: rel.clone(), measure: Measure::Count }; - let as_written = fx.with_planes(|pl| run_as_written(&q, pl, None).unwrap()); - assert_eq!(as_written.answer, Answer::Count(c)); let want = (0..N).filter(|&i| holds(&fx, rel, i)).count() as u64; - assert_eq!(c, want, "{rel:?}"); + let rw = stage1(&fx, rel); + let aw = count_run(&fx, rel, false); + if let Ok((c, _, _)) = rw { + assert_eq!(c, want, "rewritten {rel:?}"); + } + if let Ok((c, _, _)) = aw { + assert_eq!(c, want, "as written {rel:?}"); + } + // A rewrite that leaves a program wider than as written is a + // stage-1 finding (counted, reported), not a wrong answer. + widened += usize::from(rw.is_err() && aw.is_ok()); + both += usize::from(rw.is_ok() && aw.is_ok()); + only_rewritten += usize::from(rw.is_ok() && aw.is_err()); let n = normalize(rel); if n == Rel::Empty || n == Rel::All { contradictions += 1; - assert_eq!(programs, 0, "{rel:?} reduced to {n:?} but ran"); + assert_eq!(rw.map(|r| r.1), Ok(0), "{rel:?} reduced to {n:?} but ran"); } } + // anti-vacuity: most programs are answered both ways + assert!(both * 2 > progs.len(), "only {both} answered both ways"); + eprintln!("answered both {both}, only rewritten {only_rewritten}, widened {widened}"); // anti-vacuity: the corpus really contains decidable programs - assert!(contradictions > 100, "only {contradictions} decidable programs"); + assert!( + contradictions > 100, + "only {contradictions} decidable programs" + ); // and programs that must run - assert!(contradictions * 2 < progs.len(), "{contradictions} of {}", progs.len()); + assert!( + contradictions * 2 < progs.len(), + "{contradictions} of {}", + progs.len() + ); } /// Check 3: the COUNT terminal == popcount(R) == reference. @@ -686,9 +872,18 @@ mod tests { let mut r = vec![0u64; W]; materialize(&fx, &expr(form, k), &mut r); let got = payload(&fx, &r, k); - assert_eq!(got, reference_out(&fx, form, k), "{p:?} {d} {w} {form:?} k {k}"); + assert_eq!( + got, + reference_out(&fx, form, k), + "{p:?} {d} {w} {form:?} k {k}" + ); let want: u64 = (0..k) - .map(|l| r.iter().zip(&fx.p[l]).map(|(a, b)| u64::from((a & b).count_ones())).sum::()) + .map(|l| { + r.iter() + .zip(&fx.p[l]) + .map(|(a, b)| u64::from((a & b).count_ones())) + .sum::() + }) .sum(); assert_eq!(got.reads, want); if form == Form::And { @@ -725,7 +920,10 @@ mod tests { let uri = dir.path().join(format!("c{j}")); let ds = write(uri.to_str().unwrap(), &fx).await; let ids = row_ids(&ds).await; - assert!(ids.iter().all(|&x| x != u64::MAX), "every coordinate stored"); + assert!( + ids.iter().all(|&x| x != u64::MAX), + "every coordinate stored" + ); for k in [1, 2, 4] { let mut r = vec![0u64; W]; materialize(&fx, &expr(Form::And, k), &mut r); @@ -775,8 +973,19 @@ mod tests { let fx = fixture(p, d, w); for l in 0..LANES { let n = fx.p[l].iter().map(|x| x.count_ones() as f64).sum::(); + // Presence is drawn per address (uniform) or per 64-address + // word (clustered): a binomial over `units` draws, bounded at + // 5 standard deviations, in addresses. + let (units, scale) = match p { + Pattern::Uniform => (N as f64, 1.0), + Pattern::Clustered => ((N / 64) as f64, 64.0), + }; let want = d * N as f64; - assert!((n - want).abs() <= 0.1 * want + 64.0, "{p:?} {d} lane {l}: {n}"); + let sd = (units * d * (1.0 - d)).sqrt() * scale; + assert!( + (n - want).abs() <= 5.0 * sd + scale, + "{p:?} {d} lane {l}: {n}" + ); for i in 0..N { let is_p = fx.p[l][i / 64] >> (i % 64) & 1 == 1; assert_eq!(is_p, fx.t[l][i] != POISON, "poison exactly at absent"); From 7d6ad4980b6adf41c59224ce016cd9d62ccbe4c1 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 16 Oct 2026 01:15:15 +0000 Subject: [PATCH 5/7] D-HOLO-H14d: clustered presence selects an exact word count per lane Review found the per-word draw missed the declared density (5,568 vs 6,554 present addresses at 10 %), so equal-labelled cells compared different densities; widening the tolerance only hid it. Clustered presence now takes exactly round(d x 1,024) words per lane (lowest seeded draws). Check 8 keeps the pre-registered 10 % bound and asserts the exact clustered count; it was red on the old fixture before the change. Amendment A2 item 2 rewritten. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011BMJnDBAfzcuQh5HeT39Rh --- .../plans/d-holo-h14d-logic-mask-read-v1.md | 14 +++-- crates/holo-h14d-probe/src/main.rs | 52 +++++++++++++------ 2 files changed, 46 insertions(+), 20 deletions(-) diff --git a/.claude/plans/d-holo-h14d-logic-mask-read-v1.md b/.claude/plans/d-holo-h14d-logic-mask-read-v1.md index ba8d6f954..0f16bdbe3 100644 --- a/.claude/plans/d-holo-h14d-logic-mask-read-v1.md +++ b/.claude/plans/d-holo-h14d-logic-mask-read-v1.md @@ -127,11 +127,15 @@ Two corrections, both found by the checks before a single timing ran. rewritten). Only the scratch-slot refusal is accepted; any other error fails the check. Anti-vacuity: more than half the corpus must be answered both ways. -2. **Check 8, tolerance.** Clustered presence is drawn per 64-address word, so - its count is a binomial over 1,024 draws scaled by 64, with about 9 % - relative spread at 10 % density; the flat 10 % bound failed on a correct - fixture. The bound is now 5 binomial standard deviations in the pattern's - own draw unit. +2. **Check 8, clustered fixture.** An independent draw per 64-address word + gives only 1,024 draws per lane, so the clustered count missed the declared + density (5,568 vs 6,554 present addresses at 10 %, lane 4): cells with the + same label would compare different densities. Clustered presence now + selects exactly `round(d × 1,024)` words per lane (the lowest seeded draws), + so every clustered cell holds exactly its declared density; check 8 keeps + the pre-registered 10 % bound and additionally asserts the exact clustered + count. (A first correction widened the tolerance instead; review rejected + it because it hid the density mismatch rather than removing it.) First observation, from the corrected check (not a timing): of 2,000 programs, 1,583 are answered both ways, 396 only after the rewrite, and 2 are widened by diff --git a/crates/holo-h14d-probe/src/main.rs b/crates/holo-h14d-probe/src/main.rs index f8764204e..34deca048 100644 --- a/crates/holo-h14d-probe/src/main.rs +++ b/crates/holo-h14d-probe/src/main.rs @@ -72,14 +72,40 @@ impl Pattern { } } +fn draw(l: usize, key: u64) -> u64 { + mix((l as u64) << 40 ^ key ^ 0x5151) +} + +/// Clustered presence selects exactly `round(d × N/64)` of the tile's words +/// per lane: the words whose seeded draw ranks lowest. Returns the largest +/// selected draw (`None` when no word is selected), cached per (d, lane). +fn clustered_threshold(d: f64, l: usize) -> Option { + use std::collections::HashMap; + use std::sync::{Mutex, OnceLock}; + static CACHE: OnceLock>>> = OnceLock::new(); + let cache = CACHE.get_or_init(Mutex::default); + *cache + .lock() + .unwrap() + .entry((d.to_bits(), l)) + .or_insert_with(|| { + let m = (d * W as f64).round() as usize; + let mut h: Vec = (0..W as u64).map(|w| draw(l, w)).collect(); + h.sort_unstable(); + m.checked_sub(1).map(|j| h[j]) + }) +} + /// Whether lane `l` holds a value at address `i` (closed form; the oracle). +/// Uniform: an independent draw per address. Clustered: whole 64-address +/// words, an exact count of them per lane (see [`clustered_threshold`]). fn present(p: Pattern, d: f64, l: usize, i: usize) -> bool { - let key = match p { - Pattern::Uniform => i as u64, - Pattern::Clustered => (i / 64) as u64, - }; - let h = mix((l as u64) << 40 ^ key ^ 0x5151); - ((h >> 11) as f64 / (1u64 << 53) as f64) < d + match p { + Pattern::Uniform => ((draw(l, i as u64) >> 11) as f64 / (1u64 << 53) as f64) < d, + Pattern::Clustered => { + clustered_threshold(d, l).is_some_and(|t| draw(l, (i / 64) as u64) <= t) + } + } } /// The value lane `l` holds at address `i` when present: small, so sums fit. @@ -973,19 +999,15 @@ mod tests { let fx = fixture(p, d, w); for l in 0..LANES { let n = fx.p[l].iter().map(|x| x.count_ones() as f64).sum::(); - // Presence is drawn per address (uniform) or per 64-address - // word (clustered): a binomial over `units` draws, bounded at - // 5 standard deviations, in addresses. - let (units, scale) = match p { - Pattern::Uniform => (N as f64, 1.0), - Pattern::Clustered => ((N / 64) as f64, 64.0), - }; let want = d * N as f64; - let sd = (units * d * (1.0 - d)).sqrt() * scale; assert!( - (n - want).abs() <= 5.0 * sd + scale, + (n - want).abs() <= 0.1 * want + 64.0, "{p:?} {d} lane {l}: {n}" ); + if p == Pattern::Clustered { + // Clustered counts are exact: round(d × words) whole words. + assert_eq!(n as usize, 64 * (d * W as f64).round() as usize); + } for i in 0..N { let is_p = fx.p[l][i / 64] >> (i % 64) & 1 == 1; assert_eq!(is_p, fx.t[l][i] != POISON, "poison exactly at absent"); From 802db7dfea88ecd33790a85d176910b62e2b902b Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 16 Oct 2026 01:20:55 +0000 Subject: [PATCH 6/7] D-HOLO-H14d: report NA per survivor when a mask has no survivors survivors.max(1) reported the empty call's fixed cost as ns per survivor in cells where R is empty (review P2). Payload and Lance per-survivor rows now print NA there; nothing else changes. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011BMJnDBAfzcuQh5HeT39Rh --- crates/holo-h14d-probe/src/main.rs | 40 +++++++++++++++++++----------- 1 file changed, 26 insertions(+), 14 deletions(-) diff --git a/crates/holo-h14d-probe/src/main.rs b/crates/holo-h14d-probe/src/main.rs index 34deca048..1337ba7ab 100644 --- a/crates/holo-h14d-probe/src/main.rs +++ b/crates/holo-h14d-probe/src/main.rs @@ -693,19 +693,27 @@ async fn main() { row(cache, "count_ns_per_word", format!("{ns:.3}")); // stage 4: payload terminal over the survivors let o = payload(&fx, &r, k); - let ns = time( - if cold { 1 } else { 50 }, - survivors.max(1) as f64, - || { - if cold { - evict(&mut ev) - } - }, - || { - std::hint::black_box(payload(&fx, &r, k)); - }, - ); - row(cache, "payload_ns_per_survivor", format!("{ns:.3}")); + // With no survivors there is nothing per survivor + // to time; the call's fixed cost is not reported + // under that name. + let per_survivor = if survivors == 0 { + "NA".to_string() + } else { + let ns = time( + if cold { 1 } else { 50 }, + survivors as f64, + || { + if cold { + evict(&mut ev) + } + }, + || { + std::hint::black_box(payload(&fx, &r, k)); + }, + ); + format!("{ns:.3}") + }; + row(cache, "payload_ns_per_survivor", per_survivor); if !cold { row("-", "payload_reads", o.reads.to_string()); } @@ -764,7 +772,11 @@ async fn main() { row( "-", "lance_ns_per_survivor_wall", - format!("{:.1}", wall / survivors.max(1) as f64), + if survivors == 0 { + "NA".to_string() + } else { + format!("{:.1}", wall / survivors as f64) + }, ); assert_eq!( got.len() as u64, From 175f4374206bd2f517a0eb6f3b671d591f45b9c3 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 16 Oct 2026 02:20:13 +0000 Subject: [PATCH 7/7] board: D-HOLO H14d results, #1573 merge record, relalg absorption issue Records the v4 run of C's four-stage operation (plan Results section, board entry with the raw CSV, STATUS row), the #1573 merge in PR_ARC and LATEST_STATE, and ISS-RELALG-ABSORPTION-AFTER-DE-MORGAN (2 of 2,000 programs widened by normalize). Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011BMJnDBAfzcuQh5HeT39Rh --- .claude/board/ISSUES.md | 8 + .claude/board/LATEST_STATE.md | 5 + .claude/board/PR_ARC_INVENTORY.md | 7 + .claude/board/STATUS_BOARD.md | 2 +- .../2026-10-16-d-holo-h14d-logic-mask-read.md | 2642 +++++++++++++++++ .claude/board/entries/README.md | 3 +- .../plans/d-holo-h14d-logic-mask-read-v1.md | 97 +- 7 files changed, 2754 insertions(+), 10 deletions(-) create mode 100644 .claude/board/entries/2026-10-16-d-holo-h14d-logic-mask-read.md diff --git a/.claude/board/ISSUES.md b/.claude/board/ISSUES.md index 3ef95acff..14535ea18 100644 --- a/.claude/board/ISSUES.md +++ b/.claude/board/ISSUES.md @@ -1,3 +1,11 @@ +## ISS-RELALG-ABSORPTION-AFTER-DE-MORGAN — `normalize` can leave a program wider than as written (2026-10-16) + +**Status:** OPEN. **Basis:** MEASURED (D-HOLO-H14d stage 1, `crates/holo-h14d-probe`, 2 of 2,000 generated programs). + +- `¬(x ∧ (x ∨ y))` with `x = P1 ∧ P4` should reduce by absorption to `¬x = ¬P1 ∨ ¬P4`. `lance-graph-relalg::normalize` pushes the negation inward first (De Morgan), flattens, and returns `¬P1 ∨ ¬P4 ∨ ((¬P1 ∨ ¬P4) ∧ ¬P5 ∧ ¬P7)`: the dual absorption pattern `a ∨ (a ∧ b)` is present but `a` is spread across the flattened `Or`, so the rule no longer matches. +- Consequence: the rewritten program needs more scratch slots than the original; the original answers, the rewrite is refused (`MAX_SLOTS` = 8). Answers are never wrong; only width. +- **What closes it:** a relalg test with this case (rewritten no wider than as written, and == the row oracle), red first, then absorption applied before De Morgan or matched against flattened operand sets; disable run red. + ## ISS-QUALIA-A2B-CLUT-UNMEASURED — no measured transform from convergence 17D to the calibrated PCS 17D (2026-10-16) **Status:** OPEN. **Basis:** VERIFIED-IN-CODE (`contract::qualia_profile::SHARED_AXES` maps 5 of 17 axes by name; `device_to_pcs_shared` returns `measured = false` for the other 12). HYPOTHESIS: same-named axes mean the same thing. diff --git a/.claude/board/LATEST_STATE.md b/.claude/board/LATEST_STATE.md index 5017e89d1..192eafbb2 100644 --- a/.claude/board/LATEST_STATE.md +++ b/.claude/board/LATEST_STATE.md @@ -1,3 +1,8 @@ +## 2026-10-16 — main after #1573 (merged `461bbd1a`); D-HOLO H14c on main + +- **On `main` (#1573):** D-HOLO H14c probes and results (thought-first reads, Lance 13 masked I/O). Probe code only, no library change. +- **In PR:** #1575 (D-HOLO H14d: C's own operation in four stages — relalg logic, address mask, Lance prefilter, terminal; measured on v4). New issue `ISS-RELALG-ABSORPTION-AFTER-DE-MORGAN`. + ## 2026-10-16 — main after #1569 (merged `09f31561`); H14b on main as a withdrawn record - **On `main` (#1569):** D-HOLO H14b arm M and its results, marked withdrawn: no layout verdict on C. Probe code only (an example), no library change. diff --git a/.claude/board/PR_ARC_INVENTORY.md b/.claude/board/PR_ARC_INVENTORY.md index 641b2a189..7c21162c9 100644 --- a/.claude/board/PR_ARC_INVENTORY.md +++ b/.claude/board/PR_ARC_INVENTORY.md @@ -1,3 +1,10 @@ +## 2026-10-16 — lance-graph PR #1573 (merged `461bbd1a`, branch `ccr-9f3b8075-74u47l-holo-h14c`, head `e4681f10`, 11 commits) — D-HOLO H14c: thought-first reads, Hamming presence, Lance 13 masked I/O + +- **Added:** `holo_thought_first_probe` (point projection, mask-risc populations, terminal rows; 10 oracle tests) and the `lane_footprint` instrument in `lance-graph-mask-risc/examples`; `crates/holo-lance-masked-io-probe` (excluded from the workspace: Lance 13 masked reads, stale-map hazard across rewrites); plan `d-holo-h14c-thought-first-v1`, entry `2026-10-15-d-holo-h14c-thought-first.md`, STATUS row D-HOLO-H14c. +- **Locked:** a read consults exactly the requested lane tables for any number of touched lanes; populations load no value; a scattered 1 % mask cuts Lance rows but not bytes (page-bound), a clustered one cuts both; a stale coordinate map omits silently and the version check refuses it. +- **Deferred / open:** the C vs B comparison lines in that PR rest on the withdrawn row-first framing; C's own four-stage operation is D-HOLO-H14d (#1575). Positional tables are page-dense at uniform 1 % (≈ 93× payload resident). +- **Confidence:** medium; oracle tests and disable runs red; about 40 % run-to-run noise on the VM. + ## 2026-10-16 — lance-graph PR #1569 (merged `09f31561`, branch `ccr-9f3b8075-74u47l-holo-h14b`, head `2f07941c`) — D-HOLO H14b: lane mask M measured, then withdrawn - **Added:** arm M (C's per-lane tables plus one `u32` per row naming the changed lanes) in `holo_lane_storage_probe` with 4 tests; plan section, entry `2026-10-15-d-holo-h14b-lane-mask.md`, STATUS row D-HOLO-H14b (WITHDRAWN). diff --git a/.claude/board/STATUS_BOARD.md b/.claude/board/STATUS_BOARD.md index 0332230ce..6a71079ae 100644 --- a/.claude/board/STATUS_BOARD.md +++ b/.claude/board/STATUS_BOARD.md @@ -60,7 +60,7 @@ Plan: `.claude/plans/relalg-v1.md`. Crate: `crates/lance-graph-relalg` (own work | **D-HOLO-H14** | Per classid x thought x 64k tile: full 512-byte row writes vs a connected lane delta (row key + lane mask + changed lanes in one record), and per-(thought, lane) tables indexed directly by the row address (`Lane_l[index]`, no traversal; presence masks folded, materialization charged only at a terminal); session thought masks and thought lane masks kept as separate levels | Measured 2026-10-15 (v4, one class): C folds 10–256× faster than B on F1/F2; C merge-on-read 2.8–6.1× slower than B; C default and B default both not met; returned to the operator with the crossover; H14b measured (row D-HOLO-H14b) | == dense reference; C default iff at k <= 4 its fold queries are >= 2x faster than B, its reads with terminal materialization <= 1.25x B and bytes <= B; else B default iff read and session read <= 1.25x A and bytes <= 0.5x A; mixed result returns to the operator | | **D-HOLO-H14b** | C plus one positional u32 lane mask per row per thought (`Mask[i]`), so merge-on-read reads only the tables the mask names; folds unchanged | Measured 2026-10-15 (v4, one class, entry 2026-10-15-d-holo-h14b-lane-mask): prediction falsified in 9 of 18 cells at k <= 4 (all 1 % cells pass, failures at 10 % and 100 % dirty); bytes <= B by construction, not measured (`2f07941c`); M faster than C on full-row read in 35 of 36 cells; M beats B on F3 in all 12 cells at 1 % dirty; M default not met. WITHDRAWN 2026-10-15 as a layout candidate (category error: M transposes C's presence planes into a row index; H14/H14b measured row reconstruction, not C's primary operation); numbers kept; follow-up D-HOLO-H14c | M default iff at k <= 4 on every cell its full-row and session read <= 1.25x B and bytes <= B; folds equal C (tested) | | **D-HOLO-H14c** | Thought-first positional reads `Thought(t)[Table(a)[i] : Table(b)[i]]`: point projection, presence/Hamming populations through mask-risc, explicit terminal rows; memory and fragmentation of positional tables; Lance 13 masked I/O; coordinate identity across rewrites (sub-ids -1 … -6) | Measured 2026-10-15 (v4, entry 2026-10-15-d-holo-h14c-thought-first): acceptance A–E met (tables consulted == k for every U; k = 2 read at U = 31 0.90–1.16x U = 2); C vs B on query-shaped reads mixed; uniform 1 % positional tables ≈ 93x payload resident (flagged); Lance prediction holds (uniform 1 % mask 1.00x bytes, clustered 0.24x); stale maps omit silently, refused by the version check; returned to the operator | tables consulted == requested lanes for every touched count; at k = 2, U = 31 read <= 1.25x U = 2; populations load no value; no row materialized outside the terminal; no wrong coordinate across rewrites; Lance prediction (1 % uniform mask does not halve bytes_read, 1 % clustered does) | -| **D-HOLO-H14d** | C's own operation in four stages, C only: (1) relalg symbolic reduction of the thought's set expression, (2) materialize `R = P_a ∧ P_b ∧ A` (or `∨`) over presence planes, (3) Lance 13 read pruned by `R`, (4) COUNT/EXISTS from `R` or the operation on `T_a[i], T_b[i]` for survivors; sub-ids -1 … -5 | Pre-registered 2026-10-16 (plan d-holo-h14d-logic-mask-read-v1); not run | `R` == per-address reference; rewritten == as written on 2,000 programs; payload reads == |R| × k; Lance rows == |R| with reference values; five disable runs red | +| **D-HOLO-H14d** | C's own operation in four stages, C only: (1) relalg symbolic reduction of the thought's set expression, (2) materialize `R = P_a ∧ P_b ∧ A` (or `∨`) over presence planes, (3) Lance 13 read pruned by `R`, (4) COUNT/EXISTS from `R` or the operation on `T_a[i], T_b[i]` for survivors; sub-ids -1 … -5 | Measured 2026-10-16 (v4, entry 2026-10-16-d-holo-h14d-logic-mask-read): stage 1 decides 675/2,000 programs with 0 runs, 396 answered only after the rewrite, 2 widened (ISS-RELALG-ABSORPTION-AFTER-DE-MORGAN), passes 1,065 vs 5,898; R costs 2–10 ns per 64-address word; Lance scans exactly |R| everywhere, bytes 1.00x at uniform 1 % full tile, 0.19x clustered 1 %, 0.01–0.12x inside a 1,024/8,192 aperture; payload ~6 ns per lane load, reads == |R| × k, not flat at small |R| (fixed word scan; prediction 4 falsified); fused Σ ~1.3 ns per value; point query 8–45 ns hot; returned to the operator | `R` == per-address reference; rewritten == as written on 2,000 programs; payload reads == |R| × k; Lance rows == |R| with reference values; five disable runs red | | **D-RA-1** | `Rel` + `normalize` + `symbolic` + R2IL lowering | Shipped #1546 `c21bd165` (11 tests, 11 disable runs red; four comparisons on one lane 8 → 2 ops; 70/2,000 small descriptions refused as written, all run rewritten) | == row oracle over 400 generated descriptions × 5 measures | | **D-RA-2** | Rules into the contract set IR (D-CMR-1/-6); relalg keeps only lowering or is deleted | Queued (maintainer decision) | relalg tests pass unchanged against the contract IR | | **D-RA-3** | Datalog rules as algebra values; names are labels resolved through the label codebook, never strings in a rule | Queued (after D-RA-2) | codebook-built rules == hand-written `Rel`; unknown label refused at resolution | diff --git a/.claude/board/entries/2026-10-16-d-holo-h14d-logic-mask-read.md b/.claude/board/entries/2026-10-16-d-holo-h14d-logic-mask-read.md new file mode 100644 index 000000000..34cefc491 --- /dev/null +++ b/.claude/board/entries/2026-10-16-d-holo-h14d-logic-mask-read.md @@ -0,0 +1,2642 @@ +# D-HOLO-H14d — logic → address mask → masked read → terminal, C only (v4, 2026-10-16) + +**Status:** MEASURED. Plan: `.claude/plans/d-holo-h14d-logic-mask-read-v1.md` (pre-registered before the run; amendments A1, A2 before any timing; results there). +**Probe:** `crates/holo-h14d-probe` (excluded from the workspace). `tier: v4 (avx512f)`, rustc 1.99.0, lance 13.0.0 (resolved at build time and printed by the probe; no lockfile is tracked). Measured commit `802db7df`. + +- Stage 1 (relalg logic): of 2,000 generated programs, 675 decided + symbolically with 0 programs run, 396 answered only after the rewrite (as + written they exceed the 8 scratch slots), 2 widened by it (absorption missed + after De Morgan; `ISS-RELALG-ABSORPTION-AFTER-DE-MORGAN`). On the 1,583 + answered both ways: 1,065 passes rewritten vs 5,898 as written. 1.9 µs per + program to reduce. +- Stage 2 (address mask `R`): 2–10 ns per 64-address word (0.03–0.15 ns per + address), growing with operands, not with `|R|`; flat in density within + 1.25× in 11 of 14 rows (three single-cell spikes). +- Stage 3 (Lance 13 prefilter with `R`): rows scanned == returned == `|R|` in + all 96 cells. Bytes follow page locality: full tile uniform 1 % reads 1.00× + (H14c reproduced), clustered 1 % 0.19×, clustered 10 % 0.99× (64-address runs + are below Lance page size); a 1,024- or 8,192-address aperture reads + 0.01–0.12×; an empty `R` reads 0 bytes. +- Stage 4 (terminals): payload reads == `|R| × k` exactly; about 6 ns per lane + load per survivor hot, plus a fixed scan of `R`'s 1,024 words (~1.5 ns each), + so per-survivor cost is not flat at small `|R|` (prediction 4 falsified as + stated). Fused Σ: about 1.3 ns per summed value at 50 %, ~5× under the + explicit terminal. Single-address query: 8–45 ns hot, 17–184 ns cold. + +**OPEN:** page-scale clustering (which address order puts a thought's +survivors on few Lance pages); the payload terminal's fixed word scan; the +relalg absorption miss. No hardware counters on this VM. + +## Raw data (machine-readable) + +Columns: `csv,stage,pattern,density,width,form,k,cache,metric,value`. Stage 1 +rows carry the corpus counts; stage 2-4 rows one metric per cell. `NA` marks a +per-survivor metric in a cell with no survivors. Lance rows (`lance_*`) are for +the `∧` form only; `lance_ns_per_survivor_wall` is one timed call, not a median. + +```csv +lance: 13.0.0 (resolved at build time; no lockfile is tracked) +tier: v4 (avx512f) +csv,stage,pattern,density,width,form,k,cache,metric,value +csv,1,uniform,0.1,65536,-,-,-,programs,2000 +csv,1,uniform,0.1,65536,-,-,-,decided_symbolically,675 +csv,1,uniform,0.1,65536,-,-,-,refused_rewritten,21 +csv,1,uniform,0.1,65536,-,-,-,refused_as_written,415 +csv,1,uniform,0.1,65536,-,-,-,answered_both,1583 +csv,1,uniform,0.1,65536,-,-,-,widened_by_rewrite,2 +csv,1,uniform,0.1,65536,-,-,-,passes_rewritten_where_both,1065 +csv,1,uniform,0.1,65536,-,-,-,passes_as_written_where_both,5898 +csv,1,uniform,0.1,65536,-,-,-,reduce_ns_per_program,1857.0 +csv,2-4,uniform,0.001,1024,and,1,-,survivors,1 +csv,2-4,uniform,0.001,1024,and,1,hot,materialize_ns_per_word,2.185 +csv,2-4,uniform,0.001,1024,and,1,hot,count_ns_per_word,2.536 +csv,2-4,uniform,0.001,1024,and,1,hot,payload_ns_per_survivor,1787.440 +csv,2-4,uniform,0.001,1024,and,1,-,payload_reads,1 +csv,2-4,uniform,0.001,1024,and,1,hot,fused_sum_ns_per_word,3.305 +csv,2-4,uniform,0.001,1024,and,1,hot,point_ns_per_query,8.454 +csv,2-4,uniform,0.001,1024,and,1,cold,materialize_ns_per_word,39.837 +csv,2-4,uniform,0.001,1024,and,1,cold,count_ns_per_word,45.519 +csv,2-4,uniform,0.001,1024,and,1,cold,payload_ns_per_survivor,5087.000 +csv,2-4,uniform,0.001,1024,and,1,cold,fused_sum_ns_per_word,46.352 +csv,2-4,uniform,0.001,1024,and,1,cold,point_ns_per_query,15.305 +csv,2-4,uniform,0.001,1024,and,1,-,lance_rows_returned,1 +csv,2-4,uniform,0.001,1024,and,1,-,lance_rows_scanned_masked,1 +csv,2-4,uniform,0.001,1024,and,1,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.001,1024,and,1,-,lance_bytes_masked,1424 +csv,2-4,uniform,0.001,1024,and,1,-,lance_bytes_unmasked,126306 +csv,2-4,uniform,0.001,1024,and,1,-,lance_ns_per_survivor_wall,3868254.0 +csv,2-4,uniform,0.001,1024,and,2,-,survivors,0 +csv,2-4,uniform,0.001,1024,and,2,hot,materialize_ns_per_word,2.560 +csv,2-4,uniform,0.001,1024,and,2,hot,count_ns_per_word,2.375 +csv,2-4,uniform,0.001,1024,and,2,hot,payload_ns_per_survivor,NA +csv,2-4,uniform,0.001,1024,and,2,-,payload_reads,0 +csv,2-4,uniform,0.001,1024,and,2,hot,fused_sum_ns_per_word,3.886 +csv,2-4,uniform,0.001,1024,and,2,hot,point_ns_per_query,8.476 +csv,2-4,uniform,0.001,1024,and,2,cold,materialize_ns_per_word,47.575 +csv,2-4,uniform,0.001,1024,and,2,cold,count_ns_per_word,44.163 +csv,2-4,uniform,0.001,1024,and,2,cold,payload_ns_per_survivor,NA +csv,2-4,uniform,0.001,1024,and,2,cold,fused_sum_ns_per_word,53.351 +csv,2-4,uniform,0.001,1024,and,2,cold,point_ns_per_query,14.693 +csv,2-4,uniform,0.001,1024,and,2,-,lance_rows_returned,0 +csv,2-4,uniform,0.001,1024,and,2,-,lance_rows_scanned_masked,0 +csv,2-4,uniform,0.001,1024,and,2,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.001,1024,and,2,-,lance_bytes_masked,0 +csv,2-4,uniform,0.001,1024,and,2,-,lance_bytes_unmasked,132552 +csv,2-4,uniform,0.001,1024,and,2,-,lance_ns_per_survivor_wall,NA +csv,2-4,uniform,0.001,1024,and,4,-,survivors,0 +csv,2-4,uniform,0.001,1024,and,4,hot,materialize_ns_per_word,2.951 +csv,2-4,uniform,0.001,1024,and,4,hot,count_ns_per_word,3.020 +csv,2-4,uniform,0.001,1024,and,4,hot,payload_ns_per_survivor,NA +csv,2-4,uniform,0.001,1024,and,4,-,payload_reads,0 +csv,2-4,uniform,0.001,1024,and,4,hot,fused_sum_ns_per_word,4.935 +csv,2-4,uniform,0.001,1024,and,4,hot,point_ns_per_query,8.541 +csv,2-4,uniform,0.001,1024,and,4,cold,materialize_ns_per_word,46.737 +csv,2-4,uniform,0.001,1024,and,4,cold,count_ns_per_word,54.136 +csv,2-4,uniform,0.001,1024,and,4,cold,payload_ns_per_survivor,NA +csv,2-4,uniform,0.001,1024,and,4,cold,fused_sum_ns_per_word,55.971 +csv,2-4,uniform,0.001,1024,and,4,cold,point_ns_per_query,15.627 +csv,2-4,uniform,0.001,1024,and,4,-,lance_rows_returned,0 +csv,2-4,uniform,0.001,1024,and,4,-,lance_rows_scanned_masked,0 +csv,2-4,uniform,0.001,1024,and,4,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.001,1024,and,4,-,lance_bytes_masked,0 +csv,2-4,uniform,0.001,1024,and,4,-,lance_bytes_unmasked,135328 +csv,2-4,uniform,0.001,1024,and,4,-,lance_ns_per_survivor_wall,NA +csv,2-4,uniform,0.001,1024,and,8,-,survivors,0 +csv,2-4,uniform,0.001,1024,and,8,hot,materialize_ns_per_word,7.040 +csv,2-4,uniform,0.001,1024,and,8,hot,count_ns_per_word,6.618 +csv,2-4,uniform,0.001,1024,and,8,hot,payload_ns_per_survivor,NA +csv,2-4,uniform,0.001,1024,and,8,-,payload_reads,0 +csv,2-4,uniform,0.001,1024,and,8,hot,fused_sum_ns_per_word,7.560 +csv,2-4,uniform,0.001,1024,and,8,hot,point_ns_per_query,8.705 +csv,2-4,uniform,0.001,1024,and,8,cold,materialize_ns_per_word,54.515 +csv,2-4,uniform,0.001,1024,and,8,cold,count_ns_per_word,63.220 +csv,2-4,uniform,0.001,1024,and,8,cold,payload_ns_per_survivor,NA +csv,2-4,uniform,0.001,1024,and,8,cold,fused_sum_ns_per_word,61.775 +csv,2-4,uniform,0.001,1024,and,8,cold,point_ns_per_query,15.441 +csv,2-4,uniform,0.001,1024,and,8,-,lance_rows_returned,0 +csv,2-4,uniform,0.001,1024,and,8,-,lance_rows_scanned_masked,0 +csv,2-4,uniform,0.001,1024,and,8,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.001,1024,and,8,-,lance_bytes_masked,0 +csv,2-4,uniform,0.001,1024,and,8,-,lance_bytes_unmasked,149216 +csv,2-4,uniform,0.001,1024,and,8,-,lance_ns_per_survivor_wall,NA +csv,2-4,uniform,0.001,1024,or,2,-,survivors,3 +csv,2-4,uniform,0.001,1024,or,2,hot,materialize_ns_per_word,3.746 +csv,2-4,uniform,0.001,1024,or,2,hot,count_ns_per_word,3.503 +csv,2-4,uniform,0.001,1024,or,2,hot,payload_ns_per_survivor,536.680 +csv,2-4,uniform,0.001,1024,or,2,-,payload_reads,3 +csv,2-4,uniform,0.001,1024,or,2,hot,fused_sum_ns_per_word,5.805 +csv,2-4,uniform,0.001,1024,or,2,hot,point_ns_per_query,8.478 +csv,2-4,uniform,0.001,1024,or,2,cold,materialize_ns_per_word,43.149 +csv,2-4,uniform,0.001,1024,or,2,cold,count_ns_per_word,53.640 +csv,2-4,uniform,0.001,1024,or,2,cold,payload_ns_per_survivor,1691.000 +csv,2-4,uniform,0.001,1024,or,2,cold,fused_sum_ns_per_word,56.188 +csv,2-4,uniform,0.001,1024,or,2,cold,point_ns_per_query,14.562 +csv,2-4,uniform,0.001,1024,or,4,-,survivors,4 +csv,2-4,uniform,0.001,1024,or,4,hot,materialize_ns_per_word,4.660 +csv,2-4,uniform,0.001,1024,or,4,hot,count_ns_per_word,4.792 +csv,2-4,uniform,0.001,1024,or,4,hot,payload_ns_per_survivor,406.135 +csv,2-4,uniform,0.001,1024,or,4,-,payload_reads,4 +csv,2-4,uniform,0.001,1024,or,4,hot,fused_sum_ns_per_word,6.885 +csv,2-4,uniform,0.001,1024,or,4,hot,point_ns_per_query,8.554 +csv,2-4,uniform,0.001,1024,or,4,cold,materialize_ns_per_word,46.976 +csv,2-4,uniform,0.001,1024,or,4,cold,count_ns_per_word,58.891 +csv,2-4,uniform,0.001,1024,or,4,cold,payload_ns_per_survivor,1432.750 +csv,2-4,uniform,0.001,1024,or,4,cold,fused_sum_ns_per_word,62.267 +csv,2-4,uniform,0.001,1024,or,4,cold,point_ns_per_query,15.029 +csv,2-4,uniform,0.001,1024,or,8,-,survivors,8 +csv,2-4,uniform,0.001,1024,or,8,hot,materialize_ns_per_word,9.278 +csv,2-4,uniform,0.001,1024,or,8,hot,count_ns_per_word,9.063 +csv,2-4,uniform,0.001,1024,or,8,hot,payload_ns_per_survivor,216.252 +csv,2-4,uniform,0.001,1024,or,8,-,payload_reads,8 +csv,2-4,uniform,0.001,1024,or,8,hot,fused_sum_ns_per_word,10.398 +csv,2-4,uniform,0.001,1024,or,8,hot,point_ns_per_query,8.684 +csv,2-4,uniform,0.001,1024,or,8,cold,materialize_ns_per_word,59.206 +csv,2-4,uniform,0.001,1024,or,8,cold,count_ns_per_word,67.326 +csv,2-4,uniform,0.001,1024,or,8,cold,payload_ns_per_survivor,836.875 +csv,2-4,uniform,0.001,1024,or,8,cold,fused_sum_ns_per_word,68.166 +csv,2-4,uniform,0.001,1024,or,8,cold,point_ns_per_query,16.729 +csv,2-4,uniform,0.001,8192,and,1,-,survivors,5 +csv,2-4,uniform,0.001,8192,and,1,hot,materialize_ns_per_word,2.147 +csv,2-4,uniform,0.001,8192,and,1,hot,count_ns_per_word,1.761 +csv,2-4,uniform,0.001,8192,and,1,hot,payload_ns_per_survivor,323.996 +csv,2-4,uniform,0.001,8192,and,1,-,payload_reads,5 +csv,2-4,uniform,0.001,8192,and,1,hot,fused_sum_ns_per_word,3.229 +csv,2-4,uniform,0.001,8192,and,1,hot,point_ns_per_query,8.882 +csv,2-4,uniform,0.001,8192,and,1,cold,materialize_ns_per_word,35.297 +csv,2-4,uniform,0.001,8192,and,1,cold,count_ns_per_word,43.544 +csv,2-4,uniform,0.001,8192,and,1,cold,payload_ns_per_survivor,1158.000 +csv,2-4,uniform,0.001,8192,and,1,cold,fused_sum_ns_per_word,48.181 +csv,2-4,uniform,0.001,8192,and,1,cold,point_ns_per_query,23.224 +csv,2-4,uniform,0.001,8192,and,1,-,lance_rows_returned,5 +csv,2-4,uniform,0.001,8192,and,1,-,lance_rows_scanned_masked,5 +csv,2-4,uniform,0.001,8192,and,1,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.001,8192,and,1,-,lance_bytes_masked,11104 +csv,2-4,uniform,0.001,8192,and,1,-,lance_bytes_unmasked,126306 +csv,2-4,uniform,0.001,8192,and,1,-,lance_ns_per_survivor_wall,633511.8 +csv,2-4,uniform,0.001,8192,and,2,-,survivors,0 +csv,2-4,uniform,0.001,8192,and,2,hot,materialize_ns_per_word,2.608 +csv,2-4,uniform,0.001,8192,and,2,hot,count_ns_per_word,2.328 +csv,2-4,uniform,0.001,8192,and,2,hot,payload_ns_per_survivor,NA +csv,2-4,uniform,0.001,8192,and,2,-,payload_reads,0 +csv,2-4,uniform,0.001,8192,and,2,hot,fused_sum_ns_per_word,3.697 +csv,2-4,uniform,0.001,8192,and,2,hot,point_ns_per_query,8.447 +csv,2-4,uniform,0.001,8192,and,2,cold,materialize_ns_per_word,39.876 +csv,2-4,uniform,0.001,8192,and,2,cold,count_ns_per_word,48.860 +csv,2-4,uniform,0.001,8192,and,2,cold,payload_ns_per_survivor,NA +csv,2-4,uniform,0.001,8192,and,2,cold,fused_sum_ns_per_word,49.553 +csv,2-4,uniform,0.001,8192,and,2,cold,point_ns_per_query,16.436 +csv,2-4,uniform,0.001,8192,and,2,-,lance_rows_returned,0 +csv,2-4,uniform,0.001,8192,and,2,-,lance_rows_scanned_masked,0 +csv,2-4,uniform,0.001,8192,and,2,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.001,8192,and,2,-,lance_bytes_masked,0 +csv,2-4,uniform,0.001,8192,and,2,-,lance_bytes_unmasked,132552 +csv,2-4,uniform,0.001,8192,and,2,-,lance_ns_per_survivor_wall,NA +csv,2-4,uniform,0.001,8192,and,4,-,survivors,0 +csv,2-4,uniform,0.001,8192,and,4,hot,materialize_ns_per_word,3.335 +csv,2-4,uniform,0.001,8192,and,4,hot,count_ns_per_word,3.321 +csv,2-4,uniform,0.001,8192,and,4,hot,payload_ns_per_survivor,NA +csv,2-4,uniform,0.001,8192,and,4,-,payload_reads,0 +csv,2-4,uniform,0.001,8192,and,4,hot,fused_sum_ns_per_word,4.905 +csv,2-4,uniform,0.001,8192,and,4,hot,point_ns_per_query,9.116 +csv,2-4,uniform,0.001,8192,and,4,cold,materialize_ns_per_word,45.516 +csv,2-4,uniform,0.001,8192,and,4,cold,count_ns_per_word,49.908 +csv,2-4,uniform,0.001,8192,and,4,cold,payload_ns_per_survivor,NA +csv,2-4,uniform,0.001,8192,and,4,cold,fused_sum_ns_per_word,53.754 +csv,2-4,uniform,0.001,8192,and,4,cold,point_ns_per_query,17.627 +csv,2-4,uniform,0.001,8192,and,4,-,lance_rows_returned,0 +csv,2-4,uniform,0.001,8192,and,4,-,lance_rows_scanned_masked,0 +csv,2-4,uniform,0.001,8192,and,4,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.001,8192,and,4,-,lance_bytes_masked,0 +csv,2-4,uniform,0.001,8192,and,4,-,lance_bytes_unmasked,135328 +csv,2-4,uniform,0.001,8192,and,4,-,lance_ns_per_survivor_wall,NA +csv,2-4,uniform,0.001,8192,and,8,-,survivors,0 +csv,2-4,uniform,0.001,8192,and,8,hot,materialize_ns_per_word,6.477 +csv,2-4,uniform,0.001,8192,and,8,hot,count_ns_per_word,6.046 +csv,2-4,uniform,0.001,8192,and,8,hot,payload_ns_per_survivor,NA +csv,2-4,uniform,0.001,8192,and,8,-,payload_reads,0 +csv,2-4,uniform,0.001,8192,and,8,hot,fused_sum_ns_per_word,7.554 +csv,2-4,uniform,0.001,8192,and,8,hot,point_ns_per_query,9.114 +csv,2-4,uniform,0.001,8192,and,8,cold,materialize_ns_per_word,54.540 +csv,2-4,uniform,0.001,8192,and,8,cold,count_ns_per_word,63.806 +csv,2-4,uniform,0.001,8192,and,8,cold,payload_ns_per_survivor,NA +csv,2-4,uniform,0.001,8192,and,8,cold,fused_sum_ns_per_word,64.894 +csv,2-4,uniform,0.001,8192,and,8,cold,point_ns_per_query,18.963 +csv,2-4,uniform,0.001,8192,and,8,-,lance_rows_returned,0 +csv,2-4,uniform,0.001,8192,and,8,-,lance_rows_scanned_masked,0 +csv,2-4,uniform,0.001,8192,and,8,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.001,8192,and,8,-,lance_bytes_masked,0 +csv,2-4,uniform,0.001,8192,and,8,-,lance_bytes_unmasked,149216 +csv,2-4,uniform,0.001,8192,and,8,-,lance_ns_per_survivor_wall,NA +csv,2-4,uniform,0.001,8192,or,2,-,survivors,14 +csv,2-4,uniform,0.001,8192,or,2,hot,materialize_ns_per_word,3.583 +csv,2-4,uniform,0.001,8192,or,2,hot,count_ns_per_word,3.400 +csv,2-4,uniform,0.001,8192,or,2,hot,payload_ns_per_survivor,122.939 +csv,2-4,uniform,0.001,8192,or,2,-,payload_reads,14 +csv,2-4,uniform,0.001,8192,or,2,hot,fused_sum_ns_per_word,4.992 +csv,2-4,uniform,0.001,8192,or,2,hot,point_ns_per_query,8.470 +csv,2-4,uniform,0.001,8192,or,2,cold,materialize_ns_per_word,43.605 +csv,2-4,uniform,0.001,8192,or,2,cold,count_ns_per_word,54.918 +csv,2-4,uniform,0.001,8192,or,2,cold,payload_ns_per_survivor,482.000 +csv,2-4,uniform,0.001,8192,or,2,cold,fused_sum_ns_per_word,58.286 +csv,2-4,uniform,0.001,8192,or,2,cold,point_ns_per_query,16.209 +csv,2-4,uniform,0.001,8192,or,4,-,survivors,29 +csv,2-4,uniform,0.001,8192,or,4,hot,materialize_ns_per_word,4.784 +csv,2-4,uniform,0.001,8192,or,4,hot,count_ns_per_word,4.768 +csv,2-4,uniform,0.001,8192,or,4,hot,payload_ns_per_survivor,64.522 +csv,2-4,uniform,0.001,8192,or,4,-,payload_reads,29 +csv,2-4,uniform,0.001,8192,or,4,hot,fused_sum_ns_per_word,7.168 +csv,2-4,uniform,0.001,8192,or,4,hot,point_ns_per_query,8.865 +csv,2-4,uniform,0.001,8192,or,4,cold,materialize_ns_per_word,47.249 +csv,2-4,uniform,0.001,8192,or,4,cold,count_ns_per_word,57.726 +csv,2-4,uniform,0.001,8192,or,4,cold,payload_ns_per_survivor,319.345 +csv,2-4,uniform,0.001,8192,or,4,cold,fused_sum_ns_per_word,64.464 +csv,2-4,uniform,0.001,8192,or,4,cold,point_ns_per_query,17.158 +csv,2-4,uniform,0.001,8192,or,8,-,survivors,64 +csv,2-4,uniform,0.001,8192,or,8,hot,materialize_ns_per_word,9.478 +csv,2-4,uniform,0.001,8192,or,8,hot,count_ns_per_word,9.476 +csv,2-4,uniform,0.001,8192,or,8,hot,payload_ns_per_survivor,43.220 +csv,2-4,uniform,0.001,8192,or,8,-,payload_reads,64 +csv,2-4,uniform,0.001,8192,or,8,hot,fused_sum_ns_per_word,10.512 +csv,2-4,uniform,0.001,8192,or,8,hot,point_ns_per_query,9.554 +csv,2-4,uniform,0.001,8192,or,8,cold,materialize_ns_per_word,73.982 +csv,2-4,uniform,0.001,8192,or,8,cold,count_ns_per_word,74.895 +csv,2-4,uniform,0.001,8192,or,8,cold,payload_ns_per_survivor,327.188 +csv,2-4,uniform,0.001,8192,or,8,cold,fused_sum_ns_per_word,75.455 +csv,2-4,uniform,0.001,8192,or,8,cold,point_ns_per_query,19.481 +csv,2-4,uniform,0.001,65536,and,1,-,survivors,46 +csv,2-4,uniform,0.001,65536,and,1,hot,materialize_ns_per_word,2.110 +csv,2-4,uniform,0.001,65536,and,1,hot,count_ns_per_word,1.793 +csv,2-4,uniform,0.001,65536,and,1,hot,payload_ns_per_survivor,42.533 +csv,2-4,uniform,0.001,65536,and,1,-,payload_reads,46 +csv,2-4,uniform,0.001,65536,and,1,hot,fused_sum_ns_per_word,3.451 +csv,2-4,uniform,0.001,65536,and,1,hot,point_ns_per_query,8.338 +csv,2-4,uniform,0.001,65536,and,1,cold,materialize_ns_per_word,39.976 +csv,2-4,uniform,0.001,65536,and,1,cold,count_ns_per_word,48.340 +csv,2-4,uniform,0.001,65536,and,1,cold,payload_ns_per_survivor,266.152 +csv,2-4,uniform,0.001,65536,and,1,cold,fused_sum_ns_per_word,60.352 +csv,2-4,uniform,0.001,65536,and,1,cold,point_ns_per_query,17.615 +csv,2-4,uniform,0.001,65536,and,1,-,lance_rows_returned,46 +csv,2-4,uniform,0.001,65536,and,1,-,lance_rows_scanned_masked,46 +csv,2-4,uniform,0.001,65536,and,1,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.001,65536,and,1,-,lance_bytes_masked,81984 +csv,2-4,uniform,0.001,65536,and,1,-,lance_bytes_unmasked,126306 +csv,2-4,uniform,0.001,65536,and,1,-,lance_ns_per_survivor_wall,89958.2 +csv,2-4,uniform,0.001,65536,and,2,-,survivors,1 +csv,2-4,uniform,0.001,65536,and,2,hot,materialize_ns_per_word,2.464 +csv,2-4,uniform,0.001,65536,and,2,hot,count_ns_per_word,2.307 +csv,2-4,uniform,0.001,65536,and,2,hot,payload_ns_per_survivor,1609.200 +csv,2-4,uniform,0.001,65536,and,2,-,payload_reads,2 +csv,2-4,uniform,0.001,65536,and,2,hot,fused_sum_ns_per_word,4.147 +csv,2-4,uniform,0.001,65536,and,2,hot,point_ns_per_query,8.773 +csv,2-4,uniform,0.001,65536,and,2,cold,materialize_ns_per_word,41.837 +csv,2-4,uniform,0.001,65536,and,2,cold,count_ns_per_word,48.826 +csv,2-4,uniform,0.001,65536,and,2,cold,payload_ns_per_survivor,4796.000 +csv,2-4,uniform,0.001,65536,and,2,cold,fused_sum_ns_per_word,55.095 +csv,2-4,uniform,0.001,65536,and,2,cold,point_ns_per_query,18.161 +csv,2-4,uniform,0.001,65536,and,2,-,lance_rows_returned,1 +csv,2-4,uniform,0.001,65536,and,2,-,lance_rows_scanned_masked,1 +csv,2-4,uniform,0.001,65536,and,2,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.001,65536,and,2,-,lance_bytes_masked,4408 +csv,2-4,uniform,0.001,65536,and,2,-,lance_bytes_unmasked,132552 +csv,2-4,uniform,0.001,65536,and,2,-,lance_ns_per_survivor_wall,2661681.0 +csv,2-4,uniform,0.001,65536,and,4,-,survivors,0 +csv,2-4,uniform,0.001,65536,and,4,hot,materialize_ns_per_word,3.986 +csv,2-4,uniform,0.001,65536,and,4,hot,count_ns_per_word,3.327 +csv,2-4,uniform,0.001,65536,and,4,hot,payload_ns_per_survivor,NA +csv,2-4,uniform,0.001,65536,and,4,-,payload_reads,0 +csv,2-4,uniform,0.001,65536,and,4,hot,fused_sum_ns_per_word,5.184 +csv,2-4,uniform,0.001,65536,and,4,hot,point_ns_per_query,10.324 +csv,2-4,uniform,0.001,65536,and,4,cold,materialize_ns_per_word,47.842 +csv,2-4,uniform,0.001,65536,and,4,cold,count_ns_per_word,58.869 +csv,2-4,uniform,0.001,65536,and,4,cold,payload_ns_per_survivor,NA +csv,2-4,uniform,0.001,65536,and,4,cold,fused_sum_ns_per_word,62.975 +csv,2-4,uniform,0.001,65536,and,4,cold,point_ns_per_query,26.950 +csv,2-4,uniform,0.001,65536,and,4,-,lance_rows_returned,0 +csv,2-4,uniform,0.001,65536,and,4,-,lance_rows_scanned_masked,0 +csv,2-4,uniform,0.001,65536,and,4,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.001,65536,and,4,-,lance_bytes_masked,0 +csv,2-4,uniform,0.001,65536,and,4,-,lance_bytes_unmasked,135328 +csv,2-4,uniform,0.001,65536,and,4,-,lance_ns_per_survivor_wall,NA +csv,2-4,uniform,0.001,65536,and,8,-,survivors,0 +csv,2-4,uniform,0.001,65536,and,8,hot,materialize_ns_per_word,6.817 +csv,2-4,uniform,0.001,65536,and,8,hot,count_ns_per_word,6.864 +csv,2-4,uniform,0.001,65536,and,8,hot,payload_ns_per_survivor,NA +csv,2-4,uniform,0.001,65536,and,8,-,payload_reads,0 +csv,2-4,uniform,0.001,65536,and,8,hot,fused_sum_ns_per_word,7.895 +csv,2-4,uniform,0.001,65536,and,8,hot,point_ns_per_query,14.554 +csv,2-4,uniform,0.001,65536,and,8,cold,materialize_ns_per_word,57.757 +csv,2-4,uniform,0.001,65536,and,8,cold,count_ns_per_word,64.448 +csv,2-4,uniform,0.001,65536,and,8,cold,payload_ns_per_survivor,NA +csv,2-4,uniform,0.001,65536,and,8,cold,fused_sum_ns_per_word,64.263 +csv,2-4,uniform,0.001,65536,and,8,cold,point_ns_per_query,38.676 +csv,2-4,uniform,0.001,65536,and,8,-,lance_rows_returned,0 +csv,2-4,uniform,0.001,65536,and,8,-,lance_rows_scanned_masked,0 +csv,2-4,uniform,0.001,65536,and,8,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.001,65536,and,8,-,lance_bytes_masked,0 +csv,2-4,uniform,0.001,65536,and,8,-,lance_bytes_unmasked,149216 +csv,2-4,uniform,0.001,65536,and,8,-,lance_ns_per_survivor_wall,NA +csv,2-4,uniform,0.001,65536,or,2,-,survivors,111 +csv,2-4,uniform,0.001,65536,or,2,hot,materialize_ns_per_word,3.656 +csv,2-4,uniform,0.001,65536,or,2,hot,count_ns_per_word,3.482 +csv,2-4,uniform,0.001,65536,or,2,hot,payload_ns_per_survivor,19.036 +csv,2-4,uniform,0.001,65536,or,2,-,payload_reads,112 +csv,2-4,uniform,0.001,65536,or,2,hot,fused_sum_ns_per_word,5.369 +csv,2-4,uniform,0.001,65536,or,2,hot,point_ns_per_query,8.752 +csv,2-4,uniform,0.001,65536,or,2,cold,materialize_ns_per_word,40.478 +csv,2-4,uniform,0.001,65536,or,2,cold,count_ns_per_word,52.559 +csv,2-4,uniform,0.001,65536,or,2,cold,payload_ns_per_survivor,202.640 +csv,2-4,uniform,0.001,65536,or,2,cold,fused_sum_ns_per_word,69.571 +csv,2-4,uniform,0.001,65536,or,2,cold,point_ns_per_query,18.682 +csv,2-4,uniform,0.001,65536,or,4,-,survivors,244 +csv,2-4,uniform,0.001,65536,or,4,hot,materialize_ns_per_word,4.776 +csv,2-4,uniform,0.001,65536,or,4,hot,count_ns_per_word,4.818 +csv,2-4,uniform,0.001,65536,or,4,hot,payload_ns_per_survivor,17.078 +csv,2-4,uniform,0.001,65536,or,4,-,payload_reads,245 +csv,2-4,uniform,0.001,65536,or,4,hot,fused_sum_ns_per_word,7.079 +csv,2-4,uniform,0.001,65536,or,4,hot,point_ns_per_query,10.585 +csv,2-4,uniform,0.001,65536,or,4,cold,materialize_ns_per_word,47.184 +csv,2-4,uniform,0.001,65536,or,4,cold,count_ns_per_word,68.017 +csv,2-4,uniform,0.001,65536,or,4,cold,payload_ns_per_survivor,233.549 +csv,2-4,uniform,0.001,65536,or,4,cold,fused_sum_ns_per_word,81.129 +csv,2-4,uniform,0.001,65536,or,4,cold,point_ns_per_query,24.692 +csv,2-4,uniform,0.001,65536,or,8,-,survivors,529 +csv,2-4,uniform,0.001,65536,or,8,hot,materialize_ns_per_word,9.760 +csv,2-4,uniform,0.001,65536,or,8,hot,count_ns_per_word,9.489 +csv,2-4,uniform,0.001,65536,or,8,hot,payload_ns_per_survivor,30.465 +csv,2-4,uniform,0.001,65536,or,8,-,payload_reads,531 +csv,2-4,uniform,0.001,65536,or,8,hot,fused_sum_ns_per_word,11.144 +csv,2-4,uniform,0.001,65536,or,8,hot,point_ns_per_query,14.501 +csv,2-4,uniform,0.001,65536,or,8,cold,materialize_ns_per_word,57.965 +csv,2-4,uniform,0.001,65536,or,8,cold,count_ns_per_word,69.989 +csv,2-4,uniform,0.001,65536,or,8,cold,payload_ns_per_survivor,238.174 +csv,2-4,uniform,0.001,65536,or,8,cold,fused_sum_ns_per_word,98.112 +csv,2-4,uniform,0.001,65536,or,8,cold,point_ns_per_query,70.885 +csv,2-4,uniform,0.01,1024,and,1,-,survivors,13 +csv,2-4,uniform,0.01,1024,and,1,hot,materialize_ns_per_word,2.490 +csv,2-4,uniform,0.01,1024,and,1,hot,count_ns_per_word,1.806 +csv,2-4,uniform,0.01,1024,and,1,hot,payload_ns_per_survivor,131.406 +csv,2-4,uniform,0.01,1024,and,1,-,payload_reads,13 +csv,2-4,uniform,0.01,1024,and,1,hot,fused_sum_ns_per_word,3.373 +csv,2-4,uniform,0.01,1024,and,1,hot,point_ns_per_query,8.468 +csv,2-4,uniform,0.01,1024,and,1,cold,materialize_ns_per_word,37.528 +csv,2-4,uniform,0.01,1024,and,1,cold,count_ns_per_word,48.244 +csv,2-4,uniform,0.01,1024,and,1,cold,payload_ns_per_survivor,395.615 +csv,2-4,uniform,0.01,1024,and,1,cold,fused_sum_ns_per_word,52.389 +csv,2-4,uniform,0.01,1024,and,1,cold,point_ns_per_query,12.227 +csv,2-4,uniform,0.01,1024,and,1,-,lance_rows_returned,13 +csv,2-4,uniform,0.01,1024,and,1,-,lance_rows_scanned_masked,13 +csv,2-4,uniform,0.01,1024,and,1,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.01,1024,and,1,-,lance_bytes_masked,1872 +csv,2-4,uniform,0.01,1024,and,1,-,lance_bytes_unmasked,131834 +csv,2-4,uniform,0.01,1024,and,1,-,lance_ns_per_survivor_wall,246714.9 +csv,2-4,uniform,0.01,1024,and,2,-,survivors,0 +csv,2-4,uniform,0.01,1024,and,2,hot,materialize_ns_per_word,2.444 +csv,2-4,uniform,0.01,1024,and,2,hot,count_ns_per_word,2.227 +csv,2-4,uniform,0.01,1024,and,2,hot,payload_ns_per_survivor,NA +csv,2-4,uniform,0.01,1024,and,2,-,payload_reads,0 +csv,2-4,uniform,0.01,1024,and,2,hot,fused_sum_ns_per_word,3.823 +csv,2-4,uniform,0.01,1024,and,2,hot,point_ns_per_query,8.491 +csv,2-4,uniform,0.01,1024,and,2,cold,materialize_ns_per_word,42.843 +csv,2-4,uniform,0.01,1024,and,2,cold,count_ns_per_word,52.045 +csv,2-4,uniform,0.01,1024,and,2,cold,payload_ns_per_survivor,NA +csv,2-4,uniform,0.01,1024,and,2,cold,fused_sum_ns_per_word,58.892 +csv,2-4,uniform,0.01,1024,and,2,cold,point_ns_per_query,13.228 +csv,2-4,uniform,0.01,1024,and,2,-,lance_rows_returned,0 +csv,2-4,uniform,0.01,1024,and,2,-,lance_rows_scanned_masked,0 +csv,2-4,uniform,0.01,1024,and,2,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.01,1024,and,2,-,lance_bytes_masked,0 +csv,2-4,uniform,0.01,1024,and,2,-,lance_bytes_unmasked,143056 +csv,2-4,uniform,0.01,1024,and,2,-,lance_ns_per_survivor_wall,NA +csv,2-4,uniform,0.01,1024,and,4,-,survivors,0 +csv,2-4,uniform,0.01,1024,and,4,hot,materialize_ns_per_word,3.018 +csv,2-4,uniform,0.01,1024,and,4,hot,count_ns_per_word,2.976 +csv,2-4,uniform,0.01,1024,and,4,hot,payload_ns_per_survivor,NA +csv,2-4,uniform,0.01,1024,and,4,-,payload_reads,0 +csv,2-4,uniform,0.01,1024,and,4,hot,fused_sum_ns_per_word,4.736 +csv,2-4,uniform,0.01,1024,and,4,hot,point_ns_per_query,8.291 +csv,2-4,uniform,0.01,1024,and,4,cold,materialize_ns_per_word,43.104 +csv,2-4,uniform,0.01,1024,and,4,cold,count_ns_per_word,57.385 +csv,2-4,uniform,0.01,1024,and,4,cold,payload_ns_per_survivor,NA +csv,2-4,uniform,0.01,1024,and,4,cold,fused_sum_ns_per_word,60.357 +csv,2-4,uniform,0.01,1024,and,4,cold,point_ns_per_query,15.414 +csv,2-4,uniform,0.01,1024,and,4,-,lance_rows_returned,0 +csv,2-4,uniform,0.01,1024,and,4,-,lance_rows_scanned_masked,0 +csv,2-4,uniform,0.01,1024,and,4,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.01,1024,and,4,-,lance_bytes_masked,0 +csv,2-4,uniform,0.01,1024,and,4,-,lance_bytes_unmasked,153528 +csv,2-4,uniform,0.01,1024,and,4,-,lance_ns_per_survivor_wall,NA +csv,2-4,uniform,0.01,1024,and,8,-,survivors,0 +csv,2-4,uniform,0.01,1024,and,8,hot,materialize_ns_per_word,6.376 +csv,2-4,uniform,0.01,1024,and,8,hot,count_ns_per_word,6.880 +csv,2-4,uniform,0.01,1024,and,8,hot,payload_ns_per_survivor,NA +csv,2-4,uniform,0.01,1024,and,8,-,payload_reads,0 +csv,2-4,uniform,0.01,1024,and,8,hot,fused_sum_ns_per_word,7.380 +csv,2-4,uniform,0.01,1024,and,8,hot,point_ns_per_query,10.346 +csv,2-4,uniform,0.01,1024,and,8,cold,materialize_ns_per_word,49.018 +csv,2-4,uniform,0.01,1024,and,8,cold,count_ns_per_word,57.586 +csv,2-4,uniform,0.01,1024,and,8,cold,payload_ns_per_survivor,NA +csv,2-4,uniform,0.01,1024,and,8,cold,fused_sum_ns_per_word,55.082 +csv,2-4,uniform,0.01,1024,and,8,cold,point_ns_per_query,15.546 +csv,2-4,uniform,0.01,1024,and,8,-,lance_rows_returned,0 +csv,2-4,uniform,0.01,1024,and,8,-,lance_rows_scanned_masked,0 +csv,2-4,uniform,0.01,1024,and,8,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.01,1024,and,8,-,lance_bytes_masked,0 +csv,2-4,uniform,0.01,1024,and,8,-,lance_bytes_unmasked,183104 +csv,2-4,uniform,0.01,1024,and,8,-,lance_ns_per_survivor_wall,NA +csv,2-4,uniform,0.01,1024,or,2,-,survivors,23 +csv,2-4,uniform,0.01,1024,or,2,hot,materialize_ns_per_word,3.596 +csv,2-4,uniform,0.01,1024,or,2,hot,count_ns_per_word,3.457 +csv,2-4,uniform,0.01,1024,or,2,hot,payload_ns_per_survivor,74.657 +csv,2-4,uniform,0.01,1024,or,2,-,payload_reads,23 +csv,2-4,uniform,0.01,1024,or,2,hot,fused_sum_ns_per_word,5.060 +csv,2-4,uniform,0.01,1024,or,2,hot,point_ns_per_query,8.482 +csv,2-4,uniform,0.01,1024,or,2,cold,materialize_ns_per_word,41.097 +csv,2-4,uniform,0.01,1024,or,2,cold,count_ns_per_word,51.744 +csv,2-4,uniform,0.01,1024,or,2,cold,payload_ns_per_survivor,294.565 +csv,2-4,uniform,0.01,1024,or,2,cold,fused_sum_ns_per_word,56.408 +csv,2-4,uniform,0.01,1024,or,2,cold,point_ns_per_query,12.854 +csv,2-4,uniform,0.01,1024,or,4,-,survivors,36 +csv,2-4,uniform,0.01,1024,or,4,hot,materialize_ns_per_word,4.747 +csv,2-4,uniform,0.01,1024,or,4,hot,count_ns_per_word,4.748 +csv,2-4,uniform,0.01,1024,or,4,hot,payload_ns_per_survivor,55.393 +csv,2-4,uniform,0.01,1024,or,4,-,payload_reads,37 +csv,2-4,uniform,0.01,1024,or,4,hot,fused_sum_ns_per_word,7.019 +csv,2-4,uniform,0.01,1024,or,4,hot,point_ns_per_query,8.561 +csv,2-4,uniform,0.01,1024,or,4,cold,materialize_ns_per_word,57.890 +csv,2-4,uniform,0.01,1024,or,4,cold,count_ns_per_word,57.627 +csv,2-4,uniform,0.01,1024,or,4,cold,payload_ns_per_survivor,214.056 +csv,2-4,uniform,0.01,1024,or,4,cold,fused_sum_ns_per_word,55.381 +csv,2-4,uniform,0.01,1024,or,4,cold,point_ns_per_query,13.254 +csv,2-4,uniform,0.01,1024,or,8,-,survivors,82 +csv,2-4,uniform,0.01,1024,or,8,hot,materialize_ns_per_word,12.496 +csv,2-4,uniform,0.01,1024,or,8,hot,count_ns_per_word,8.989 +csv,2-4,uniform,0.01,1024,or,8,hot,payload_ns_per_survivor,37.592 +csv,2-4,uniform,0.01,1024,or,8,-,payload_reads,89 +csv,2-4,uniform,0.01,1024,or,8,hot,fused_sum_ns_per_word,10.438 +csv,2-4,uniform,0.01,1024,or,8,hot,point_ns_per_query,7.957 +csv,2-4,uniform,0.01,1024,or,8,cold,materialize_ns_per_word,52.105 +csv,2-4,uniform,0.01,1024,or,8,cold,count_ns_per_word,81.856 +csv,2-4,uniform,0.01,1024,or,8,cold,payload_ns_per_survivor,193.439 +csv,2-4,uniform,0.01,1024,or,8,cold,fused_sum_ns_per_word,65.834 +csv,2-4,uniform,0.01,1024,or,8,cold,point_ns_per_query,16.220 +csv,2-4,uniform,0.01,8192,and,1,-,survivors,90 +csv,2-4,uniform,0.01,8192,and,1,hot,materialize_ns_per_word,2.119 +csv,2-4,uniform,0.01,8192,and,1,hot,count_ns_per_word,1.802 +csv,2-4,uniform,0.01,8192,and,1,hot,payload_ns_per_survivor,23.667 +csv,2-4,uniform,0.01,8192,and,1,-,payload_reads,90 +csv,2-4,uniform,0.01,8192,and,1,hot,fused_sum_ns_per_word,4.360 +csv,2-4,uniform,0.01,8192,and,1,hot,point_ns_per_query,8.910 +csv,2-4,uniform,0.01,8192,and,1,cold,materialize_ns_per_word,34.158 +csv,2-4,uniform,0.01,8192,and,1,cold,count_ns_per_word,43.020 +csv,2-4,uniform,0.01,8192,and,1,cold,payload_ns_per_survivor,101.789 +csv,2-4,uniform,0.01,8192,and,1,cold,fused_sum_ns_per_word,54.852 +csv,2-4,uniform,0.01,8192,and,1,cold,point_ns_per_query,16.553 +csv,2-4,uniform,0.01,8192,and,1,-,lance_rows_returned,90 +csv,2-4,uniform,0.01,8192,and,1,-,lance_rows_scanned_masked,90 +csv,2-4,uniform,0.01,8192,and,1,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.01,8192,and,1,-,lance_bytes_masked,13520 +csv,2-4,uniform,0.01,8192,and,1,-,lance_bytes_unmasked,131834 +csv,2-4,uniform,0.01,8192,and,1,-,lance_ns_per_survivor_wall,22269.7 +csv,2-4,uniform,0.01,8192,and,2,-,survivors,1 +csv,2-4,uniform,0.01,8192,and,2,hot,materialize_ns_per_word,2.453 +csv,2-4,uniform,0.01,8192,and,2,hot,count_ns_per_word,2.264 +csv,2-4,uniform,0.01,8192,and,2,hot,payload_ns_per_survivor,1540.120 +csv,2-4,uniform,0.01,8192,and,2,-,payload_reads,2 +csv,2-4,uniform,0.01,8192,and,2,hot,fused_sum_ns_per_word,3.765 +csv,2-4,uniform,0.01,8192,and,2,hot,point_ns_per_query,8.498 +csv,2-4,uniform,0.01,8192,and,2,cold,materialize_ns_per_word,38.443 +csv,2-4,uniform,0.01,8192,and,2,cold,count_ns_per_word,38.459 +csv,2-4,uniform,0.01,8192,and,2,cold,payload_ns_per_survivor,4487.000 +csv,2-4,uniform,0.01,8192,and,2,cold,fused_sum_ns_per_word,55.840 +csv,2-4,uniform,0.01,8192,and,2,cold,point_ns_per_query,17.092 +csv,2-4,uniform,0.01,8192,and,2,-,lance_rows_returned,1 +csv,2-4,uniform,0.01,8192,and,2,-,lance_rows_scanned_masked,1 +csv,2-4,uniform,0.01,8192,and,2,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.01,8192,and,2,-,lance_bytes_masked,2536 +csv,2-4,uniform,0.01,8192,and,2,-,lance_bytes_unmasked,143056 +csv,2-4,uniform,0.01,8192,and,2,-,lance_ns_per_survivor_wall,2893268.0 +csv,2-4,uniform,0.01,8192,and,4,-,survivors,0 +csv,2-4,uniform,0.01,8192,and,4,hot,materialize_ns_per_word,3.295 +csv,2-4,uniform,0.01,8192,and,4,hot,count_ns_per_word,3.220 +csv,2-4,uniform,0.01,8192,and,4,hot,payload_ns_per_survivor,NA +csv,2-4,uniform,0.01,8192,and,4,-,payload_reads,0 +csv,2-4,uniform,0.01,8192,and,4,hot,fused_sum_ns_per_word,4.999 +csv,2-4,uniform,0.01,8192,and,4,hot,point_ns_per_query,9.072 +csv,2-4,uniform,0.01,8192,and,4,cold,materialize_ns_per_word,47.783 +csv,2-4,uniform,0.01,8192,and,4,cold,count_ns_per_word,50.442 +csv,2-4,uniform,0.01,8192,and,4,cold,payload_ns_per_survivor,NA +csv,2-4,uniform,0.01,8192,and,4,cold,fused_sum_ns_per_word,52.120 +csv,2-4,uniform,0.01,8192,and,4,cold,point_ns_per_query,19.600 +csv,2-4,uniform,0.01,8192,and,4,-,lance_rows_returned,0 +csv,2-4,uniform,0.01,8192,and,4,-,lance_rows_scanned_masked,0 +csv,2-4,uniform,0.01,8192,and,4,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.01,8192,and,4,-,lance_bytes_masked,0 +csv,2-4,uniform,0.01,8192,and,4,-,lance_bytes_unmasked,153528 +csv,2-4,uniform,0.01,8192,and,4,-,lance_ns_per_survivor_wall,NA +csv,2-4,uniform,0.01,8192,and,8,-,survivors,0 +csv,2-4,uniform,0.01,8192,and,8,hot,materialize_ns_per_word,6.748 +csv,2-4,uniform,0.01,8192,and,8,hot,count_ns_per_word,6.222 +csv,2-4,uniform,0.01,8192,and,8,hot,payload_ns_per_survivor,NA +csv,2-4,uniform,0.01,8192,and,8,-,payload_reads,0 +csv,2-4,uniform,0.01,8192,and,8,hot,fused_sum_ns_per_word,7.314 +csv,2-4,uniform,0.01,8192,and,8,hot,point_ns_per_query,9.488 +csv,2-4,uniform,0.01,8192,and,8,cold,materialize_ns_per_word,49.514 +csv,2-4,uniform,0.01,8192,and,8,cold,count_ns_per_word,62.003 +csv,2-4,uniform,0.01,8192,and,8,cold,payload_ns_per_survivor,NA +csv,2-4,uniform,0.01,8192,and,8,cold,fused_sum_ns_per_word,65.845 +csv,2-4,uniform,0.01,8192,and,8,cold,point_ns_per_query,31.062 +csv,2-4,uniform,0.01,8192,and,8,-,lance_rows_returned,0 +csv,2-4,uniform,0.01,8192,and,8,-,lance_rows_scanned_masked,0 +csv,2-4,uniform,0.01,8192,and,8,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.01,8192,and,8,-,lance_bytes_masked,0 +csv,2-4,uniform,0.01,8192,and,8,-,lance_bytes_unmasked,183104 +csv,2-4,uniform,0.01,8192,and,8,-,lance_ns_per_survivor_wall,NA +csv,2-4,uniform,0.01,8192,or,2,-,survivors,183 +csv,2-4,uniform,0.01,8192,or,2,hot,materialize_ns_per_word,3.675 +csv,2-4,uniform,0.01,8192,or,2,hot,count_ns_per_word,3.567 +csv,2-4,uniform,0.01,8192,or,2,hot,payload_ns_per_survivor,16.002 +csv,2-4,uniform,0.01,8192,or,2,-,payload_reads,184 +csv,2-4,uniform,0.01,8192,or,2,hot,fused_sum_ns_per_word,5.312 +csv,2-4,uniform,0.01,8192,or,2,hot,point_ns_per_query,8.499 +csv,2-4,uniform,0.01,8192,or,2,cold,materialize_ns_per_word,42.500 +csv,2-4,uniform,0.01,8192,or,2,cold,count_ns_per_word,30.163 +csv,2-4,uniform,0.01,8192,or,2,cold,payload_ns_per_survivor,83.464 +csv,2-4,uniform,0.01,8192,or,2,cold,fused_sum_ns_per_word,58.505 +csv,2-4,uniform,0.01,8192,or,2,cold,point_ns_per_query,15.413 +csv,2-4,uniform,0.01,8192,or,4,-,survivors,345 +csv,2-4,uniform,0.01,8192,or,4,hot,materialize_ns_per_word,4.847 +csv,2-4,uniform,0.01,8192,or,4,hot,count_ns_per_word,4.798 +csv,2-4,uniform,0.01,8192,or,4,hot,payload_ns_per_survivor,16.769 +csv,2-4,uniform,0.01,8192,or,4,-,payload_reads,350 +csv,2-4,uniform,0.01,8192,or,4,hot,fused_sum_ns_per_word,8.047 +csv,2-4,uniform,0.01,8192,or,4,hot,point_ns_per_query,9.058 +csv,2-4,uniform,0.01,8192,or,4,cold,materialize_ns_per_word,44.224 +csv,2-4,uniform,0.01,8192,or,4,cold,count_ns_per_word,51.503 +csv,2-4,uniform,0.01,8192,or,4,cold,payload_ns_per_survivor,124.139 +csv,2-4,uniform,0.01,8192,or,4,cold,fused_sum_ns_per_word,63.055 +csv,2-4,uniform,0.01,8192,or,4,cold,point_ns_per_query,17.695 +csv,2-4,uniform,0.01,8192,or,8,-,survivors,676 +csv,2-4,uniform,0.01,8192,or,8,hot,materialize_ns_per_word,9.417 +csv,2-4,uniform,0.01,8192,or,8,hot,count_ns_per_word,8.791 +csv,2-4,uniform,0.01,8192,or,8,hot,payload_ns_per_survivor,27.810 +csv,2-4,uniform,0.01,8192,or,8,-,payload_reads,702 +csv,2-4,uniform,0.01,8192,or,8,hot,fused_sum_ns_per_word,11.920 +csv,2-4,uniform,0.01,8192,or,8,hot,point_ns_per_query,13.214 +csv,2-4,uniform,0.01,8192,or,8,cold,materialize_ns_per_word,70.865 +csv,2-4,uniform,0.01,8192,or,8,cold,count_ns_per_word,59.394 +csv,2-4,uniform,0.01,8192,or,8,cold,payload_ns_per_survivor,128.901 +csv,2-4,uniform,0.01,8192,or,8,cold,fused_sum_ns_per_word,70.652 +csv,2-4,uniform,0.01,8192,or,8,cold,point_ns_per_query,21.982 +csv,2-4,uniform,0.01,65536,and,1,-,survivors,692 +csv,2-4,uniform,0.01,65536,and,1,hot,materialize_ns_per_word,2.180 +csv,2-4,uniform,0.01,65536,and,1,hot,count_ns_per_word,1.809 +csv,2-4,uniform,0.01,65536,and,1,hot,payload_ns_per_survivor,10.263 +csv,2-4,uniform,0.01,65536,and,1,-,payload_reads,692 +csv,2-4,uniform,0.01,65536,and,1,hot,fused_sum_ns_per_word,4.261 +csv,2-4,uniform,0.01,65536,and,1,hot,point_ns_per_query,8.167 +csv,2-4,uniform,0.01,65536,and,1,cold,materialize_ns_per_word,28.463 +csv,2-4,uniform,0.01,65536,and,1,cold,count_ns_per_word,36.879 +csv,2-4,uniform,0.01,65536,and,1,cold,payload_ns_per_survivor,93.299 +csv,2-4,uniform,0.01,65536,and,1,cold,fused_sum_ns_per_word,65.231 +csv,2-4,uniform,0.01,65536,and,1,cold,point_ns_per_query,25.365 +csv,2-4,uniform,0.01,65536,and,1,-,lance_rows_returned,692 +csv,2-4,uniform,0.01,65536,and,1,-,lance_rows_scanned_masked,692 +csv,2-4,uniform,0.01,65536,and,1,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.01,65536,and,1,-,lance_bytes_masked,131640 +csv,2-4,uniform,0.01,65536,and,1,-,lance_bytes_unmasked,131834 +csv,2-4,uniform,0.01,65536,and,1,-,lance_ns_per_survivor_wall,4776.7 +csv,2-4,uniform,0.01,65536,and,2,-,survivors,9 +csv,2-4,uniform,0.01,65536,and,2,hot,materialize_ns_per_word,3.426 +csv,2-4,uniform,0.01,65536,and,2,hot,count_ns_per_word,3.351 +csv,2-4,uniform,0.01,65536,and,2,hot,payload_ns_per_survivor,260.318 +csv,2-4,uniform,0.01,65536,and,2,-,payload_reads,18 +csv,2-4,uniform,0.01,65536,and,2,hot,fused_sum_ns_per_word,6.872 +csv,2-4,uniform,0.01,65536,and,2,hot,point_ns_per_query,14.892 +csv,2-4,uniform,0.01,65536,and,2,cold,materialize_ns_per_word,35.787 +csv,2-4,uniform,0.01,65536,and,2,cold,count_ns_per_word,43.693 +csv,2-4,uniform,0.01,65536,and,2,cold,payload_ns_per_survivor,665.444 +csv,2-4,uniform,0.01,65536,and,2,cold,fused_sum_ns_per_word,50.541 +csv,2-4,uniform,0.01,65536,and,2,cold,point_ns_per_query,23.090 +csv,2-4,uniform,0.01,65536,and,2,-,lance_rows_returned,9 +csv,2-4,uniform,0.01,65536,and,2,-,lance_rows_scanned_masked,9 +csv,2-4,uniform,0.01,65536,and,2,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.01,65536,and,2,-,lance_bytes_masked,27880 +csv,2-4,uniform,0.01,65536,and,2,-,lance_bytes_unmasked,143056 +csv,2-4,uniform,0.01,65536,and,2,-,lance_ns_per_survivor_wall,385482.0 +csv,2-4,uniform,0.01,65536,and,4,-,survivors,0 +csv,2-4,uniform,0.01,65536,and,4,hot,materialize_ns_per_word,6.596 +csv,2-4,uniform,0.01,65536,and,4,hot,count_ns_per_word,5.713 +csv,2-4,uniform,0.01,65536,and,4,hot,payload_ns_per_survivor,NA +csv,2-4,uniform,0.01,65536,and,4,-,payload_reads,0 +csv,2-4,uniform,0.01,65536,and,4,hot,fused_sum_ns_per_word,9.349 +csv,2-4,uniform,0.01,65536,and,4,hot,point_ns_per_query,21.941 +csv,2-4,uniform,0.01,65536,and,4,cold,materialize_ns_per_word,47.384 +csv,2-4,uniform,0.01,65536,and,4,cold,count_ns_per_word,54.928 +csv,2-4,uniform,0.01,65536,and,4,cold,payload_ns_per_survivor,NA +csv,2-4,uniform,0.01,65536,and,4,cold,fused_sum_ns_per_word,56.780 +csv,2-4,uniform,0.01,65536,and,4,cold,point_ns_per_query,37.500 +csv,2-4,uniform,0.01,65536,and,4,-,lance_rows_returned,0 +csv,2-4,uniform,0.01,65536,and,4,-,lance_rows_scanned_masked,0 +csv,2-4,uniform,0.01,65536,and,4,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.01,65536,and,4,-,lance_bytes_masked,0 +csv,2-4,uniform,0.01,65536,and,4,-,lance_bytes_unmasked,153528 +csv,2-4,uniform,0.01,65536,and,4,-,lance_ns_per_survivor_wall,NA +csv,2-4,uniform,0.01,65536,and,8,-,survivors,0 +csv,2-4,uniform,0.01,65536,and,8,hot,materialize_ns_per_word,6.888 +csv,2-4,uniform,0.01,65536,and,8,hot,count_ns_per_word,6.388 +csv,2-4,uniform,0.01,65536,and,8,hot,payload_ns_per_survivor,NA +csv,2-4,uniform,0.01,65536,and,8,-,payload_reads,0 +csv,2-4,uniform,0.01,65536,and,8,hot,fused_sum_ns_per_word,7.641 +csv,2-4,uniform,0.01,65536,and,8,hot,point_ns_per_query,15.184 +csv,2-4,uniform,0.01,65536,and,8,cold,materialize_ns_per_word,51.624 +csv,2-4,uniform,0.01,65536,and,8,cold,count_ns_per_word,57.309 +csv,2-4,uniform,0.01,65536,and,8,cold,payload_ns_per_survivor,NA +csv,2-4,uniform,0.01,65536,and,8,cold,fused_sum_ns_per_word,56.224 +csv,2-4,uniform,0.01,65536,and,8,cold,point_ns_per_query,55.448 +csv,2-4,uniform,0.01,65536,and,8,-,lance_rows_returned,0 +csv,2-4,uniform,0.01,65536,and,8,-,lance_rows_scanned_masked,0 +csv,2-4,uniform,0.01,65536,and,8,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.01,65536,and,8,-,lance_bytes_masked,0 +csv,2-4,uniform,0.01,65536,and,8,-,lance_bytes_unmasked,183104 +csv,2-4,uniform,0.01,65536,and,8,-,lance_ns_per_survivor_wall,NA +csv,2-4,uniform,0.01,65536,or,2,-,survivors,1345 +csv,2-4,uniform,0.01,65536,or,2,hot,materialize_ns_per_word,3.603 +csv,2-4,uniform,0.01,65536,or,2,hot,count_ns_per_word,3.462 +csv,2-4,uniform,0.01,65536,or,2,hot,payload_ns_per_survivor,17.404 +csv,2-4,uniform,0.01,65536,or,2,-,payload_reads,1354 +csv,2-4,uniform,0.01,65536,or,2,hot,fused_sum_ns_per_word,7.277 +csv,2-4,uniform,0.01,65536,or,2,hot,point_ns_per_query,8.731 +csv,2-4,uniform,0.01,65536,or,2,cold,materialize_ns_per_word,37.720 +csv,2-4,uniform,0.01,65536,or,2,cold,count_ns_per_word,48.693 +csv,2-4,uniform,0.01,65536,or,2,cold,payload_ns_per_survivor,72.280 +csv,2-4,uniform,0.01,65536,or,2,cold,fused_sum_ns_per_word,101.456 +csv,2-4,uniform,0.01,65536,or,2,cold,point_ns_per_query,30.538 +csv,2-4,uniform,0.01,65536,or,4,-,survivors,2624 +csv,2-4,uniform,0.01,65536,or,4,hot,materialize_ns_per_word,5.224 +csv,2-4,uniform,0.01,65536,or,4,hot,count_ns_per_word,4.784 +csv,2-4,uniform,0.01,65536,or,4,hot,payload_ns_per_survivor,26.290 +csv,2-4,uniform,0.01,65536,or,4,-,payload_reads,2655 +csv,2-4,uniform,0.01,65536,or,4,hot,fused_sum_ns_per_word,17.300 +csv,2-4,uniform,0.01,65536,or,4,hot,point_ns_per_query,10.075 +csv,2-4,uniform,0.01,65536,or,4,cold,materialize_ns_per_word,35.232 +csv,2-4,uniform,0.01,65536,or,4,cold,count_ns_per_word,54.918 +csv,2-4,uniform,0.01,65536,or,4,cold,payload_ns_per_survivor,93.199 +csv,2-4,uniform,0.01,65536,or,4,cold,fused_sum_ns_per_word,85.212 +csv,2-4,uniform,0.01,65536,or,4,cold,point_ns_per_query,34.091 +csv,2-4,uniform,0.01,65536,or,8,-,survivors,5121 +csv,2-4,uniform,0.01,65536,or,8,hot,materialize_ns_per_word,9.590 +csv,2-4,uniform,0.01,65536,or,8,hot,count_ns_per_word,9.126 +csv,2-4,uniform,0.01,65536,or,8,hot,payload_ns_per_survivor,33.151 +csv,2-4,uniform,0.01,65536,or,8,-,payload_reads,5304 +csv,2-4,uniform,0.01,65536,or,8,hot,fused_sum_ns_per_word,25.006 +csv,2-4,uniform,0.01,65536,or,8,hot,point_ns_per_query,16.701 +csv,2-4,uniform,0.01,65536,or,8,cold,materialize_ns_per_word,49.976 +csv,2-4,uniform,0.01,65536,or,8,cold,count_ns_per_word,61.360 +csv,2-4,uniform,0.01,65536,or,8,cold,payload_ns_per_survivor,110.683 +csv,2-4,uniform,0.01,65536,or,8,cold,fused_sum_ns_per_word,98.947 +csv,2-4,uniform,0.01,65536,or,8,cold,point_ns_per_query,54.472 +csv,2-4,uniform,0.1,1024,and,1,-,survivors,113 +csv,2-4,uniform,0.1,1024,and,1,hot,materialize_ns_per_word,2.174 +csv,2-4,uniform,0.1,1024,and,1,hot,count_ns_per_word,1.848 +csv,2-4,uniform,0.1,1024,and,1,hot,payload_ns_per_survivor,20.604 +csv,2-4,uniform,0.1,1024,and,1,-,payload_reads,113 +csv,2-4,uniform,0.1,1024,and,1,hot,fused_sum_ns_per_word,3.534 +csv,2-4,uniform,0.1,1024,and,1,hot,point_ns_per_query,8.441 +csv,2-4,uniform,0.1,1024,and,1,cold,materialize_ns_per_word,21.200 +csv,2-4,uniform,0.1,1024,and,1,cold,count_ns_per_word,21.741 +csv,2-4,uniform,0.1,1024,and,1,cold,payload_ns_per_survivor,62.885 +csv,2-4,uniform,0.1,1024,and,1,cold,fused_sum_ns_per_word,41.850 +csv,2-4,uniform,0.1,1024,and,1,cold,point_ns_per_query,24.124 +csv,2-4,uniform,0.1,1024,and,1,-,lance_rows_returned,113 +csv,2-4,uniform,0.1,1024,and,1,-,lance_rows_scanned_masked,113 +csv,2-4,uniform,0.1,1024,and,1,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.1,1024,and,1,-,lance_bytes_masked,5448 +csv,2-4,uniform,0.1,1024,and,1,-,lance_bytes_unmasked,187411 +csv,2-4,uniform,0.1,1024,and,1,-,lance_ns_per_survivor_wall,20623.2 +csv,2-4,uniform,0.1,1024,and,2,-,survivors,13 +csv,2-4,uniform,0.1,1024,and,2,hot,materialize_ns_per_word,2.455 +csv,2-4,uniform,0.1,1024,and,2,hot,count_ns_per_word,2.184 +csv,2-4,uniform,0.1,1024,and,2,hot,payload_ns_per_survivor,131.542 +csv,2-4,uniform,0.1,1024,and,2,-,payload_reads,26 +csv,2-4,uniform,0.1,1024,and,2,hot,fused_sum_ns_per_word,3.928 +csv,2-4,uniform,0.1,1024,and,2,hot,point_ns_per_query,8.374 +csv,2-4,uniform,0.1,1024,and,2,cold,materialize_ns_per_word,24.937 +csv,2-4,uniform,0.1,1024,and,2,cold,count_ns_per_word,27.997 +csv,2-4,uniform,0.1,1024,and,2,cold,payload_ns_per_survivor,439.154 +csv,2-4,uniform,0.1,1024,and,2,cold,fused_sum_ns_per_word,49.579 +csv,2-4,uniform,0.1,1024,and,2,cold,point_ns_per_query,16.987 +csv,2-4,uniform,0.1,1024,and,2,-,lance_rows_returned,13 +csv,2-4,uniform,0.1,1024,and,2,-,lance_rows_scanned_masked,13 +csv,2-4,uniform,0.1,1024,and,2,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.1,1024,and,2,-,lance_bytes_masked,9728 +csv,2-4,uniform,0.1,1024,and,2,-,lance_bytes_unmasked,254496 +csv,2-4,uniform,0.1,1024,and,2,-,lance_ns_per_survivor_wall,168304.5 +csv,2-4,uniform,0.1,1024,and,4,-,survivors,0 +csv,2-4,uniform,0.1,1024,and,4,hot,materialize_ns_per_word,3.374 +csv,2-4,uniform,0.1,1024,and,4,hot,count_ns_per_word,3.244 +csv,2-4,uniform,0.1,1024,and,4,hot,payload_ns_per_survivor,NA +csv,2-4,uniform,0.1,1024,and,4,-,payload_reads,0 +csv,2-4,uniform,0.1,1024,and,4,hot,fused_sum_ns_per_word,4.990 +csv,2-4,uniform,0.1,1024,and,4,hot,point_ns_per_query,8.597 +csv,2-4,uniform,0.1,1024,and,4,cold,materialize_ns_per_word,34.974 +csv,2-4,uniform,0.1,1024,and,4,cold,count_ns_per_word,45.983 +csv,2-4,uniform,0.1,1024,and,4,cold,payload_ns_per_survivor,NA +csv,2-4,uniform,0.1,1024,and,4,cold,fused_sum_ns_per_word,52.432 +csv,2-4,uniform,0.1,1024,and,4,cold,point_ns_per_query,16.571 +csv,2-4,uniform,0.1,1024,and,4,-,lance_rows_returned,0 +csv,2-4,uniform,0.1,1024,and,4,-,lance_rows_scanned_masked,0 +csv,2-4,uniform,0.1,1024,and,4,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.1,1024,and,4,-,lance_bytes_masked,0 +csv,2-4,uniform,0.1,1024,and,4,-,lance_bytes_unmasked,377296 +csv,2-4,uniform,0.1,1024,and,4,-,lance_ns_per_survivor_wall,NA +csv,2-4,uniform,0.1,1024,and,8,-,survivors,0 +csv,2-4,uniform,0.1,1024,and,8,hot,materialize_ns_per_word,7.207 +csv,2-4,uniform,0.1,1024,and,8,hot,count_ns_per_word,6.563 +csv,2-4,uniform,0.1,1024,and,8,hot,payload_ns_per_survivor,NA +csv,2-4,uniform,0.1,1024,and,8,-,payload_reads,0 +csv,2-4,uniform,0.1,1024,and,8,hot,fused_sum_ns_per_word,8.195 +csv,2-4,uniform,0.1,1024,and,8,hot,point_ns_per_query,8.733 +csv,2-4,uniform,0.1,1024,and,8,cold,materialize_ns_per_word,49.278 +csv,2-4,uniform,0.1,1024,and,8,cold,count_ns_per_word,54.572 +csv,2-4,uniform,0.1,1024,and,8,cold,payload_ns_per_survivor,NA +csv,2-4,uniform,0.1,1024,and,8,cold,fused_sum_ns_per_word,68.646 +csv,2-4,uniform,0.1,1024,and,8,cold,point_ns_per_query,18.621 +csv,2-4,uniform,0.1,1024,and,8,-,lance_rows_returned,0 +csv,2-4,uniform,0.1,1024,and,8,-,lance_rows_scanned_masked,0 +csv,2-4,uniform,0.1,1024,and,8,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.1,1024,and,8,-,lance_bytes_masked,0 +csv,2-4,uniform,0.1,1024,and,8,-,lance_bytes_unmasked,627432 +csv,2-4,uniform,0.1,1024,and,8,-,lance_ns_per_survivor_wall,NA +csv,2-4,uniform,0.1,1024,or,2,-,survivors,208 +csv,2-4,uniform,0.1,1024,or,2,hot,materialize_ns_per_word,3.656 +csv,2-4,uniform,0.1,1024,or,2,hot,count_ns_per_word,3.504 +csv,2-4,uniform,0.1,1024,or,2,hot,payload_ns_per_survivor,19.165 +csv,2-4,uniform,0.1,1024,or,2,-,payload_reads,221 +csv,2-4,uniform,0.1,1024,or,2,hot,fused_sum_ns_per_word,6.150 +csv,2-4,uniform,0.1,1024,or,2,hot,point_ns_per_query,8.503 +csv,2-4,uniform,0.1,1024,or,2,cold,materialize_ns_per_word,42.337 +csv,2-4,uniform,0.1,1024,or,2,cold,count_ns_per_word,56.756 +csv,2-4,uniform,0.1,1024,or,2,cold,payload_ns_per_survivor,61.913 +csv,2-4,uniform,0.1,1024,or,2,cold,fused_sum_ns_per_word,64.086 +csv,2-4,uniform,0.1,1024,or,2,cold,point_ns_per_query,15.064 +csv,2-4,uniform,0.1,1024,or,4,-,survivors,352 +csv,2-4,uniform,0.1,1024,or,4,hot,materialize_ns_per_word,4.697 +csv,2-4,uniform,0.1,1024,or,4,hot,count_ns_per_word,4.802 +csv,2-4,uniform,0.1,1024,or,4,hot,payload_ns_per_survivor,21.388 +csv,2-4,uniform,0.1,1024,or,4,-,payload_reads,422 +csv,2-4,uniform,0.1,1024,or,4,hot,fused_sum_ns_per_word,7.817 +csv,2-4,uniform,0.1,1024,or,4,hot,point_ns_per_query,8.584 +csv,2-4,uniform,0.1,1024,or,4,cold,materialize_ns_per_word,39.378 +csv,2-4,uniform,0.1,1024,or,4,cold,count_ns_per_word,57.979 +csv,2-4,uniform,0.1,1024,or,4,cold,payload_ns_per_survivor,101.105 +csv,2-4,uniform,0.1,1024,or,4,cold,fused_sum_ns_per_word,64.112 +csv,2-4,uniform,0.1,1024,or,4,cold,point_ns_per_query,17.036 +csv,2-4,uniform,0.1,1024,or,8,-,survivors,577 +csv,2-4,uniform,0.1,1024,or,8,hot,materialize_ns_per_word,10.148 +csv,2-4,uniform,0.1,1024,or,8,hot,count_ns_per_word,10.275 +csv,2-4,uniform,0.1,1024,or,8,hot,payload_ns_per_survivor,32.595 +csv,2-4,uniform,0.1,1024,or,8,-,payload_reads,828 +csv,2-4,uniform,0.1,1024,or,8,hot,fused_sum_ns_per_word,11.700 +csv,2-4,uniform,0.1,1024,or,8,hot,point_ns_per_query,8.697 +csv,2-4,uniform,0.1,1024,or,8,cold,materialize_ns_per_word,56.235 +csv,2-4,uniform,0.1,1024,or,8,cold,count_ns_per_word,67.338 +csv,2-4,uniform,0.1,1024,or,8,cold,payload_ns_per_survivor,101.953 +csv,2-4,uniform,0.1,1024,or,8,cold,fused_sum_ns_per_word,70.949 +csv,2-4,uniform,0.1,1024,or,8,cold,point_ns_per_query,16.818 +csv,2-4,uniform,0.1,8192,and,1,-,survivors,846 +csv,2-4,uniform,0.1,8192,and,1,hot,materialize_ns_per_word,3.302 +csv,2-4,uniform,0.1,8192,and,1,hot,count_ns_per_word,3.420 +csv,2-4,uniform,0.1,8192,and,1,hot,payload_ns_per_survivor,15.303 +csv,2-4,uniform,0.1,8192,and,1,-,payload_reads,846 +csv,2-4,uniform,0.1,8192,and,1,hot,fused_sum_ns_per_word,9.444 +csv,2-4,uniform,0.1,8192,and,1,hot,point_ns_per_query,13.751 +csv,2-4,uniform,0.1,8192,and,1,cold,materialize_ns_per_word,36.681 +csv,2-4,uniform,0.1,8192,and,1,cold,count_ns_per_word,43.721 +csv,2-4,uniform,0.1,8192,and,1,cold,payload_ns_per_survivor,30.059 +csv,2-4,uniform,0.1,8192,and,1,cold,fused_sum_ns_per_word,54.604 +csv,2-4,uniform,0.1,8192,and,1,cold,point_ns_per_query,19.549 +csv,2-4,uniform,0.1,8192,and,1,-,lance_rows_returned,846 +csv,2-4,uniform,0.1,8192,and,1,-,lance_rows_scanned_masked,846 +csv,2-4,uniform,0.1,8192,and,1,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.1,8192,and,1,-,lance_bytes_masked,20584 +csv,2-4,uniform,0.1,8192,and,1,-,lance_bytes_unmasked,187411 +csv,2-4,uniform,0.1,8192,and,1,-,lance_ns_per_survivor_wall,3557.8 +csv,2-4,uniform,0.1,8192,and,2,-,survivors,81 +csv,2-4,uniform,0.1,8192,and,2,hot,materialize_ns_per_word,2.181 +csv,2-4,uniform,0.1,8192,and,2,hot,count_ns_per_word,2.010 +csv,2-4,uniform,0.1,8192,and,2,hot,payload_ns_per_survivor,29.261 +csv,2-4,uniform,0.1,8192,and,2,-,payload_reads,162 +csv,2-4,uniform,0.1,8192,and,2,hot,fused_sum_ns_per_word,3.821 +csv,2-4,uniform,0.1,8192,and,2,hot,point_ns_per_query,8.677 +csv,2-4,uniform,0.1,8192,and,2,cold,materialize_ns_per_word,37.688 +csv,2-4,uniform,0.1,8192,and,2,cold,count_ns_per_word,49.764 +csv,2-4,uniform,0.1,8192,and,2,cold,payload_ns_per_survivor,138.704 +csv,2-4,uniform,0.1,8192,and,2,cold,fused_sum_ns_per_word,56.978 +csv,2-4,uniform,0.1,8192,and,2,cold,point_ns_per_query,22.070 +csv,2-4,uniform,0.1,8192,and,2,-,lance_rows_returned,81 +csv,2-4,uniform,0.1,8192,and,2,-,lance_rows_scanned_masked,81 +csv,2-4,uniform,0.1,8192,and,2,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.1,8192,and,2,-,lance_bytes_masked,28760 +csv,2-4,uniform,0.1,8192,and,2,-,lance_bytes_unmasked,254496 +csv,2-4,uniform,0.1,8192,and,2,-,lance_ns_per_survivor_wall,42981.0 +csv,2-4,uniform,0.1,8192,and,4,-,survivors,2 +csv,2-4,uniform,0.1,8192,and,4,hot,materialize_ns_per_word,3.483 +csv,2-4,uniform,0.1,8192,and,4,hot,count_ns_per_word,3.490 +csv,2-4,uniform,0.1,8192,and,4,hot,payload_ns_per_survivor,817.030 +csv,2-4,uniform,0.1,8192,and,4,-,payload_reads,8 +csv,2-4,uniform,0.1,8192,and,4,hot,fused_sum_ns_per_word,5.168 +csv,2-4,uniform,0.1,8192,and,4,hot,point_ns_per_query,8.511 +csv,2-4,uniform,0.1,8192,and,4,cold,materialize_ns_per_word,57.548 +csv,2-4,uniform,0.1,8192,and,4,cold,count_ns_per_word,56.496 +csv,2-4,uniform,0.1,8192,and,4,cold,payload_ns_per_survivor,2808.500 +csv,2-4,uniform,0.1,8192,and,4,cold,fused_sum_ns_per_word,60.914 +csv,2-4,uniform,0.1,8192,and,4,cold,point_ns_per_query,28.284 +csv,2-4,uniform,0.1,8192,and,4,-,lance_rows_returned,2 +csv,2-4,uniform,0.1,8192,and,4,-,lance_rows_scanned_masked,2 +csv,2-4,uniform,0.1,8192,and,4,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.1,8192,and,4,-,lance_bytes_masked,35448 +csv,2-4,uniform,0.1,8192,and,4,-,lance_bytes_unmasked,377296 +csv,2-4,uniform,0.1,8192,and,4,-,lance_ns_per_survivor_wall,1786745.5 +csv,2-4,uniform,0.1,8192,and,8,-,survivors,0 +csv,2-4,uniform,0.1,8192,and,8,hot,materialize_ns_per_word,7.046 +csv,2-4,uniform,0.1,8192,and,8,hot,count_ns_per_word,6.587 +csv,2-4,uniform,0.1,8192,and,8,hot,payload_ns_per_survivor,NA +csv,2-4,uniform,0.1,8192,and,8,-,payload_reads,0 +csv,2-4,uniform,0.1,8192,and,8,hot,fused_sum_ns_per_word,8.053 +csv,2-4,uniform,0.1,8192,and,8,hot,point_ns_per_query,9.458 +csv,2-4,uniform,0.1,8192,and,8,cold,materialize_ns_per_word,57.496 +csv,2-4,uniform,0.1,8192,and,8,cold,count_ns_per_word,69.074 +csv,2-4,uniform,0.1,8192,and,8,cold,payload_ns_per_survivor,NA +csv,2-4,uniform,0.1,8192,and,8,cold,fused_sum_ns_per_word,69.246 +csv,2-4,uniform,0.1,8192,and,8,cold,point_ns_per_query,39.679 +csv,2-4,uniform,0.1,8192,and,8,-,lance_rows_returned,0 +csv,2-4,uniform,0.1,8192,and,8,-,lance_rows_scanned_masked,0 +csv,2-4,uniform,0.1,8192,and,8,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.1,8192,and,8,-,lance_bytes_masked,0 +csv,2-4,uniform,0.1,8192,and,8,-,lance_bytes_unmasked,627432 +csv,2-4,uniform,0.1,8192,and,8,-,lance_ns_per_survivor_wall,NA +csv,2-4,uniform,0.1,8192,or,2,-,survivors,1623 +csv,2-4,uniform,0.1,8192,or,2,hot,materialize_ns_per_word,3.644 +csv,2-4,uniform,0.1,8192,or,2,hot,count_ns_per_word,3.527 +csv,2-4,uniform,0.1,8192,or,2,hot,payload_ns_per_survivor,16.489 +csv,2-4,uniform,0.1,8192,or,2,-,payload_reads,1704 +csv,2-4,uniform,0.1,8192,or,2,hot,fused_sum_ns_per_word,7.838 +csv,2-4,uniform,0.1,8192,or,2,hot,point_ns_per_query,8.577 +csv,2-4,uniform,0.1,8192,or,2,cold,materialize_ns_per_word,42.190 +csv,2-4,uniform,0.1,8192,or,2,cold,count_ns_per_word,52.695 +csv,2-4,uniform,0.1,8192,or,2,cold,payload_ns_per_survivor,37.267 +csv,2-4,uniform,0.1,8192,or,2,cold,fused_sum_ns_per_word,62.126 +csv,2-4,uniform,0.1,8192,or,2,cold,point_ns_per_query,23.083 +csv,2-4,uniform,0.1,8192,or,4,-,survivors,2920 +csv,2-4,uniform,0.1,8192,or,4,hot,materialize_ns_per_word,4.809 +csv,2-4,uniform,0.1,8192,or,4,hot,count_ns_per_word,4.812 +csv,2-4,uniform,0.1,8192,or,4,hot,payload_ns_per_survivor,25.762 +csv,2-4,uniform,0.1,8192,or,4,-,payload_reads,3386 +csv,2-4,uniform,0.1,8192,or,4,hot,fused_sum_ns_per_word,11.071 +csv,2-4,uniform,0.1,8192,or,4,hot,point_ns_per_query,8.504 +csv,2-4,uniform,0.1,8192,or,4,cold,materialize_ns_per_word,48.384 +csv,2-4,uniform,0.1,8192,or,4,cold,count_ns_per_word,56.387 +csv,2-4,uniform,0.1,8192,or,4,cold,payload_ns_per_survivor,39.772 +csv,2-4,uniform,0.1,8192,or,4,cold,fused_sum_ns_per_word,70.741 +csv,2-4,uniform,0.1,8192,or,4,cold,point_ns_per_query,29.344 +csv,2-4,uniform,0.1,8192,or,8,-,survivors,4741 +csv,2-4,uniform,0.1,8192,or,8,hot,materialize_ns_per_word,9.339 +csv,2-4,uniform,0.1,8192,or,8,hot,count_ns_per_word,8.890 +csv,2-4,uniform,0.1,8192,or,8,hot,payload_ns_per_survivor,39.764 +csv,2-4,uniform,0.1,8192,or,8,-,payload_reads,6616 +csv,2-4,uniform,0.1,8192,or,8,hot,fused_sum_ns_per_word,15.374 +csv,2-4,uniform,0.1,8192,or,8,hot,point_ns_per_query,9.234 +csv,2-4,uniform,0.1,8192,or,8,cold,materialize_ns_per_word,66.256 +csv,2-4,uniform,0.1,8192,or,8,cold,count_ns_per_word,77.002 +csv,2-4,uniform,0.1,8192,or,8,cold,payload_ns_per_survivor,70.586 +csv,2-4,uniform,0.1,8192,or,8,cold,fused_sum_ns_per_word,98.710 +csv,2-4,uniform,0.1,8192,or,8,cold,point_ns_per_query,36.380 +csv,2-4,uniform,0.1,65536,and,1,-,survivors,6606 +csv,2-4,uniform,0.1,65536,and,1,hot,materialize_ns_per_word,2.200 +csv,2-4,uniform,0.1,65536,and,1,hot,count_ns_per_word,2.414 +csv,2-4,uniform,0.1,65536,and,1,hot,payload_ns_per_survivor,7.821 +csv,2-4,uniform,0.1,65536,and,1,-,payload_reads,6606 +csv,2-4,uniform,0.1,65536,and,1,hot,fused_sum_ns_per_word,18.289 +csv,2-4,uniform,0.1,65536,and,1,hot,point_ns_per_query,8.271 +csv,2-4,uniform,0.1,65536,and,1,cold,materialize_ns_per_word,37.088 +csv,2-4,uniform,0.1,65536,and,1,cold,count_ns_per_word,43.048 +csv,2-4,uniform,0.1,65536,and,1,cold,payload_ns_per_survivor,15.957 +csv,2-4,uniform,0.1,65536,and,1,cold,fused_sum_ns_per_word,81.977 +csv,2-4,uniform,0.1,65536,and,1,cold,point_ns_per_query,30.222 +csv,2-4,uniform,0.1,65536,and,1,-,lance_rows_returned,6606 +csv,2-4,uniform,0.1,65536,and,1,-,lance_rows_scanned_masked,6606 +csv,2-4,uniform,0.1,65536,and,1,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.1,65536,and,1,-,lance_bytes_masked,187216 +csv,2-4,uniform,0.1,65536,and,1,-,lance_bytes_unmasked,187411 +csv,2-4,uniform,0.1,65536,and,1,-,lance_ns_per_survivor_wall,1220.0 +csv,2-4,uniform,0.1,65536,and,2,-,survivors,679 +csv,2-4,uniform,0.1,65536,and,2,hot,materialize_ns_per_word,3.042 +csv,2-4,uniform,0.1,65536,and,2,hot,count_ns_per_word,2.995 +csv,2-4,uniform,0.1,65536,and,2,hot,payload_ns_per_survivor,25.127 +csv,2-4,uniform,0.1,65536,and,2,-,payload_reads,1358 +csv,2-4,uniform,0.1,65536,and,2,hot,fused_sum_ns_per_word,7.318 +csv,2-4,uniform,0.1,65536,and,2,hot,point_ns_per_query,14.279 +csv,2-4,uniform,0.1,65536,and,2,cold,materialize_ns_per_word,36.776 +csv,2-4,uniform,0.1,65536,and,2,cold,count_ns_per_word,48.708 +csv,2-4,uniform,0.1,65536,and,2,cold,payload_ns_per_survivor,180.563 +csv,2-4,uniform,0.1,65536,and,2,cold,fused_sum_ns_per_word,80.094 +csv,2-4,uniform,0.1,65536,and,2,cold,point_ns_per_query,47.160 +csv,2-4,uniform,0.1,65536,and,2,-,lance_rows_returned,679 +csv,2-4,uniform,0.1,65536,and,2,-,lance_rows_scanned_masked,679 +csv,2-4,uniform,0.1,65536,and,2,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.1,65536,and,2,-,lance_bytes_masked,250336 +csv,2-4,uniform,0.1,65536,and,2,-,lance_bytes_unmasked,254496 +csv,2-4,uniform,0.1,65536,and,2,-,lance_ns_per_survivor_wall,4648.9 +csv,2-4,uniform,0.1,65536,and,4,-,survivors,8 +csv,2-4,uniform,0.1,65536,and,4,hot,materialize_ns_per_word,3.295 +csv,2-4,uniform,0.1,65536,and,4,hot,count_ns_per_word,3.080 +csv,2-4,uniform,0.1,65536,and,4,hot,payload_ns_per_survivor,237.575 +csv,2-4,uniform,0.1,65536,and,4,-,payload_reads,32 +csv,2-4,uniform,0.1,65536,and,4,hot,fused_sum_ns_per_word,4.895 +csv,2-4,uniform,0.1,65536,and,4,hot,point_ns_per_query,11.658 +csv,2-4,uniform,0.1,65536,and,4,cold,materialize_ns_per_word,48.423 +csv,2-4,uniform,0.1,65536,and,4,cold,count_ns_per_word,47.442 +csv,2-4,uniform,0.1,65536,and,4,cold,payload_ns_per_survivor,1163.250 +csv,2-4,uniform,0.1,65536,and,4,cold,fused_sum_ns_per_word,59.224 +csv,2-4,uniform,0.1,65536,and,4,cold,point_ns_per_query,77.295 +csv,2-4,uniform,0.1,65536,and,4,-,lance_rows_returned,8 +csv,2-4,uniform,0.1,65536,and,4,-,lance_rows_scanned_masked,8 +csv,2-4,uniform,0.1,65536,and,4,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.1,65536,and,4,-,lance_bytes_masked,140352 +csv,2-4,uniform,0.1,65536,and,4,-,lance_bytes_unmasked,377296 +csv,2-4,uniform,0.1,65536,and,4,-,lance_ns_per_survivor_wall,635035.8 +csv,2-4,uniform,0.1,65536,and,8,-,survivors,0 +csv,2-4,uniform,0.1,65536,and,8,hot,materialize_ns_per_word,6.541 +csv,2-4,uniform,0.1,65536,and,8,hot,count_ns_per_word,8.515 +csv,2-4,uniform,0.1,65536,and,8,hot,payload_ns_per_survivor,NA +csv,2-4,uniform,0.1,65536,and,8,-,payload_reads,0 +csv,2-4,uniform,0.1,65536,and,8,hot,fused_sum_ns_per_word,7.160 +csv,2-4,uniform,0.1,65536,and,8,hot,point_ns_per_query,20.732 +csv,2-4,uniform,0.1,65536,and,8,cold,materialize_ns_per_word,59.825 +csv,2-4,uniform,0.1,65536,and,8,cold,count_ns_per_word,76.074 +csv,2-4,uniform,0.1,65536,and,8,cold,payload_ns_per_survivor,NA +csv,2-4,uniform,0.1,65536,and,8,cold,fused_sum_ns_per_word,69.305 +csv,2-4,uniform,0.1,65536,and,8,cold,point_ns_per_query,139.637 +csv,2-4,uniform,0.1,65536,and,8,-,lance_rows_returned,0 +csv,2-4,uniform,0.1,65536,and,8,-,lance_rows_scanned_masked,0 +csv,2-4,uniform,0.1,65536,and,8,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.1,65536,and,8,-,lance_bytes_masked,0 +csv,2-4,uniform,0.1,65536,and,8,-,lance_bytes_unmasked,627432 +csv,2-4,uniform,0.1,65536,and,8,-,lance_ns_per_survivor_wall,NA +csv,2-4,uniform,0.1,65536,or,2,-,survivors,12515 +csv,2-4,uniform,0.1,65536,or,2,hot,materialize_ns_per_word,3.898 +csv,2-4,uniform,0.1,65536,or,2,hot,count_ns_per_word,3.509 +csv,2-4,uniform,0.1,65536,or,2,hot,payload_ns_per_survivor,18.172 +csv,2-4,uniform,0.1,65536,or,2,-,payload_reads,13194 +csv,2-4,uniform,0.1,65536,or,2,hot,fused_sum_ns_per_word,25.635 +csv,2-4,uniform,0.1,65536,or,2,hot,point_ns_per_query,8.645 +csv,2-4,uniform,0.1,65536,or,2,cold,materialize_ns_per_word,51.666 +csv,2-4,uniform,0.1,65536,or,2,cold,count_ns_per_word,60.501 +csv,2-4,uniform,0.1,65536,or,2,cold,payload_ns_per_survivor,30.406 +csv,2-4,uniform,0.1,65536,or,2,cold,fused_sum_ns_per_word,145.662 +csv,2-4,uniform,0.1,65536,or,2,cold,point_ns_per_query,68.515 +csv,2-4,uniform,0.1,65536,or,4,-,survivors,22776 +csv,2-4,uniform,0.1,65536,or,4,hot,materialize_ns_per_word,4.978 +csv,2-4,uniform,0.1,65536,or,4,hot,count_ns_per_word,4.850 +csv,2-4,uniform,0.1,65536,or,4,hot,payload_ns_per_survivor,25.635 +csv,2-4,uniform,0.1,65536,or,4,-,payload_reads,26435 +csv,2-4,uniform,0.1,65536,or,4,hot,fused_sum_ns_per_word,36.185 +csv,2-4,uniform,0.1,65536,or,4,hot,point_ns_per_query,12.425 +csv,2-4,uniform,0.1,65536,or,4,cold,materialize_ns_per_word,57.872 +csv,2-4,uniform,0.1,65536,or,4,cold,count_ns_per_word,57.601 +csv,2-4,uniform,0.1,65536,or,4,cold,payload_ns_per_survivor,30.170 +csv,2-4,uniform,0.1,65536,or,4,cold,fused_sum_ns_per_word,111.841 +csv,2-4,uniform,0.1,65536,or,4,cold,point_ns_per_query,75.700 +csv,2-4,uniform,0.1,65536,or,8,-,survivors,37446 +csv,2-4,uniform,0.1,65536,or,8,hot,materialize_ns_per_word,9.139 +csv,2-4,uniform,0.1,65536,or,8,hot,count_ns_per_word,10.352 +csv,2-4,uniform,0.1,65536,or,8,hot,payload_ns_per_survivor,41.398 +csv,2-4,uniform,0.1,65536,or,8,-,payload_reads,52513 +csv,2-4,uniform,0.1,65536,or,8,hot,fused_sum_ns_per_word,52.909 +csv,2-4,uniform,0.1,65536,or,8,hot,point_ns_per_query,18.298 +csv,2-4,uniform,0.1,65536,or,8,cold,materialize_ns_per_word,54.621 +csv,2-4,uniform,0.1,65536,or,8,cold,count_ns_per_word,80.693 +csv,2-4,uniform,0.1,65536,or,8,cold,payload_ns_per_survivor,50.359 +csv,2-4,uniform,0.1,65536,or,8,cold,fused_sum_ns_per_word,129.659 +csv,2-4,uniform,0.1,65536,or,8,cold,point_ns_per_query,135.367 +csv,2-4,uniform,0.5,1024,and,1,-,survivors,524 +csv,2-4,uniform,0.5,1024,and,1,hot,materialize_ns_per_word,3.186 +csv,2-4,uniform,0.5,1024,and,1,hot,count_ns_per_word,2.900 +csv,2-4,uniform,0.5,1024,and,1,hot,payload_ns_per_survivor,14.056 +csv,2-4,uniform,0.5,1024,and,1,-,payload_reads,524 +csv,2-4,uniform,0.5,1024,and,1,hot,fused_sum_ns_per_word,6.601 +csv,2-4,uniform,0.5,1024,and,1,hot,point_ns_per_query,12.266 +csv,2-4,uniform,0.5,1024,and,1,cold,materialize_ns_per_word,43.002 +csv,2-4,uniform,0.5,1024,and,1,cold,count_ns_per_word,40.442 +csv,2-4,uniform,0.5,1024,and,1,cold,payload_ns_per_survivor,34.124 +csv,2-4,uniform,0.5,1024,and,1,cold,fused_sum_ns_per_word,48.953 +csv,2-4,uniform,0.5,1024,and,1,cold,point_ns_per_query,16.659 +csv,2-4,uniform,0.5,1024,and,1,-,lance_rows_returned,524 +csv,2-4,uniform,0.5,1024,and,1,-,lance_rows_scanned_masked,524 +csv,2-4,uniform,0.5,1024,and,1,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.5,1024,and,1,-,lance_bytes_masked,9136 +csv,2-4,uniform,0.5,1024,and,1,-,lance_bytes_unmasked,372244 +csv,2-4,uniform,0.5,1024,and,1,-,lance_ns_per_survivor_wall,3835.0 +csv,2-4,uniform,0.5,1024,and,2,-,survivors,256 +csv,2-4,uniform,0.5,1024,and,2,hot,materialize_ns_per_word,2.537 +csv,2-4,uniform,0.5,1024,and,2,hot,count_ns_per_word,2.315 +csv,2-4,uniform,0.5,1024,and,2,hot,payload_ns_per_survivor,17.084 +csv,2-4,uniform,0.5,1024,and,2,-,payload_reads,512 +csv,2-4,uniform,0.5,1024,and,2,hot,fused_sum_ns_per_word,4.225 +csv,2-4,uniform,0.5,1024,and,2,hot,point_ns_per_query,8.593 +csv,2-4,uniform,0.5,1024,and,2,cold,materialize_ns_per_word,36.392 +csv,2-4,uniform,0.5,1024,and,2,cold,count_ns_per_word,41.911 +csv,2-4,uniform,0.5,1024,and,2,cold,payload_ns_per_survivor,57.855 +csv,2-4,uniform,0.5,1024,and,2,cold,fused_sum_ns_per_word,51.370 +csv,2-4,uniform,0.5,1024,and,2,cold,point_ns_per_query,16.708 +csv,2-4,uniform,0.5,1024,and,2,-,lance_rows_returned,256 +csv,2-4,uniform,0.5,1024,and,2,-,lance_rows_scanned_masked,256 +csv,2-4,uniform,0.5,1024,and,2,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.5,1024,and,2,-,lance_bytes_masked,16912 +csv,2-4,uniform,0.5,1024,and,2,-,lance_bytes_unmasked,623288 +csv,2-4,uniform,0.5,1024,and,2,-,lance_ns_per_survivor_wall,13423.4 +csv,2-4,uniform,0.5,1024,and,4,-,survivors,65 +csv,2-4,uniform,0.5,1024,and,4,hot,materialize_ns_per_word,3.512 +csv,2-4,uniform,0.5,1024,and,4,hot,count_ns_per_word,3.257 +csv,2-4,uniform,0.5,1024,and,4,hot,payload_ns_per_survivor,45.399 +csv,2-4,uniform,0.5,1024,and,4,-,payload_reads,260 +csv,2-4,uniform,0.5,1024,and,4,hot,fused_sum_ns_per_word,5.523 +csv,2-4,uniform,0.5,1024,and,4,hot,point_ns_per_query,8.706 +csv,2-4,uniform,0.5,1024,and,4,cold,materialize_ns_per_word,40.808 +csv,2-4,uniform,0.5,1024,and,4,cold,count_ns_per_word,51.144 +csv,2-4,uniform,0.5,1024,and,4,cold,payload_ns_per_survivor,161.846 +csv,2-4,uniform,0.5,1024,and,4,cold,fused_sum_ns_per_word,54.430 +csv,2-4,uniform,0.5,1024,and,4,cold,point_ns_per_query,19.030 +csv,2-4,uniform,0.5,1024,and,4,-,lance_rows_returned,65 +csv,2-4,uniform,0.5,1024,and,4,-,lance_rows_scanned_masked,65 +csv,2-4,uniform,0.5,1024,and,4,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.5,1024,and,4,-,lance_bytes_masked,32632 +csv,2-4,uniform,0.5,1024,and,4,-,lance_bytes_unmasked,1111464 +csv,2-4,uniform,0.5,1024,and,4,-,lance_ns_per_survivor_wall,50353.2 +csv,2-4,uniform,0.5,1024,and,8,-,survivors,3 +csv,2-4,uniform,0.5,1024,and,8,hot,materialize_ns_per_word,9.531 +csv,2-4,uniform,0.5,1024,and,8,hot,count_ns_per_word,8.778 +csv,2-4,uniform,0.5,1024,and,8,hot,payload_ns_per_survivor,650.227 +csv,2-4,uniform,0.5,1024,and,8,-,payload_reads,24 +csv,2-4,uniform,0.5,1024,and,8,hot,fused_sum_ns_per_word,10.928 +csv,2-4,uniform,0.5,1024,and,8,hot,point_ns_per_query,12.076 +csv,2-4,uniform,0.5,1024,and,8,cold,materialize_ns_per_word,46.830 +csv,2-4,uniform,0.5,1024,and,8,cold,count_ns_per_word,62.140 +csv,2-4,uniform,0.5,1024,and,8,cold,payload_ns_per_survivor,2213.000 +csv,2-4,uniform,0.5,1024,and,8,cold,fused_sum_ns_per_word,60.083 +csv,2-4,uniform,0.5,1024,and,8,cold,point_ns_per_query,19.917 +csv,2-4,uniform,0.5,1024,and,8,-,lance_rows_returned,3 +csv,2-4,uniform,0.5,1024,and,8,-,lance_rows_scanned_masked,3 +csv,2-4,uniform,0.5,1024,and,8,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.5,1024,and,8,-,lance_bytes_masked,63752 +csv,2-4,uniform,0.5,1024,and,8,-,lance_bytes_unmasked,2096496 +csv,2-4,uniform,0.5,1024,and,8,-,lance_ns_per_survivor_wall,1275938.3 +csv,2-4,uniform,0.5,1024,or,2,-,survivors,772 +csv,2-4,uniform,0.5,1024,or,2,hot,materialize_ns_per_word,3.988 +csv,2-4,uniform,0.5,1024,or,2,hot,count_ns_per_word,3.942 +csv,2-4,uniform,0.5,1024,or,2,hot,payload_ns_per_survivor,16.598 +csv,2-4,uniform,0.5,1024,or,2,-,payload_reads,1028 +csv,2-4,uniform,0.5,1024,or,2,hot,fused_sum_ns_per_word,6.519 +csv,2-4,uniform,0.5,1024,or,2,hot,point_ns_per_query,8.594 +csv,2-4,uniform,0.5,1024,or,2,cold,materialize_ns_per_word,36.254 +csv,2-4,uniform,0.5,1024,or,2,cold,count_ns_per_word,40.914 +csv,2-4,uniform,0.5,1024,or,2,cold,payload_ns_per_survivor,53.759 +csv,2-4,uniform,0.5,1024,or,2,cold,fused_sum_ns_per_word,53.966 +csv,2-4,uniform,0.5,1024,or,2,cold,point_ns_per_query,17.094 +csv,2-4,uniform,0.5,1024,or,4,-,survivors,962 +csv,2-4,uniform,0.5,1024,or,4,hot,materialize_ns_per_word,4.896 +csv,2-4,uniform,0.5,1024,or,4,hot,count_ns_per_word,4.832 +csv,2-4,uniform,0.5,1024,or,4,hot,payload_ns_per_survivor,29.101 +csv,2-4,uniform,0.5,1024,or,4,-,payload_reads,2075 +csv,2-4,uniform,0.5,1024,or,4,hot,fused_sum_ns_per_word,8.021 +csv,2-4,uniform,0.5,1024,or,4,hot,point_ns_per_query,8.773 +csv,2-4,uniform,0.5,1024,or,4,cold,materialize_ns_per_word,40.693 +csv,2-4,uniform,0.5,1024,or,4,cold,count_ns_per_word,59.736 +csv,2-4,uniform,0.5,1024,or,4,cold,payload_ns_per_survivor,69.038 +csv,2-4,uniform,0.5,1024,or,4,cold,fused_sum_ns_per_word,58.965 +csv,2-4,uniform,0.5,1024,or,4,cold,point_ns_per_query,16.937 +csv,2-4,uniform,0.5,1024,or,8,-,survivors,1021 +csv,2-4,uniform,0.5,1024,or,8,hot,materialize_ns_per_word,9.330 +csv,2-4,uniform,0.5,1024,or,8,hot,count_ns_per_word,9.400 +csv,2-4,uniform,0.5,1024,or,8,hot,payload_ns_per_survivor,136.833 +csv,2-4,uniform,0.5,1024,or,8,-,payload_reads,4102 +csv,2-4,uniform,0.5,1024,or,8,hot,fused_sum_ns_per_word,21.780 +csv,2-4,uniform,0.5,1024,or,8,hot,point_ns_per_query,14.396 +csv,2-4,uniform,0.5,1024,or,8,cold,materialize_ns_per_word,72.484 +csv,2-4,uniform,0.5,1024,or,8,cold,count_ns_per_word,71.804 +csv,2-4,uniform,0.5,1024,or,8,cold,payload_ns_per_survivor,132.599 +csv,2-4,uniform,0.5,1024,or,8,cold,fused_sum_ns_per_word,71.181 +csv,2-4,uniform,0.5,1024,or,8,cold,point_ns_per_query,20.311 +csv,2-4,uniform,0.5,8192,and,1,-,survivors,4190 +csv,2-4,uniform,0.5,8192,and,1,hot,materialize_ns_per_word,2.150 +csv,2-4,uniform,0.5,8192,and,1,hot,count_ns_per_word,1.842 +csv,2-4,uniform,0.5,8192,and,1,hot,payload_ns_per_survivor,6.800 +csv,2-4,uniform,0.5,8192,and,1,-,payload_reads,4190 +csv,2-4,uniform,0.5,8192,and,1,hot,fused_sum_ns_per_word,8.214 +csv,2-4,uniform,0.5,8192,and,1,hot,point_ns_per_query,8.188 +csv,2-4,uniform,0.5,8192,and,1,cold,materialize_ns_per_word,29.097 +csv,2-4,uniform,0.5,8192,and,1,cold,count_ns_per_word,35.508 +csv,2-4,uniform,0.5,8192,and,1,cold,payload_ns_per_survivor,14.397 +csv,2-4,uniform,0.5,8192,and,1,cold,fused_sum_ns_per_word,45.579 +csv,2-4,uniform,0.5,8192,and,1,cold,point_ns_per_query,27.189 +csv,2-4,uniform,0.5,8192,and,1,-,lance_rows_returned,4190 +csv,2-4,uniform,0.5,8192,and,1,-,lance_rows_scanned_masked,4190 +csv,2-4,uniform,0.5,8192,and,1,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.5,8192,and,1,-,lance_bytes_masked,43800 +csv,2-4,uniform,0.5,8192,and,1,-,lance_bytes_unmasked,372244 +csv,2-4,uniform,0.5,8192,and,1,-,lance_ns_per_survivor_wall,882.8 +csv,2-4,uniform,0.5,8192,and,2,-,survivors,2004 +csv,2-4,uniform,0.5,8192,and,2,hot,materialize_ns_per_word,2.148 +csv,2-4,uniform,0.5,8192,and,2,hot,count_ns_per_word,1.988 +csv,2-4,uniform,0.5,8192,and,2,hot,payload_ns_per_survivor,12.670 +csv,2-4,uniform,0.5,8192,and,2,-,payload_reads,4008 +csv,2-4,uniform,0.5,8192,and,2,hot,fused_sum_ns_per_word,7.087 +csv,2-4,uniform,0.5,8192,and,2,hot,point_ns_per_query,8.862 +csv,2-4,uniform,0.5,8192,and,2,cold,materialize_ns_per_word,39.888 +csv,2-4,uniform,0.5,8192,and,2,cold,count_ns_per_word,48.105 +csv,2-4,uniform,0.5,8192,and,2,cold,payload_ns_per_survivor,31.112 +csv,2-4,uniform,0.5,8192,and,2,cold,fused_sum_ns_per_word,55.158 +csv,2-4,uniform,0.5,8192,and,2,cold,point_ns_per_query,40.345 +csv,2-4,uniform,0.5,8192,and,2,-,lance_rows_returned,2004 +csv,2-4,uniform,0.5,8192,and,2,-,lance_rows_scanned_masked,2004 +csv,2-4,uniform,0.5,8192,and,2,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.5,8192,and,2,-,lance_bytes_masked,74216 +csv,2-4,uniform,0.5,8192,and,2,-,lance_bytes_unmasked,623288 +csv,2-4,uniform,0.5,8192,and,2,-,lance_ns_per_survivor_wall,1859.5 +csv,2-4,uniform,0.5,8192,and,4,-,survivors,516 +csv,2-4,uniform,0.5,8192,and,4,hot,materialize_ns_per_word,3.161 +csv,2-4,uniform,0.5,8192,and,4,hot,count_ns_per_word,3.093 +csv,2-4,uniform,0.5,8192,and,4,hot,payload_ns_per_survivor,25.341 +csv,2-4,uniform,0.5,8192,and,4,-,payload_reads,2064 +csv,2-4,uniform,0.5,8192,and,4,hot,fused_sum_ns_per_word,6.775 +csv,2-4,uniform,0.5,8192,and,4,hot,point_ns_per_query,8.999 +csv,2-4,uniform,0.5,8192,and,4,cold,materialize_ns_per_word,42.072 +csv,2-4,uniform,0.5,8192,and,4,cold,count_ns_per_word,55.208 +csv,2-4,uniform,0.5,8192,and,4,cold,payload_ns_per_survivor,106.990 +csv,2-4,uniform,0.5,8192,and,4,cold,fused_sum_ns_per_word,58.776 +csv,2-4,uniform,0.5,8192,and,4,cold,point_ns_per_query,32.550 +csv,2-4,uniform,0.5,8192,and,4,-,lance_rows_returned,516 +csv,2-4,uniform,0.5,8192,and,4,-,lance_rows_scanned_masked,516 +csv,2-4,uniform,0.5,8192,and,4,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.5,8192,and,4,-,lance_bytes_masked,136104 +csv,2-4,uniform,0.5,8192,and,4,-,lance_bytes_unmasked,1111464 +csv,2-4,uniform,0.5,8192,and,4,-,lance_ns_per_survivor_wall,5546.4 +csv,2-4,uniform,0.5,8192,and,8,-,survivors,30 +csv,2-4,uniform,0.5,8192,and,8,hot,materialize_ns_per_word,6.579 +csv,2-4,uniform,0.5,8192,and,8,hot,count_ns_per_word,6.429 +csv,2-4,uniform,0.5,8192,and,8,hot,payload_ns_per_survivor,103.196 +csv,2-4,uniform,0.5,8192,and,8,-,payload_reads,240 +csv,2-4,uniform,0.5,8192,and,8,hot,fused_sum_ns_per_word,7.458 +csv,2-4,uniform,0.5,8192,and,8,hot,point_ns_per_query,10.373 +csv,2-4,uniform,0.5,8192,and,8,cold,materialize_ns_per_word,43.611 +csv,2-4,uniform,0.5,8192,and,8,cold,count_ns_per_word,50.496 +csv,2-4,uniform,0.5,8192,and,8,cold,payload_ns_per_survivor,467.733 +csv,2-4,uniform,0.5,8192,and,8,cold,fused_sum_ns_per_word,57.623 +csv,2-4,uniform,0.5,8192,and,8,cold,point_ns_per_query,43.665 +csv,2-4,uniform,0.5,8192,and,8,-,lance_rows_returned,30 +csv,2-4,uniform,0.5,8192,and,8,-,lance_rows_scanned_masked,30 +csv,2-4,uniform,0.5,8192,and,8,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.5,8192,and,8,-,lance_bytes_masked,259152 +csv,2-4,uniform,0.5,8192,and,8,-,lance_bytes_unmasked,2096496 +csv,2-4,uniform,0.5,8192,and,8,-,lance_ns_per_survivor_wall,150745.3 +csv,2-4,uniform,0.5,8192,or,2,-,survivors,6177 +csv,2-4,uniform,0.5,8192,or,2,hot,materialize_ns_per_word,4.006 +csv,2-4,uniform,0.5,8192,or,2,hot,count_ns_per_word,4.589 +csv,2-4,uniform,0.5,8192,or,2,hot,payload_ns_per_survivor,18.419 +csv,2-4,uniform,0.5,8192,or,2,-,payload_reads,8181 +csv,2-4,uniform,0.5,8192,or,2,hot,fused_sum_ns_per_word,12.288 +csv,2-4,uniform,0.5,8192,or,2,hot,point_ns_per_query,8.659 +csv,2-4,uniform,0.5,8192,or,2,cold,materialize_ns_per_word,45.090 +csv,2-4,uniform,0.5,8192,or,2,cold,count_ns_per_word,53.405 +csv,2-4,uniform,0.5,8192,or,2,cold,payload_ns_per_survivor,24.404 +csv,2-4,uniform,0.5,8192,or,2,cold,fused_sum_ns_per_word,68.306 +csv,2-4,uniform,0.5,8192,or,2,cold,point_ns_per_query,29.225 +csv,2-4,uniform,0.5,8192,or,4,-,survivors,7685 +csv,2-4,uniform,0.5,8192,or,4,hot,materialize_ns_per_word,5.887 +csv,2-4,uniform,0.5,8192,or,4,hot,count_ns_per_word,4.825 +csv,2-4,uniform,0.5,8192,or,4,hot,payload_ns_per_survivor,41.660 +csv,2-4,uniform,0.5,8192,or,4,-,payload_reads,16485 +csv,2-4,uniform,0.5,8192,or,4,hot,fused_sum_ns_per_word,14.534 +csv,2-4,uniform,0.5,8192,or,4,hot,point_ns_per_query,10.606 +csv,2-4,uniform,0.5,8192,or,4,cold,materialize_ns_per_word,44.653 +csv,2-4,uniform,0.5,8192,or,4,cold,count_ns_per_word,48.165 +csv,2-4,uniform,0.5,8192,or,4,cold,payload_ns_per_survivor,45.425 +csv,2-4,uniform,0.5,8192,or,4,cold,fused_sum_ns_per_word,74.842 +csv,2-4,uniform,0.5,8192,or,4,cold,point_ns_per_query,36.012 +csv,2-4,uniform,0.5,8192,or,8,-,survivors,8161 +csv,2-4,uniform,0.5,8192,or,8,hot,materialize_ns_per_word,9.538 +csv,2-4,uniform,0.5,8192,or,8,hot,count_ns_per_word,9.484 +csv,2-4,uniform,0.5,8192,or,8,hot,payload_ns_per_survivor,110.704 +csv,2-4,uniform,0.5,8192,or,8,-,payload_reads,32740 +csv,2-4,uniform,0.5,8192,or,8,hot,fused_sum_ns_per_word,18.270 +csv,2-4,uniform,0.5,8192,or,8,hot,point_ns_per_query,8.967 +csv,2-4,uniform,0.5,8192,or,8,cold,materialize_ns_per_word,53.719 +csv,2-4,uniform,0.5,8192,or,8,cold,count_ns_per_word,64.056 +csv,2-4,uniform,0.5,8192,or,8,cold,payload_ns_per_survivor,116.220 +csv,2-4,uniform,0.5,8192,or,8,cold,fused_sum_ns_per_word,81.415 +csv,2-4,uniform,0.5,8192,or,8,cold,point_ns_per_query,42.800 +csv,2-4,uniform,0.5,65536,and,1,-,survivors,33120 +csv,2-4,uniform,0.5,65536,and,1,hot,materialize_ns_per_word,2.022 +csv,2-4,uniform,0.5,65536,and,1,hot,count_ns_per_word,1.761 +csv,2-4,uniform,0.5,65536,and,1,hot,payload_ns_per_survivor,6.276 +csv,2-4,uniform,0.5,65536,and,1,-,payload_reads,33120 +csv,2-4,uniform,0.5,65536,and,1,hot,fused_sum_ns_per_word,41.004 +csv,2-4,uniform,0.5,65536,and,1,hot,point_ns_per_query,9.032 +csv,2-4,uniform,0.5,65536,and,1,cold,materialize_ns_per_word,34.213 +csv,2-4,uniform,0.5,65536,and,1,cold,count_ns_per_word,41.110 +csv,2-4,uniform,0.5,65536,and,1,cold,payload_ns_per_survivor,7.580 +csv,2-4,uniform,0.5,65536,and,1,cold,fused_sum_ns_per_word,102.365 +csv,2-4,uniform,0.5,65536,and,1,cold,point_ns_per_query,47.181 +csv,2-4,uniform,0.5,65536,and,1,-,lance_rows_returned,33120 +csv,2-4,uniform,0.5,65536,and,1,-,lance_rows_scanned_masked,33120 +csv,2-4,uniform,0.5,65536,and,1,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.5,65536,and,1,-,lance_bytes_masked,371984 +csv,2-4,uniform,0.5,65536,and,1,-,lance_bytes_unmasked,372244 +csv,2-4,uniform,0.5,65536,and,1,-,lance_ns_per_survivor_wall,411.6 +csv,2-4,uniform,0.5,65536,and,2,-,survivors,16591 +csv,2-4,uniform,0.5,65536,and,2,hot,materialize_ns_per_word,2.561 +csv,2-4,uniform,0.5,65536,and,2,hot,count_ns_per_word,2.357 +csv,2-4,uniform,0.5,65536,and,2,hot,payload_ns_per_survivor,11.517 +csv,2-4,uniform,0.5,65536,and,2,-,payload_reads,33182 +csv,2-4,uniform,0.5,65536,and,2,hot,fused_sum_ns_per_word,27.154 +csv,2-4,uniform,0.5,65536,and,2,hot,point_ns_per_query,10.735 +csv,2-4,uniform,0.5,65536,and,2,cold,materialize_ns_per_word,23.292 +csv,2-4,uniform,0.5,65536,and,2,cold,count_ns_per_word,41.063 +csv,2-4,uniform,0.5,65536,and,2,cold,payload_ns_per_survivor,15.676 +csv,2-4,uniform,0.5,65536,and,2,cold,fused_sum_ns_per_word,108.479 +csv,2-4,uniform,0.5,65536,and,2,cold,point_ns_per_query,64.860 +csv,2-4,uniform,0.5,65536,and,2,-,lance_rows_returned,16591 +csv,2-4,uniform,0.5,65536,and,2,-,lance_rows_scanned_masked,16591 +csv,2-4,uniform,0.5,65536,and,2,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.5,65536,and,2,-,lance_bytes_masked,619064 +csv,2-4,uniform,0.5,65536,and,2,-,lance_bytes_unmasked,623288 +csv,2-4,uniform,0.5,65536,and,2,-,lance_ns_per_survivor_wall,737.9 +csv,2-4,uniform,0.5,65536,and,4,-,survivors,4074 +csv,2-4,uniform,0.5,65536,and,4,hot,materialize_ns_per_word,3.429 +csv,2-4,uniform,0.5,65536,and,4,hot,count_ns_per_word,3.398 +csv,2-4,uniform,0.5,65536,and,4,hot,payload_ns_per_survivor,24.379 +csv,2-4,uniform,0.5,65536,and,4,-,payload_reads,16296 +csv,2-4,uniform,0.5,65536,and,4,hot,fused_sum_ns_per_word,18.896 +csv,2-4,uniform,0.5,65536,and,4,hot,point_ns_per_query,18.729 +csv,2-4,uniform,0.5,65536,and,4,cold,materialize_ns_per_word,38.825 +csv,2-4,uniform,0.5,65536,and,4,cold,count_ns_per_word,55.122 +csv,2-4,uniform,0.5,65536,and,4,cold,payload_ns_per_survivor,50.855 +csv,2-4,uniform,0.5,65536,and,4,cold,fused_sum_ns_per_word,91.948 +csv,2-4,uniform,0.5,65536,and,4,cold,point_ns_per_query,114.482 +csv,2-4,uniform,0.5,65536,and,4,-,lance_rows_returned,4074 +csv,2-4,uniform,0.5,65536,and,4,-,lance_rows_scanned_masked,4074 +csv,2-4,uniform,0.5,65536,and,4,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.5,65536,and,4,-,lance_bytes_masked,1111208 +csv,2-4,uniform,0.5,65536,and,4,-,lance_bytes_unmasked,1111464 +csv,2-4,uniform,0.5,65536,and,4,-,lance_ns_per_survivor_wall,2213.1 +csv,2-4,uniform,0.5,65536,and,8,-,survivors,247 +csv,2-4,uniform,0.5,65536,and,8,hot,materialize_ns_per_word,7.516 +csv,2-4,uniform,0.5,65536,and,8,hot,count_ns_per_word,8.261 +csv,2-4,uniform,0.5,65536,and,8,hot,payload_ns_per_survivor,48.271 +csv,2-4,uniform,0.5,65536,and,8,-,payload_reads,1976 +csv,2-4,uniform,0.5,65536,and,8,hot,fused_sum_ns_per_word,8.322 +csv,2-4,uniform,0.5,65536,and,8,hot,point_ns_per_query,45.209 +csv,2-4,uniform,0.5,65536,and,8,cold,materialize_ns_per_word,54.608 +csv,2-4,uniform,0.5,65536,and,8,cold,count_ns_per_word,62.394 +csv,2-4,uniform,0.5,65536,and,8,cold,payload_ns_per_survivor,414.235 +csv,2-4,uniform,0.5,65536,and,8,cold,fused_sum_ns_per_word,82.290 +csv,2-4,uniform,0.5,65536,and,8,cold,point_ns_per_query,183.876 +csv,2-4,uniform,0.5,65536,and,8,-,lance_rows_returned,247 +csv,2-4,uniform,0.5,65536,and,8,-,lance_rows_scanned_masked,247 +csv,2-4,uniform,0.5,65536,and,8,-,lance_rows_scanned_unmasked,65536 +csv,2-4,uniform,0.5,65536,and,8,-,lance_bytes_masked,2095984 +csv,2-4,uniform,0.5,65536,and,8,-,lance_bytes_unmasked,2096496 +csv,2-4,uniform,0.5,65536,and,8,-,lance_ns_per_survivor_wall,38597.1 +csv,2-4,uniform,0.5,65536,or,2,-,survivors,49300 +csv,2-4,uniform,0.5,65536,or,2,hot,materialize_ns_per_word,4.201 +csv,2-4,uniform,0.5,65536,or,2,hot,count_ns_per_word,4.176 +csv,2-4,uniform,0.5,65536,or,2,hot,payload_ns_per_survivor,18.738 +csv,2-4,uniform,0.5,65536,or,2,-,payload_reads,65891 +csv,2-4,uniform,0.5,65536,or,2,hot,fused_sum_ns_per_word,59.343 +csv,2-4,uniform,0.5,65536,or,2,hot,point_ns_per_query,9.858 +csv,2-4,uniform,0.5,65536,or,2,cold,materialize_ns_per_word,44.205 +csv,2-4,uniform,0.5,65536,or,2,cold,count_ns_per_word,56.691 +csv,2-4,uniform,0.5,65536,or,2,cold,payload_ns_per_survivor,22.056 +csv,2-4,uniform,0.5,65536,or,2,cold,fused_sum_ns_per_word,123.261 +csv,2-4,uniform,0.5,65536,or,2,cold,point_ns_per_query,65.079 +csv,2-4,uniform,0.5,65536,or,4,-,survivors,61442 +csv,2-4,uniform,0.5,65536,or,4,hot,materialize_ns_per_word,5.055 +csv,2-4,uniform,0.5,65536,or,4,hot,count_ns_per_word,4.956 +csv,2-4,uniform,0.5,65536,or,4,hot,payload_ns_per_survivor,40.560 +csv,2-4,uniform,0.5,65536,or,4,-,payload_reads,131294 +csv,2-4,uniform,0.5,65536,or,4,hot,fused_sum_ns_per_word,67.579 +csv,2-4,uniform,0.5,65536,or,4,hot,point_ns_per_query,17.637 +csv,2-4,uniform,0.5,65536,or,4,cold,materialize_ns_per_word,53.144 +csv,2-4,uniform,0.5,65536,or,4,cold,count_ns_per_word,63.882 +csv,2-4,uniform,0.5,65536,or,4,cold,payload_ns_per_survivor,40.844 +csv,2-4,uniform,0.5,65536,or,4,cold,fused_sum_ns_per_word,147.856 +csv,2-4,uniform,0.5,65536,or,4,cold,point_ns_per_query,109.919 +csv,2-4,uniform,0.5,65536,or,8,-,survivors,65252 +csv,2-4,uniform,0.5,65536,or,8,hot,materialize_ns_per_word,9.374 +csv,2-4,uniform,0.5,65536,or,8,hot,count_ns_per_word,9.321 +csv,2-4,uniform,0.5,65536,or,8,hot,payload_ns_per_survivor,107.996 +csv,2-4,uniform,0.5,65536,or,8,-,payload_reads,261893 +csv,2-4,uniform,0.5,65536,or,8,hot,fused_sum_ns_per_word,74.610 +csv,2-4,uniform,0.5,65536,or,8,hot,point_ns_per_query,44.297 +csv,2-4,uniform,0.5,65536,or,8,cold,materialize_ns_per_word,64.732 +csv,2-4,uniform,0.5,65536,or,8,cold,count_ns_per_word,75.972 +csv,2-4,uniform,0.5,65536,or,8,cold,payload_ns_per_survivor,109.626 +csv,2-4,uniform,0.5,65536,or,8,cold,fused_sum_ns_per_word,161.611 +csv,2-4,uniform,0.5,65536,or,8,cold,point_ns_per_query,182.707 +csv,2-4,clustered,0.001,1024,and,1,-,survivors,0 +csv,2-4,clustered,0.001,1024,and,1,hot,materialize_ns_per_word,2.148 +csv,2-4,clustered,0.001,1024,and,1,hot,count_ns_per_word,1.836 +csv,2-4,clustered,0.001,1024,and,1,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,1024,and,1,-,payload_reads,0 +csv,2-4,clustered,0.001,1024,and,1,hot,fused_sum_ns_per_word,3.351 +csv,2-4,clustered,0.001,1024,and,1,hot,point_ns_per_query,8.319 +csv,2-4,clustered,0.001,1024,and,1,cold,materialize_ns_per_word,36.683 +csv,2-4,clustered,0.001,1024,and,1,cold,count_ns_per_word,48.415 +csv,2-4,clustered,0.001,1024,and,1,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,1024,and,1,cold,fused_sum_ns_per_word,54.132 +csv,2-4,clustered,0.001,1024,and,1,cold,point_ns_per_query,14.717 +csv,2-4,clustered,0.001,1024,and,1,-,lance_rows_returned,0 +csv,2-4,clustered,0.001,1024,and,1,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.001,1024,and,1,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.001,1024,and,1,-,lance_bytes_masked,0 +csv,2-4,clustered,0.001,1024,and,1,-,lance_bytes_unmasked,126402 +csv,2-4,clustered,0.001,1024,and,1,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.001,1024,and,2,-,survivors,0 +csv,2-4,clustered,0.001,1024,and,2,hot,materialize_ns_per_word,2.099 +csv,2-4,clustered,0.001,1024,and,2,hot,count_ns_per_word,1.957 +csv,2-4,clustered,0.001,1024,and,2,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,1024,and,2,-,payload_reads,0 +csv,2-4,clustered,0.001,1024,and,2,hot,fused_sum_ns_per_word,3.651 +csv,2-4,clustered,0.001,1024,and,2,hot,point_ns_per_query,8.484 +csv,2-4,clustered,0.001,1024,and,2,cold,materialize_ns_per_word,37.606 +csv,2-4,clustered,0.001,1024,and,2,cold,count_ns_per_word,44.148 +csv,2-4,clustered,0.001,1024,and,2,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,1024,and,2,cold,fused_sum_ns_per_word,53.579 +csv,2-4,clustered,0.001,1024,and,2,cold,point_ns_per_query,14.772 +csv,2-4,clustered,0.001,1024,and,2,-,lance_rows_returned,0 +csv,2-4,clustered,0.001,1024,and,2,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.001,1024,and,2,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.001,1024,and,2,-,lance_bytes_masked,0 +csv,2-4,clustered,0.001,1024,and,2,-,lance_bytes_unmasked,132544 +csv,2-4,clustered,0.001,1024,and,2,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.001,1024,and,4,-,survivors,0 +csv,2-4,clustered,0.001,1024,and,4,hot,materialize_ns_per_word,3.060 +csv,2-4,clustered,0.001,1024,and,4,hot,count_ns_per_word,3.048 +csv,2-4,clustered,0.001,1024,and,4,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,1024,and,4,-,payload_reads,0 +csv,2-4,clustered,0.001,1024,and,4,hot,fused_sum_ns_per_word,4.811 +csv,2-4,clustered,0.001,1024,and,4,hot,point_ns_per_query,8.479 +csv,2-4,clustered,0.001,1024,and,4,cold,materialize_ns_per_word,44.379 +csv,2-4,clustered,0.001,1024,and,4,cold,count_ns_per_word,53.238 +csv,2-4,clustered,0.001,1024,and,4,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,1024,and,4,cold,fused_sum_ns_per_word,59.388 +csv,2-4,clustered,0.001,1024,and,4,cold,point_ns_per_query,16.527 +csv,2-4,clustered,0.001,1024,and,4,-,lance_rows_returned,0 +csv,2-4,clustered,0.001,1024,and,4,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.001,1024,and,4,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.001,1024,and,4,-,lance_bytes_masked,0 +csv,2-4,clustered,0.001,1024,and,4,-,lance_bytes_unmasked,134976 +csv,2-4,clustered,0.001,1024,and,4,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.001,1024,and,8,-,survivors,0 +csv,2-4,clustered,0.001,1024,and,8,hot,materialize_ns_per_word,6.689 +csv,2-4,clustered,0.001,1024,and,8,hot,count_ns_per_word,6.594 +csv,2-4,clustered,0.001,1024,and,8,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,1024,and,8,-,payload_reads,0 +csv,2-4,clustered,0.001,1024,and,8,hot,fused_sum_ns_per_word,7.620 +csv,2-4,clustered,0.001,1024,and,8,hot,point_ns_per_query,8.569 +csv,2-4,clustered,0.001,1024,and,8,cold,materialize_ns_per_word,52.177 +csv,2-4,clustered,0.001,1024,and,8,cold,count_ns_per_word,62.542 +csv,2-4,clustered,0.001,1024,and,8,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,1024,and,8,cold,fused_sum_ns_per_word,67.102 +csv,2-4,clustered,0.001,1024,and,8,cold,point_ns_per_query,16.267 +csv,2-4,clustered,0.001,1024,and,8,-,lance_rows_returned,0 +csv,2-4,clustered,0.001,1024,and,8,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.001,1024,and,8,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.001,1024,and,8,-,lance_bytes_masked,0 +csv,2-4,clustered,0.001,1024,and,8,-,lance_bytes_unmasked,148032 +csv,2-4,clustered,0.001,1024,and,8,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.001,1024,or,2,-,survivors,0 +csv,2-4,clustered,0.001,1024,or,2,hot,materialize_ns_per_word,4.081 +csv,2-4,clustered,0.001,1024,or,2,hot,count_ns_per_word,3.696 +csv,2-4,clustered,0.001,1024,or,2,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,1024,or,2,-,payload_reads,0 +csv,2-4,clustered,0.001,1024,or,2,hot,fused_sum_ns_per_word,5.258 +csv,2-4,clustered,0.001,1024,or,2,hot,point_ns_per_query,10.176 +csv,2-4,clustered,0.001,1024,or,2,cold,materialize_ns_per_word,43.081 +csv,2-4,clustered,0.001,1024,or,2,cold,count_ns_per_word,51.393 +csv,2-4,clustered,0.001,1024,or,2,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,1024,or,2,cold,fused_sum_ns_per_word,54.835 +csv,2-4,clustered,0.001,1024,or,2,cold,point_ns_per_query,14.817 +csv,2-4,clustered,0.001,1024,or,4,-,survivors,0 +csv,2-4,clustered,0.001,1024,or,4,hot,materialize_ns_per_word,4.846 +csv,2-4,clustered,0.001,1024,or,4,hot,count_ns_per_word,4.830 +csv,2-4,clustered,0.001,1024,or,4,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,1024,or,4,-,payload_reads,0 +csv,2-4,clustered,0.001,1024,or,4,hot,fused_sum_ns_per_word,6.974 +csv,2-4,clustered,0.001,1024,or,4,hot,point_ns_per_query,8.543 +csv,2-4,clustered,0.001,1024,or,4,cold,materialize_ns_per_word,48.080 +csv,2-4,clustered,0.001,1024,or,4,cold,count_ns_per_word,56.438 +csv,2-4,clustered,0.001,1024,or,4,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,1024,or,4,cold,fused_sum_ns_per_word,59.121 +csv,2-4,clustered,0.001,1024,or,4,cold,point_ns_per_query,20.547 +csv,2-4,clustered,0.001,1024,or,8,-,survivors,0 +csv,2-4,clustered,0.001,1024,or,8,hot,materialize_ns_per_word,9.489 +csv,2-4,clustered,0.001,1024,or,8,hot,count_ns_per_word,10.312 +csv,2-4,clustered,0.001,1024,or,8,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,1024,or,8,-,payload_reads,0 +csv,2-4,clustered,0.001,1024,or,8,hot,fused_sum_ns_per_word,11.057 +csv,2-4,clustered,0.001,1024,or,8,hot,point_ns_per_query,8.612 +csv,2-4,clustered,0.001,1024,or,8,cold,materialize_ns_per_word,62.333 +csv,2-4,clustered,0.001,1024,or,8,cold,count_ns_per_word,67.034 +csv,2-4,clustered,0.001,1024,or,8,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,1024,or,8,cold,fused_sum_ns_per_word,64.428 +csv,2-4,clustered,0.001,1024,or,8,cold,point_ns_per_query,14.655 +csv,2-4,clustered,0.001,8192,and,1,-,survivors,0 +csv,2-4,clustered,0.001,8192,and,1,hot,materialize_ns_per_word,2.121 +csv,2-4,clustered,0.001,8192,and,1,hot,count_ns_per_word,1.779 +csv,2-4,clustered,0.001,8192,and,1,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,8192,and,1,-,payload_reads,0 +csv,2-4,clustered,0.001,8192,and,1,hot,fused_sum_ns_per_word,3.336 +csv,2-4,clustered,0.001,8192,and,1,hot,point_ns_per_query,9.298 +csv,2-4,clustered,0.001,8192,and,1,cold,materialize_ns_per_word,35.272 +csv,2-4,clustered,0.001,8192,and,1,cold,count_ns_per_word,45.543 +csv,2-4,clustered,0.001,8192,and,1,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,8192,and,1,cold,fused_sum_ns_per_word,46.148 +csv,2-4,clustered,0.001,8192,and,1,cold,point_ns_per_query,16.325 +csv,2-4,clustered,0.001,8192,and,1,-,lance_rows_returned,0 +csv,2-4,clustered,0.001,8192,and,1,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.001,8192,and,1,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.001,8192,and,1,-,lance_bytes_masked,0 +csv,2-4,clustered,0.001,8192,and,1,-,lance_bytes_unmasked,126402 +csv,2-4,clustered,0.001,8192,and,1,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.001,8192,and,2,-,survivors,0 +csv,2-4,clustered,0.001,8192,and,2,hot,materialize_ns_per_word,2.205 +csv,2-4,clustered,0.001,8192,and,2,hot,count_ns_per_word,2.038 +csv,2-4,clustered,0.001,8192,and,2,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,8192,and,2,-,payload_reads,0 +csv,2-4,clustered,0.001,8192,and,2,hot,fused_sum_ns_per_word,3.710 +csv,2-4,clustered,0.001,8192,and,2,hot,point_ns_per_query,8.436 +csv,2-4,clustered,0.001,8192,and,2,cold,materialize_ns_per_word,35.212 +csv,2-4,clustered,0.001,8192,and,2,cold,count_ns_per_word,46.340 +csv,2-4,clustered,0.001,8192,and,2,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,8192,and,2,cold,fused_sum_ns_per_word,47.381 +csv,2-4,clustered,0.001,8192,and,2,cold,point_ns_per_query,16.004 +csv,2-4,clustered,0.001,8192,and,2,-,lance_rows_returned,0 +csv,2-4,clustered,0.001,8192,and,2,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.001,8192,and,2,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.001,8192,and,2,-,lance_bytes_masked,0 +csv,2-4,clustered,0.001,8192,and,2,-,lance_bytes_unmasked,132544 +csv,2-4,clustered,0.001,8192,and,2,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.001,8192,and,4,-,survivors,0 +csv,2-4,clustered,0.001,8192,and,4,hot,materialize_ns_per_word,3.141 +csv,2-4,clustered,0.001,8192,and,4,hot,count_ns_per_word,3.033 +csv,2-4,clustered,0.001,8192,and,4,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,8192,and,4,-,payload_reads,0 +csv,2-4,clustered,0.001,8192,and,4,hot,fused_sum_ns_per_word,5.126 +csv,2-4,clustered,0.001,8192,and,4,hot,point_ns_per_query,8.817 +csv,2-4,clustered,0.001,8192,and,4,cold,materialize_ns_per_word,45.048 +csv,2-4,clustered,0.001,8192,and,4,cold,count_ns_per_word,54.349 +csv,2-4,clustered,0.001,8192,and,4,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,8192,and,4,cold,fused_sum_ns_per_word,57.957 +csv,2-4,clustered,0.001,8192,and,4,cold,point_ns_per_query,16.667 +csv,2-4,clustered,0.001,8192,and,4,-,lance_rows_returned,0 +csv,2-4,clustered,0.001,8192,and,4,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.001,8192,and,4,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.001,8192,and,4,-,lance_bytes_masked,0 +csv,2-4,clustered,0.001,8192,and,4,-,lance_bytes_unmasked,134976 +csv,2-4,clustered,0.001,8192,and,4,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.001,8192,and,8,-,survivors,0 +csv,2-4,clustered,0.001,8192,and,8,hot,materialize_ns_per_word,7.142 +csv,2-4,clustered,0.001,8192,and,8,hot,count_ns_per_word,6.978 +csv,2-4,clustered,0.001,8192,and,8,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,8192,and,8,-,payload_reads,0 +csv,2-4,clustered,0.001,8192,and,8,hot,fused_sum_ns_per_word,8.083 +csv,2-4,clustered,0.001,8192,and,8,hot,point_ns_per_query,9.444 +csv,2-4,clustered,0.001,8192,and,8,cold,materialize_ns_per_word,54.438 +csv,2-4,clustered,0.001,8192,and,8,cold,count_ns_per_word,63.263 +csv,2-4,clustered,0.001,8192,and,8,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,8192,and,8,cold,fused_sum_ns_per_word,61.710 +csv,2-4,clustered,0.001,8192,and,8,cold,point_ns_per_query,20.162 +csv,2-4,clustered,0.001,8192,and,8,-,lance_rows_returned,0 +csv,2-4,clustered,0.001,8192,and,8,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.001,8192,and,8,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.001,8192,and,8,-,lance_bytes_masked,0 +csv,2-4,clustered,0.001,8192,and,8,-,lance_bytes_unmasked,148032 +csv,2-4,clustered,0.001,8192,and,8,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.001,8192,or,2,-,survivors,0 +csv,2-4,clustered,0.001,8192,or,2,hot,materialize_ns_per_word,6.965 +csv,2-4,clustered,0.001,8192,or,2,hot,count_ns_per_word,6.319 +csv,2-4,clustered,0.001,8192,or,2,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,8192,or,2,-,payload_reads,0 +csv,2-4,clustered,0.001,8192,or,2,hot,fused_sum_ns_per_word,10.106 +csv,2-4,clustered,0.001,8192,or,2,hot,point_ns_per_query,13.513 +csv,2-4,clustered,0.001,8192,or,2,cold,materialize_ns_per_word,43.467 +csv,2-4,clustered,0.001,8192,or,2,cold,count_ns_per_word,51.784 +csv,2-4,clustered,0.001,8192,or,2,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,8192,or,2,cold,fused_sum_ns_per_word,56.638 +csv,2-4,clustered,0.001,8192,or,2,cold,point_ns_per_query,16.301 +csv,2-4,clustered,0.001,8192,or,4,-,survivors,0 +csv,2-4,clustered,0.001,8192,or,4,hot,materialize_ns_per_word,4.814 +csv,2-4,clustered,0.001,8192,or,4,hot,count_ns_per_word,4.820 +csv,2-4,clustered,0.001,8192,or,4,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,8192,or,4,-,payload_reads,0 +csv,2-4,clustered,0.001,8192,or,4,hot,fused_sum_ns_per_word,6.903 +csv,2-4,clustered,0.001,8192,or,4,hot,point_ns_per_query,9.188 +csv,2-4,clustered,0.001,8192,or,4,cold,materialize_ns_per_word,46.882 +csv,2-4,clustered,0.001,8192,or,4,cold,count_ns_per_word,58.485 +csv,2-4,clustered,0.001,8192,or,4,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,8192,or,4,cold,fused_sum_ns_per_word,59.362 +csv,2-4,clustered,0.001,8192,or,4,cold,point_ns_per_query,18.400 +csv,2-4,clustered,0.001,8192,or,8,-,survivors,0 +csv,2-4,clustered,0.001,8192,or,8,hot,materialize_ns_per_word,9.608 +csv,2-4,clustered,0.001,8192,or,8,hot,count_ns_per_word,9.670 +csv,2-4,clustered,0.001,8192,or,8,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,8192,or,8,-,payload_reads,0 +csv,2-4,clustered,0.001,8192,or,8,hot,fused_sum_ns_per_word,10.681 +csv,2-4,clustered,0.001,8192,or,8,hot,point_ns_per_query,9.247 +csv,2-4,clustered,0.001,8192,or,8,cold,materialize_ns_per_word,61.711 +csv,2-4,clustered,0.001,8192,or,8,cold,count_ns_per_word,71.095 +csv,2-4,clustered,0.001,8192,or,8,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,8192,or,8,cold,fused_sum_ns_per_word,72.278 +csv,2-4,clustered,0.001,8192,or,8,cold,point_ns_per_query,21.050 +csv,2-4,clustered,0.001,65536,and,1,-,survivors,64 +csv,2-4,clustered,0.001,65536,and,1,hot,materialize_ns_per_word,3.752 +csv,2-4,clustered,0.001,65536,and,1,hot,count_ns_per_word,2.806 +csv,2-4,clustered,0.001,65536,and,1,hot,payload_ns_per_survivor,42.901 +csv,2-4,clustered,0.001,65536,and,1,-,payload_reads,64 +csv,2-4,clustered,0.001,65536,and,1,hot,fused_sum_ns_per_word,5.817 +csv,2-4,clustered,0.001,65536,and,1,hot,point_ns_per_query,14.021 +csv,2-4,clustered,0.001,65536,and,1,cold,materialize_ns_per_word,40.633 +csv,2-4,clustered,0.001,65536,and,1,cold,count_ns_per_word,46.029 +csv,2-4,clustered,0.001,65536,and,1,cold,payload_ns_per_survivor,97.578 +csv,2-4,clustered,0.001,65536,and,1,cold,fused_sum_ns_per_word,49.171 +csv,2-4,clustered,0.001,65536,and,1,cold,point_ns_per_query,17.174 +csv,2-4,clustered,0.001,65536,and,1,-,lance_rows_returned,64 +csv,2-4,clustered,0.001,65536,and,1,-,lance_rows_scanned_masked,64 +csv,2-4,clustered,0.001,65536,and,1,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.001,65536,and,1,-,lance_bytes_masked,2368 +csv,2-4,clustered,0.001,65536,and,1,-,lance_bytes_unmasked,126402 +csv,2-4,clustered,0.001,65536,and,1,-,lance_ns_per_survivor_wall,38249.4 +csv,2-4,clustered,0.001,65536,and,2,-,survivors,0 +csv,2-4,clustered,0.001,65536,and,2,hot,materialize_ns_per_word,2.455 +csv,2-4,clustered,0.001,65536,and,2,hot,count_ns_per_word,2.275 +csv,2-4,clustered,0.001,65536,and,2,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,65536,and,2,-,payload_reads,0 +csv,2-4,clustered,0.001,65536,and,2,hot,fused_sum_ns_per_word,3.857 +csv,2-4,clustered,0.001,65536,and,2,hot,point_ns_per_query,8.658 +csv,2-4,clustered,0.001,65536,and,2,cold,materialize_ns_per_word,36.724 +csv,2-4,clustered,0.001,65536,and,2,cold,count_ns_per_word,44.432 +csv,2-4,clustered,0.001,65536,and,2,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,65536,and,2,cold,fused_sum_ns_per_word,53.392 +csv,2-4,clustered,0.001,65536,and,2,cold,point_ns_per_query,18.869 +csv,2-4,clustered,0.001,65536,and,2,-,lance_rows_returned,0 +csv,2-4,clustered,0.001,65536,and,2,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.001,65536,and,2,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.001,65536,and,2,-,lance_bytes_masked,0 +csv,2-4,clustered,0.001,65536,and,2,-,lance_bytes_unmasked,132544 +csv,2-4,clustered,0.001,65536,and,2,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.001,65536,and,4,-,survivors,0 +csv,2-4,clustered,0.001,65536,and,4,hot,materialize_ns_per_word,3.175 +csv,2-4,clustered,0.001,65536,and,4,hot,count_ns_per_word,3.060 +csv,2-4,clustered,0.001,65536,and,4,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,65536,and,4,-,payload_reads,0 +csv,2-4,clustered,0.001,65536,and,4,hot,fused_sum_ns_per_word,4.910 +csv,2-4,clustered,0.001,65536,and,4,hot,point_ns_per_query,10.888 +csv,2-4,clustered,0.001,65536,and,4,cold,materialize_ns_per_word,53.278 +csv,2-4,clustered,0.001,65536,and,4,cold,count_ns_per_word,53.199 +csv,2-4,clustered,0.001,65536,and,4,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,65536,and,4,cold,fused_sum_ns_per_word,57.101 +csv,2-4,clustered,0.001,65536,and,4,cold,point_ns_per_query,24.835 +csv,2-4,clustered,0.001,65536,and,4,-,lance_rows_returned,0 +csv,2-4,clustered,0.001,65536,and,4,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.001,65536,and,4,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.001,65536,and,4,-,lance_bytes_masked,0 +csv,2-4,clustered,0.001,65536,and,4,-,lance_bytes_unmasked,134976 +csv,2-4,clustered,0.001,65536,and,4,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.001,65536,and,8,-,survivors,0 +csv,2-4,clustered,0.001,65536,and,8,hot,materialize_ns_per_word,6.512 +csv,2-4,clustered,0.001,65536,and,8,hot,count_ns_per_word,6.561 +csv,2-4,clustered,0.001,65536,and,8,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,65536,and,8,-,payload_reads,0 +csv,2-4,clustered,0.001,65536,and,8,hot,fused_sum_ns_per_word,8.029 +csv,2-4,clustered,0.001,65536,and,8,hot,point_ns_per_query,14.444 +csv,2-4,clustered,0.001,65536,and,8,cold,materialize_ns_per_word,55.060 +csv,2-4,clustered,0.001,65536,and,8,cold,count_ns_per_word,68.011 +csv,2-4,clustered,0.001,65536,and,8,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.001,65536,and,8,cold,fused_sum_ns_per_word,69.751 +csv,2-4,clustered,0.001,65536,and,8,cold,point_ns_per_query,37.987 +csv,2-4,clustered,0.001,65536,and,8,-,lance_rows_returned,0 +csv,2-4,clustered,0.001,65536,and,8,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.001,65536,and,8,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.001,65536,and,8,-,lance_bytes_masked,0 +csv,2-4,clustered,0.001,65536,and,8,-,lance_bytes_unmasked,148032 +csv,2-4,clustered,0.001,65536,and,8,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.001,65536,or,2,-,survivors,128 +csv,2-4,clustered,0.001,65536,or,2,hot,materialize_ns_per_word,3.933 +csv,2-4,clustered,0.001,65536,or,2,hot,count_ns_per_word,3.518 +csv,2-4,clustered,0.001,65536,or,2,hot,payload_ns_per_survivor,20.110 +csv,2-4,clustered,0.001,65536,or,2,-,payload_reads,128 +csv,2-4,clustered,0.001,65536,or,2,hot,fused_sum_ns_per_word,5.763 +csv,2-4,clustered,0.001,65536,or,2,hot,point_ns_per_query,9.254 +csv,2-4,clustered,0.001,65536,or,2,cold,materialize_ns_per_word,44.450 +csv,2-4,clustered,0.001,65536,or,2,cold,count_ns_per_word,54.146 +csv,2-4,clustered,0.001,65536,or,2,cold,payload_ns_per_survivor,69.625 +csv,2-4,clustered,0.001,65536,or,2,cold,fused_sum_ns_per_word,59.243 +csv,2-4,clustered,0.001,65536,or,2,cold,point_ns_per_query,19.194 +csv,2-4,clustered,0.001,65536,or,4,-,survivors,256 +csv,2-4,clustered,0.001,65536,or,4,hot,materialize_ns_per_word,5.545 +csv,2-4,clustered,0.001,65536,or,4,hot,count_ns_per_word,4.889 +csv,2-4,clustered,0.001,65536,or,4,hot,payload_ns_per_survivor,17.630 +csv,2-4,clustered,0.001,65536,or,4,-,payload_reads,256 +csv,2-4,clustered,0.001,65536,or,4,hot,fused_sum_ns_per_word,6.770 +csv,2-4,clustered,0.001,65536,or,4,hot,point_ns_per_query,11.036 +csv,2-4,clustered,0.001,65536,or,4,cold,materialize_ns_per_word,48.996 +csv,2-4,clustered,0.001,65536,or,4,cold,count_ns_per_word,63.922 +csv,2-4,clustered,0.001,65536,or,4,cold,payload_ns_per_survivor,75.391 +csv,2-4,clustered,0.001,65536,or,4,cold,fused_sum_ns_per_word,55.551 +csv,2-4,clustered,0.001,65536,or,4,cold,point_ns_per_query,22.982 +csv,2-4,clustered,0.001,65536,or,8,-,survivors,512 +csv,2-4,clustered,0.001,65536,or,8,hot,materialize_ns_per_word,9.087 +csv,2-4,clustered,0.001,65536,or,8,hot,count_ns_per_word,9.027 +csv,2-4,clustered,0.001,65536,or,8,hot,payload_ns_per_survivor,22.001 +csv,2-4,clustered,0.001,65536,or,8,-,payload_reads,512 +csv,2-4,clustered,0.001,65536,or,8,hot,fused_sum_ns_per_word,10.819 +csv,2-4,clustered,0.001,65536,or,8,hot,point_ns_per_query,15.036 +csv,2-4,clustered,0.001,65536,or,8,cold,materialize_ns_per_word,58.946 +csv,2-4,clustered,0.001,65536,or,8,cold,count_ns_per_word,70.606 +csv,2-4,clustered,0.001,65536,or,8,cold,payload_ns_per_survivor,88.096 +csv,2-4,clustered,0.001,65536,or,8,cold,fused_sum_ns_per_word,72.408 +csv,2-4,clustered,0.001,65536,or,8,cold,point_ns_per_query,35.838 +csv,2-4,clustered,0.01,1024,and,1,-,survivors,0 +csv,2-4,clustered,0.01,1024,and,1,hot,materialize_ns_per_word,2.160 +csv,2-4,clustered,0.01,1024,and,1,hot,count_ns_per_word,1.911 +csv,2-4,clustered,0.01,1024,and,1,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.01,1024,and,1,-,payload_reads,0 +csv,2-4,clustered,0.01,1024,and,1,hot,fused_sum_ns_per_word,3.415 +csv,2-4,clustered,0.01,1024,and,1,hot,point_ns_per_query,8.453 +csv,2-4,clustered,0.01,1024,and,1,cold,materialize_ns_per_word,35.688 +csv,2-4,clustered,0.01,1024,and,1,cold,count_ns_per_word,44.422 +csv,2-4,clustered,0.01,1024,and,1,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.01,1024,and,1,cold,fused_sum_ns_per_word,47.891 +csv,2-4,clustered,0.01,1024,and,1,cold,point_ns_per_query,14.442 +csv,2-4,clustered,0.01,1024,and,1,-,lance_rows_returned,0 +csv,2-4,clustered,0.01,1024,and,1,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.01,1024,and,1,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.01,1024,and,1,-,lance_bytes_masked,0 +csv,2-4,clustered,0.01,1024,and,1,-,lance_bytes_unmasked,129266 +csv,2-4,clustered,0.01,1024,and,1,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.01,1024,and,2,-,survivors,0 +csv,2-4,clustered,0.01,1024,and,2,hot,materialize_ns_per_word,2.172 +csv,2-4,clustered,0.01,1024,and,2,hot,count_ns_per_word,1.963 +csv,2-4,clustered,0.01,1024,and,2,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.01,1024,and,2,-,payload_reads,0 +csv,2-4,clustered,0.01,1024,and,2,hot,fused_sum_ns_per_word,3.677 +csv,2-4,clustered,0.01,1024,and,2,hot,point_ns_per_query,8.490 +csv,2-4,clustered,0.01,1024,and,2,cold,materialize_ns_per_word,39.519 +csv,2-4,clustered,0.01,1024,and,2,cold,count_ns_per_word,41.376 +csv,2-4,clustered,0.01,1024,and,2,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.01,1024,and,2,cold,fused_sum_ns_per_word,38.884 +csv,2-4,clustered,0.01,1024,and,2,cold,point_ns_per_query,13.561 +csv,2-4,clustered,0.01,1024,and,2,-,lance_rows_returned,0 +csv,2-4,clustered,0.01,1024,and,2,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.01,1024,and,2,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.01,1024,and,2,-,lance_bytes_masked,0 +csv,2-4,clustered,0.01,1024,and,2,-,lance_bytes_unmasked,138304 +csv,2-4,clustered,0.01,1024,and,2,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.01,1024,and,4,-,survivors,0 +csv,2-4,clustered,0.01,1024,and,4,hot,materialize_ns_per_word,3.283 +csv,2-4,clustered,0.01,1024,and,4,hot,count_ns_per_word,3.040 +csv,2-4,clustered,0.01,1024,and,4,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.01,1024,and,4,-,payload_reads,0 +csv,2-4,clustered,0.01,1024,and,4,hot,fused_sum_ns_per_word,5.514 +csv,2-4,clustered,0.01,1024,and,4,hot,point_ns_per_query,8.551 +csv,2-4,clustered,0.01,1024,and,4,cold,materialize_ns_per_word,40.374 +csv,2-4,clustered,0.01,1024,and,4,cold,count_ns_per_word,54.463 +csv,2-4,clustered,0.01,1024,and,4,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.01,1024,and,4,cold,fused_sum_ns_per_word,51.986 +csv,2-4,clustered,0.01,1024,and,4,cold,point_ns_per_query,15.232 +csv,2-4,clustered,0.01,1024,and,4,-,lance_rows_returned,0 +csv,2-4,clustered,0.01,1024,and,4,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.01,1024,and,4,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.01,1024,and,4,-,lance_bytes_masked,0 +csv,2-4,clustered,0.01,1024,and,4,-,lance_bytes_unmasked,144384 +csv,2-4,clustered,0.01,1024,and,4,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.01,1024,and,8,-,survivors,0 +csv,2-4,clustered,0.01,1024,and,8,hot,materialize_ns_per_word,6.846 +csv,2-4,clustered,0.01,1024,and,8,hot,count_ns_per_word,6.088 +csv,2-4,clustered,0.01,1024,and,8,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.01,1024,and,8,-,payload_reads,0 +csv,2-4,clustered,0.01,1024,and,8,hot,fused_sum_ns_per_word,7.090 +csv,2-4,clustered,0.01,1024,and,8,hot,point_ns_per_query,8.667 +csv,2-4,clustered,0.01,1024,and,8,cold,materialize_ns_per_word,57.576 +csv,2-4,clustered,0.01,1024,and,8,cold,count_ns_per_word,68.097 +csv,2-4,clustered,0.01,1024,and,8,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.01,1024,and,8,cold,fused_sum_ns_per_word,68.130 +csv,2-4,clustered,0.01,1024,and,8,cold,point_ns_per_query,15.515 +csv,2-4,clustered,0.01,1024,and,8,-,lance_rows_returned,0 +csv,2-4,clustered,0.01,1024,and,8,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.01,1024,and,8,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.01,1024,and,8,-,lance_bytes_masked,0 +csv,2-4,clustered,0.01,1024,and,8,-,lance_bytes_unmasked,164736 +csv,2-4,clustered,0.01,1024,and,8,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.01,1024,or,2,-,survivors,64 +csv,2-4,clustered,0.01,1024,or,2,hot,materialize_ns_per_word,3.662 +csv,2-4,clustered,0.01,1024,or,2,hot,count_ns_per_word,3.538 +csv,2-4,clustered,0.01,1024,or,2,hot,payload_ns_per_survivor,32.427 +csv,2-4,clustered,0.01,1024,or,2,-,payload_reads,64 +csv,2-4,clustered,0.01,1024,or,2,hot,fused_sum_ns_per_word,5.980 +csv,2-4,clustered,0.01,1024,or,2,hot,point_ns_per_query,8.486 +csv,2-4,clustered,0.01,1024,or,2,cold,materialize_ns_per_word,40.335 +csv,2-4,clustered,0.01,1024,or,2,cold,count_ns_per_word,48.305 +csv,2-4,clustered,0.01,1024,or,2,cold,payload_ns_per_survivor,110.469 +csv,2-4,clustered,0.01,1024,or,2,cold,fused_sum_ns_per_word,58.823 +csv,2-4,clustered,0.01,1024,or,2,cold,point_ns_per_query,14.699 +csv,2-4,clustered,0.01,1024,or,4,-,survivors,64 +csv,2-4,clustered,0.01,1024,or,4,hot,materialize_ns_per_word,4.746 +csv,2-4,clustered,0.01,1024,or,4,hot,count_ns_per_word,4.769 +csv,2-4,clustered,0.01,1024,or,4,hot,payload_ns_per_survivor,37.108 +csv,2-4,clustered,0.01,1024,or,4,-,payload_reads,64 +csv,2-4,clustered,0.01,1024,or,4,hot,fused_sum_ns_per_word,6.729 +csv,2-4,clustered,0.01,1024,or,4,hot,point_ns_per_query,8.239 +csv,2-4,clustered,0.01,1024,or,4,cold,materialize_ns_per_word,43.697 +csv,2-4,clustered,0.01,1024,or,4,cold,count_ns_per_word,64.780 +csv,2-4,clustered,0.01,1024,or,4,cold,payload_ns_per_survivor,138.219 +csv,2-4,clustered,0.01,1024,or,4,cold,fused_sum_ns_per_word,68.282 +csv,2-4,clustered,0.01,1024,or,4,cold,point_ns_per_query,15.886 +csv,2-4,clustered,0.01,1024,or,8,-,survivors,64 +csv,2-4,clustered,0.01,1024,or,8,hot,materialize_ns_per_word,9.397 +csv,2-4,clustered,0.01,1024,or,8,hot,count_ns_per_word,8.888 +csv,2-4,clustered,0.01,1024,or,8,hot,payload_ns_per_survivor,43.681 +csv,2-4,clustered,0.01,1024,or,8,-,payload_reads,64 +csv,2-4,clustered,0.01,1024,or,8,hot,fused_sum_ns_per_word,10.266 +csv,2-4,clustered,0.01,1024,or,8,hot,point_ns_per_query,8.663 +csv,2-4,clustered,0.01,1024,or,8,cold,materialize_ns_per_word,58.875 +csv,2-4,clustered,0.01,1024,or,8,cold,count_ns_per_word,68.579 +csv,2-4,clustered,0.01,1024,or,8,cold,payload_ns_per_survivor,160.062 +csv,2-4,clustered,0.01,1024,or,8,cold,fused_sum_ns_per_word,70.599 +csv,2-4,clustered,0.01,1024,or,8,cold,point_ns_per_query,16.666 +csv,2-4,clustered,0.01,8192,and,1,-,survivors,64 +csv,2-4,clustered,0.01,8192,and,1,hot,materialize_ns_per_word,2.125 +csv,2-4,clustered,0.01,8192,and,1,hot,count_ns_per_word,1.781 +csv,2-4,clustered,0.01,8192,and,1,hot,payload_ns_per_survivor,31.196 +csv,2-4,clustered,0.01,8192,and,1,-,payload_reads,64 +csv,2-4,clustered,0.01,8192,and,1,hot,fused_sum_ns_per_word,3.324 +csv,2-4,clustered,0.01,8192,and,1,hot,point_ns_per_query,8.820 +csv,2-4,clustered,0.01,8192,and,1,cold,materialize_ns_per_word,36.856 +csv,2-4,clustered,0.01,8192,and,1,cold,count_ns_per_word,46.122 +csv,2-4,clustered,0.01,8192,and,1,cold,payload_ns_per_survivor,99.906 +csv,2-4,clustered,0.01,8192,and,1,cold,fused_sum_ns_per_word,49.181 +csv,2-4,clustered,0.01,8192,and,1,cold,point_ns_per_query,16.017 +csv,2-4,clustered,0.01,8192,and,1,-,lance_rows_returned,64 +csv,2-4,clustered,0.01,8192,and,1,-,lance_rows_scanned_masked,64 +csv,2-4,clustered,0.01,8192,and,1,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.01,8192,and,1,-,lance_bytes_masked,2112 +csv,2-4,clustered,0.01,8192,and,1,-,lance_bytes_unmasked,129266 +csv,2-4,clustered,0.01,8192,and,1,-,lance_ns_per_survivor_wall,51472.1 +csv,2-4,clustered,0.01,8192,and,2,-,survivors,0 +csv,2-4,clustered,0.01,8192,and,2,hot,materialize_ns_per_word,2.474 +csv,2-4,clustered,0.01,8192,and,2,hot,count_ns_per_word,2.339 +csv,2-4,clustered,0.01,8192,and,2,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.01,8192,and,2,-,payload_reads,0 +csv,2-4,clustered,0.01,8192,and,2,hot,fused_sum_ns_per_word,3.768 +csv,2-4,clustered,0.01,8192,and,2,hot,point_ns_per_query,8.494 +csv,2-4,clustered,0.01,8192,and,2,cold,materialize_ns_per_word,40.841 +csv,2-4,clustered,0.01,8192,and,2,cold,count_ns_per_word,47.813 +csv,2-4,clustered,0.01,8192,and,2,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.01,8192,and,2,cold,fused_sum_ns_per_word,50.774 +csv,2-4,clustered,0.01,8192,and,2,cold,point_ns_per_query,17.107 +csv,2-4,clustered,0.01,8192,and,2,-,lance_rows_returned,0 +csv,2-4,clustered,0.01,8192,and,2,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.01,8192,and,2,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.01,8192,and,2,-,lance_bytes_masked,0 +csv,2-4,clustered,0.01,8192,and,2,-,lance_bytes_unmasked,138304 +csv,2-4,clustered,0.01,8192,and,2,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.01,8192,and,4,-,survivors,0 +csv,2-4,clustered,0.01,8192,and,4,hot,materialize_ns_per_word,3.350 +csv,2-4,clustered,0.01,8192,and,4,hot,count_ns_per_word,3.073 +csv,2-4,clustered,0.01,8192,and,4,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.01,8192,and,4,-,payload_reads,0 +csv,2-4,clustered,0.01,8192,and,4,hot,fused_sum_ns_per_word,4.766 +csv,2-4,clustered,0.01,8192,and,4,hot,point_ns_per_query,8.529 +csv,2-4,clustered,0.01,8192,and,4,cold,materialize_ns_per_word,39.419 +csv,2-4,clustered,0.01,8192,and,4,cold,count_ns_per_word,51.942 +csv,2-4,clustered,0.01,8192,and,4,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.01,8192,and,4,cold,fused_sum_ns_per_word,57.282 +csv,2-4,clustered,0.01,8192,and,4,cold,point_ns_per_query,19.507 +csv,2-4,clustered,0.01,8192,and,4,-,lance_rows_returned,0 +csv,2-4,clustered,0.01,8192,and,4,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.01,8192,and,4,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.01,8192,and,4,-,lance_bytes_masked,0 +csv,2-4,clustered,0.01,8192,and,4,-,lance_bytes_unmasked,144384 +csv,2-4,clustered,0.01,8192,and,4,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.01,8192,and,8,-,survivors,0 +csv,2-4,clustered,0.01,8192,and,8,hot,materialize_ns_per_word,6.104 +csv,2-4,clustered,0.01,8192,and,8,hot,count_ns_per_word,6.571 +csv,2-4,clustered,0.01,8192,and,8,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.01,8192,and,8,-,payload_reads,0 +csv,2-4,clustered,0.01,8192,and,8,hot,fused_sum_ns_per_word,7.661 +csv,2-4,clustered,0.01,8192,and,8,hot,point_ns_per_query,9.152 +csv,2-4,clustered,0.01,8192,and,8,cold,materialize_ns_per_word,49.535 +csv,2-4,clustered,0.01,8192,and,8,cold,count_ns_per_word,62.123 +csv,2-4,clustered,0.01,8192,and,8,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.01,8192,and,8,cold,fused_sum_ns_per_word,64.539 +csv,2-4,clustered,0.01,8192,and,8,cold,point_ns_per_query,23.956 +csv,2-4,clustered,0.01,8192,and,8,-,lance_rows_returned,0 +csv,2-4,clustered,0.01,8192,and,8,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.01,8192,and,8,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.01,8192,and,8,-,lance_bytes_masked,0 +csv,2-4,clustered,0.01,8192,and,8,-,lance_bytes_unmasked,164736 +csv,2-4,clustered,0.01,8192,and,8,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.01,8192,or,2,-,survivors,256 +csv,2-4,clustered,0.01,8192,or,2,hot,materialize_ns_per_word,4.366 +csv,2-4,clustered,0.01,8192,or,2,hot,count_ns_per_word,3.396 +csv,2-4,clustered,0.01,8192,or,2,hot,payload_ns_per_survivor,14.544 +csv,2-4,clustered,0.01,8192,or,2,-,payload_reads,256 +csv,2-4,clustered,0.01,8192,or,2,hot,fused_sum_ns_per_word,5.447 +csv,2-4,clustered,0.01,8192,or,2,hot,point_ns_per_query,8.491 +csv,2-4,clustered,0.01,8192,or,2,cold,materialize_ns_per_word,47.904 +csv,2-4,clustered,0.01,8192,or,2,cold,count_ns_per_word,56.211 +csv,2-4,clustered,0.01,8192,or,2,cold,payload_ns_per_survivor,52.773 +csv,2-4,clustered,0.01,8192,or,2,cold,fused_sum_ns_per_word,63.279 +csv,2-4,clustered,0.01,8192,or,2,cold,point_ns_per_query,18.394 +csv,2-4,clustered,0.01,8192,or,4,-,survivors,320 +csv,2-4,clustered,0.01,8192,or,4,hot,materialize_ns_per_word,4.817 +csv,2-4,clustered,0.01,8192,or,4,hot,count_ns_per_word,4.784 +csv,2-4,clustered,0.01,8192,or,4,hot,payload_ns_per_survivor,16.535 +csv,2-4,clustered,0.01,8192,or,4,-,payload_reads,320 +csv,2-4,clustered,0.01,8192,or,4,hot,fused_sum_ns_per_word,6.939 +csv,2-4,clustered,0.01,8192,or,4,hot,point_ns_per_query,8.628 +csv,2-4,clustered,0.01,8192,or,4,cold,materialize_ns_per_word,51.754 +csv,2-4,clustered,0.01,8192,or,4,cold,count_ns_per_word,60.371 +csv,2-4,clustered,0.01,8192,or,4,cold,payload_ns_per_survivor,66.266 +csv,2-4,clustered,0.01,8192,or,4,cold,fused_sum_ns_per_word,65.432 +csv,2-4,clustered,0.01,8192,or,4,cold,point_ns_per_query,19.765 +csv,2-4,clustered,0.01,8192,or,8,-,survivors,448 +csv,2-4,clustered,0.01,8192,or,8,hot,materialize_ns_per_word,8.757 +csv,2-4,clustered,0.01,8192,or,8,hot,count_ns_per_word,8.645 +csv,2-4,clustered,0.01,8192,or,8,hot,payload_ns_per_survivor,22.507 +csv,2-4,clustered,0.01,8192,or,8,-,payload_reads,448 +csv,2-4,clustered,0.01,8192,or,8,hot,fused_sum_ns_per_word,11.906 +csv,2-4,clustered,0.01,8192,or,8,hot,point_ns_per_query,8.756 +csv,2-4,clustered,0.01,8192,or,8,cold,materialize_ns_per_word,57.319 +csv,2-4,clustered,0.01,8192,or,8,cold,count_ns_per_word,70.094 +csv,2-4,clustered,0.01,8192,or,8,cold,payload_ns_per_survivor,112.708 +csv,2-4,clustered,0.01,8192,or,8,cold,fused_sum_ns_per_word,70.277 +csv,2-4,clustered,0.01,8192,or,8,cold,point_ns_per_query,22.121 +csv,2-4,clustered,0.01,65536,and,1,-,survivors,640 +csv,2-4,clustered,0.01,65536,and,1,hot,materialize_ns_per_word,2.146 +csv,2-4,clustered,0.01,65536,and,1,hot,count_ns_per_word,1.766 +csv,2-4,clustered,0.01,65536,and,1,hot,payload_ns_per_survivor,8.596 +csv,2-4,clustered,0.01,65536,and,1,-,payload_reads,640 +csv,2-4,clustered,0.01,65536,and,1,hot,fused_sum_ns_per_word,3.888 +csv,2-4,clustered,0.01,65536,and,1,hot,point_ns_per_query,8.406 +csv,2-4,clustered,0.01,65536,and,1,cold,materialize_ns_per_word,31.646 +csv,2-4,clustered,0.01,65536,and,1,cold,count_ns_per_word,42.029 +csv,2-4,clustered,0.01,65536,and,1,cold,payload_ns_per_survivor,30.570 +csv,2-4,clustered,0.01,65536,and,1,cold,fused_sum_ns_per_word,39.858 +csv,2-4,clustered,0.01,65536,and,1,cold,point_ns_per_query,16.476 +csv,2-4,clustered,0.01,65536,and,1,-,lance_rows_returned,640 +csv,2-4,clustered,0.01,65536,and,1,-,lance_rows_scanned_masked,640 +csv,2-4,clustered,0.01,65536,and,1,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.01,65536,and,1,-,lance_bytes_masked,24656 +csv,2-4,clustered,0.01,65536,and,1,-,lance_bytes_unmasked,129266 +csv,2-4,clustered,0.01,65536,and,1,-,lance_ns_per_survivor_wall,3520.6 +csv,2-4,clustered,0.01,65536,and,2,-,survivors,0 +csv,2-4,clustered,0.01,65536,and,2,hot,materialize_ns_per_word,2.402 +csv,2-4,clustered,0.01,65536,and,2,hot,count_ns_per_word,2.346 +csv,2-4,clustered,0.01,65536,and,2,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.01,65536,and,2,-,payload_reads,0 +csv,2-4,clustered,0.01,65536,and,2,hot,fused_sum_ns_per_word,3.581 +csv,2-4,clustered,0.01,65536,and,2,hot,point_ns_per_query,8.848 +csv,2-4,clustered,0.01,65536,and,2,cold,materialize_ns_per_word,43.011 +csv,2-4,clustered,0.01,65536,and,2,cold,count_ns_per_word,46.793 +csv,2-4,clustered,0.01,65536,and,2,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.01,65536,and,2,cold,fused_sum_ns_per_word,51.118 +csv,2-4,clustered,0.01,65536,and,2,cold,point_ns_per_query,20.788 +csv,2-4,clustered,0.01,65536,and,2,-,lance_rows_returned,0 +csv,2-4,clustered,0.01,65536,and,2,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.01,65536,and,2,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.01,65536,and,2,-,lance_bytes_masked,0 +csv,2-4,clustered,0.01,65536,and,2,-,lance_bytes_unmasked,138304 +csv,2-4,clustered,0.01,65536,and,2,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.01,65536,and,4,-,survivors,0 +csv,2-4,clustered,0.01,65536,and,4,hot,materialize_ns_per_word,3.079 +csv,2-4,clustered,0.01,65536,and,4,hot,count_ns_per_word,3.041 +csv,2-4,clustered,0.01,65536,and,4,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.01,65536,and,4,-,payload_reads,0 +csv,2-4,clustered,0.01,65536,and,4,hot,fused_sum_ns_per_word,4.593 +csv,2-4,clustered,0.01,65536,and,4,hot,point_ns_per_query,11.353 +csv,2-4,clustered,0.01,65536,and,4,cold,materialize_ns_per_word,43.182 +csv,2-4,clustered,0.01,65536,and,4,cold,count_ns_per_word,53.502 +csv,2-4,clustered,0.01,65536,and,4,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.01,65536,and,4,cold,fused_sum_ns_per_word,57.427 +csv,2-4,clustered,0.01,65536,and,4,cold,point_ns_per_query,32.225 +csv,2-4,clustered,0.01,65536,and,4,-,lance_rows_returned,0 +csv,2-4,clustered,0.01,65536,and,4,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.01,65536,and,4,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.01,65536,and,4,-,lance_bytes_masked,0 +csv,2-4,clustered,0.01,65536,and,4,-,lance_bytes_unmasked,144384 +csv,2-4,clustered,0.01,65536,and,4,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.01,65536,and,8,-,survivors,0 +csv,2-4,clustered,0.01,65536,and,8,hot,materialize_ns_per_word,7.632 +csv,2-4,clustered,0.01,65536,and,8,hot,count_ns_per_word,6.229 +csv,2-4,clustered,0.01,65536,and,8,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.01,65536,and,8,-,payload_reads,0 +csv,2-4,clustered,0.01,65536,and,8,hot,fused_sum_ns_per_word,8.586 +csv,2-4,clustered,0.01,65536,and,8,hot,point_ns_per_query,27.075 +csv,2-4,clustered,0.01,65536,and,8,cold,materialize_ns_per_word,54.946 +csv,2-4,clustered,0.01,65536,and,8,cold,count_ns_per_word,61.373 +csv,2-4,clustered,0.01,65536,and,8,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.01,65536,and,8,cold,fused_sum_ns_per_word,64.834 +csv,2-4,clustered,0.01,65536,and,8,cold,point_ns_per_query,70.201 +csv,2-4,clustered,0.01,65536,and,8,-,lance_rows_returned,0 +csv,2-4,clustered,0.01,65536,and,8,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.01,65536,and,8,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.01,65536,and,8,-,lance_bytes_masked,0 +csv,2-4,clustered,0.01,65536,and,8,-,lance_bytes_unmasked,164736 +csv,2-4,clustered,0.01,65536,and,8,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.01,65536,or,2,-,survivors,1280 +csv,2-4,clustered,0.01,65536,or,2,hot,materialize_ns_per_word,3.610 +csv,2-4,clustered,0.01,65536,or,2,hot,count_ns_per_word,3.396 +csv,2-4,clustered,0.01,65536,or,2,hot,payload_ns_per_survivor,9.643 +csv,2-4,clustered,0.01,65536,or,2,-,payload_reads,1280 +csv,2-4,clustered,0.01,65536,or,2,hot,fused_sum_ns_per_word,6.623 +csv,2-4,clustered,0.01,65536,or,2,hot,point_ns_per_query,8.544 +csv,2-4,clustered,0.01,65536,or,2,cold,materialize_ns_per_word,42.400 +csv,2-4,clustered,0.01,65536,or,2,cold,count_ns_per_word,55.212 +csv,2-4,clustered,0.01,65536,or,2,cold,payload_ns_per_survivor,37.356 +csv,2-4,clustered,0.01,65536,or,2,cold,fused_sum_ns_per_word,63.407 +csv,2-4,clustered,0.01,65536,or,2,cold,point_ns_per_query,20.615 +csv,2-4,clustered,0.01,65536,or,4,-,survivors,2496 +csv,2-4,clustered,0.01,65536,or,4,hot,materialize_ns_per_word,5.143 +csv,2-4,clustered,0.01,65536,or,4,hot,count_ns_per_word,4.720 +csv,2-4,clustered,0.01,65536,or,4,hot,payload_ns_per_survivor,13.205 +csv,2-4,clustered,0.01,65536,or,4,-,payload_reads,2560 +csv,2-4,clustered,0.01,65536,or,4,hot,fused_sum_ns_per_word,11.128 +csv,2-4,clustered,0.01,65536,or,4,hot,point_ns_per_query,11.432 +csv,2-4,clustered,0.01,65536,or,4,cold,materialize_ns_per_word,53.252 +csv,2-4,clustered,0.01,65536,or,4,cold,count_ns_per_word,60.521 +csv,2-4,clustered,0.01,65536,or,4,cold,payload_ns_per_survivor,31.115 +csv,2-4,clustered,0.01,65536,or,4,cold,fused_sum_ns_per_word,78.068 +csv,2-4,clustered,0.01,65536,or,4,cold,point_ns_per_query,31.816 +csv,2-4,clustered,0.01,65536,or,8,-,survivors,4800 +csv,2-4,clustered,0.01,65536,or,8,hot,materialize_ns_per_word,9.200 +csv,2-4,clustered,0.01,65536,or,8,hot,count_ns_per_word,8.730 +csv,2-4,clustered,0.01,65536,or,8,hot,payload_ns_per_survivor,19.012 +csv,2-4,clustered,0.01,65536,or,8,-,payload_reads,5120 +csv,2-4,clustered,0.01,65536,or,8,hot,fused_sum_ns_per_word,15.192 +csv,2-4,clustered,0.01,65536,or,8,hot,point_ns_per_query,14.879 +csv,2-4,clustered,0.01,65536,or,8,cold,materialize_ns_per_word,63.623 +csv,2-4,clustered,0.01,65536,or,8,cold,count_ns_per_word,70.774 +csv,2-4,clustered,0.01,65536,or,8,cold,payload_ns_per_survivor,33.530 +csv,2-4,clustered,0.01,65536,or,8,cold,fused_sum_ns_per_word,104.377 +csv,2-4,clustered,0.01,65536,or,8,cold,point_ns_per_query,49.675 +csv,2-4,clustered,0.1,1024,and,1,-,survivors,0 +csv,2-4,clustered,0.1,1024,and,1,hot,materialize_ns_per_word,2.252 +csv,2-4,clustered,0.1,1024,and,1,hot,count_ns_per_word,1.876 +csv,2-4,clustered,0.1,1024,and,1,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.1,1024,and,1,-,payload_reads,0 +csv,2-4,clustered,0.1,1024,and,1,hot,fused_sum_ns_per_word,3.354 +csv,2-4,clustered,0.1,1024,and,1,hot,point_ns_per_query,8.444 +csv,2-4,clustered,0.1,1024,and,1,cold,materialize_ns_per_word,38.725 +csv,2-4,clustered,0.1,1024,and,1,cold,count_ns_per_word,54.490 +csv,2-4,clustered,0.1,1024,and,1,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.1,1024,and,1,cold,fused_sum_ns_per_word,53.066 +csv,2-4,clustered,0.1,1024,and,1,cold,point_ns_per_query,20.395 +csv,2-4,clustered,0.1,1024,and,1,-,lance_rows_returned,0 +csv,2-4,clustered,0.1,1024,and,1,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.1,1024,and,1,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.1,1024,and,1,-,lance_bytes_masked,0 +csv,2-4,clustered,0.1,1024,and,1,-,lance_bytes_unmasked,158747 +csv,2-4,clustered,0.1,1024,and,1,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.1,1024,and,2,-,survivors,0 +csv,2-4,clustered,0.1,1024,and,2,hot,materialize_ns_per_word,2.133 +csv,2-4,clustered,0.1,1024,and,2,hot,count_ns_per_word,1.959 +csv,2-4,clustered,0.1,1024,and,2,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.1,1024,and,2,-,payload_reads,0 +csv,2-4,clustered,0.1,1024,and,2,hot,fused_sum_ns_per_word,3.587 +csv,2-4,clustered,0.1,1024,and,2,hot,point_ns_per_query,8.527 +csv,2-4,clustered,0.1,1024,and,2,cold,materialize_ns_per_word,31.155 +csv,2-4,clustered,0.1,1024,and,2,cold,count_ns_per_word,40.055 +csv,2-4,clustered,0.1,1024,and,2,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.1,1024,and,2,cold,fused_sum_ns_per_word,53.516 +csv,2-4,clustered,0.1,1024,and,2,cold,point_ns_per_query,14.667 +csv,2-4,clustered,0.1,1024,and,2,-,lance_rows_returned,0 +csv,2-4,clustered,0.1,1024,and,2,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.1,1024,and,2,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.1,1024,and,2,-,lance_bytes_masked,0 +csv,2-4,clustered,0.1,1024,and,2,-,lance_bytes_unmasked,197296 +csv,2-4,clustered,0.1,1024,and,2,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.1,1024,and,4,-,survivors,0 +csv,2-4,clustered,0.1,1024,and,4,hot,materialize_ns_per_word,3.056 +csv,2-4,clustered,0.1,1024,and,4,hot,count_ns_per_word,3.020 +csv,2-4,clustered,0.1,1024,and,4,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.1,1024,and,4,-,payload_reads,0 +csv,2-4,clustered,0.1,1024,and,4,hot,fused_sum_ns_per_word,4.859 +csv,2-4,clustered,0.1,1024,and,4,hot,point_ns_per_query,8.555 +csv,2-4,clustered,0.1,1024,and,4,cold,materialize_ns_per_word,44.362 +csv,2-4,clustered,0.1,1024,and,4,cold,count_ns_per_word,49.815 +csv,2-4,clustered,0.1,1024,and,4,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.1,1024,and,4,cold,fused_sum_ns_per_word,55.594 +csv,2-4,clustered,0.1,1024,and,4,cold,point_ns_per_query,14.940 +csv,2-4,clustered,0.1,1024,and,4,-,lance_rows_returned,0 +csv,2-4,clustered,0.1,1024,and,4,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.1,1024,and,4,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.1,1024,and,4,-,lance_bytes_masked,0 +csv,2-4,clustered,0.1,1024,and,4,-,lance_bytes_unmasked,262352 +csv,2-4,clustered,0.1,1024,and,4,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.1,1024,and,8,-,survivors,0 +csv,2-4,clustered,0.1,1024,and,8,hot,materialize_ns_per_word,6.521 +csv,2-4,clustered,0.1,1024,and,8,hot,count_ns_per_word,6.258 +csv,2-4,clustered,0.1,1024,and,8,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.1,1024,and,8,-,payload_reads,0 +csv,2-4,clustered,0.1,1024,and,8,hot,fused_sum_ns_per_word,7.286 +csv,2-4,clustered,0.1,1024,and,8,hot,point_ns_per_query,8.918 +csv,2-4,clustered,0.1,1024,and,8,cold,materialize_ns_per_word,49.467 +csv,2-4,clustered,0.1,1024,and,8,cold,count_ns_per_word,59.188 +csv,2-4,clustered,0.1,1024,and,8,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.1,1024,and,8,cold,fused_sum_ns_per_word,60.395 +csv,2-4,clustered,0.1,1024,and,8,cold,point_ns_per_query,17.846 +csv,2-4,clustered,0.1,1024,and,8,-,lance_rows_returned,0 +csv,2-4,clustered,0.1,1024,and,8,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.1,1024,and,8,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.1,1024,and,8,-,lance_bytes_masked,0 +csv,2-4,clustered,0.1,1024,and,8,-,lance_bytes_unmasked,400792 +csv,2-4,clustered,0.1,1024,and,8,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.1,1024,or,2,-,survivors,64 +csv,2-4,clustered,0.1,1024,or,2,hot,materialize_ns_per_word,3.577 +csv,2-4,clustered,0.1,1024,or,2,hot,count_ns_per_word,3.382 +csv,2-4,clustered,0.1,1024,or,2,hot,payload_ns_per_survivor,32.150 +csv,2-4,clustered,0.1,1024,or,2,-,payload_reads,64 +csv,2-4,clustered,0.1,1024,or,2,hot,fused_sum_ns_per_word,5.842 +csv,2-4,clustered,0.1,1024,or,2,hot,point_ns_per_query,8.486 +csv,2-4,clustered,0.1,1024,or,2,cold,materialize_ns_per_word,40.995 +csv,2-4,clustered,0.1,1024,or,2,cold,count_ns_per_word,49.814 +csv,2-4,clustered,0.1,1024,or,2,cold,payload_ns_per_survivor,106.781 +csv,2-4,clustered,0.1,1024,or,2,cold,fused_sum_ns_per_word,64.557 +csv,2-4,clustered,0.1,1024,or,2,cold,point_ns_per_query,14.505 +csv,2-4,clustered,0.1,1024,or,4,-,survivors,128 +csv,2-4,clustered,0.1,1024,or,4,hot,materialize_ns_per_word,5.475 +csv,2-4,clustered,0.1,1024,or,4,hot,count_ns_per_word,5.473 +csv,2-4,clustered,0.1,1024,or,4,hot,payload_ns_per_survivor,24.498 +csv,2-4,clustered,0.1,1024,or,4,-,payload_reads,128 +csv,2-4,clustered,0.1,1024,or,4,hot,fused_sum_ns_per_word,7.219 +csv,2-4,clustered,0.1,1024,or,4,hot,point_ns_per_query,8.543 +csv,2-4,clustered,0.1,1024,or,4,cold,materialize_ns_per_word,44.607 +csv,2-4,clustered,0.1,1024,or,4,cold,count_ns_per_word,52.230 +csv,2-4,clustered,0.1,1024,or,4,cold,payload_ns_per_survivor,86.320 +csv,2-4,clustered,0.1,1024,or,4,cold,fused_sum_ns_per_word,76.524 +csv,2-4,clustered,0.1,1024,or,4,cold,point_ns_per_query,17.893 +csv,2-4,clustered,0.1,1024,or,8,-,survivors,512 +csv,2-4,clustered,0.1,1024,or,8,hot,materialize_ns_per_word,9.363 +csv,2-4,clustered,0.1,1024,or,8,hot,count_ns_per_word,8.870 +csv,2-4,clustered,0.1,1024,or,8,hot,payload_ns_per_survivor,22.484 +csv,2-4,clustered,0.1,1024,or,8,-,payload_reads,640 +csv,2-4,clustered,0.1,1024,or,8,hot,fused_sum_ns_per_word,10.744 +csv,2-4,clustered,0.1,1024,or,8,hot,point_ns_per_query,8.623 +csv,2-4,clustered,0.1,1024,or,8,cold,materialize_ns_per_word,65.739 +csv,2-4,clustered,0.1,1024,or,8,cold,count_ns_per_word,79.042 +csv,2-4,clustered,0.1,1024,or,8,cold,payload_ns_per_survivor,87.936 +csv,2-4,clustered,0.1,1024,or,8,cold,fused_sum_ns_per_word,79.863 +csv,2-4,clustered,0.1,1024,or,8,cold,point_ns_per_query,19.485 +csv,2-4,clustered,0.1,8192,and,1,-,survivors,640 +csv,2-4,clustered,0.1,8192,and,1,hot,materialize_ns_per_word,2.524 +csv,2-4,clustered,0.1,8192,and,1,hot,count_ns_per_word,1.805 +csv,2-4,clustered,0.1,8192,and,1,hot,payload_ns_per_survivor,8.554 +csv,2-4,clustered,0.1,8192,and,1,-,payload_reads,640 +csv,2-4,clustered,0.1,8192,and,1,hot,fused_sum_ns_per_word,3.919 +csv,2-4,clustered,0.1,8192,and,1,hot,point_ns_per_query,8.602 +csv,2-4,clustered,0.1,8192,and,1,cold,materialize_ns_per_word,40.308 +csv,2-4,clustered,0.1,8192,and,1,cold,count_ns_per_word,47.199 +csv,2-4,clustered,0.1,8192,and,1,cold,payload_ns_per_survivor,31.484 +csv,2-4,clustered,0.1,8192,and,1,cold,fused_sum_ns_per_word,50.477 +csv,2-4,clustered,0.1,8192,and,1,cold,point_ns_per_query,25.223 +csv,2-4,clustered,0.1,8192,and,1,-,lance_rows_returned,640 +csv,2-4,clustered,0.1,8192,and,1,-,lance_rows_scanned_masked,640 +csv,2-4,clustered,0.1,8192,and,1,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.1,8192,and,1,-,lance_bytes_masked,14680 +csv,2-4,clustered,0.1,8192,and,1,-,lance_bytes_unmasked,158747 +csv,2-4,clustered,0.1,8192,and,1,-,lance_ns_per_survivor_wall,3258.8 +csv,2-4,clustered,0.1,8192,and,2,-,survivors,0 +csv,2-4,clustered,0.1,8192,and,2,hot,materialize_ns_per_word,2.255 +csv,2-4,clustered,0.1,8192,and,2,hot,count_ns_per_word,2.075 +csv,2-4,clustered,0.1,8192,and,2,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.1,8192,and,2,-,payload_reads,0 +csv,2-4,clustered,0.1,8192,and,2,hot,fused_sum_ns_per_word,3.685 +csv,2-4,clustered,0.1,8192,and,2,hot,point_ns_per_query,8.422 +csv,2-4,clustered,0.1,8192,and,2,cold,materialize_ns_per_word,41.508 +csv,2-4,clustered,0.1,8192,and,2,cold,count_ns_per_word,48.370 +csv,2-4,clustered,0.1,8192,and,2,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.1,8192,and,2,cold,fused_sum_ns_per_word,49.529 +csv,2-4,clustered,0.1,8192,and,2,cold,point_ns_per_query,21.403 +csv,2-4,clustered,0.1,8192,and,2,-,lance_rows_returned,0 +csv,2-4,clustered,0.1,8192,and,2,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.1,8192,and,2,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.1,8192,and,2,-,lance_bytes_masked,0 +csv,2-4,clustered,0.1,8192,and,2,-,lance_bytes_unmasked,197296 +csv,2-4,clustered,0.1,8192,and,2,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.1,8192,and,4,-,survivors,0 +csv,2-4,clustered,0.1,8192,and,4,hot,materialize_ns_per_word,3.169 +csv,2-4,clustered,0.1,8192,and,4,hot,count_ns_per_word,3.088 +csv,2-4,clustered,0.1,8192,and,4,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.1,8192,and,4,-,payload_reads,0 +csv,2-4,clustered,0.1,8192,and,4,hot,fused_sum_ns_per_word,4.862 +csv,2-4,clustered,0.1,8192,and,4,hot,point_ns_per_query,8.837 +csv,2-4,clustered,0.1,8192,and,4,cold,materialize_ns_per_word,46.341 +csv,2-4,clustered,0.1,8192,and,4,cold,count_ns_per_word,53.653 +csv,2-4,clustered,0.1,8192,and,4,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.1,8192,and,4,cold,fused_sum_ns_per_word,54.422 +csv,2-4,clustered,0.1,8192,and,4,cold,point_ns_per_query,23.953 +csv,2-4,clustered,0.1,8192,and,4,-,lance_rows_returned,0 +csv,2-4,clustered,0.1,8192,and,4,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.1,8192,and,4,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.1,8192,and,4,-,lance_bytes_masked,0 +csv,2-4,clustered,0.1,8192,and,4,-,lance_bytes_unmasked,262352 +csv,2-4,clustered,0.1,8192,and,4,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.1,8192,and,8,-,survivors,0 +csv,2-4,clustered,0.1,8192,and,8,hot,materialize_ns_per_word,6.246 +csv,2-4,clustered,0.1,8192,and,8,hot,count_ns_per_word,6.262 +csv,2-4,clustered,0.1,8192,and,8,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.1,8192,and,8,-,payload_reads,0 +csv,2-4,clustered,0.1,8192,and,8,hot,fused_sum_ns_per_word,7.754 +csv,2-4,clustered,0.1,8192,and,8,hot,point_ns_per_query,9.379 +csv,2-4,clustered,0.1,8192,and,8,cold,materialize_ns_per_word,58.181 +csv,2-4,clustered,0.1,8192,and,8,cold,count_ns_per_word,69.194 +csv,2-4,clustered,0.1,8192,and,8,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.1,8192,and,8,cold,fused_sum_ns_per_word,70.771 +csv,2-4,clustered,0.1,8192,and,8,cold,point_ns_per_query,45.146 +csv,2-4,clustered,0.1,8192,and,8,-,lance_rows_returned,0 +csv,2-4,clustered,0.1,8192,and,8,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.1,8192,and,8,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.1,8192,and,8,-,lance_bytes_masked,0 +csv,2-4,clustered,0.1,8192,and,8,-,lance_bytes_unmasked,400792 +csv,2-4,clustered,0.1,8192,and,8,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.1,8192,or,2,-,survivors,1408 +csv,2-4,clustered,0.1,8192,or,2,hot,materialize_ns_per_word,3.566 +csv,2-4,clustered,0.1,8192,or,2,hot,count_ns_per_word,3.780 +csv,2-4,clustered,0.1,8192,or,2,hot,payload_ns_per_survivor,9.165 +csv,2-4,clustered,0.1,8192,or,2,-,payload_reads,1408 +csv,2-4,clustered,0.1,8192,or,2,hot,fused_sum_ns_per_word,6.522 +csv,2-4,clustered,0.1,8192,or,2,hot,point_ns_per_query,8.331 +csv,2-4,clustered,0.1,8192,or,2,cold,materialize_ns_per_word,44.102 +csv,2-4,clustered,0.1,8192,or,2,cold,count_ns_per_word,48.293 +csv,2-4,clustered,0.1,8192,or,2,cold,payload_ns_per_survivor,40.278 +csv,2-4,clustered,0.1,8192,or,2,cold,fused_sum_ns_per_word,63.447 +csv,2-4,clustered,0.1,8192,or,2,cold,point_ns_per_query,20.032 +csv,2-4,clustered,0.1,8192,or,4,-,survivors,1984 +csv,2-4,clustered,0.1,8192,or,4,hot,materialize_ns_per_word,4.770 +csv,2-4,clustered,0.1,8192,or,4,hot,count_ns_per_word,4.838 +csv,2-4,clustered,0.1,8192,or,4,hot,payload_ns_per_survivor,12.799 +csv,2-4,clustered,0.1,8192,or,4,-,payload_reads,2304 +csv,2-4,clustered,0.1,8192,or,4,hot,fused_sum_ns_per_word,9.034 +csv,2-4,clustered,0.1,8192,or,4,hot,point_ns_per_query,8.671 +csv,2-4,clustered,0.1,8192,or,4,cold,materialize_ns_per_word,43.167 +csv,2-4,clustered,0.1,8192,or,4,cold,count_ns_per_word,54.704 +csv,2-4,clustered,0.1,8192,or,4,cold,payload_ns_per_survivor,36.855 +csv,2-4,clustered,0.1,8192,or,4,cold,fused_sum_ns_per_word,63.475 +csv,2-4,clustered,0.1,8192,or,4,cold,point_ns_per_query,23.171 +csv,2-4,clustered,0.1,8192,or,8,-,survivors,3904 +csv,2-4,clustered,0.1,8192,or,8,hot,materialize_ns_per_word,9.249 +csv,2-4,clustered,0.1,8192,or,8,hot,count_ns_per_word,9.404 +csv,2-4,clustered,0.1,8192,or,8,hot,payload_ns_per_survivor,19.393 +csv,2-4,clustered,0.1,8192,or,8,-,payload_reads,5248 +csv,2-4,clustered,0.1,8192,or,8,hot,fused_sum_ns_per_word,15.194 +csv,2-4,clustered,0.1,8192,or,8,hot,point_ns_per_query,9.162 +csv,2-4,clustered,0.1,8192,or,8,cold,materialize_ns_per_word,61.130 +csv,2-4,clustered,0.1,8192,or,8,cold,count_ns_per_word,77.770 +csv,2-4,clustered,0.1,8192,or,8,cold,payload_ns_per_survivor,36.166 +csv,2-4,clustered,0.1,8192,or,8,cold,fused_sum_ns_per_word,81.130 +csv,2-4,clustered,0.1,8192,or,8,cold,point_ns_per_query,31.322 +csv,2-4,clustered,0.1,65536,and,1,-,survivors,6528 +csv,2-4,clustered,0.1,65536,and,1,hot,materialize_ns_per_word,2.160 +csv,2-4,clustered,0.1,65536,and,1,hot,count_ns_per_word,1.815 +csv,2-4,clustered,0.1,65536,and,1,hot,payload_ns_per_survivor,6.783 +csv,2-4,clustered,0.1,65536,and,1,-,payload_reads,6528 +csv,2-4,clustered,0.1,65536,and,1,hot,fused_sum_ns_per_word,10.603 +csv,2-4,clustered,0.1,65536,and,1,hot,point_ns_per_query,8.572 +csv,2-4,clustered,0.1,65536,and,1,cold,materialize_ns_per_word,21.599 +csv,2-4,clustered,0.1,65536,and,1,cold,count_ns_per_word,22.896 +csv,2-4,clustered,0.1,65536,and,1,cold,payload_ns_per_survivor,13.311 +csv,2-4,clustered,0.1,65536,and,1,cold,fused_sum_ns_per_word,78.880 +csv,2-4,clustered,0.1,65536,and,1,cold,point_ns_per_query,27.312 +csv,2-4,clustered,0.1,65536,and,1,-,lance_rows_returned,6528 +csv,2-4,clustered,0.1,65536,and,1,-,lance_rows_scanned_masked,6528 +csv,2-4,clustered,0.1,65536,and,1,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.1,65536,and,1,-,lance_bytes_masked,157256 +csv,2-4,clustered,0.1,65536,and,1,-,lance_bytes_unmasked,158747 +csv,2-4,clustered,0.1,65536,and,1,-,lance_ns_per_survivor_wall,410.8 +csv,2-4,clustered,0.1,65536,and,2,-,survivors,704 +csv,2-4,clustered,0.1,65536,and,2,hot,materialize_ns_per_word,2.250 +csv,2-4,clustered,0.1,65536,and,2,hot,count_ns_per_word,2.163 +csv,2-4,clustered,0.1,65536,and,2,hot,payload_ns_per_survivor,12.816 +csv,2-4,clustered,0.1,65536,and,2,-,payload_reads,1408 +csv,2-4,clustered,0.1,65536,and,2,hot,fused_sum_ns_per_word,6.905 +csv,2-4,clustered,0.1,65536,and,2,hot,point_ns_per_query,7.843 +csv,2-4,clustered,0.1,65536,and,2,cold,materialize_ns_per_word,28.834 +csv,2-4,clustered,0.1,65536,and,2,cold,count_ns_per_word,25.246 +csv,2-4,clustered,0.1,65536,and,2,cold,payload_ns_per_survivor,58.712 +csv,2-4,clustered,0.1,65536,and,2,cold,fused_sum_ns_per_word,46.063 +csv,2-4,clustered,0.1,65536,and,2,cold,point_ns_per_query,41.708 +csv,2-4,clustered,0.1,65536,and,2,-,lance_rows_returned,704 +csv,2-4,clustered,0.1,65536,and,2,-,lance_rows_scanned_masked,704 +csv,2-4,clustered,0.1,65536,and,2,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.1,65536,and,2,-,lance_bytes_masked,58992 +csv,2-4,clustered,0.1,65536,and,2,-,lance_bytes_unmasked,197296 +csv,2-4,clustered,0.1,65536,and,2,-,lance_ns_per_survivor_wall,3298.8 +csv,2-4,clustered,0.1,65536,and,4,-,survivors,0 +csv,2-4,clustered,0.1,65536,and,4,hot,materialize_ns_per_word,2.996 +csv,2-4,clustered,0.1,65536,and,4,hot,count_ns_per_word,3.035 +csv,2-4,clustered,0.1,65536,and,4,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.1,65536,and,4,-,payload_reads,0 +csv,2-4,clustered,0.1,65536,and,4,hot,fused_sum_ns_per_word,5.370 +csv,2-4,clustered,0.1,65536,and,4,hot,point_ns_per_query,14.620 +csv,2-4,clustered,0.1,65536,and,4,cold,materialize_ns_per_word,37.066 +csv,2-4,clustered,0.1,65536,and,4,cold,count_ns_per_word,60.671 +csv,2-4,clustered,0.1,65536,and,4,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.1,65536,and,4,cold,fused_sum_ns_per_word,61.407 +csv,2-4,clustered,0.1,65536,and,4,cold,point_ns_per_query,70.288 +csv,2-4,clustered,0.1,65536,and,4,-,lance_rows_returned,0 +csv,2-4,clustered,0.1,65536,and,4,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.1,65536,and,4,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.1,65536,and,4,-,lance_bytes_masked,0 +csv,2-4,clustered,0.1,65536,and,4,-,lance_bytes_unmasked,262352 +csv,2-4,clustered,0.1,65536,and,4,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.1,65536,and,8,-,survivors,0 +csv,2-4,clustered,0.1,65536,and,8,hot,materialize_ns_per_word,6.956 +csv,2-4,clustered,0.1,65536,and,8,hot,count_ns_per_word,6.510 +csv,2-4,clustered,0.1,65536,and,8,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.1,65536,and,8,-,payload_reads,0 +csv,2-4,clustered,0.1,65536,and,8,hot,fused_sum_ns_per_word,7.916 +csv,2-4,clustered,0.1,65536,and,8,hot,point_ns_per_query,19.044 +csv,2-4,clustered,0.1,65536,and,8,cold,materialize_ns_per_word,48.654 +csv,2-4,clustered,0.1,65536,and,8,cold,count_ns_per_word,60.807 +csv,2-4,clustered,0.1,65536,and,8,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.1,65536,and,8,cold,fused_sum_ns_per_word,61.392 +csv,2-4,clustered,0.1,65536,and,8,cold,point_ns_per_query,110.353 +csv,2-4,clustered,0.1,65536,and,8,-,lance_rows_returned,0 +csv,2-4,clustered,0.1,65536,and,8,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.1,65536,and,8,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.1,65536,and,8,-,lance_bytes_masked,0 +csv,2-4,clustered,0.1,65536,and,8,-,lance_bytes_unmasked,400792 +csv,2-4,clustered,0.1,65536,and,8,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.1,65536,or,2,-,survivors,12352 +csv,2-4,clustered,0.1,65536,or,2,hot,materialize_ns_per_word,3.725 +csv,2-4,clustered,0.1,65536,or,2,hot,count_ns_per_word,4.256 +csv,2-4,clustered,0.1,65536,or,2,hot,payload_ns_per_survivor,9.179 +csv,2-4,clustered,0.1,65536,or,2,-,payload_reads,13056 +csv,2-4,clustered,0.1,65536,or,2,hot,fused_sum_ns_per_word,18.111 +csv,2-4,clustered,0.1,65536,or,2,hot,point_ns_per_query,9.227 +csv,2-4,clustered,0.1,65536,or,2,cold,materialize_ns_per_word,40.928 +csv,2-4,clustered,0.1,65536,or,2,cold,count_ns_per_word,49.106 +csv,2-4,clustered,0.1,65536,or,2,cold,payload_ns_per_survivor,14.338 +csv,2-4,clustered,0.1,65536,or,2,cold,fused_sum_ns_per_word,95.332 +csv,2-4,clustered,0.1,65536,or,2,cold,point_ns_per_query,41.916 +csv,2-4,clustered,0.1,65536,or,4,-,survivors,21824 +csv,2-4,clustered,0.1,65536,or,4,hot,materialize_ns_per_word,5.616 +csv,2-4,clustered,0.1,65536,or,4,hot,count_ns_per_word,5.032 +csv,2-4,clustered,0.1,65536,or,4,hot,payload_ns_per_survivor,12.772 +csv,2-4,clustered,0.1,65536,or,4,-,payload_reads,26112 +csv,2-4,clustered,0.1,65536,or,4,hot,fused_sum_ns_per_word,30.204 +csv,2-4,clustered,0.1,65536,or,4,hot,point_ns_per_query,11.641 +csv,2-4,clustered,0.1,65536,or,4,cold,materialize_ns_per_word,38.750 +csv,2-4,clustered,0.1,65536,or,4,cold,count_ns_per_word,55.403 +csv,2-4,clustered,0.1,65536,or,4,cold,payload_ns_per_survivor,19.734 +csv,2-4,clustered,0.1,65536,or,4,cold,fused_sum_ns_per_word,124.236 +csv,2-4,clustered,0.1,65536,or,4,cold,point_ns_per_query,73.182 +csv,2-4,clustered,0.1,65536,or,8,-,survivors,36608 +csv,2-4,clustered,0.1,65536,or,8,hot,materialize_ns_per_word,9.438 +csv,2-4,clustered,0.1,65536,or,8,hot,count_ns_per_word,9.522 +csv,2-4,clustered,0.1,65536,or,8,hot,payload_ns_per_survivor,20.172 +csv,2-4,clustered,0.1,65536,or,8,-,payload_reads,52224 +csv,2-4,clustered,0.1,65536,or,8,hot,fused_sum_ns_per_word,49.078 +csv,2-4,clustered,0.1,65536,or,8,hot,point_ns_per_query,18.730 +csv,2-4,clustered,0.1,65536,or,8,cold,materialize_ns_per_word,56.352 +csv,2-4,clustered,0.1,65536,or,8,cold,count_ns_per_word,65.697 +csv,2-4,clustered,0.1,65536,or,8,cold,payload_ns_per_survivor,30.358 +csv,2-4,clustered,0.1,65536,or,8,cold,fused_sum_ns_per_word,126.503 +csv,2-4,clustered,0.1,65536,or,8,cold,point_ns_per_query,105.560 +csv,2-4,clustered,0.5,1024,and,1,-,survivors,576 +csv,2-4,clustered,0.5,1024,and,1,hot,materialize_ns_per_word,2.210 +csv,2-4,clustered,0.5,1024,and,1,hot,count_ns_per_word,1.857 +csv,2-4,clustered,0.5,1024,and,1,hot,payload_ns_per_survivor,8.848 +csv,2-4,clustered,0.5,1024,and,1,-,payload_reads,576 +csv,2-4,clustered,0.5,1024,and,1,hot,fused_sum_ns_per_word,3.925 +csv,2-4,clustered,0.5,1024,and,1,hot,point_ns_per_query,8.463 +csv,2-4,clustered,0.5,1024,and,1,cold,materialize_ns_per_word,33.070 +csv,2-4,clustered,0.5,1024,and,1,cold,count_ns_per_word,43.829 +csv,2-4,clustered,0.5,1024,and,1,cold,payload_ns_per_survivor,30.003 +csv,2-4,clustered,0.5,1024,and,1,cold,fused_sum_ns_per_word,52.123 +csv,2-4,clustered,0.5,1024,and,1,cold,point_ns_per_query,21.409 +csv,2-4,clustered,0.5,1024,and,1,-,lance_rows_returned,576 +csv,2-4,clustered,0.5,1024,and,1,-,lance_rows_scanned_masked,576 +csv,2-4,clustered,0.5,1024,and,1,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.5,1024,and,1,-,lance_bytes_masked,6472 +csv,2-4,clustered,0.5,1024,and,1,-,lance_bytes_unmasked,290335 +csv,2-4,clustered,0.5,1024,and,1,-,lance_ns_per_survivor_wall,2865.8 +csv,2-4,clustered,0.5,1024,and,2,-,survivors,256 +csv,2-4,clustered,0.5,1024,and,2,hot,materialize_ns_per_word,2.269 +csv,2-4,clustered,0.5,1024,and,2,hot,count_ns_per_word,2.120 +csv,2-4,clustered,0.5,1024,and,2,hot,payload_ns_per_survivor,17.109 +csv,2-4,clustered,0.5,1024,and,2,-,payload_reads,512 +csv,2-4,clustered,0.5,1024,and,2,hot,fused_sum_ns_per_word,4.424 +csv,2-4,clustered,0.5,1024,and,2,hot,point_ns_per_query,8.545 +csv,2-4,clustered,0.5,1024,and,2,cold,materialize_ns_per_word,34.012 +csv,2-4,clustered,0.5,1024,and,2,cold,count_ns_per_word,45.200 +csv,2-4,clustered,0.5,1024,and,2,cold,payload_ns_per_survivor,54.613 +csv,2-4,clustered,0.5,1024,and,2,cold,fused_sum_ns_per_word,57.414 +csv,2-4,clustered,0.5,1024,and,2,cold,point_ns_per_query,17.553 +csv,2-4,clustered,0.5,1024,and,2,-,lance_rows_returned,256 +csv,2-4,clustered,0.5,1024,and,2,-,lance_rows_scanned_masked,256 +csv,2-4,clustered,0.5,1024,and,2,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.5,1024,and,2,-,lance_bytes_masked,11024 +csv,2-4,clustered,0.5,1024,and,2,-,lance_bytes_unmasked,460492 +csv,2-4,clustered,0.5,1024,and,2,-,lance_ns_per_survivor_wall,11575.5 +csv,2-4,clustered,0.5,1024,and,4,-,survivors,64 +csv,2-4,clustered,0.5,1024,and,4,hot,materialize_ns_per_word,3.364 +csv,2-4,clustered,0.5,1024,and,4,hot,count_ns_per_word,3.750 +csv,2-4,clustered,0.5,1024,and,4,hot,payload_ns_per_survivor,44.652 +csv,2-4,clustered,0.5,1024,and,4,-,payload_reads,256 +csv,2-4,clustered,0.5,1024,and,4,hot,fused_sum_ns_per_word,5.448 +csv,2-4,clustered,0.5,1024,and,4,hot,point_ns_per_query,8.721 +csv,2-4,clustered,0.5,1024,and,4,cold,materialize_ns_per_word,47.593 +csv,2-4,clustered,0.5,1024,and,4,cold,count_ns_per_word,59.091 +csv,2-4,clustered,0.5,1024,and,4,cold,payload_ns_per_survivor,125.750 +csv,2-4,clustered,0.5,1024,and,4,cold,fused_sum_ns_per_word,61.822 +csv,2-4,clustered,0.5,1024,and,4,cold,point_ns_per_query,24.287 +csv,2-4,clustered,0.5,1024,and,4,-,lance_rows_returned,64 +csv,2-4,clustered,0.5,1024,and,4,-,lance_rows_scanned_masked,64 +csv,2-4,clustered,0.5,1024,and,4,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.5,1024,and,4,-,lance_bytes_masked,19472 +csv,2-4,clustered,0.5,1024,and,4,-,lance_bytes_unmasked,788692 +csv,2-4,clustered,0.5,1024,and,4,-,lance_ns_per_survivor_wall,63425.0 +csv,2-4,clustered,0.5,1024,and,8,-,survivors,0 +csv,2-4,clustered,0.5,1024,and,8,hot,materialize_ns_per_word,9.128 +csv,2-4,clustered,0.5,1024,and,8,hot,count_ns_per_word,10.808 +csv,2-4,clustered,0.5,1024,and,8,hot,payload_ns_per_survivor,NA +csv,2-4,clustered,0.5,1024,and,8,-,payload_reads,0 +csv,2-4,clustered,0.5,1024,and,8,hot,fused_sum_ns_per_word,12.982 +csv,2-4,clustered,0.5,1024,and,8,hot,point_ns_per_query,14.202 +csv,2-4,clustered,0.5,1024,and,8,cold,materialize_ns_per_word,62.513 +csv,2-4,clustered,0.5,1024,and,8,cold,count_ns_per_word,62.396 +csv,2-4,clustered,0.5,1024,and,8,cold,payload_ns_per_survivor,NA +csv,2-4,clustered,0.5,1024,and,8,cold,fused_sum_ns_per_word,63.048 +csv,2-4,clustered,0.5,1024,and,8,cold,point_ns_per_query,20.788 +csv,2-4,clustered,0.5,1024,and,8,-,lance_rows_returned,0 +csv,2-4,clustered,0.5,1024,and,8,-,lance_rows_scanned_masked,0 +csv,2-4,clustered,0.5,1024,and,8,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.5,1024,and,8,-,lance_bytes_masked,0 +csv,2-4,clustered,0.5,1024,and,8,-,lance_bytes_unmasked,1453380 +csv,2-4,clustered,0.5,1024,and,8,-,lance_ns_per_survivor_wall,NA +csv,2-4,clustered,0.5,1024,or,2,-,survivors,704 +csv,2-4,clustered,0.5,1024,or,2,hot,materialize_ns_per_word,3.663 +csv,2-4,clustered,0.5,1024,or,2,hot,count_ns_per_word,3.431 +csv,2-4,clustered,0.5,1024,or,2,hot,payload_ns_per_survivor,11.332 +csv,2-4,clustered,0.5,1024,or,2,-,payload_reads,960 +csv,2-4,clustered,0.5,1024,or,2,hot,fused_sum_ns_per_word,5.948 +csv,2-4,clustered,0.5,1024,or,2,hot,point_ns_per_query,8.540 +csv,2-4,clustered,0.5,1024,or,2,cold,materialize_ns_per_word,39.210 +csv,2-4,clustered,0.5,1024,or,2,cold,count_ns_per_word,47.757 +csv,2-4,clustered,0.5,1024,or,2,cold,payload_ns_per_survivor,52.634 +csv,2-4,clustered,0.5,1024,or,2,cold,fused_sum_ns_per_word,58.541 +csv,2-4,clustered,0.5,1024,or,2,cold,point_ns_per_query,16.681 +csv,2-4,clustered,0.5,1024,or,4,-,survivors,960 +csv,2-4,clustered,0.5,1024,or,4,hot,materialize_ns_per_word,8.250 +csv,2-4,clustered,0.5,1024,or,4,hot,count_ns_per_word,8.346 +csv,2-4,clustered,0.5,1024,or,4,hot,payload_ns_per_survivor,27.944 +csv,2-4,clustered,0.5,1024,or,4,-,payload_reads,1856 +csv,2-4,clustered,0.5,1024,or,4,hot,fused_sum_ns_per_word,14.047 +csv,2-4,clustered,0.5,1024,or,4,hot,point_ns_per_query,13.378 +csv,2-4,clustered,0.5,1024,or,4,cold,materialize_ns_per_word,52.346 +csv,2-4,clustered,0.5,1024,or,4,cold,count_ns_per_word,56.861 +csv,2-4,clustered,0.5,1024,or,4,cold,payload_ns_per_survivor,51.170 +csv,2-4,clustered,0.5,1024,or,4,cold,fused_sum_ns_per_word,59.364 +csv,2-4,clustered,0.5,1024,or,4,cold,point_ns_per_query,18.156 +csv,2-4,clustered,0.5,1024,or,8,-,survivors,1024 +csv,2-4,clustered,0.5,1024,or,8,hot,materialize_ns_per_word,8.937 +csv,2-4,clustered,0.5,1024,or,8,hot,count_ns_per_word,8.914 +csv,2-4,clustered,0.5,1024,or,8,hot,payload_ns_per_survivor,28.003 +csv,2-4,clustered,0.5,1024,or,8,-,payload_reads,4160 +csv,2-4,clustered,0.5,1024,or,8,hot,fused_sum_ns_per_word,11.333 +csv,2-4,clustered,0.5,1024,or,8,hot,point_ns_per_query,8.923 +csv,2-4,clustered,0.5,1024,or,8,cold,materialize_ns_per_word,59.483 +csv,2-4,clustered,0.5,1024,or,8,cold,count_ns_per_word,69.231 +csv,2-4,clustered,0.5,1024,or,8,cold,payload_ns_per_survivor,61.193 +csv,2-4,clustered,0.5,1024,or,8,cold,fused_sum_ns_per_word,73.766 +csv,2-4,clustered,0.5,1024,or,8,cold,point_ns_per_query,20.861 +csv,2-4,clustered,0.5,8192,and,1,-,survivors,3968 +csv,2-4,clustered,0.5,8192,and,1,hot,materialize_ns_per_word,2.102 +csv,2-4,clustered,0.5,8192,and,1,hot,count_ns_per_word,1.772 +csv,2-4,clustered,0.5,8192,and,1,hot,payload_ns_per_survivor,6.682 +csv,2-4,clustered,0.5,8192,and,1,-,payload_reads,3968 +csv,2-4,clustered,0.5,8192,and,1,hot,fused_sum_ns_per_word,7.793 +csv,2-4,clustered,0.5,8192,and,1,hot,point_ns_per_query,8.405 +csv,2-4,clustered,0.5,8192,and,1,cold,materialize_ns_per_word,36.063 +csv,2-4,clustered,0.5,8192,and,1,cold,count_ns_per_word,44.177 +csv,2-4,clustered,0.5,8192,and,1,cold,payload_ns_per_survivor,17.126 +csv,2-4,clustered,0.5,8192,and,1,cold,fused_sum_ns_per_word,56.514 +csv,2-4,clustered,0.5,8192,and,1,cold,point_ns_per_query,22.240 +csv,2-4,clustered,0.5,8192,and,1,-,lance_rows_returned,3968 +csv,2-4,clustered,0.5,8192,and,1,-,lance_rows_scanned_masked,3968 +csv,2-4,clustered,0.5,8192,and,1,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.5,8192,and,1,-,lance_bytes_masked,32640 +csv,2-4,clustered,0.5,8192,and,1,-,lance_bytes_unmasked,290335 +csv,2-4,clustered,0.5,8192,and,1,-,lance_ns_per_survivor_wall,648.4 +csv,2-4,clustered,0.5,8192,and,2,-,survivors,1792 +csv,2-4,clustered,0.5,8192,and,2,hot,materialize_ns_per_word,2.047 +csv,2-4,clustered,0.5,8192,and,2,hot,count_ns_per_word,1.898 +csv,2-4,clustered,0.5,8192,and,2,hot,payload_ns_per_survivor,11.587 +csv,2-4,clustered,0.5,8192,and,2,-,payload_reads,3584 +csv,2-4,clustered,0.5,8192,and,2,hot,fused_sum_ns_per_word,5.574 +csv,2-4,clustered,0.5,8192,and,2,hot,point_ns_per_query,8.508 +csv,2-4,clustered,0.5,8192,and,2,cold,materialize_ns_per_word,37.452 +csv,2-4,clustered,0.5,8192,and,2,cold,count_ns_per_word,45.974 +csv,2-4,clustered,0.5,8192,and,2,cold,payload_ns_per_survivor,37.832 +csv,2-4,clustered,0.5,8192,and,2,cold,fused_sum_ns_per_word,61.970 +csv,2-4,clustered,0.5,8192,and,2,cold,point_ns_per_query,26.608 +csv,2-4,clustered,0.5,8192,and,2,-,lance_rows_returned,1792 +csv,2-4,clustered,0.5,8192,and,2,-,lance_rows_scanned_masked,1792 +csv,2-4,clustered,0.5,8192,and,2,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.5,8192,and,2,-,lance_bytes_masked,50544 +csv,2-4,clustered,0.5,8192,and,2,-,lance_bytes_unmasked,460492 +csv,2-4,clustered,0.5,8192,and,2,-,lance_ns_per_survivor_wall,1264.4 +csv,2-4,clustered,0.5,8192,and,4,-,survivors,576 +csv,2-4,clustered,0.5,8192,and,4,hot,materialize_ns_per_word,2.938 +csv,2-4,clustered,0.5,8192,and,4,hot,count_ns_per_word,2.999 +csv,2-4,clustered,0.5,8192,and,4,hot,payload_ns_per_survivor,23.457 +csv,2-4,clustered,0.5,8192,and,4,-,payload_reads,2304 +csv,2-4,clustered,0.5,8192,and,4,hot,fused_sum_ns_per_word,5.958 +csv,2-4,clustered,0.5,8192,and,4,hot,point_ns_per_query,8.308 +csv,2-4,clustered,0.5,8192,and,4,cold,materialize_ns_per_word,41.905 +csv,2-4,clustered,0.5,8192,and,4,cold,count_ns_per_word,45.721 +csv,2-4,clustered,0.5,8192,and,4,cold,payload_ns_per_survivor,88.719 +csv,2-4,clustered,0.5,8192,and,4,cold,fused_sum_ns_per_word,58.723 +csv,2-4,clustered,0.5,8192,and,4,cold,point_ns_per_query,35.730 +csv,2-4,clustered,0.5,8192,and,4,-,lance_rows_returned,576 +csv,2-4,clustered,0.5,8192,and,4,-,lance_rows_scanned_masked,576 +csv,2-4,clustered,0.5,8192,and,4,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.5,8192,and,4,-,lance_bytes_masked,71560 +csv,2-4,clustered,0.5,8192,and,4,-,lance_bytes_unmasked,788692 +csv,2-4,clustered,0.5,8192,and,4,-,lance_ns_per_survivor_wall,3898.0 +csv,2-4,clustered,0.5,8192,and,8,-,survivors,64 +csv,2-4,clustered,0.5,8192,and,8,hot,materialize_ns_per_word,6.682 +csv,2-4,clustered,0.5,8192,and,8,hot,count_ns_per_word,6.790 +csv,2-4,clustered,0.5,8192,and,8,hot,payload_ns_per_survivor,62.968 +csv,2-4,clustered,0.5,8192,and,8,-,payload_reads,512 +csv,2-4,clustered,0.5,8192,and,8,hot,fused_sum_ns_per_word,7.532 +csv,2-4,clustered,0.5,8192,and,8,hot,point_ns_per_query,9.384 +csv,2-4,clustered,0.5,8192,and,8,cold,materialize_ns_per_word,70.174 +csv,2-4,clustered,0.5,8192,and,8,cold,count_ns_per_word,72.123 +csv,2-4,clustered,0.5,8192,and,8,cold,payload_ns_per_survivor,149.922 +csv,2-4,clustered,0.5,8192,and,8,cold,fused_sum_ns_per_word,71.484 +csv,2-4,clustered,0.5,8192,and,8,cold,point_ns_per_query,46.120 +csv,2-4,clustered,0.5,8192,and,8,-,lance_rows_returned,64 +csv,2-4,clustered,0.5,8192,and,8,-,lance_rows_scanned_masked,64 +csv,2-4,clustered,0.5,8192,and,8,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.5,8192,and,8,-,lance_bytes_masked,46408 +csv,2-4,clustered,0.5,8192,and,8,-,lance_bytes_unmasked,1453380 +csv,2-4,clustered,0.5,8192,and,8,-,lance_ns_per_survivor_wall,64803.6 +csv,2-4,clustered,0.5,8192,or,2,-,survivors,5696 +csv,2-4,clustered,0.5,8192,or,2,hot,materialize_ns_per_word,4.040 +csv,2-4,clustered,0.5,8192,or,2,hot,count_ns_per_word,3.871 +csv,2-4,clustered,0.5,8192,or,2,hot,payload_ns_per_survivor,9.502 +csv,2-4,clustered,0.5,8192,or,2,-,payload_reads,7488 +csv,2-4,clustered,0.5,8192,or,2,hot,fused_sum_ns_per_word,11.655 +csv,2-4,clustered,0.5,8192,or,2,hot,point_ns_per_query,8.530 +csv,2-4,clustered,0.5,8192,or,2,cold,materialize_ns_per_word,48.989 +csv,2-4,clustered,0.5,8192,or,2,cold,count_ns_per_word,46.989 +csv,2-4,clustered,0.5,8192,or,2,cold,payload_ns_per_survivor,17.523 +csv,2-4,clustered,0.5,8192,or,2,cold,fused_sum_ns_per_word,62.490 +csv,2-4,clustered,0.5,8192,or,2,cold,point_ns_per_query,25.051 +csv,2-4,clustered,0.5,8192,or,4,-,survivors,7744 +csv,2-4,clustered,0.5,8192,or,4,hot,materialize_ns_per_word,5.063 +csv,2-4,clustered,0.5,8192,or,4,hot,count_ns_per_word,5.034 +csv,2-4,clustered,0.5,8192,or,4,hot,payload_ns_per_survivor,14.615 +csv,2-4,clustered,0.5,8192,or,4,-,payload_reads,15808 +csv,2-4,clustered,0.5,8192,or,4,hot,fused_sum_ns_per_word,15.072 +csv,2-4,clustered,0.5,8192,or,4,hot,point_ns_per_query,8.954 +csv,2-4,clustered,0.5,8192,or,4,cold,materialize_ns_per_word,48.922 +csv,2-4,clustered,0.5,8192,or,4,cold,count_ns_per_word,56.431 +csv,2-4,clustered,0.5,8192,or,4,cold,payload_ns_per_survivor,22.936 +csv,2-4,clustered,0.5,8192,or,4,cold,fused_sum_ns_per_word,75.426 +csv,2-4,clustered,0.5,8192,or,4,cold,point_ns_per_query,33.544 +csv,2-4,clustered,0.5,8192,or,8,-,survivors,8192 +csv,2-4,clustered,0.5,8192,or,8,hot,materialize_ns_per_word,9.465 +csv,2-4,clustered,0.5,8192,or,8,hot,count_ns_per_word,9.224 +csv,2-4,clustered,0.5,8192,or,8,hot,payload_ns_per_survivor,27.061 +csv,2-4,clustered,0.5,8192,or,8,-,payload_reads,31744 +csv,2-4,clustered,0.5,8192,or,8,hot,fused_sum_ns_per_word,18.550 +csv,2-4,clustered,0.5,8192,or,8,hot,point_ns_per_query,10.743 +csv,2-4,clustered,0.5,8192,or,8,cold,materialize_ns_per_word,59.204 +csv,2-4,clustered,0.5,8192,or,8,cold,count_ns_per_word,71.042 +csv,2-4,clustered,0.5,8192,or,8,cold,payload_ns_per_survivor,36.113 +csv,2-4,clustered,0.5,8192,or,8,cold,fused_sum_ns_per_word,79.788 +csv,2-4,clustered,0.5,8192,or,8,cold,point_ns_per_query,45.833 +csv,2-4,clustered,0.5,65536,and,1,-,survivors,32768 +csv,2-4,clustered,0.5,65536,and,1,hot,materialize_ns_per_word,2.072 +csv,2-4,clustered,0.5,65536,and,1,hot,count_ns_per_word,1.793 +csv,2-4,clustered,0.5,65536,and,1,hot,payload_ns_per_survivor,6.315 +csv,2-4,clustered,0.5,65536,and,1,-,payload_reads,32768 +csv,2-4,clustered,0.5,65536,and,1,hot,fused_sum_ns_per_word,37.362 +csv,2-4,clustered,0.5,65536,and,1,hot,point_ns_per_query,8.613 +csv,2-4,clustered,0.5,65536,and,1,cold,materialize_ns_per_word,31.244 +csv,2-4,clustered,0.5,65536,and,1,cold,count_ns_per_word,28.476 +csv,2-4,clustered,0.5,65536,and,1,cold,payload_ns_per_survivor,8.427 +csv,2-4,clustered,0.5,65536,and,1,cold,fused_sum_ns_per_word,111.364 +csv,2-4,clustered,0.5,65536,and,1,cold,point_ns_per_query,42.648 +csv,2-4,clustered,0.5,65536,and,1,-,lance_rows_returned,32768 +csv,2-4,clustered,0.5,65536,and,1,-,lance_rows_scanned_masked,32768 +csv,2-4,clustered,0.5,65536,and,1,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.5,65536,and,1,-,lance_bytes_masked,290080 +csv,2-4,clustered,0.5,65536,and,1,-,lance_bytes_unmasked,290335 +csv,2-4,clustered,0.5,65536,and,1,-,lance_ns_per_survivor_wall,199.5 +csv,2-4,clustered,0.5,65536,and,2,-,survivors,16064 +csv,2-4,clustered,0.5,65536,and,2,hot,materialize_ns_per_word,2.725 +csv,2-4,clustered,0.5,65536,and,2,hot,count_ns_per_word,2.322 +csv,2-4,clustered,0.5,65536,and,2,hot,payload_ns_per_survivor,11.316 +csv,2-4,clustered,0.5,65536,and,2,-,payload_reads,32128 +csv,2-4,clustered,0.5,65536,and,2,hot,fused_sum_ns_per_word,20.304 +csv,2-4,clustered,0.5,65536,and,2,hot,point_ns_per_query,9.644 +csv,2-4,clustered,0.5,65536,and,2,cold,materialize_ns_per_word,35.075 +csv,2-4,clustered,0.5,65536,and,2,cold,count_ns_per_word,47.916 +csv,2-4,clustered,0.5,65536,and,2,cold,payload_ns_per_survivor,17.592 +csv,2-4,clustered,0.5,65536,and,2,cold,fused_sum_ns_per_word,84.341 +csv,2-4,clustered,0.5,65536,and,2,cold,point_ns_per_query,65.811 +csv,2-4,clustered,0.5,65536,and,2,-,lance_rows_returned,16064 +csv,2-4,clustered,0.5,65536,and,2,-,lance_rows_scanned_masked,16064 +csv,2-4,clustered,0.5,65536,and,2,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.5,65536,and,2,-,lance_bytes_masked,456272 +csv,2-4,clustered,0.5,65536,and,2,-,lance_bytes_unmasked,460492 +csv,2-4,clustered,0.5,65536,and,2,-,lance_ns_per_survivor_wall,309.1 +csv,2-4,clustered,0.5,65536,and,4,-,survivors,4032 +csv,2-4,clustered,0.5,65536,and,4,hot,materialize_ns_per_word,3.338 +csv,2-4,clustered,0.5,65536,and,4,hot,count_ns_per_word,3.421 +csv,2-4,clustered,0.5,65536,and,4,hot,payload_ns_per_survivor,21.198 +csv,2-4,clustered,0.5,65536,and,4,-,payload_reads,16128 +csv,2-4,clustered,0.5,65536,and,4,hot,fused_sum_ns_per_word,9.290 +csv,2-4,clustered,0.5,65536,and,4,hot,point_ns_per_query,18.085 +csv,2-4,clustered,0.5,65536,and,4,cold,materialize_ns_per_word,47.087 +csv,2-4,clustered,0.5,65536,and,4,cold,count_ns_per_word,65.771 +csv,2-4,clustered,0.5,65536,and,4,cold,payload_ns_per_survivor,53.168 +csv,2-4,clustered,0.5,65536,and,4,cold,fused_sum_ns_per_word,78.717 +csv,2-4,clustered,0.5,65536,and,4,cold,point_ns_per_query,110.077 +csv,2-4,clustered,0.5,65536,and,4,-,lance_rows_returned,4032 +csv,2-4,clustered,0.5,65536,and,4,-,lance_rows_scanned_masked,4032 +csv,2-4,clustered,0.5,65536,and,4,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.5,65536,and,4,-,lance_bytes_masked,691840 +csv,2-4,clustered,0.5,65536,and,4,-,lance_bytes_unmasked,788692 +csv,2-4,clustered,0.5,65536,and,4,-,lance_ns_per_survivor_wall,1298.2 +csv,2-4,clustered,0.5,65536,and,8,-,survivors,256 +csv,2-4,clustered,0.5,65536,and,8,hot,materialize_ns_per_word,7.129 +csv,2-4,clustered,0.5,65536,and,8,hot,count_ns_per_word,6.196 +csv,2-4,clustered,0.5,65536,and,8,hot,payload_ns_per_survivor,49.312 +csv,2-4,clustered,0.5,65536,and,8,-,payload_reads,2048 +csv,2-4,clustered,0.5,65536,and,8,hot,fused_sum_ns_per_word,8.380 +csv,2-4,clustered,0.5,65536,and,8,hot,point_ns_per_query,42.864 +csv,2-4,clustered,0.5,65536,and,8,cold,materialize_ns_per_word,62.290 +csv,2-4,clustered,0.5,65536,and,8,cold,count_ns_per_word,65.471 +csv,2-4,clustered,0.5,65536,and,8,cold,payload_ns_per_survivor,100.051 +csv,2-4,clustered,0.5,65536,and,8,cold,fused_sum_ns_per_word,64.455 +csv,2-4,clustered,0.5,65536,and,8,cold,point_ns_per_query,179.296 +csv,2-4,clustered,0.5,65536,and,8,-,lance_rows_returned,256 +csv,2-4,clustered,0.5,65536,and,8,-,lance_rows_scanned_masked,256 +csv,2-4,clustered,0.5,65536,and,8,-,lance_rows_scanned_unmasked,65536 +csv,2-4,clustered,0.5,65536,and,8,-,lance_bytes_masked,177232 +csv,2-4,clustered,0.5,65536,and,8,-,lance_bytes_unmasked,1453380 +csv,2-4,clustered,0.5,65536,and,8,-,lance_ns_per_survivor_wall,16734.7 +csv,2-4,clustered,0.5,65536,or,2,-,survivors,49472 +csv,2-4,clustered,0.5,65536,or,2,hot,materialize_ns_per_word,4.325 +csv,2-4,clustered,0.5,65536,or,2,hot,count_ns_per_word,5.505 +csv,2-4,clustered,0.5,65536,or,2,hot,payload_ns_per_survivor,11.398 +csv,2-4,clustered,0.5,65536,or,2,-,payload_reads,65536 +csv,2-4,clustered,0.5,65536,or,2,hot,fused_sum_ns_per_word,55.597 +csv,2-4,clustered,0.5,65536,or,2,hot,point_ns_per_query,9.693 +csv,2-4,clustered,0.5,65536,or,2,cold,materialize_ns_per_word,46.326 +csv,2-4,clustered,0.5,65536,or,2,cold,count_ns_per_word,43.155 +csv,2-4,clustered,0.5,65536,or,2,cold,payload_ns_per_survivor,19.587 +csv,2-4,clustered,0.5,65536,or,2,cold,fused_sum_ns_per_word,141.395 +csv,2-4,clustered,0.5,65536,or,2,cold,point_ns_per_query,60.116 +csv,2-4,clustered,0.5,65536,or,4,-,survivors,61376 +csv,2-4,clustered,0.5,65536,or,4,hot,materialize_ns_per_word,5.597 +csv,2-4,clustered,0.5,65536,or,4,hot,count_ns_per_word,4.891 +csv,2-4,clustered,0.5,65536,or,4,hot,payload_ns_per_survivor,15.298 +csv,2-4,clustered,0.5,65536,or,4,-,payload_reads,131072 +csv,2-4,clustered,0.5,65536,or,4,hot,fused_sum_ns_per_word,112.653 +csv,2-4,clustered,0.5,65536,or,4,hot,point_ns_per_query,33.395 +csv,2-4,clustered,0.5,65536,or,4,cold,materialize_ns_per_word,48.985 +csv,2-4,clustered,0.5,65536,or,4,cold,count_ns_per_word,52.829 +csv,2-4,clustered,0.5,65536,or,4,cold,payload_ns_per_survivor,16.675 +csv,2-4,clustered,0.5,65536,or,4,cold,fused_sum_ns_per_word,128.258 +csv,2-4,clustered,0.5,65536,or,4,cold,point_ns_per_query,105.511 +csv,2-4,clustered,0.5,65536,or,8,-,survivors,65408 +csv,2-4,clustered,0.5,65536,or,8,hot,materialize_ns_per_word,9.302 +csv,2-4,clustered,0.5,65536,or,8,hot,count_ns_per_word,9.443 +csv,2-4,clustered,0.5,65536,or,8,hot,payload_ns_per_survivor,29.898 +csv,2-4,clustered,0.5,65536,or,8,-,payload_reads,262144 +csv,2-4,clustered,0.5,65536,or,8,hot,fused_sum_ns_per_word,75.363 +csv,2-4,clustered,0.5,65536,or,8,hot,point_ns_per_query,40.611 +csv,2-4,clustered,0.5,65536,or,8,cold,materialize_ns_per_word,56.026 +csv,2-4,clustered,0.5,65536,or,8,cold,count_ns_per_word,72.805 +csv,2-4,clustered,0.5,65536,or,8,cold,payload_ns_per_survivor,33.260 +csv,2-4,clustered,0.5,65536,or,8,cold,fused_sum_ns_per_word,154.431 +csv,2-4,clustered,0.5,65536,or,8,cold,point_ns_per_query,174.774 +``` diff --git a/.claude/board/entries/README.md b/.claude/board/entries/README.md index 0d47d834c..62a57f3e3 100644 --- a/.claude/board/entries/README.md +++ b/.claude/board/entries/README.md @@ -25,10 +25,11 @@ index row, (3) no duplicate entry id. Checks 1 and 2 are deliberately opposite directions; the stranding this convention prevents shows up in exactly one of them, never both. -348 entries, 2026-08-06 .. 2026-10-15. +349 entries, 2026-08-06 .. 2026-10-16. | date | entry id | finding | file | |---|---|---|---| +| 2026-10-16 | `D-HOLO-H14d` | | [2026-10-16-d-holo-h14d-logic-mask-read.md](2026-10-16-d-holo-h14d-logic-mask-read.md) | | 2026-10-15 | `nars-metta-ce64-mapping-inventory` | | [2026-10-15-nars-metta-ce64-mapping-inventory.md](2026-10-15-nars-metta-ce64-mapping-inventory.md) | | 2026-10-15 | `D-ASM-0` | | [2026-10-15-metta-datalog-assimilation-plan.md](2026-10-15-metta-datalog-assimilation-plan.md) | | 2026-10-15 | `ledger-correction-wire-contract` | | [2026-10-15-ledger-correction-wire-contract.md](2026-10-15-ledger-correction-wire-contract.md) | diff --git a/.claude/plans/d-holo-h14d-logic-mask-read-v1.md b/.claude/plans/d-holo-h14d-logic-mask-read-v1.md index 0f16bdbe3..e8490d175 100644 --- a/.claude/plans/d-holo-h14d-logic-mask-read-v1.md +++ b/.claude/plans/d-holo-h14d-logic-mask-read-v1.md @@ -1,6 +1,6 @@ # D-HOLO-H14d — logic → address mask → masked read → terminal (C only) -**Status:** PRE-REGISTERED 2026-10-16. Nothing below has been run. +**Status:** MEASURED 2026-10-16 (v4, `tier: v4 (avx512f)`, lance 13.0.0). Results in § Results; entry `2026-10-16-d-holo-h14d-logic-mask-read.md`. Returned to the operator. **Follows:** D-HOLO-H14c (#1573). H14, H14b and part of H14c measured C by rebuilding rows or against row-first layouts (B, M); that framing is withdrawn (#1569). This probe measures C's own operation and nothing else. @@ -29,13 +29,13 @@ whose presence bits the mask has already proved. No arm B, S or M. ## Checklist -- [ ] Pre-registration committed before any timing (this file) -- [ ] Probe crate `crates/holo-h14d-probe` (excluded from the workspace, like the relalg crate; path deps: relalg, mask-risc; registry: lance 13, arrow 58, tokio) -- [ ] Oracles (§ Checks) written first and red against a stub -- [ ] Disable runs (§ Disable runs) red, files restored -- [ ] v4 run, tier printed by the program -- [ ] Results section, board entry with raw CSV, STATUS row, AGENT_LOG -- [ ] Draft PR; no merge +- [x] Pre-registration committed before any timing (this file) +- [x] Probe crate `crates/holo-h14d-probe` (excluded from the workspace; path deps relalg, mask-risc, r2il; registry lance 13, arrow 58, tokio) +- [x] Oracles (§ Checks) written before the timing code ran. Not run against a stub: red evidence comes from the five disable runs and from check 8 going red on the old clustered fixture (A2). +- [x] Disable runs (§ Disable runs) red, files restored; repeated after A2 +- [x] v4 run, tier printed by the program +- [x] Results section, board entry with raw CSV, STATUS row (no agent run, so no AGENT_LOG entry) +- [x] PR #1575 (marked ready by the operator); no merge ## Sub-ids @@ -152,6 +152,87 @@ word, per survivor, per query; never whole-call milliseconds. About 40 % run-to-run noise was measured on this VM in H14c; differences below that are not read as results. +## Results (v4, 2026-10-16) + +`tier: v4 (avx512f)`, lance 13.0.0, one tile of 65,536 addresses. All eight +checks pass on the measured commit (`802db7df`); the five disable runs each turn +their check red (disable 2 turns checks 4 and 5 red, not check 6: the Lance +read uses `R` independently of the payload terminal, so the plan's "and 6" was +wrong for that disable). Raw CSV in the board entry. Timings are medians of 7 +batches; about 40 % run-to-run noise applies, so single-cell differences below +that are not read. + +**Stage 1 (logic, D-HOLO-H14d-1).** Of 2,000 generated programs: + +| outcome | programs | +|---|---| +| decided symbolically (`Empty`/`All`, 0 programs run) | 675 (34 %) | +| answered both rewritten and as written | 1,583 | +| answered only after the rewrite (as written exceeds the 8 scratch slots) | 396 | +| refused both ways | 19 | +| widened by the rewrite (answered as written, refused rewritten) | 2 | + +On the 1,583 answered both ways the rewrite runs 1,065 mask-risc passes against +5,898 as written (5.5× fewer). The reduction costs 1.9 µs per program +(`normalize` + `symbolic`, no data). Prediction 1 holds: every program that +normalizes to `Empty` or `All` ran 0 programs (check 2). The 2 widened programs +are the absorption miss in A2. + +**Stage 2 (address mask, D-HOLO-H14d-2).** Hot, full aperture, ns per 64-address word: + +| form | k = 1 | k = 2 | k = 4 | k = 8 | +|---|---|---|---|---| +| `∧` materialize R | 2.0–3.8 | 2.3–3.4 | 3.0–6.6 | 6.5–7.6 | +| `∨ … ∧ A` materialize R | — | 3.6–4.3 | 4.8–5.6 | 9.1–9.8 | +| COUNT (`∧`) | 1.8–2.8 | 2.2–3.4 | 3.0–5.7 | 6.2–8.5 | + +That is 0.03–0.15 ns per address. Cost grows with the number of operands, not +with `|R|`. Prediction 2 (flat in density within 1.25×) holds in 11 of 14 +pattern × form × k rows; the three misses are single-cell spikes (1.39×, 2.0×, +1.81×), not trends in density, and sit inside the measured noise. + +**Stage 3 (Lance masked read, D-HOLO-H14d-3).** `rows_scanned == |R|` and +returned rows == `|R|` in all 96 `∧` cells (prediction 3, first half, holds). +Bytes read with `R`, as a fraction of the same projection without it, k = 1: + +| aperture | uniform 0.1 % | uniform 1 % | uniform 10 % | clustered 1 % | clustered 10 % | +|---|---|---|---|---|---| +| 1,024 | 0.01 | 0.01 | 0.03 | 0.00 (R = 0) | 0.00 (R = 0) | +| 8,192 | 0.09 | 0.10 | 0.11 | 0.02 | 0.09 | +| 65,536 | 0.65 | 1.00 | 1.00 | 0.19 | 0.99 | + +The aperture decides the bytes: a narrow `A` keeps survivors on a few pages. +Over the full tile, uniform 1 % reads all bytes (H14c reproduced), clustered 1 % +reads 0.19, but clustered 10 % reads 0.99: runs of 64 addresses are much +smaller than a Lance page, so 10 % of words still touch nearly every page. +Clustering helps only at page scale. An empty `R` reads 0 bytes. Prediction 3, +second half, holds with that refinement. + +**Stage 4 (terminals, D-HOLO-H14d-4/-5).** Payload reads == `|R| × k` in every +`∧` cell (check 4). The explicit payload terminal costs about 6 ns per lane +load per survivor once `R` is large (hot, 50 %: 6.3 / 11.5 / 24.4 / 48.3 ns per +survivor at k = 1 / 2 / 4 / 8), plus a fixed scan of `R`'s 1,024 words of about +1.5 ns per word. Prediction 4 (flat per survivor within 1.5×) is **falsified** +as stated: at small `|R|` the fixed word scan dominates (k = 2, `|R|` = 1: +1.6 µs per survivor). Per lane load it is flat. The fused Σ terminal +(`Measure::Sum`, one mask-risc program) costs 3.5–41 ns per word, about +1.3 ns per summed value at 50 %, roughly 5× cheaper than the explicit terminal +on dense `R`. Single-address query (prediction 5): hot 8–45 ns, cold 17–184 ns; +cost grows with k and with the number of present lanes (loads), with no search. + +**What this answers.** C's own operation runs in four stages whose costs are +separable: the logic stage is microseconds per program and removes a third of +the corpus outright; the address mask costs nanoseconds per 64 addresses; the +mask makes Lance scan exactly the survivors, and saves bytes when the survivors +sit on few pages (a narrow aperture, or clustering at page scale); the payload +terminal costs about 6 ns per lane load, and a fused terminal several times +less. No layout decision follows from these numbers. + +**Open.** Page-scale clustering (which address order puts a thought's +survivors on few Lance pages); the payload terminal's fixed word scan (iterating +only non-zero words of `R`, or a survivor list from the mask program); the +relalg absorption miss (2 of 2,000). + ## Not measured Hardware counters (none on this VM). Lance decoded bytes, pages and