Recomposition Consistency Test¶
Test / assessment — instantiates Constraint Propagation and Decoupling
Tests whether independently produced local solutions still satisfy the original global constraints when combined.
Decoupling earns its speed by letting subproblems be solved in isolation — but isolation is a promissory note that comes due at the end. Recomposition Consistency Test is where the note is called: after the local solutions come back, it reassembles them and checks the combined result against the original global constraints, invariants, and shared-resource limits that the split set aside. The one idea that makes it this mechanism and not a sibling is that it is a post-hoc verification of an assembled whole — it runs after local solving, on the recombined artifact, asking one question: do the pieces that were each individually valid still hold together? When they don't, it doesn't just fail; it records which global constraint broke and which local commitments collided, so the violation can be traced back rather than merely announced.
Example¶
A corporation builds next year's budget by decoupling: each of five divisions plans its own spend against its own targets, in parallel, and each division's plan is internally sound. Before the consolidated budget is approved, finance runs a recomposition consistency test — it sums the divisional plans into a single corporate budget and checks the global constraints that no division could see on its own: the firm-wide capital-expenditure ceiling, the group cash-flow covenant with lenders, and the intercompany transfers that must net to zero.
Two of the three global checks pass. The third fails: divisions A and C each booked the same shared data-center build as their own capex, so the consolidated capex total exceeds the ceiling by the cost of one data center double-counted. The test doesn't stop at "over budget." It records the specific violation — capex ceiling exceeded — and traces it to the collision: two locally-valid plans claiming one shared resource. That trace is what routes the fix to the right place (deconflict the shared line, or re-propagate the ceiling as a divisional constraint) instead of sending every division back to redo sound work.
How it works¶
The test is assemble, check, and localize:
- Reassemble the local solutions into the combined artifact, honoring the interface commitments each subproblem was given.
- Re-apply the global constraints. Evaluate every original hard constraint, invariant, shared-resource limit, and cross-boundary condition against the whole, especially the ones no single subproblem could check.
- Record pass or violation. For each global constraint, report satisfied or violated — and where violated, capture which local commitments conflict and by how much.
- Localize the cause. Attribute each violation to the interface, shared resource, or residual coupling that produced it, so remediation targets the seam rather than the pieces.
It renders a verdict on an assembled result; it does not decide where to split, narrow domains, or fix references.
Tuning parameters¶
- Check coverage — test only the constraints suspected to cross boundaries, or re-evaluate the full global set. Fuller coverage catches more but costs more to run.
- Tolerance — exact satisfaction versus an allowed residual band on near-continuous global constraints. A tolerance absorbs harmless rounding but can wave through a real drift if set too wide.
- Granularity of attribution — a bare pass/fail, or a full trace of which local commitments collided. Richer attribution speeds the fix but takes more instrumentation.
- Cadence — a single test at final assembly, or repeated tests as each subproblem lands. Frequent checks catch violations early but re-run overhead many times.
- Failure routing — whether a violation loops back to re-propagation, to boundary redesign, or to local re-solving. The right route depends on whether the cause was a missed constraint, a bad split, or a local error.
When it helps, and when it misleads¶
Its strength is that it is the safety net the whole decoupling strategy depends on: it catches the fallacy of composition[n1] — the case where every part is individually valid yet the whole violates a constraint no part could see — before the recombined result is trusted or shipped. And by localizing the violation, it turns "something's wrong globally" into "this shared resource is double-claimed," which is actionable.
Its failure mode is being run too late and too coarse: a single end-of-line pass/fail discovers a deep incompatibility only after all local work is done and expensive to redo, which is the worst time to learn the split was unsafe. A test with weak coverage or a loose tolerance can also pass a result that quietly violates a constraint it never checked, manufacturing false confidence. And it verifies but does not repair — treating a green result as proof the decoupling was well-chosen (rather than merely that this instance held) invites the next assembly to fail differently. The discipline is to run it as early and as often as the interfaces allow, keep coverage aligned to the actual global constraints, and treat a failure as a signal to revisit the boundary, not just to patch the seam.
How it implements the components¶
Recomposition Consistency Test realizes the validation slice of the archetype — the check that closes the decoupling loop:
consistency_and_recomposition_check— it is that check: it reassembles the local solutions and verifies the combined result still satisfies the original global constraints and invariants.conflict_explanation_record— on a violation it records which global constraint broke and which local commitments collided, producing a traceable account rather than a bare failure.
It validates a partition after the fact; it does not decide where to split or define the subproblems (coupling_boundary_map, decoupled_subproblem_partition) — that is Cut-Set or Separator Analysis, which acts before local solving. Nor does it derive the constraint implications it re-checks (propagation_rule_set, derived_implication_register); those come from Domain Reduction Pass and Backward Deadline Pass.
Related¶
- Instantiates: Constraint Propagation and Decoupling — the test supplies the recomposition check that makes decoupled solving trustworthy.
- Consumes: Cut-Set or Separator Analysis supplies the partition and interface commitments whose reassembly it validates.
- Sibling mechanisms: Backward Deadline Pass · Constraint Dependency Matrix · Cut-Set or Separator Analysis · Domain Reduction Pass · Gauge-Fixing Choice · Constraint-Satisfaction Solver Pass
Editorial Notes¶
Form Classification¶
Form family: Experiment, Test & Rehearsal
Rationale: Recomposition Consistency Test operates by actively reassembles local solutions and exercises the whole against global constraints and interfaces. That concrete deployed or enacted form is Experiment, Test & Rehearsal under the frozen taxonomy.
Nearest alternative: Assessment, Review & Assurance — Although Assessment, Review & Assurance can support this mechanism, the frozen evidence makes its operative form the act that actively reassembles local solutions and exercises the whole against global constraints and interfaces; the alternative is therefore secondary rather than defining.
Review outcome: Adjudicated after independent review; high confidence.
Origin Attribution¶
Primary origin: Computer Science & Software Engineering
Origin pattern: Cross-disciplinary synthesis
Present-day reach: Multi-domain
Rationale: Compositional verification checks local components under assumptions and then discharges those assumptions at system level; mathematics supplies its proof structure.
Related originating lineages:
- Mathematics — Compositional proof and constraint consistency independently formalize the same requirement.
Review resolution: The blind reviewers disagreed on primary lineage. Light authoritative research resolves the defining form in favor of computer_science: Compositional verification checks local components under assumptions and then discharges those assumptions at system level; mathematics supplies its proof structure. The rejected primary is retained only when it materially shaped the mechanism, and present-day breadth is recorded separately as domain_reach=multi_domain.
Review outcome: Researched adjudication after independent review; high confidence.
Sources consulted:
Notes¶
[n1] The fallacy of composition — inferring that what is true of each part must be true of the whole. Decoupled solving is exactly where this bites: each local solution can satisfy its own constraints while the combined result violates a global one, which is why a recomposition check is not optional. ↩