feat(planner): enumerate local logical alternatives without execution timing

Cargo.toml

@@ -2,6 +2,7 @@
 members = [
     "crates/asap-physical-operators",
     "crates/types",
+    "crates/frontend-common",
     "crates/sql-function-catalog",
     "crates/asap-aware-mapping",
     "crates/frontend-promql",

crates/asap-aware-mapping/src/accuracy/composition.rs

@@ -448,9 +448,7 @@ fn composed_provenance(
 }
 
 pub(super) fn exact_operation_rule(operation: &ExactOperation) -> Option<CompositionOperator> {
-    let ExactOperation::Aggregate { measures, .. } = operation else {
-        return None;
-    };
+    let ExactOperation::Aggregate { measures, .. } = operation;
     match measures.as_slice() {
         [intent] => crate::function_rules::function_rules(intent).map(|rules| rules.accuracy),
         // The remaining functions are exact over exact samples, but have
@@ -1035,8 +1033,8 @@ mod tests {
             reduction: asap_types::pre_asap::Reduction::PerEntity,
             measures: vec![intent],
             output_names: vec![],
-            having: None,
             filters: vec![],
+            having: None,
         };
         assert_eq!(
             DefaultAccuracyModel.exact_operation_rule(&operation(AggIntent::Rate)),

crates/asap-aware-mapping/src/accuracy/estimators/cms.rs

@@ -65,7 +65,7 @@ mod tests {
     }
 
     #[test]
-    fn heap_readout_retains_frequency_metric() {
+    fn heap_evaluation_retains_frequency_metric() {
         use asap_types::post_asap::{GroupingStrategy, SketchKind};
         let cms_heap = SketchParams::CmsWithHeap {
             width: 272,

crates/asap-aware-mapping/src/accuracy/estimators/hll.rs

@@ -1,7 +1,7 @@
 //! Estimator-specific confidence for classic HLL's linear-counting branch.
 //!
 //! This is conditional on independent uniform bucket hashes and an enforced
-//! upper bound on distinct items in the complete readout population (including
+//! upper bound on distinct items in the complete evaluation population (including
 //! all merged panes). It is not an RSE-to-normal conversion or an ERP fit.
 
 use super::*;
@@ -56,13 +56,13 @@ impl ClassicHllConfidence {
                 value: self.relative_error,
             },
             failure_probability: ProbabilityExpr::Constant { value: delta },
-            provenance: vec![GuaranteeSource::SketchReadout {
+            provenance: vec![GuaranteeSource::SketchEvaluation {
                 algorithm: "Hll".into(),
                 contract: "classic_hll_linear_counting_collision_bound_v1".into(),
                 params: serde_json::json!({"precision": precision,
                     "max_distinct": self.max_distinct, "relative_error": self.relative_error,
                     "hash_assumption": "independent_uniform_buckets",
-                    "population_scope": "complete_readout_including_merged_panes"}),
+                    "population_scope": "complete_evaluation_including_merged_panes"}),
                 query: "Cardinality".into(),
             }],
         })
@@ -187,7 +187,7 @@ mod tests {
             }
         }
     }
-    /// The model's readout formula matches the actual classic estimator after merge.
+    /// The model's evaluation formula matches the actual classic estimator after merge.
     #[test]
     fn native_classic_estimator_and_merged_registers_use_the_same_contract() {
         use asap_sketchlib::sketches::hll::{Classic, HyperLogLogP16};

crates/asap-aware-mapping/src/accuracy/estimators/kll.rs

@@ -69,7 +69,7 @@ mod tests {
         assert_eq!(g.approximate_layer_count(), 1);
         assert!(g.provenance.iter().any(|source| matches!(
             source,
-            GuaranteeSource::SketchReadout { contract, .. }
+            GuaranteeSource::SketchEvaluation { contract, .. }
                 if contract == "apache_datasketches_kll_empirical_99_a9b42755072b"
         )));
     }

crates/asap-aware-mapping/src/accuracy/estimators/mod.rs

@@ -46,7 +46,7 @@ fn bounded_guarantee(
         metric,
         bound: BoundExpr::Constant { value: bound },
         failure_probability: delta,
-        provenance: vec![GuaranteeSource::SketchReadout {
+        provenance: vec![GuaranteeSource::SketchEvaluation {
             algorithm: format!("{algorithm:?}"),
             contract: contract.into(),
             params: serde_json::to_value(params).unwrap_or(serde_json::Value::Null),
@@ -169,9 +169,9 @@ impl<'a> EstimatorAccuracy<'a> {
 
     fn hll(&self) -> Option<hll::ClassicHllConfidence> {
         let EstimatorContract::ClassicHll {
-            max_distinct_per_readout,
+            max_distinct_per_evaluation,
         } = self.contract?;
-        hll::ClassicHllConfidence::new(max_distinct_per_readout, self.epsilon)
+        hll::ClassicHllConfidence::new(max_distinct_per_evaluation, self.epsilon)
     }
 
     pub(crate) fn size_params(&self, algorithm: &SketchAlgorithm) -> Option<SketchParams> {

crates/asap-aware-mapping/src/accuracy/estimators/univmon.rs

@@ -1,4 +1,4 @@
-//! UnivMon currently certifies only its exact unit-update total readout.
+//! UnivMon currently certifies only its exact unit-update total evaluation.
 use super::*;
 
 pub(super) fn guarantee(query: &SketchStatistic) -> Option<ResultGuarantee> {

crates/asap-aware-mapping/src/accuracy/evidence.rs

@@ -2,12 +2,12 @@
 use super::*;
 
 /// A trusted source assertion scoped by `AccuracyEvidenceProvider` to one
-/// complete readout. Choosing this variant asserts the estimator and hash
+/// complete evaluation. Choosing this variant asserts the estimator and hash
 /// assumptions; it must not be inferred from sampled population statistics.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum EstimatorContract {
     /// Classic HLL with independent uniform bucket hashing, including merged panes.
-    ClassicHll { max_distinct_per_readout: u32 },
+    ClassicHll { max_distinct_per_evaluation: u32 },
 }
 
 /// An enforced domain for every sample of a direct quantile operand, in every
@@ -18,7 +18,7 @@ pub enum EstimatorContract {
 pub struct QuantileInputDomain {
     pub lower: f64,
     pub upper: f64,
-    /// Upper bound on samples per evaluation, matching the pinned readout's
+    /// Upper bound on samples per evaluation, matching the pinned evaluation's
     /// exact Float64 rank limit. The population must also be nonempty.
     pub max_samples: u64,
     pub contract: String,
@@ -87,31 +87,22 @@ pub struct PropagationStats {
 /// Supplies typed planning-time evidence required by propagation rules.
 pub trait AccuracyEvidenceProvider {
     /// Trusted estimator contract for this complete aggregate expression,
-    /// including source, filters, grouping and all panes in each readout.
+    /// including source, filters, grouping and all panes in each evaluation.
     /// An observed cardinality is not an enforced population bound.
-    fn estimator_contract(
-        &self,
-        _expression: &asap_types::pre_asap::QueryExpr,
-    ) -> Option<EstimatorContract> {
+    fn estimator_contract(&self, _expression: &OperatorNode) -> Option<EstimatorContract> {
         None
     }
 
     /// Enforced upper bound on distinct (partition, item) identities across a
-    /// complete TopK readout. Used to union-bound score errors for adaptively
+    /// complete TopK evaluation. Used to union-bound score errors for adaptively
     /// selected candidates. Observed cardinality is not sufficient evidence.
-    fn topk_max_distinct_items(
-        &self,
-        _expression: &asap_types::pre_asap::QueryExpr,
-    ) -> Option<u64> {
+    fn topk_max_distinct_items(&self, _expression: &OperatorNode) -> Option<u64> {
         None
     }
 
     /// Proof scoped to this complete quantile expression, including its source,
     /// filters, grouping and window. `None` means unknown, including emptiness.
-    fn quantile_input_domain(
-        &self,
-        _operand: &asap_types::pre_asap::query_expr::QueryExpr,
-    ) -> Option<QuantileInputDomain> {
+    fn quantile_input_domain(&self, _operand: &OperatorNode) -> Option<QuantileInputDomain> {
         None
     }
 

crates/asap-aware-mapping/src/accuracy/mod.rs

@@ -20,18 +20,20 @@ pub use evidence::{
     QuantileInputDomain, WorkloadAccuracyEvidence,
 };
 
+use asap_types::ir::OperatorNode;
 use asap_types::post_asap::{
-    AccuracyError, BoundExpr, CompositionOperator, ErrorMetric, ExactOperation, FieldDataType,
-    GuaranteeSource, ProbabilityExpr, ResultGuarantee, SketchAlgorithm, SketchParams,
-    SketchStatistic,
+    AccuracyError, BoundExpr, CompositionOperator, ErrorMetric, FieldDataType, GuaranteeSource,
+    ProbabilityExpr, ResultGuarantee, SketchAlgorithm, SketchParams, SketchStatistic,
 };
 use asap_types::types::AccuracyTarget;
 
+use crate::exact_composition::ExactOperation;
+
 /// The deployment-extensible accuracy algebra. `asap-aware-mapping` ships
 /// [`DefaultAccuracyModel`]; a deployment with a proof for a composition the
 /// default rejects (a registered cross-metric conversion, say) implements
 /// this trait and passes it to
-/// [`crate::replacement::SketchAlgorithmStrategy::new_with_planning_inputs`].
+/// [`crate::replacement::ASAPStrategies::new_with_planning_inputs`].
 pub trait AccuracyModel {
     /// The definition-registered rule for applying `operation` to an
     /// approximate input. `None` means the function is exact only over exact
@@ -78,7 +80,7 @@ pub struct DefaultAccuracyModel;
 const SATISFACTION_TOLERANCE: f64 = 1e-9;
 
 impl DefaultAccuracyModel {
-    /// Derive the guarantee for the committed estimator parameters and readout.
+    /// Derive the guarantee for the committed estimator parameters and evaluation.
     pub fn sketch_guarantee(
         algorithm: &SketchAlgorithm,
         params: &SketchParams,