Skip to content

docs(testing): testing strategy, tiers and a measured coverage matrix (#1253 T0) - #1254

Draft
zzylol wants to merge 35 commits into
refactor/1207-toolsfrom
test/1253-t0-strategy-doc
Draft

zzylol wants to merge 35 commits into
refactor/1207-toolsfrom
test/1253-t0-strategy-doc

Conversation

@zzylol

@zzylol zzylol commented Nov 10, 2026 •

Copy link
Copy Markdown
Contributor

Summary

Review guide

Behavior: before → after

A developer adds a Pass 2 rule and wants to know which tests to write and which ones may change:

Before After
Where a rule test goes and how its memo is built no guidance; tests assemble IR by hand or go through the whole pipeline a rule unit test in the stage crate, its memo built through the production frontends and Stage 0
What may pin a plan hand-written tests and snapshots both pin plans only snapshots pin whole plans and costs; other tests assert properties, rule outputs or oracle numbers
Checking a cost MILP objective = plan_cost (shared code, Example 1 passed it) hand-computed costs from the concepts doc's formulas, plus the contracts
A slow or known-failing test bare #[ignore] or free-text reasons #[ignore = "<issue or PR>: reason"]; tiers full tier: / nightly tier: in full_tier / nightly_tier modules
What is covered unknown the matrix, e.g. PromQL quantile: planned (runtime_install.rs::the_plan_carries_stage3s_predicted_usage), executed only on a query-time DAG built without the planner

It serves the test-structure need of #1253: a design change fails the tests of the rule it changes, and cost or answer bugs are caught by an independent check.

Interfaces

None (documentation only). The tier markers are a convention for test attributes and module names, listed under decisions.

Algorithm changes

None.

Decisions and open questions

Needs reviewer decision

None.

Decided

Independent review, round 1: findings fixed

  1. Two promised metamorphic relations do not exist: accuracy monotonicity and rate scaling are now listed as not checked (T5); "a duplicate adds about 0" names f-exact-duplicate, "adding a query" names added-query.
  2. One-sided exhaustive-search tolerance: now equality to a relative 1e-9 (mip_rel_gap is 0), enumerated plans must pass the contracts, and a memo above 10⁵ plans is not enumerated and the cap is reported.
  3. Hand-computed oracle could call planner code: rule added (expected values are literals or arithmetic over literals in the doc comment; only unit costs read from the cost inputs; each fails on the pre-fix code where one exists).
  4. Nightly selector missed the snapshots: snapshots are their own tier with the existing UPDATE_SNAPSHOTS / --ignored commands of planner-snapshots.md.
  5. Dead concepts-doc link: the dependency on docs(concepts): memo groups, properties, requirements, per-stage interfaces and rules #1224 (docs/memo-group-model) is stated; the citation is "§5, Cost and retention".
  6. Oracle tier differs from Tracking: restructure ASAPPlanner tests around layers and independent oracles #1253: small-data execution oracles are in the fast tier (seconds), larger data in full; the change from Tracking: restructure ASAPPlanner tests around layers and independent oracles #1253 is stated.
  7. Admissibility and (K) contracts reuse planner code: both listed as consistency checks, with MILP objective = plan_cost.
  8. kll_quantile_of_all_null_group_is_null overstated: annotated "answers on trivial groups only, no ε check".
  9. Matrix not the full cross product: stated as factored on purpose, and the operator × {range, repeating} × {exact, ε} tables added (measured by opening each test).
  10. Snapshot cost diff: a PR that regenerates snapshots lists each changed workload's old → new cost_per_second.
  • Acceptance: the doc and the registry state that no ASAPWorkloads workload files exist in-repo (only planner_fuzz generator patterns).

Skipped

  • Efficiency, "plan each workload once and share it between the contracts and the snapshots": the snapshots run the asap_planner binary in a release build, the contracts plan in-process in debug; sharing would couple the two tiers. The contracts' slow sets plan in parallel instead (T2).

Verification

Scope Passed / failed / ignored Newly failing vs base Notes
none run n/a 0 documentation only

Matrix evidence: each cell's test was opened and checked to exercise that combination (query text, range_evaluation, absent series_count, supported_summaries, max_error); the operator × time shape × accuracy tables were measured the same way on b367388eb; test counts per crate by the grep command in the doc (1,538 tests, 11 #[ignore). Registry planning times measured with a debug build of every registry workload to Stage 3 (0.02 s to 7 s; random mixed about 7 s each).

Follow-ups

…iming, lifetime }

Deletes Schedule and the σ-only InvalidPhysicalProperties variants; the only
invalid combination left is (IngestionTime, OneEvaluation). satisfies_physical
checks timing x lifetime only; delivers_on is the per-context alignment check
(w | I and w | φ). A OneEvaluation result runs in one evaluation context, so
x_{κ,v} covers it as for ℓ = None.
…physical drops memo

InvalidLogicalProperties gains SketchBuildWithoutParameters and renames
FloorNotInParameterList to ParametersNotInList, returned by
LogicalProperties::new. LogicalRequirement::new no longer checks list
membership (a floor is any value of the family's parameter type, e.g.
heap_size >= k), so it returns Self. satisfies_physical takes only the
producer and consumer.
Context::QueryEvaluation(QueryId) becomes Context::Evaluation(EvaluationSchedule):
queries with the same (interval, phase) are evaluated together and share
their OneEvaluation results. evaluation_schedule returns that schedule.
QueryId stays for z_{q,v}. A non-periodic query has no context yet.
InvalidLogicalProperties -> LogicalPropertiesError, InvalidPhysicalProperties
-> PhysicalPropertiesError, LogicalRequirement -> LogicalRequirements
(parameter_floor -> parameter_floor_for_required_accuracy), satisfies_logical
/ satisfies_physical -> producer_satisfies_logical_requirements /
producer_satisfies_physical_requirements, Medium -> StorageMedium,
Context / ContextId -> ExecutionContext / ExecutionContextId
(x_in_context / y_in_context -> x_in_execution_context /
y_in_execution_context). PhysicalCandidate and PhysicalCandidateKey fields
-> logical_candidate_id, physical_properties; edge fields ->
producer_candidate_id, consumer_candidate_id; PhysicalASAPMemoCandidates
fields -> logical_candidates, physical_candidates.
Deletes EvaluationSchedule and ExecutionContext::evaluation_schedule. An
evaluation context is Evaluation { recurrence, range_evaluation }: queries
with equal ones share it and its OneEvaluation results, one-off queries
included. ExecutionContext, ExecutionContextId and RefreshWindowId move to
asap_types::stages so PhysicalCandidate::delivers_on can take the context.
Contexts are deduplicated by equality (QueryRecurrence holds an f64).
PhysicalASAPDAGValidationError::InvalidPhysicalProperties becomes
PhysicalProperties { node, reason }. In the files this unit edits, "kept"
describing a materialized result or retained data becomes "materialized"
or "retained" (cost, materialized views, realizer, installable plan,
deployment capabilities; locals kept/raw_kept_rows -> retained/
raw_retained_rows), and "reader" becomes "query" where it is a query
(execution demand, ScheduleGroup::queries, cost usage, labels, tests) or
"consumer" where it is a consuming candidate.
find_or_add_group returns the node rules' SchemaDerivationError and
add_candidate a CandidateError (the node rules, or an output that differs
from the group's). Bodies stay todo!() until PR 2.
…mo (#1207 PR 0)

Memo::groups is private, read through groups(); groups are added only
through find_or_add_group and queries through add_query (todo!() until
PR 2). memo_of_queries returns Result and its body is todo!() until PR 2,
which builds Stage 0 on find_or_add_group; Stage 0's node-level CSE (cse.rs),
its test_support export and the dead share_identical helper are deleted.
…OperatorInput; coverage only in the memo (#1207 PR 0)

MemoGroup { expression, group_properties: GroupProperties, parents, queries,
candidates } replaces logical_node and child_groups; GroupProperties {
schema, result_kind, summary_coverage,
shareable_when_equal } is derived once by derive_group_properties, which
applies the existing rules to the expression over MemoGroupAsInputs.

The rules (output_schema, output_kind, validate_inputs,
is_shareable_when_equal, summary builds, window chains, scalar subqueries,
top-k, populations) are generic over OperatorInput, implemented for
Rc<OperatorNode> and MemoGroupAsInput; only how they read an input changed.
BuiltOrInput carries the builds a rule makes while deriving (one build over
a chain's window, the build a rollup or a selection stands for).

SummaryCoverage { definition: SummaryStateDefinition { input_group,
unlifted_operators }, selection } is derived only from memo groups
(derive_from_inputs) and stored in GroupProperties; node-tree coverage,
NodeToSummaryCoverageCache, derive_cached and OperatorNode::coverage are
deleted, so node trees have no merge check. Memo::logical_node_trees is
deleted: Pass 1 target discovery (PR 3), devtools group labels (PR 9) and
the export's view coverage (PR 6) are todo!(). find_or_add_group and
add_candidate derive the properties, then todo!() until PR 2.
…elpers (#1207 PR 0)

One state's θ is no longer sized for several consumers: θ comes from
parameter_list per candidate. size_for_all_readers had no non-test caller;
min_recorded, kll::shared_k and univmon::shared_heap served only it.
…perators; delete merged_window_build_node (#1207 PR 0)

- BuiltOrInput / BuiltInput renamed InputOrTemporaryBuild / TemporaryBuild:
  a build a rule constructs only while it derives, never stored in the memo.
- SummaryStateDefinition::unlifted_operators is Vec<Operator<Option<MemoGroupId>>>:
  None marks an operator's main input, Some(g) another input group it reads
  (a scalar subquery's). States whose definitions read subqueries compare and
  merge; CoverageError::SubqueryInDefinition deleted.
- merged_window_build_node deleted with its test; the accuracy guarantee of a
  read of merged tumbling windows is todo!() until PR 4 rewrites it over groups.
…, TimeBound, Pass 2 pruned list, Stage 2 entry (#1207 PR 0)

- Delete WindowLayout, LogicalProperties::window_layout and its two error
  variants, SummaryMerge::newest_tumbling_windows and
  SummaryTumblingWindowChain::tumbling_window_count, with the count-based
  chain builds and expansion; behaviour that read the count is todo!() for
  PR 1, 2, 6, 7 or 9.
- SelectionBox { columns } only, and TimeBound { At, FromEvaluationTime };
  lifting TimeRange/TimeShift is todo!() for PR 2.
- PrunedLogicalCandidate, PruneCause, RootPruneReason and
  LogicalASAPMemoCandidates::pruned.
- error_propagation(consumer, metric) -> Option<ErrorPropagation>;
  Memo::set_input_requirements.
- PhysicalCandidateKey deleted (PrunedCandidate<PhysicalCandidate>),
  PrunedCandidate::group and PhysicalASAPMemoCandidates::query_roots
  dropped; new(logical, physical, edges, pruned).
- Stage 2 entry takes &DeploymentCapabilities (moved into asap-types) and
  cannot fail; PruneReason follows the doc's Stage 2 table.
- DataArrival::{Ingesting, Mixed} gain max_out_of_order_ms.
- GroupProperties::summary_coverage -> aggregate_coverage.
…l; ScalarValue::Timestamp (#1207 PR 0)

Replace TimeBound by IntervalConstraintLimit { FixedValue(ScalarValue),
EvaluationTimePlusMs(i64) }: Constraint::Interval holds
Bound<IntervalConstraintLimit> on every column, so the timestamp column
and value columns share one interval type. Doc comments carry the
examples (m[5m], offset 1h, @ T, SQL ts >= literal, price > 10).
ScalarValue::Timestamp(ms since the epoch) is the fixed value of an
@ T or a SQL timestamp literal.
…s; delete ParametersOfAnotherFamily (#1207 PR 0)

A range m[r] evaluated at t reads (t - r, t]: IntervalConstraintLimit and
Constraint::Interval examples, the chain window doc and the primitive-schema
table now use Excluded lower and Included upper ends. A parameter list holds
only its own family's parameters, so ParametersNotInList also rejects another
family's parameters.
…acy, the plan is one PhysicalASAPDAG (#1207 PR 0)

- Terminology: ops' `family` is `summary_type`; FieldDataType::Sketch(SketchAlgorithm)
  (SketchKind, GroupingStrategy, HydraKind and the ops' `grouping` deleted);
  FamilyCapability is SummaryTypeCapability; parameter_list(algorithm).
- θ is structure only: SketchParams derives equality; KLL failure_probability,
  UnivMon distinct_failure_probability and HLL/KMV relative_error deleted.
- ValueSign and GroupProperties::column_sign; SourceFacts::column_signs
  replaces values_non_negative.
- LogicalRequirements { required_accuracy: Option<RequiredAccuracy> };
  RootPruneReason::BelowRequiredAccuracy; Memo::add_query takes the target
  and n_q; AggIntent measures carry no accuracy and front ends take none.
- asap-accuracy: AccuracyEvidence::measured_guarantee, theoretical_guarantee
  (was local_guarantee), producer_satisfies_logical_requirements(memo,
  producer, consumer, input_index, evidence); the AccuracyModel trait and
  evidence provider, Pass 1's accuracy pruning and AccuracyCheckInputs deleted.
- Physical: ExecutionContext::Evaluation { grid: EvaluationGrid },
  IngestionPipeline(RefreshWindow); RefreshWindowId deleted;
  producer_satisfies_physical_requirements(producer, consumer_timing);
  PruneReason::CountMinWeightsNotProvenNonNegative.
- Plan: PlanOutput { plan: PhysicalASAPDAG }; PhysicalASAPDAGNode::
  selected_physical_candidate; select_plan returns (PhysicalASAPDAG,
  Selection); Selection { accepted_accuracy_per_query, pruned_candidates,
  milp_* }; RealizedPlan, PhysicalWorkloadPlan, DagOfSelectedCandidates,
  SelectedEdge, SelectedNodeId, AssignmentRealizer, ScanWindow and the
  scan/view window functions, SearchReport, SearchStatus, InexactObjective,
  ObjectiveDiffersFromPlanCost, SelectedPlanFailedCheck and
  PlanCost::cost_unit deleted.
- Plan file wire version 14 (summary_type, Sketch(algorithm), no grouping).
- Cost names: NodeCostSource, cost_source, PlanRanking::Cost; Serialize on
  PruneReason, PhysicalProperties, OriginOfCandidateForMemoGroup and
  RootPruneReason.
…e trait, MemoQuery, evaluation grids of groups (#1207 PR 0)

2026-11-09 decisions:
- theoretical_guarantee and AccuracyEvidence::measured_guarantee take the
  failure probability and return the error bound that holds at it (None
  when θ cannot fail that rarely); bodies stay todo!() for PR 4.
- AccuracyEvidence is a trait; NoMeasuredGuarantees has no measurement.
  PlanningModels::evidence and Pass 2 take &dyn AccuracyEvidence.
- The memo holds its queries in one Vec<MemoQuery> { root,
  accuracy_target, values_per_evaluation }; add_query(query).
- SupportedSummary::family is summary_type.
- satisfies is deleted with metric_meets, scope_meets, native_target and
  AccuracyScope::covers, which only it used; target_limit is the
  comparison limit with the tolerance.
- PhysicalCandidate::delivers_on(&PhysicalASAPMemoCandidates, context).
- GroupProperties::depends_on_evaluation_time (derived in PR 2) and
  LogicalASAPMemoCandidates::evaluation_grid_of_group (filled in PR 4).
… the tests that use it (#1207 PR 0)

pass1/composition.rs composed one whole-workload candidate DAG from one
per-computation candidate per target, for tests only; planning adds every
way to compute to the memo instead. It and the 74 tests and fixture helpers
that compose through it are deleted (no interim code for PR 3).
Move-only. Split asap-logical-asap-optimization into asap-stage0-memo,
asap-stage1-pass1-per-computation-candidates and
asap-stage1-pass2-reuse-candidates; rename asap-physical-asap-optimization
to asap-stage2-physical-optimization and asap-plan-selection to
asap-stage3-plan-selection. The old test_support splits by caller. The
crate-graph test checks the new crates; no stage crate depends on another.
Pass 1's tests that build Stage 0's memo and Stage 0's tests that lower
PromQL through Pass 1 are deleted, with the dev-dependencies and helpers
only they used. lower_promql moves to Pass 1's test fixtures, so Pass 1
no longer depends on the PromQL frontend outside its own tests. The
crate-graph test now also checks dev-dependencies between stage crates.
…1207 PR 0b)

Frontend tests that compose Pass 1 candidates and Pass 1 tests that
lower PromQL through the frontend are deleted, with the helpers,
dev-dependencies and test targets only they used. MetricsQL's test that
compares with PromQL's lowering goes too, so no frontend tests depend on
another frontend. The crate-graph test checks dev-dependencies between
stage crates with no exceptions.
…R 0b)

The PromQL test that planned through asap-planner is deleted with its
planner_support helpers; the PromQL and SQL frontends drop their
asap-planner dev-dependency, and PromQL its unused asap-accuracy one.
The crate-graph test now also forbids a stage crate's dev-dependency on
the facade.
- LogicalProperties::new(expression, parameters): a sketch build (a chain
  included) needs θ from parameter_list(algorithm) of its
  FieldDataType::Sketch(algorithm); an exact operator has none.
- parameter_list(algorithm): structures only. Count-Min lists each width
  with depths 5, 7, 10 and 12, Count Sketch with 47, 81, 117 and 155 (its
  median-of-rows δ levels 1e-2 … 1e-5); heap variants each of those
  with the 1-2-5 heap sizes; UnivMon 40 entries; KLL, DDSketch, HLL, KMV
  one entry per ε level. A test keeps the lists equal to today's sizing,
  which is test-only.
- PhysicalProperties::new rejects (IngestionTime, OneEvaluation);
  producer_satisfies_physical_requirements(producer, consumer_timing).
- PhysicalCandidate::delivers_on(candidates, context): None in every
  context, OneEvaluation only in Evaluation contexts, a chain with
  AcrossEvaluations when its width divides the grid's period and phase
  (or the refresh window's width and phase), any other AcrossEvaluations
  result everywhere when its group does not depend on the evaluation
  time, else when its group's evaluation grid holds the context's times;
  Materialized(v) contexts stay todo!() for PR 7.
- Chains: one schema (window_end at column 0, keys, state), TimeRange and
  TimeShift over a chain select windows (an instant TimeRange is
  rejected), a SummaryMerge over them finalizes and rolls up as the
  chain's build over that range (the two PR 0 todos).
- summary_type_of_operator; QueryRecurrence::evaluation_grid_ms is None
  for a fixed interval without a phase.
…, depends_on_evaluation_time, aggregate_coverage), @ end()/@ start() lifted above their subtree (#1207 PR 2)

- Memo: hash-consing (find_or_add_group by expression hash), candidate
  storage (add_candidate), add_query(MemoQuery); Memo::new(declared column
  signs), private declared_column_signs read by a Scan's column_sign.
- Stage 0: memo_of_queries(roots, accuracy_targets, data) adds each query
  with its accuracy target and n_q (values_per_result over series_read),
  and collects the declared signs of the scanned sources (a counter's
  value is non-negative without a declaration).
- GroupProperties::column_sign derived per operator (concepts doc, "Value
  sign"); depends_on_evaluation_time: a TimeRange or time()/now() makes a
  result depend on the evaluation time, @ T pins it;
  reads_only_time_series: a Scan of a time series, or every input group
  reading only time series (OperatorInput::reads_only_time_series computes
  the same rule over node trees; the recursive walks in topk.rs and Pass 1
  are deleted).
- aggregate_coverage for summary states, chains, TimeRange/TimeShift over
  a chain, merges and exact Aggregates; timestamp constraints are
  IntervalConstraintLimit intervals (t - o - W, t - o]; SQL timestamp
  literals and identity casts fold so absolute filters lift.
- PromQL: @ end() / @ start() are lowered as TimeShift { at } above the
  selector or subquery they anchor, which is lowered without them, so it is
  the group of the same expression without @; coverage stops at that
  TimeShift (it is the definition's input group).
…1207 PR 2b)

GroupProperties gains column_lineage (one ColumnLineage per output column,
derived once from the input groups'). Lineage and column_sign are derived
together by one per-operator column layout (stages/column_properties.rs,
which replaces column_sign.rs): a copied column keeps its lineage and sign,
a computed one is Computed with the operator's sign rule. Chains compute
window_end and their state and keep their keys' lineage; a TimeRange or
TimeShift over a chain, and TimeShift { at: End | Start } above a selector,
pass lineage through; a merge of a chain's selected windows has the chain
build's layout.

Summary coverage names a selection's column by its SourceColumn lineage
(the one SourceColumn type, beside Source); ColumnIdentity is deleted. A
predicate on a Computed column, or on one of two columns of one lineage,
is not lifted; the regrouping key check compares lineage. Schema fields
and the IR Project lose their table qualifier; the front ends bind
qualified names with their own scope while lowering. The requalification
patches (with_aggregate_qualifiers, node.rs) are deleted.
…1207 PR 3)

Pass 1 fills Stage 0's memo with each group's initial candidates, every
intermediate result its own group and every candidate one operator over
input groups:

- computation_targets walks memo.groups(): one target per measure of each
  Aggregate group with a realization besides plain exact execution.
- add_pass1_candidates adds every group's own expression, exact
  accumulators (state group + FinalizeExactAccumulator; avg from sum and
  count), one SummaryAgg state group per sketch algorithm with one build
  candidate per configuration of parameter_list(algorithm) and separate
  SummaryEstimate readout groups, fused builds (whole-expression top-k
  heaps; nested sum/min/max merges) listing the replaced groups in
  fused_groups, multi-measure joins, and key-only HAVING pushed below in
  the consumer Filter group's candidates.
- Pass 1 sets no input requirement and no accuracy floor: every
  candidate's LogicalRequirements are empty; Pass 2 gives each readout its
  required accuracy (a top-k readout's heap_size >= k included).
- ComputationTarget and FusedComputation move into Pass 1 (crate-private),
  FusedComputation::absorbed_groups replaces target indices, HavingEntry,
  HavingPlacement and Pass1Error are deleted; pass1_memo returns
  PerComputationCandidateError.
- types: topk::ranked_column_of_group (ranked_column becomes pub(crate));
  one unique-key rule for a top-k's ranked rows, exact or a heap readout;
  any_measure_filtered generic over the predicate's input.
- Tests build their memo through the Memo methods; the integration tests
  stage1_logical_asap_optimization and per_computation_candidates_sql run
  SQL and PromQL queries through Stage 0 and Pass 1.
…requirements, dead-candidate elimination, chain groups (#1207 PR 4)

Pass 2 runs, in order: the general rollup rule with one synthesized
finest common group per cluster of equal definitions (replaces scan
widening, finer-aggregate reuse and the rollup rules); top-k reuse; reach,
caps and readout requirements (one readout candidate per requirement level,
written with Memo::set_input_requirements); dead-candidate elimination with
every root cause (PrunedLogicalCandidate); chain groups
SummaryTumblingWindowChain[w](X) for the surviving state groups, widths
from the gcd closure of the reaching queries' grids, the window and the
offsets, then elimination again; and the logical edges between survivors.
A merge, and a Filter/TimeRange/TimeShift over states, carries the θ of
the states it reads (one candidate per θ, reading only producers with that
θ). The metric rule cuts edges from readouts whose metric the consumer's
input does not accept (accepted metrics pushed down from the targeted
queries), not candidates; a candidate cut off from an input is eliminated
too. A whole-result δ with n_q unknown prunes the readouts it reaches
(ValuesPerEvaluationUnknown). The summary-input and
window-rollup rules and the local-window-composition step are deleted.

- types: LogicalRequirements::error_propagation(memo, consumer, metric)
  with the constant contracts (key-only Filter by column lineage, abs /
  clamp / negation, min / max / avg / count, + - / *), b = 0.1 private;
  AccuracyMetric::ALL; RootPruneReason::{HeapSmallerThanTopK,
  ValuesPerEvaluationUnknown}; MetricRule.accepted_metrics;
  PruneCause.through_pruned_candidates; Memo::producers; add_candidate
  checks θ against the group's state (CandidateError::LogicalProperties);
  a candidate's
  input requirements are part of its identity in add_candidate; summary
  coverage accessors no longer test-only; origins SummaryInput and
  WidenedScans deleted.
- accuracy: theoretical_guarantee at a failure probability (KLL and KMV
  evaluated at it, others checked against their own),
  producer_satisfies_logical_requirements returns the failing root reason,
  readout_metric; node-tree composition, propagation, budget split,
  function rules, PropagationStats, test_support and the test-only sizing
  deleted.
- devtools: one pass2 stage.
…natives; Count-Min weights via column_sign (#1207 PR 5)

Stage 2 expands each logical candidate Pass 2 kept into its offered
(timing, lifetime): ingestion time for time-independent groups and their
inputs (counter states only over ordered rows), AcrossEvaluations for
chains and grid-evaluated groups. Prune reasons: NoIngestionPipeline,
RawDataNotRetained, QueryTimeResultsNotRetained,
CountMinWeightsNotProvenNonNegative, InputHasNoBuildableProducer,
ReachesNoQueryOutput. Physical edges carry alpha^log and alpha^phys;
PhysicalASAPMemoCandidates indexes the admissible ones.

Deletes WeightDomain, NonNegativeWeightProof and SummaryUpdate::weight_domain
(the state group's column_sign replaces them), Pass 1's copy of
reads_only_time_series, and per-crate memo test fixtures
(asap_types::test_support).
…ive tumbling-window chains and a time-indexed store in the executor (#1207 PR 6)

Stage 3 costs each physical candidate (w_v) and each selectable edge
(c_{u,c,i}) with asap-cost, solves the baseline MILP over x, y, z, t
(constraints (A)-(F), (E) only inside strongly connected components, a
query-time result that is not materialized read by at most one consumer),
and builds the PhysicalASAPDAG of the optimum directly, each node with its
timing, lifetime, θ, retention and, materialized, its summary coverage.
asap-cost sizes summaries from the node's θ and prices chains and raw data
by the node's retention_ms. The executor builds and runs summaries with θ,
runs tumbling-window chains natively (TimeRange/TimeShift over a chain
select windows), keeps materialized rows in a time-indexed store with
retention, and evaluates TimeShift{at} once per request. Installation no
longer expands chains.
…}, h_v and constraint (R); asap-cost computes once per context (#1207 PR 7)
…tioned DDSketch guarantee, sum/avg relative contracts, HLL distinct count from the source's distinct bound (#1207 PR 8)
… by layer and every pruned candidate with its cause; planner_fuzz costs witnesses over Stage 3's plan; viewer reads the plan; snapshots and pins re-baselined (#1207 PR 9)

- asap_planner text and asap-stage-pipeline/v2: Pass 2 logical edges with alpha^log and why each fails, Pass 2 eliminated candidates with root-cause traces, Stage 2 physical edges with alpha^phys, Stage 2 and Stage 3 pruned candidates with reasons, Stage 3 plan and plan_cost; the text folds a group's candidates that differ only in theta into one line (indices, theta values, pruned counts per cause), --full prints everything; L1/P1 lists, memo node table and same_candidate deleted.
- planner_fuzz: plans with accuracy not enforced; witnesses extend Stage 3's PhysicalASAPDAG and are costed by plan_cost; shared nodes are materialized for one evaluation only within one evaluation grid; LongerWindow and NewestTumblingWindows are a TimeRange over the same chain; the accuracy relations (a-looser-accuracy, tighter-accuracy) are deleted.
- PruneReason, RootPruneReason and OriginOfCandidateForMemoGroup serialize snake_case; RejectionCause keeps only Infeasible; ErrorSelectingPlan::Cost deleted.
- price -> cost wording; develop docs and planner-layering refreshed; viewer reads the new document.
- Every in-repo workload and test fixture declares its phase (fixed_interval_at, phase 0).
- Corpus and sketch plan snapshots re-baselined; obsolete tests deleted; pins re-baselined.
…s, naming, ignore policy, tiers, stack hygiene and a measured coverage matrix (#1253 T0)
@zzylol
zzylol force-pushed the refactor/1207-tools branch from b367388 to 9e0f501 Compare November 10, 2026 13:37
@zzylol
zzylol force-pushed the test/1253-t0-strategy-doc branch from 2eb3209 to 525bf2d Compare November 10, 2026 13:37
@zzylol
zzylol force-pushed the refactor/1207-tools branch 4 times, most recently from d744bd7 to bd3a333 Compare November 16, 2026 23:04
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

documentation Improvements or additions to documentation testing Corpus, regression, differential, or benchmark tests

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant