Resimulation Scope Module (SRSM)
OOF™ Origin Open Foundation™
Independent Methodological Authority
Architecture Ecosystem: Structured Reality Standards™
Architecture Family: SIMULOS® — Simulation Governance Architecture
Parent Standard: Simulation Lifecycle & Resimulation Standard (SLRS)
Module: SRSM — Resimulation Scope Module
Operational Layer: Resimulation Scope Governance Layer
Category: Governance & Enforcement
Subcategory: Simulation Governance
Type: Core Module
Governed Space: Resimulation Scope
Origin ID: SIMULOS-SLRS-SRSM-012.4
Version: 1.0
Status: Canonical · Open Standard
Effective Date: 20 August 2026
Compatibility: OOF® Methodology OS™ · GOA™ · ORA™ · VALIDOS® · INTEGROS® · ADIT® · AGA™ ·
AIG® · ASGA™ · RIS™
AI-Readable: Yes
Authority: OOF®
Protection: MIP® — Methodology Intellectual Property Protection
Canonical Language: English
Canonical Definition
Resimulation Scope Module (SRSM) is the fourth Core Module of the SimulationLifecycle & Resimulation Standard (SLRS) within SIMULOS® — Simulation
Governance Architecture.
SRSM governs the determination of what must be resimulated after a governed
Resimulation Trigger has been established.
The Module determines the minimum sufficient and methodologically justified
resimulation boundary across affected Simulation Objects, configurations,
representations, assumptions, models, environments, inputs, scenarios,
executions, outputs, correlations, and simulation-derived evidence.
SRSM prevents two opposite governance failures:
insufficient resimulation, where the renewed simulation scope fails to cover
materially affected dependencies;
and
unnecessary resimulation, where unaffected simulation spaces are repeated
without a methodological reason.
Its task is therefore:
to translate a Resimulation Trigger into an explicit, dependency-aware,
traceable, and proportionate Resimulation Scope.
Architectural Position
SRSM is the fourth module within SLRS.It follows:
SRGM — Resimulation Trigger Module
and precedes:SRTM — Simulation Retirement & Transition Module.
The sequence is:
Lifecycle Monitoring → Drift Recognition → Resimulation Trigger → Resimulation
Scope → Retirement & Transition.
SRGM establishes:
whether resimulation is required.
SRSM establishes:
what must be resimulated.
SRTM subsequently governs whether a simulation should continue through its
lifecycle, transition toward a replacement, or be retired.
Internal Flow Position
Governed Resimulation Trigger Record → Affected Simulation BasisIdentification → Dependency Propagation Analysis → Affected Object /
Configuration Identification → Affected Scenario Space Identification →
Affected Model / Environment Identification → Affected Input Basis
Identification → Affected Execution Requirements → Affected Output /
Correlation / Evidence Identification → Scope Sufficiency Assessment →
Resimulation Scope Determination → Governed Resimulation Scope Record →
Resimulation Lifecycle Re-Entry / SRTM Operational Space
SRSM governs the space between:
a confirmed need to resimulate
and
the definition of the simulation lifecycle elements that must be reopened,
updated, repeated, reconstructed, or reassessed.
This operational space includes: resimulation scope identification; affected
simulation component identification; dependency propagation; impact
boundaries; scenario re-entry; configuration re-entry; model re-entry; input
re-entry; assumption re-entry; representation re-entry; execution re-entry;
output reassessment; correlation reassessment; evidence consequence
identification; partial resimulation; targeted resimulation; campaign
resimulation; comprehensive resimulation; scope expansion; scope reduction;
unaffected-space preservation; scope sufficiency; scope documentation.
Operational Scope
SRSM applies whenever a Resimulation Trigger requires some portion of anexisting simulation basis to be reconsidered or executed again.
It may govern: one simulation run; one parameter range; one scenario; one
scenario family; one Simulation Object configuration; one subsystem; one model
component; one environmental condition; one input distribution; one failure
mode; one mission phase; one behavioral domain; one simulation campaign;
multiple interconnected campaigns; the complete simulation lifecycle.
It applies across engineering, scientific, physical, digital, hybrid, mission,
safety, infrastructure, economic, AI, autonomous-system, digital-twin, and
future simulation environments.
SRSM remains technology-neutral. Trigger ≠
Scope
SRSM establishes the fundamental distinction:Resimulation Trigger ≠ Resimulation Scope
A trigger establishes that the existing simulation basis requires renewedsimulation activity.
It does not establish how much must be repeated.
A material change in one subsystem may require:
targeted resimulation
rather than:
complete campaign repetition.
Conversely, a seemingly localized change may propagate through dependencies
and require much broader resimulation than its initial location suggests.
Therefore:
The size of the originating change does not determine the size of the required
resimulation scope.
Minimum Sufficient Scope Principle
SRSM seeks the Minimum Sufficient Resimulation Scope.This means:
the smallest resimulation boundary that fully captures all materially affected
simulation dependencies necessary to restore the governed simulation basis for
the intended use.
“Minimum” prevents unnecessary repetition.
“Sufficient” prevents under-scoping.
The objective is not computational minimization at any cost.
The objective is methodologically justified proportionality.
Affected Simulation Basis
Every Resimulation Trigger must be mapped to the simulation basis itpotentially affects.
The affected basis may include: Simulation Object; object version; object
configuration; simulation purpose; scope; exclusions; reality representation;
abstraction; fidelity; assumptions; model structure; environment; parameters;
inputs; data; temporal conditions; scenarios; scenario coverage; execution
configuration; outputs; correlation relationships; evidence objects.
The scope cannot be determined reliably until these dependencies are visible.
Dependency Propagation Principle
A change may propagate beyond the simulation element where it originated.For example:
Input Change → affects Model Behavior → affects Scenario Outcomes → affects
Outputs → affects Simulation-to-Reality Correlation → affects Simulation
Evidence.
Or:
Object Configuration Change → affects Reality Representation → affects
Assumptions → affects Model Parameterization → affects Scenario Relevance →
affects Execution → affects Outputs.
SRSM therefore requires dependency-aware scope determination. Local Change ≠
Local Scope
A localized technical change does not guarantee a localized resimulation
requirement.
A single changed parameter may influence: multiple model components; multiple
scenario families; downstream control behavior; interaction effects; failure
thresholds; evidence already derived from previous executions.
Conversely, a large physical modification may have no material effect on a
narrowly defined simulation question.
Scope must follow material simulation dependency, not superficial change size.
Resimulation Scope Levels
SRSM may classify scope into governed levels. 1. Execution-Level ResimulationRepeat one or more executions without materially changing the upstream
simulation basis.
Appropriate where the issue concerns: execution anomaly; stochastic
repetition; failed run; incomplete execution; runtime instability.
2. Scenario-Level Resimulation
Repeat or expand specific scenarios or scenario families.
Appropriate where: new edge cases emerge; scenario conditions change; coverage
gaps are discovered; one scenario class becomes materially relevant.
3. Input-Level Resimulation
Renew simulation where input or data conditions materially change.
This may require: new datasets; updated distributions; changed temporal
inputs; changed uncertainty ranges.
4. Configuration-Level Resimulation
Repeat simulations for affected Simulation Object, model, or environment
configurations. 5. Model-Level Resimulation
Reopen the simulation model or environment basis before execution.
Appropriate where: model structure changes; model limitations are discovered;
environment behavior changes; parameterization must be reconstructed.
6. Representation-Level Resimulation
Reopen the representation of reality itself.
Appropriate where previously simplified, excluded, or inaccurately represented
reality becomes materially relevant. 7. Comprehensive Resimulation
Re-enter multiple or all materially relevant simulation lifecycle stages.
This may be necessary where change is systemic, dependencies are extensive, or
the previous simulation basis can no longer support meaningful partial reuse.
These levels may overlap.
They are governance classifications, not rigid technical implementation
categories.
Partial Resimulation
SRSM permits partial resimulation where the unaffected simulation basisremains legitimate.
A partial scope should establish: what remains unchanged; why it remains
reusable; what must be updated; what must be repeated; what downstream results
become affected; what previous evidence remains applicable; what evidence
requires reassessment.
Partial resimulation must not become an assumption of convenience.
Its sufficiency must be demonstrable.
Targeted Resimulation
Targeted resimulation may focus computational and analytical resources uponthe specific conditions affected by the Trigger.
Examples include: one failure mode; one sensor condition; one mission phase;
one environmental range; one scenario family; one subsystem interaction; one
parameter region.
Targeted resimulation can dramatically reduce unnecessary simulation effort
while preserving methodological sufficiency.
Comprehensive Resimulation
Comprehensive resimulation may be required where: Simulation Object identitymaterially changes; reality representation becomes structurally insufficient;
foundational assumptions fail; model architecture changes substantially;
multiple scenario families become affected; dependencies cannot be reliably
isolated; correlation deteriorates broadly; accumulated drift becomes
systemic; previous evidence can no longer be cleanly separated from the
affected basis.
Comprehensive resimulation should result from governed scope analysis rather
than default organizational habit.
Scope Expansion Principle
An initially narrow Resimulation Scope may need to expand.During renewed simulation activity, organizations may discover: additional
affected dependencies; new failure modes; broader scenario impact; unexpected
sensitivity; new model interactions; wider correlation deterioration;
additional evidence consequences.
SRSM therefore allows:
Initial Scope → New Information → Scope Reassessment → Expanded Scope.
A scope determination must not become immutable when new material information
emerges.
Scope Reduction Principle
A provisional scope may also be reduced where evidence establishes thatsuspected dependencies are not materially affected.
Reduction must be justified.
It should identify: the excluded simulation space; the evidence supporting
exclusion; the dependency analysis; remaining uncertainty.
Scope Reduction ≠ Convenience-Based Exclusion.
Unchanged Basis Preservation
SRSM should preserve simulation components that remain legitimately reusable.This may include: unaffected scenarios; unchanged input sets; unaffected model
components; stable environmental configurations; previous execution records;
unaffected outputs; still-applicable correlation evidence.
This prevents simulation governance from creating unnecessary computational
waste.
However, reuse requires a governed basis.
Previously Simulated ≠ Automatically Reusable.
Scenario Scope
Where the Trigger affects scenario coverage, SRSM determines which scenariospace must be reopened.
This may include: expected conditions; variations; edge cases; stress
conditions; uncertainty conditions; interaction scenarios; newly observed
scenarios; previously excluded scenarios.
SSS continues to govern scenario design.
SRSM determines which scenario governance must be re-entered because of the
Trigger.
Model & Environment Scope
Where the Trigger affects the simulation model or environment, SRSM determineswhich model or environmental elements require renewed governance.
Possible consequences include: model component revision; parameterization
revision; environment reconfiguration; boundary interaction reassessment;
version change; dependency reconstruction.
SMES governs these elements when re-entered.
SRSM governs the requirement to reopen them.
Input & Data Scope
Where simulation inputs are affected, SRSM determines which input basis mustbe reconsidered.
Possible scope may include: one variable; one dataset; one distribution; one
time period; one environmental source; one uncertainty range; the complete
input basis.
SIDS governs the renewed input and data conditions.
SRSM defines the affected boundary.
Assumption Scope
A changed assumption may propagate through many simulation layers.SRSM must determine: which assumption changed; which model components depend
upon it; which scenarios rely upon it; which executions used it; which outputs
were affected; which correlation conclusions depend upon it; which evidence
objects inherit the dependency.
SAS governs the assumption itself.
SRSM governs the lifecycle scope affected by its change.
Output and Evidence Consequence Scope
Resimulation scope does not stop at new execution.Where prior outputs or simulation-derived evidence depend upon the affected
simulation basis, SRSM should identify them for downstream reconsideration.
This may require renewed governance through:
SOGS → SRCS → SERBS.
A new simulation execution may therefore invalidate, supersede, narrow,
strengthen, or leave unchanged different portions of the previous evidence
basis.
Scope Sufficiency Assessment
Before a Resimulation Scope is accepted, SRSM should determine whether theproposed scope is sufficient to address the Trigger.
The assessment may ask: Have all material dependencies been identified? Are
affected scenarios included? Are changed assumptions covered? Are model
consequences captured? Are affected inputs reconsidered? Are downstream
outputs identified? Is correlation reassessment required? Is existing evidence
affected? Are excluded simulation spaces demonstrably unaffected? Could
residual uncertainty materially undermine the intended use?
The purpose is to prevent a technically completed resimulation from remaining
methodologically incomplete.
Scope Uncertainty
Sometimes the required scope cannot initially be determined with confidence.SRSM may therefore establish:
Provisional Resimulation Scope
where uncertainty remains.The provisional scope may be expanded or reduced as evidence emerges.
Uncertainty about scope should be documented rather than hidden through
arbitrary boundary selection.
Resimulation Re-Entry Principle
SRSM does not require every Resimulation Trigger to restart SIMULOS® fromStandard 1.
Instead, it determines the earliest materially affected governance point.
Examples:
Execution anomaly → re-enter at SES.
New scenario → re-enter at SSS.
Input distribution shift → re-enter at SIDS.
Model revision → re-enter at SMES.
Assumption failure → re-enter at SAS.
Reality representation deficiency → re-enter at RRS.
Simulation Object material change → potentially re-enter at SOS.
This enables SIMULOS® to operate recursively without forcing unnecessary
full-lifecycle repetition.
Lifecycle Propagation
Once the re-entry point is established, downstream governance should bereconsidered wherever materially affected.
For example:
SAS Re-Entry → SMES → SIDS where affected → SSS → SES → SOGS → SRCS → SERBS.
Not every downstream element must necessarily change.
But every materially dependent downstream element must be considered.
SRSM Boundary with SRGM
SRGM determines:whether resimulation is required.
SRSM determines:
what must be resimulated.
Therefore:
Trigger ≠ Scope.
SRSM must not redefine the original Trigger merely to reduce or expand
workload.
SRSM Boundary with SSS
SRSM may determine that a scenario space must be reopened.SSS governs the actual identification, variation, edge-case design, stress
conditions, and coverage of those scenarios.
SRSM Boundary with SMES
SRSM may determine that the model or environment must be reopened.SMES governs model structure, environmental configuration, boundary
interactions, parameterization, and environment versioning.
SRSM Boundary with SIDS
SRSM may identify affected input and data spaces.SIDS governs those inputs once simulation governance re-enters that layer.
SRSM Boundary with SES
SRSM determines which executions must occur again.SES governs how those simulations are instantiated, controlled, observed,
repeated, and documented.
SRSM Boundary with SOGS
SRSM may determine which prior or newly produced outputs require renewedgovernance.
SOGS governs output identification, classification, inference, limitations,
and documentation.
SRSM Boundary with SRCS
SRSM may determine that simulation-to-reality correlation must be reassessedbecause the simulation basis has materially changed.
SRCS governs the actual correlation process.
SRSM Boundary with SERBS
SRSM identifies simulation-derived evidence potentially affected byresimulation.
SERBS determines the qualification, weight, reliance boundary, limitations,
and validation interface of that evidence.
SRSM Boundary with VALIDOS®
SRSM determines the simulation-specific scope of resimulation.It does not determine the broader scope of revalidation.
A VALIDOS® revalidation process may require additional evidence or activities
outside simulation.
SRSM Boundary with ORA™
Operational Reality may provide changes that influence scope determination.ORA™ continues to govern Operational Reality itself.
SRSM governs only the resulting simulation lifecycle re-entry boundary.
SRSM Boundary with INTEGROS®
SRSM does not govern general integrity.Integrity issues may create dependencies affecting resimulation scope, but
integrity governance remains under INTEGROS®.
SRSM Boundary with ADIT®
ADIT® may audit whether the basis, exclusions, dependency analysis, scopedetermination, and resulting resimulation records are preserved and
verifiable.
SRSM governs the scope determination itself.
Minimum Implementation Framework
A minimum SRSM implementation should
establish: 1. Trigger Intake
Receive the governed Resimulation Trigger and its supporting basis. 2.Affected Basis Identification
Identify the simulation lifecycle elements directly affected by the Trigger.
3. Dependency Mapping
Determine material upstream, downstream, and cross-component dependencies. 4.
Re-Entry Point Determination
Identify the earliest materially affected SIMULOS® governance layer. 5. Scope
Classification
Determine whether execution-level, scenario-level, input-level,
configuration-level, model-level, representation-level, or comprehensive
resimulation is required. 6. Unaffected Basis Assessment
Identify previous simulation elements that remain legitimately reusable. 7.
Downstream Consequence Assessment
Identify outputs, correlation relationships, evidence objects, and reliance
boundaries requiring reconsideration. 8. Scope Sufficiency Assessment
Determine whether the proposed boundary captures all material consequences of
the Trigger. 9. Scope Adjustment Control
Permit governed expansion or reduction where new information materially
changes the required boundary. 10. Resimulation Scope Record
Document the final or provisional Resimulation Scope, exclusions,
dependencies, re-entry point, and downstream consequences. Use Case 1 — Space
Mission Simulation: Flight Software Change Before Launch
A spacecraft has completed a very large pre-launch simulation campaign
covering: ascent; navigation; orbital operations; descent; landing;
communication failures; propulsion anomalies; contingency scenarios.
A late flight-software update modifies the guidance algorithm used during
descent.
SRGM has already established a Priority Resimulation Trigger.
The organization now faces a major practical question:
Must the complete mission simulation campaign be repeated?
SRSM maps the change through the simulation dependency structure.
The updated guidance algorithm affects:
Descent Control → Navigation Interaction → Propulsion Commands → Landing
Trajectory → Fuel Consumption → Landing-Site Dispersion → Failure and
Contingency Scenarios → Mission Outputs → Relevant Simulation Evidence.
But the change may have no material relationship to unrelated orbital
communication scenarios or other unaffected mission phases.
SRSM therefore establishes a targeted but dependency-complete Resimulation
Scope.
The organization re-enters the simulation lifecycle at the affected
model/configuration layer, reconstructs the relevant scenario space, repeats
the affected execution campaign, regenerates governed outputs, and reassesses
relevant simulation-to-reality correlation and evidence.
This avoids both extremes:
repeating the entire mission campaign unnecessarily
and
testing only the modified algorithm while missing its downstream mission
interactions.
The governing principle is:
Resimulate the dependency chain affected by the change, not merely the
component where the change originated. Use Case 2 — Autonomous Robot: Rare
Failure Reveals a Missing Scenario Domain
A mobile autonomous robot has successfully completed millions of simulations
before deployment.
Operational observation later reveals failures occurring when three conditions
combine:
low-angle sunlight + partially contaminated sensor surface + unusual
pedestrian movement.
SRGM determines that the new failure pattern creates a Resimulation Trigger.
SRSM must now determine the required scope.
Repeating the complete historical campaign may consume enormous computational
resources while adding little information.
Repeating only the exact failed event may be too narrow because the failure
could belong to a broader interaction domain.
SRSM therefore traces the affected dependencies:
New Reality Condition → Reality Representation → Sensor Model → Environmental
Inputs → Scenario Family → Autonomous Behavior → Execution → Outputs →
Sim-to-Real Correlation → Existing Evidence.
The resulting scope may require: updating the representation of contaminated
sensors; expanding relevant lighting ranges; creating variations of human
movement; testing combinations rather than isolated conditions; rerunning the
affected behavioral scenario family; reassessing outputs; recalculating
relevant correlation; reconsidering simulation evidence previously used for
that operational domain.
Unaffected simulation domains remain reusable where their independence is
established.
The organization therefore avoids the misleading choice between:
rerun everything
and
rerun only the failure.
SRSM establishes the third option:
rerun everything materially connected to the failure, and preserve everything
demonstrably unaffected.
Governance Outputs
SRSM may produce: Resimulation Scope Assessment Affected Simulation Basis MapSimulation Dependency Map Resimulation Re-Entry Point Resimulation Scope
Classification Affected Scenario Scope Affected Input Scope Affected Model &
Environment Scope Affected Configuration Scope Required Execution Scope
Downstream Output Reassessment Scope Correlation Reassessment Requirement
Affected Simulation Evidence Register Unaffected Simulation Basis Statement
Scope Exclusion Record Scope Sufficiency Assessment Provisional Resimulation
Scope Final Resimulation Scope Governed Resimulation Scope Record
Enterprise Application
SRSM gives organizations a method for answering one of the most expensivequestions in simulation lifecycle management:
When something changes, how much simulation must actually be repeated?
Without governed scope determination, organizations may either repeat massive
simulation campaigns unnecessarily or perform narrow retesting that fails to
capture downstream dependencies.
SRSM enables simulation-intensive organizations to determine: the earliest
lifecycle point requiring re-entry; which scenarios must be repeated; which
model components require revision; which inputs must be updated; which
configurations are affected; which executions must be repeated; which previous
outputs remain usable; which correlation relationships require reassessment;
which simulation-derived evidence has become affected; which unaffected
simulation assets may legitimately be preserved.
This becomes especially important where simulation campaigns contain millions
or billions of executions.
The objective is not simply to reduce simulation cost.
It is to ensure that computational effort follows methodological necessity .
Foundational Principles
Resimulation Trigger does not determine Resimulation Scope.The size of a change does not determine the size of its simulation
consequence.
Local change does not necessarily imply local resimulation.
Resimulation scope must follow material dependency.
The minimum scope must still be sufficient.
Unaffected simulation assets should not be discarded merely because another
part of the simulation changed.
Previously simulated does not mean automatically reusable.
A resimulation may re-enter SIMULOS® at any materially affected lifecycle
layer.
Downstream outputs and evidence must be reconsidered where their simulation
basis has changed.
Scope may expand or contract when new information changes the known dependency
boundary.
Resimulation should repeat neither less nor more than the materially affected
simulation basis requires.