Domain Reduction Pass¶
Procedure — instantiates Constraint Propagation and Decoupling
Iteratively narrows possible values, options, quantities, or time windows by applying propagated constraints.
Each element of a coupled problem starts with a domain — the set of values, options, or quantities it might still take. Domain Reduction Pass shrinks those domains by repeatedly firing the constraints against them: whenever a constraint proves that some value is now impossible given what other elements can still be, that value is struck from the domain, and the strike cascades to the constraints that touched it. The one idea that makes it this mechanism and not a sibling is that it is an iterative narrowing to a fixed point — it loops, each pass pruning more, until a full sweep removes nothing further (or a domain empties, exposing a conflict). It does not sweep once from an endpoint, and it does not find where to split; it grinds the feasible sets down until they stop moving.
Example¶
A shopper is configuring a build-to-order laptop, and the configurator quietly runs a domain reduction pass after every click. The open domains are large: fourteen CPUs, four chassis sizes, three GPU tiers, five battery options, a range of RAM and storage. The shopper picks the thinnest chassis. That single choice fires a wave of constraints. The thin chassis can't dissipate the top two CPUs' heat, so those drop out of the CPU domain; the discrete GPU won't fit, so the GPU tier collapses to integrated only; the large battery won't physically fit, so it leaves the battery domain — and that removal fires again, because the two highest-power CPUs also required the large battery, reinforcing their exclusion.
The pass keeps looping until a full pass changes nothing: the domains have reached a fixed point. What was a catalog of thousands of buildable combinations is now a handful, each one guaranteed consistent. And when the shopper then tries to force the discrete GPU back in, the pass finds no chassis left that supports it and the GPU domain empties — the configurator surfaces why ("no available chassis provides the required PCIe lanes and cooling") rather than a bare "unavailable." That narrowed set is what makes the rest of the choice tractable.
How it works¶
The procedure is a fixed-point loop, not a one-shot sweep:
- Fire the constraints. For each active constraint, remove from each element's domain any value that has no consistent partner in the other elements' current domains.
- Cascade the removals. Every deletion re-activates the constraints touching that element, so a single prune can trigger a chain of further prunes.
- Repeat to a fixed point. Keep looping until a complete pass makes no change — the domains have stabilized under all constraints simultaneously.
- Halt on emptiness. If any domain reduces to nothing, stop: the constraints, as posed, have no consistent assignment, and the pass records the chain that led there.
Unlike an automated solver that also searches for a full assignment, this pass only narrows — it hands a smaller, still-multi-valued space to whatever chooses next.
Tuning parameters¶
- Consistency strength — how thoroughly each pass checks: prune only against directly-linked elements, or enforce deeper multi-element consistency. Stronger pruning shrinks domains more but costs more per iteration.
- Propagation order — which constraints fire first, and whether a work-queue prioritizes recently-changed elements. Order does not change the fixed point but changes how fast it is reached.
- Stop condition — run to a true fixed point, or halt early at "good enough" narrowing under a time budget. Early stopping is faster but leaves prunable dead values in the domains.
- Granularity of domains — enumerated discrete sets versus interval bounds for continuous quantities. Intervals scale to large ranges; enumerations catch odd-shaped exclusions.
- Conflict handling — on a domain wipeout, stop at the first empty domain or continue to catalog all conflicts. Cataloging more aids diagnosis but wastes work if one relaxation fixes everything.
When it helps, and when it misleads¶
Its strength is that it does cheaply what exhaustive enumeration cannot: it eliminates whole regions of impossibility before anyone searches, and it detects infeasibility early — a wiped-out domain is a conflict caught now instead of after a full solution is built. Because it reaches a fixed point[n1], its output does not depend on the order the constraints happened to fire.
Its failure mode is quietly over-pruning from an over-tight or mis-stated constraint: the pass will confidently strike valid values, and because it reports a clean, smaller domain, the loss is invisible unless the model is checked against intent. It can also stall usefulness by only narrowing — a domain reduced from thousands to dozens still isn't a decision, and treating "reduced" as "solved" is a classic misuse. And weak consistency can terminate at a fixed point that still hides an infeasibility deeper search would find. The discipline is to validate the constraints before trusting the pruning, keep the conflict record when a domain empties so the why is recoverable, and hand the narrowed space to a chooser rather than mistaking it for the answer.
How it implements the components¶
Domain Reduction Pass realizes the iterative-propagation slice of the archetype — grinding domains down and catching contradictions:
propagation_rule_set— the pruning rules it fires (delete any value with no consistent partner) are the propagation logic that turns constraints into domain removals.propagation_stop_condition— the fixed-point test (a full pass that removes nothing, or an empty domain) defines exactly when propagation halts.conflict_explanation_record— when a domain wipes out, it records the cascade of removals that led there, so the contradiction is diagnosable rather than a bare failure.
It narrows value domains iteratively; it does not derive time windows from an endpoint or budget slack (slack_or_tolerance_budget, derived_implication_register) — that is its nearest twin, Backward Deadline Pass, a single directional sweep rather than a fixed-point loop. Nor does it choose a reference frame (invariant_and_gauge_basis); that is Gauge-Fixing Choice.
Related¶
- Instantiates: Constraint Propagation and Decoupling — the pass supplies the reduced feasible space the rest of the archetype partitions and solves.
- Consumes: Constraint Dependency Matrix supplies the network of constraints whose rules it fires.
- Sibling mechanisms: Backward Deadline Pass · Constraint Dependency Matrix · Cut-Set or Separator Analysis · Gauge-Fixing Choice · Recomposition Consistency Test · Constraint-Satisfaction Solver Pass
Editorial Notes¶
Form Classification¶
Form family: Analysis, Modeling & Optimization
Rationale: Domain Reduction Pass operates as a computation, comparison, model, or analytic representation used to infer, estimate, or choose because it iteratively narrows possible values, options, quantities, or time windows by applying propagated constraints.
Independent corroboration: The frozen evidence defines Domain Reduction Pass as 'Iteratively narrows possible values, options, quantities, or time windows by applying propagated constraints', so its operative form is Analysis, Modeling & Optimization.
Nearest alternative: Intervention, Treatment & Transformation — Constraint propagation computes a fixed-point reduction of candidate domains; removals change the working representation but are the analytic result.
Review outcome: Independent reviewer agreement; medium confidence.
Origin Attribution¶
Primary origin: Computer Science & Software Engineering
Origin pattern: Cross-disciplinary synthesis
Present-day reach: Multi-domain
Rationale: Constraint programming cohered iterative domain reduction by propagating constraints until a monotone fixed point leaves no further values to prune.
Related originating lineages:
- Operations Research — Constraint-satisfaction and optimization practice co-developed bound and domain reduction for feasible quantities and schedules.
Review resolution: Computer-science constraint programming is primary, with operations research a genuine co-development lineage. Lattice mathematics supplies formal convergence theory but not a separate recognizable practice lineage.
Review outcome: Reconciled after independent review; high confidence.
Notes¶
The line between this procedure and an automated Constraint-Satisfaction Solver Pass is narrowing-versus-solving. Domain Reduction Pass only prunes to a fixed point and stops; a solver pass may continue into a search for a complete satisfying assignment. Keeping them separate is what lets a lightweight, inspectable narrowing run by hand or in a planning tool without committing to a full solver — and what lets the narrowed domains be handed to a human chooser rather than a machine verdict.
[n1] A fixed point of the reduction is a state of the domains that a further pass leaves unchanged. Because pruning only ever removes values (it is monotone), the loop is guaranteed to reach one; the same fixed point is reached regardless of the order constraints are applied, which is why the result is order-independent. ↩