Dynamic Subproblem Reuse¶
Reuse solutions to recurring subproblems so repeated decision work does not have to be recomputed.
The Diagnostic Story¶
Symptom: Teams keep solving the same problem in parallel, arriving at slightly different answers, and nobody knows which version to trust. Complex planning bogs down because every path through the decision requires rediscovering calculations that have already been done. When one assumption changes, it triggers a cascade of manual updates across documents, models, and memories.
Pivot: Convert recurring local decisions into reusable subproblem records: define the state, solve or validate the partial answer, store it with its assumptions and versioning, retrieve it when an equivalent state recurs, and recombine it into the larger solution through an explicit rule.
Resolution: Repeated work is reduced and local decisions become more consistent. Complex plans can be assembled faster because solved subproblems are available rather than re-derived from scratch. When assumptions change, invalidation rules update dependents explicitly rather than propagating silently through untracked copies.
Reach for this when you hear…¶
[operations planning] “Every regional team computed travel-time matrices from scratch and got different answers — we need one solved matrix that everyone stamps with the same version.”
[software engineering] “We're computing this same intermediate result three times in different services; memoize it once or we'll keep getting inconsistencies.”
[legal practice] “We litigated this same jurisdictional question two years ago — pull the memo, check if the facts still match, and stop redoing the analysis.”
Mechanisms / Implementations¶
- Cache Invalidation Review
- Dynamic Programming Method
- Dynamic Programming Table
- Memoization Cache
- Modular Planning Template
- Precedent Index
- Recurrence Equation
- Reusable Playbook Library
Related Abstractions¶
Abstractions this archetype builds on — directly (a source ingredient) or as a related pattern. Links follow the typed catalog namespace.
Built directly on (3)
- Caching: Store for faster retrieval.
- Dynamic Programming: Solve via subproblem reuse.
- Recursion: Breaks processes into self-similar steps.
Also references 13 related abstractions
- Abstraction: Focus on core elements.
- Algorithm: Step-by-step problem-solving procedure.
- Bounded Rationality: Limited decision capacity.
- Causality: Cause-effect relationships.
- Chunking: Group information units.
- Complexity: Measures system intricacy.
- Composition: Arranges components into a cohesive whole.
- Feedback: Outputs influence inputs.
- Modularity: Breaks systems into smaller units.
- Optimization: Finds best solution under constraints.
Variants¶
Narrower or domain-specific specializations that share this archetype's core structure. Recognized variants are established; candidate variants are provisional.
Memoized Recursive Solution · mechanism family variant · recognized
Solve a recursive problem by caching subproblem answers as they are first encountered and reusing them on repeated calls.
Bottom-Up Stage Reuse · temporal variant · recognized
Solve smaller or later-stage subproblems first, then build larger solutions from stored partial results in dependency order.
Organizational Playbook Reuse · domain variant · recognized
Capture recurring operational subproblems as reusable playbooks so teams do not redesign a response from scratch each time.