Propagation Simulation or Fault Injection¶
Simulation test — instantiates Cascade Pathway Management
Executes a modeled or live cascade — injecting a fault and pushing the system past its thresholds — to measure how far and fast propagation actually travels.
Propagation Simulation or Fault Injection stops guessing about a cascade and runs one — either in an executable model of the system or by deliberately injecting a fault into a real (or realistically emulated) one — to measure how the disturbance actually spreads. Its defining property is execution: where every other analytic mechanism reasons about propagation on paper, this one produces empirical propagation data by making the system do it. It fires a trigger, lets the transfer links carry it, and records the observed reach, speed, branching, and where thresholds actually tip — numbers that no static map or human workshop can supply because they are properties of the system in motion, not of anyone's description of it.
Example¶
A national forest agency needs to know whether its planned firebreaks will actually stop a wildfire from crossing a ridge into a populated valley. Arguing about it on a map is inconclusive, so they run a propagation simulation. They build an executable fire-spread model of the terrain — fuel loads, slope, prevailing winds — and inject an ignition at a chosen point, then let the model propagate fire cell to cell under the physics of spread.[n1]
They run it hundreds of times across wind and moisture conditions. The simulation reveals what the static map hid: under a specific dry down-slope wind, the fire jumps a canyon the planners assumed was a natural break, and reaches the valley in four hours instead of the eight they'd expected — the threshold where spread turns from creeping to explosive sits at a lower wind speed than anyone believed. Armed with the measured propagation, they move a firebreak and add a second. The simulation didn't describe the pathway; it ran the pathway and returned how far and how fast fire actually traveled, exposing an amplifying link the map never showed.
How it works¶
- Build or wire up an executable substrate. Either a validated model that reproduces the system's propagation physics, or the live/emulated system itself instrumented to be safely perturbed.
- Inject a defined trigger. A specific fault, ignition, shock, or failure is introduced at a chosen node — the experiment's independent variable.
- Let it propagate and record everything. The disturbance is allowed to travel the real transfer links while instrumentation captures reach, speed, branching factor, and the exact conditions under which each threshold tips.
- Sweep conditions to find the tipping points. The run is repeated across parameter ranges to locate where propagation shifts from linear to nonlinear — the empirical amplification profile, discovered rather than assumed.
Tuning parameters¶
- Fidelity vs. cost — how faithfully the substrate reproduces reality. High fidelity (or live injection) yields trustworthy propagation data but is expensive and, when live, risky; low-fidelity models are cheap and fast but may propagate unlike the real system.
- Blast radius / containment — for live fault injection, how much of the real system is exposed to the injected fault. Wider exposure gives more realistic data but risks a real incident; tight containment is safe but may suppress the very propagation being studied.
- Trigger set — which faults are injected and where. Broad coverage finds surprising paths; narrow focus drills the pathway of concern deeply.
- Sweep breadth — how many conditions are varied across runs. Wide sweeps map the full threshold surface but cost compute and time; narrow sweeps answer one question fast but may miss a regime where the cascade behaves differently.
When it helps, and when it misleads¶
Its strength is empirical truth about propagation: it exposes the amplifying links, the hidden bypass, and the real threshold location that maps and workshops only speculate about, because it forces the system to actually spread and measures the result. Live fault injection in particular finds the cascade paths that exist in reality but in no diagram.
Its failure mode is the confident fiction of a wrong model. A simulation is only as valid as its substrate — omit an informal link or mis-set a coupling and it will report a cascade that is precise and false, and its very quantitative polish lends that fiction unearned authority. Live injection carries the opposite danger: an experiment meant to study a cascade can cause one if containment fails. The classic misuse is validating a system against a model that shares the same blind spot as the map it was built from, so the simulation dutifully confirms a safety that isn't there. The guarding discipline is to validate the model against real incident data, to inject faults inside tested containment with an abort ready, and to treat measured propagation as evidence about the model or the tested slice, not proof about the whole live system.
How it implements the components¶
scenario_or_simulation_model— it is the executable model (or instrumented live run): the substrate on which a cascade is actually carried out.threshold_and_amplification_profile— by sweeping conditions it measures where propagation tips into nonlinearity, producing an empirical amplification profile rather than an assumed one.transfer_link_inventory— its runs exercise the real transfer links and reveal which ones actually carry the disturbance, correcting or confirming the mapped inventory.
It executes; it does not rehearse human decisions. It holds no response_authority_map and never walks who is allowed to act — that talk-through is its nearest twin, Domino Tabletop Exercise, which discusses a scenario rather than running one. And it does not itself install a cascade_breakpoint_set; it tells Dependency Cut-Set Review and Cascade Circuit Breaker where propagation really went so they can place cuts on evidence. The tabletop talks the cascade through; this mechanism makes it happen and measures it.
Related¶
- Instantiates: Cascade Pathway Management — this is the archetype's empirical test: it runs the cascade to measure propagation rather than reasoning about it.
- Consumes: Cascade Dependency Graph supplies the link structure the model or injection is built on.
- Sibling mechanisms: Domino Tabletop Exercise · Cascade Dependency Graph · Dependency Cut-Set Review · Leading-Link Indicator Dashboard · Cascade Circuit Breaker · Rate-Limit or Quarantine Gate · Consequence Cascade Workshop · Beneficial Cascade Seeding Plan
Editorial Notes¶
Form Classification¶
Form family: Experiment, Test & Rehearsal
Rationale: Propagation Simulation or Fault Injection operates as an active test, trial, simulation, drill, or rehearsal that generates evidence through a deliberate attempt or perturbation because it executes a modeled or live cascade — injecting a fault and pushing the system past its thresholds — to measure how far and fast propagation actually travels.
Independent corroboration: The frozen evidence defines Propagation Simulation or Fault Injection as 'Executes a modeled or live cascade — injecting a fault and pushing the system past its thresholds — to measure how far and fast propagation actually travels', so its operative form is Experiment, Test & Rehearsal.
Nearest alternative: Analysis, Modeling & Optimization — Propagation Simulation or Fault Injection includes features of an analytical, modeling, inference, comparison, or optimization procedure that derives insight or a solution, but its defining operation is an active test, trial, simulation, drill, or rehearsal that generates evidence through a deliberate attempt or perturbation.
Review outcome: Independent reviewer agreement; medium confidence.
Origin Attribution¶
Primary origin: Engineering & Design
Origin pattern: Convergent development
Present-day reach: Multi-domain
Rationale: Propagation Simulation or Fault Injection is most plausibly rooted in the engineering_design tradition because its characteristic form depends on physical-system design, process control, reliability, and safety engineering. The assignment tracks that formative lineage, not the many settings in which the mechanism can now be applied.
Related originating lineages:
- Computer Science & Software Engineering — The computer_science tradition materially shaped Propagation Simulation or Fault Injection through its own practice of algorithms, data structures, formal interfaces, and software-system practice.
- Security Studies & Intelligence Analysis — The security_intelligence tradition materially shaped Propagation Simulation or Fault Injection through its own practice of access control, threat containment, privileged operation, and verifiable trust.
- Systems Thinking & Cybernetics — The systems_cybernetics tradition materially shaped Propagation Simulation or Fault Injection through its own practice of feedback, thresholds, dynamic regulation, and whole-system intervention.
Review resolution: Both blind reviewers agree that engineering design is the primary origin. Explicit reconciliation resolves alternate origin disagreement. Formative alternate lineages are retained as computer_science, security_intelligence, systems_cybernetics; later breadth of use is recorded separately as domain_reach=multi_domain, while origin_mode=convergent describes the relationship among origin lineages.
Review outcome: Reconciled after independent review; high confidence.
Notes¶
[n1] Chaos engineering — the discipline (popularized by Netflix's Chaos Monkey) of deliberately injecting failures into a running system to learn how disturbance propagates and to expose weaknesses before a real incident does. It is the software instance of the general fault-injection idea this mechanism generalizes across domains. ↩