Skip to content

Cortex Translation Methodology – Simulation Pseudocode

1. Overview

This pseudocode describes one full CTM timestep under v1.3, including:

  • Event ingestion
  • Domain stress mapping
  • Governance + friction modifiers
  • Centralized Initiator State (CIS) effects
  • Dual-component load (Baseline + Transient)
  • Cross-domain cascades
  • Threshold drift and meta-state determination
  • Trajectory classification

It assumes CTM v1.2 is already implemented, and extends it; v1.3 is active only when CIS = 1.

2. Data Structures

// Domain identifiers
DOMAINS = [
  "EXECUTIVE",
  "LEGISLATURE",
  "JUDICIARY",
  "NORMS",
  "SECURITY",
  "ECONOMY",
  "MEDIA",
  "CIVIC"
]

// Per-domain state at time t (input) and t+1 (output)
struct DomainState {
    float Load                 // Total load_i(t)
    float BaselineLoad         // BaselineLoad_i(t)
    float TransientLoad        // TransientLoad_i(t)
    float ST                   // Stability Threshold ST_i
    float CST                  // Cascading Stress Threshold CST_i
    float LBT                  // Local Break Threshold LBT_i
    float CCT                  // Critical Collapse Threshold CCT_i
    float SUL                  // Stress Uptake Level SUL_i
    float DriftRate            // Current drift rate for thresholds
    float DriftStability       // Stability of threshold dynamics
    float ForcingRate          // ForcingRate_i(t)
    float InstitutionalControl // InstitutionalControl_i ∈ [0,1]
    float CFC_base             // Base Composite Friction Coefficient (system-level or per-domain)
    float CFC_effective        // Effective CFC under CIS
    float GFM                  // Governance Feedback Multiplier
    float FFM                  // Friction Feedback Multiplier
    float DecayRate            // DecayRate_i(t)
    float PrimaryShocks        // PrimaryShocks_i(t)
    float CascadedShocks       // CascadedShocks_i(t)
    float ThresholdVolatility  // Volatility metric for thresholds
}

// System-wide state
struct SystemState {
    map<Domain, DomainState> domains
    float SystemLoad              // Σ_i Load_i(t)
    float NormalizedSystemLoad    // SystemLoad / Σ Load_i_max
    string MetaState              // "NORMAL", "ELEVATED", "CASCADE", "FAILURE", "RECONFIG"
    string TrajectoryClass        // "6A", "6B", "6C", "6D", etc.
    int   ReconfigDuration        // Consecutive timesteps in RECONFIG meta-state
    int   TimeStep                // t
    int   CIS                     // 0 or 1 (Centralized Initiator State)
    string GovernanceStyle        // e.g. "CDG" or others from Governance Styles v1.0
}

// Model parameters (global)
const float Load_i_max         = 10000.0
const float BaselineDecayRate  = 0.05         // Default, adjustable in [0.01, 0.10]
const float MaxForcingRate     = 50.0
const float PropagationDecay   = 0.7          // Default, allowed range [0.5, 0.8]
const int   MaxCascadeDepth    = 2
const float MaxCascadeLoadFrac = 0.5          // CascadedShocks cap = 0.5 * Load_i_max
const float CascadeAmplification = 0.3        // 30% amplification of GFM/FFM in CASCADE
const float CDGFeedbackAmplification = 0.2    // 20% for CDG when CIS=1
const float DriftAmplificationFactor = 0.5    // +50% drift in saturation regimes
const float DriftStabilityReduction = 0.3     // -30% stability in saturation regimes
const float CorrelationFactor  = 1.3          // 30% coupling amplification on correlated crossings
const float VolatilityThreshold = some_small_value  // Implementation choice

// Cross-domain coupling matrix C[i][j] (from Appendix A)
float C[8][8]    // base coupling coefficients
float C_eff[8][8] // effective coupling under CIS and correlation

// Meta-state thresholds on NormalizedSystemLoad
const float NSL_NORMAL_MAX   = 0.25
const float NSL_ELEVATED_MAX = 0.45
const float NSL_CASCADE_MAX  = 0.70
const float NSL_FAILURE_MAX  = 0.90
// NSL ≥ 0.90 → RECONFIG

// Reconfiguration classification
const int ReconfigThreshold = N  // number of timesteps at RECONFIG before class 6D, choose N>=2

3. Input Event Structure

// Events for timestep t (after Event Parsing step)
struct Event {
    string id
    string domain         // Primary domain affected (one of DOMAINS)
    float magnitude       // Raw stress magnitude
    char polarity         // '+', '-', 'C', 'D', etc. per CTM Model
    map<string, any> tags // Additional classification from CTM Model (e.g., NSS tags)
}

// After mapping to domain impacts:
struct DomainImpact {
    float EffectiveImpact // EffectiveImpact_i(t) after all CTM Model transformations
}

DomainImpacts are derived from the CTM Model v1.0 / CTM Process v1.2 logic and are assumed to be available to the v1.3 step.

4. Main Timestep Function

function CTM_STEP_V1_3(prev_state: SystemState,
                       events: list<Event>,
                       domain_impacts: map<Domain, DomainImpact>,
                       analyst_inputs: map<string, any>) -> SystemState:

    state = copy(prev_state)
    t = prev_state.TimeStep

    //----------------------------------------------------
    // STEP 0: Update time
    //----------------------------------------------------
    state.TimeStep = t + 1

    //----------------------------------------------------
    // STEP 1: Determine CIS and Governance Context
    //----------------------------------------------------
    state.CIS = DETECT_CIS(analyst_inputs, events, domain_impacts, prev_state)

    // GovernanceStyle may be fixed per scenario or updated externally
    // E.g., "CDG" when NSS-like centralized directive governance is in effect
    state.GovernanceStyle = analyst_inputs["GovernanceStyle"]

    //----------------------------------------------------
    // STEP 2: Prepare Per-Domain ForcingRates and Impacts
    //----------------------------------------------------
    for each domain d in DOMAINS:
        // 2.1 Estimate or read ForcingRate_i(t) from analyst inputs or event density
        state.domains[d].ForcingRate = CLAMP(
            COMPUTE_FORCING_RATE(d, events, domain_impacts, analyst_inputs),
            0.0,
            MaxForcingRate
        )

        // 2.2 Pull EffectiveImpact_i(t) from domain_impacts (v1.2 logic)
        // This is used in primary shock calculation
        // If no impact, EffectiveImpact defaults to 0
        if d not in domain_impacts:
            domain_impacts[d] = DomainImpact(EffectiveImpact = 0.0)


    //----------------------------------------------------
    // STEP 3: Compute Governance Feedback (GFM) and Friction (FFM)
    //         including CDG and CIS effects
    //----------------------------------------------------
    for each domain d in DOMAINS:
        dom = state.domains[d]

        // 3.1 Compute base GFM_i(t-1) using CTM v1.2 governance style logic
        dom.GFM = COMPUTE_GFM_V1_2(d, prev_state)

        // 3.2 Compute base CFC (system-level or per-domain) using v1.2
        dom.CFC_base = COMPUTE_CFC_V1_2(d, prev_state)

        // 3.3 Apply friction suppression under CIS (Section 6.9)
        if state.CIS == 1:
            // InstitutionalControl_i comes from governance style profile (e.g., CDG table)
            dom.InstitutionalControl = GET_INSTITUTIONAL_CONTROL(d, state.GovernanceStyle)
            dom.CFC_effective = dom.CFC_base * (1.0 - dom.InstitutionalControl)
        else:
            dom.CFC_effective = dom.CFC_base
            // InstitutionalControl still recorded but not suppressing friction
            dom.InstitutionalControl = GET_INSTITUTIONAL_CONTROL(d, state.GovernanceStyle)

        // 3.4 Compute FFM_i(t-1) using effective CFC via v1.2 formula
        dom.FFM = COMPUTE_FFM_V1_2(d, prev_state, dom.CFC_effective)

        // 3.5 Apply CDG-specific feedback amplification when CIS=1 (Section: CDG)
        if state.GovernanceStyle == "CDG" and state.CIS == 1:
            dom.GFM = dom.GFM * (1.0 + CDGFeedbackAmplification)
            dom.FFM = dom.FFM * (1.0 + CDGFeedbackAmplification)

        // Persist back
        state.domains[d] = dom


    //----------------------------------------------------
    // STEP 4: Compute PrimaryShocks_i(t)
    //----------------------------------------------------
    for each domain d in DOMAINS:
        dom = state.domains[d]

        // v1.2 primary shock logic:
        // PrimaryShocks_i(t) = Σ_j [EffectiveImpact_j(t) * GFM_i(t-1) * FFM_i(t-1)]
        // Here simplified: each domain uses its own EffectiveImpact
         NOTE: simplified (no cross-domain impact matrix). Production can swap in full CTM Model mapping.
        dom.PrimaryShocks = domain_impacts[d].EffectiveImpact * dom.GFM * dom.FFM

        // If you use full cross-domain impact mapping, plug that in here instead.
        state.domains[d] = dom


    //----------------------------------------------------
    // STEP 5: Compute Cross-Domain Coupling Matrix C_eff
    //----------------------------------------------------
    C_eff = INITIALIZE_C_EFFECTIVE(C, state)

    // 5.1 Apply meta-state correlation amplification later, after threshold crossings
    // (we need loads first for that, so we’ll revisit C_eff after meta-state step if needed)


    //----------------------------------------------------
    // STEP 6: Compute DecayRate_i(t) (Base, before meta-state modification)
    //----------------------------------------------------
    for each domain d in DOMAINS:
        dom = state.domains[d]

        // Base v1.2 decay rate:
        // DecayRate_i_base = (1 - SUL_i * 0.05) * ThresholdStateMultiplier(t-1)
        DecayRate_base = COMPUTE_DECAY_RATE_BASE_V1_2(d, prev_state)

        dom.DecayRate = DecayRate_base
        state.domains[d] = dom


    //----------------------------------------------------
    // STEP 7: Compute BaselineLoad_i(t+1) (Sustained Forcing)
    //----------------------------------------------------
    for each domain d in DOMAINS:
        dom = state.domains[d]

        if state.CIS == 1:
            // BaselineLoad_i(t+1) = BaselineLoad_i(t) * (1 - BaselineDecayRate)
            //                      + ForcingRate_i(t)
            dom.BaselineLoad = dom.BaselineLoad * (1.0 - BaselineDecayRate) \
                               + dom.ForcingRate
        else:
            // No sustained forcing when CIS=0
            dom.BaselineLoad = 0.0

        state.domains[d] = dom


    //----------------------------------------------------
    // STEP 8: Compute Cascade-Active Domains and CascadedShocks
    //----------------------------------------------------
    // First, we need the current Load_i(t) to decide cascade activation.
    // At this stage, Load_i(t) = prev_state.domains[d].Load (from t).

    // 8.1 Identify cascade-active domains based on CST_i
    set<Domain> CascadeActiveDomains = {}
    for each domain d in DOMAINS:
        prev_dom = prev_state.domains[d]
        dom      = state.domains[d]

        dom.CascadedShocks = 0.0  // reset for this timestep

        # Mark domains that are in cascade range at time t.
        # NOTE: We intentionally use Load_i(t) (prev_dom.Load) here:
        #   - Cascades at timestep t propagate shocks generated at t
        #   - Activation is based on pre-update load, consistent with v1.3 spec.
        if prev_dom.Load >= prev_dom.CST:
            CascadeActiveDomains.add(d)

        state.domains[d] = dom

    // 8.2 Initialize cascade depth tracking
    // Depth 1: direct cascades from primary shocks at this timestep
    // Depth 2: one additional hop (MaxCascadeDepth = 2)
    map<Domain, int> CascadeDepth = {}
    for each domain d in DOMAINS:
        if d in CascadeActiveDomains:
            CascadeDepth[d] = 1
        else:
            CascadeDepth[d] = 0

    // 8.3 First-pass cascade propagation (depth 1)
    for each domain i in CascadeActiveDomains:
        shock_i = state.domains[i].PrimaryShocks  // or some function of shock magnitude

        for each domain j in DOMAINS:
            if j == i:
                continue

            // Prevent i -> j if we already defined cycle rules (none at depth 1)
            propagated = shock_i * C_eff[i][j] * PropagationDecay
            state.domains[j].CascadedShocks += propagated

    // 8.4 Second-pass propagation (depth 2), with cycle prevention
    // Mark which domains received cascades at depth 1
    set<Domain> Depth1Recipients = {}
    for each domain d in DOMAINS:
        if state.domains[d].CascadedShocks > 0.0:
            Depth1Recipients.add(d)

    // Now propagate from those that are cascade-active and have depth 1
    for each domain i in DOMAINS:
        if CascadeDepth[i] != 1:
            continue  // only depth-1 sources

        if state.domains[i].CascadedShocks <= 0.0:
            continue

        // Depth-2 propagation
        shock_i = state.domains[i].CascadedShocks
        for each domain j in DOMAINS:
            if j == i:
                continue

            // Cycle prevention: j cannot cascade back to any domain that cascaded to it in same cycle.
            // Minimal version: do not propagate if j was the source for i at depth 1.
            if j in CascadeActiveDomains and i in Depth1Recipients:
                continue

            propagated = shock_i * C_eff[i][j] * PropagationDecay
            // Depth 2 contribution
            state.domains[j].CascadedShocks += propagated

    // 8.5 Apply cap on CascadedShocks per domain
    for each domain d in DOMAINS:
        dom = state.domains[d]
        maxCascadeLoad = MaxCascadeLoadFrac * Load_i_max
        if dom.CascadedShocks > maxCascadeLoad:
            dom.CascadedShocks = maxCascadeLoad
        state.domains[d] = dom


    //----------------------------------------------------
    // STEP 9: Update TransientLoad_i(t+1)
    //----------------------------------------------------
    for each domain d in DOMAINS:
        dom = state.domains[d]

        // TransientLoad_i(t+1) = TransientLoad_i(t) * DecayRate_i(t)
        //                       + PrimaryShocks_i(t)
        //                       + CascadedShocks_i(t)
        dom.TransientLoad = dom.TransientLoad * dom.DecayRate \
                            + dom.PrimaryShocks \
                            + dom.CascadedShocks

        state.domains[d] = dom


    //----------------------------------------------------
    // STEP 10: Compute Total Load_i(t+1) and Clamp
    //----------------------------------------------------
    for each domain d in DOMAINS:
        dom = state.domains[d]

        total = dom.BaselineLoad + dom.TransientLoad
        if total < 0.0:
            total = 0.0
        if total > Load_i_max:
            total = Load_i_max

        dom.Load = total
        state.domains[d] = dom


    //----------------------------------------------------
    // STEP 11: Compute SystemLoad and NormalizedSystemLoad
    //----------------------------------------------------
    float sumLoads = 0.0
    float sumMaxLoads = 0.0

    for each domain d in DOMAINS:
        sumLoads    += state.domains[d].Load
        sumMaxLoads += Load_i_max

    state.SystemLoad           = sumLoads
    state.NormalizedSystemLoad = sumLoads / sumMaxLoads


    //----------------------------------------------------
    // STEP 12: Determine Meta-State from NormalizedSystemLoad
    //----------------------------------------------------
    prevMeta = prev_state.MetaState

    if state.NormalizedSystemLoad < NSL_NORMAL_MAX:
        state.MetaState = "NORMAL"
    else if state.NormalizedSystemLoad < NSL_ELEVATED_MAX:
        state.MetaState = "ELEVATED"
    else if state.NormalizedSystemLoad < NSL_CASCADE_MAX:
        state.MetaState = "CASCADE"
    else if state.NormalizedSystemLoad < NSL_FAILURE_MAX:
        state.MetaState = "FAILURE"
    else:
        state.MetaState = "RECONFIG"

    // Track Reconfiguration duration
    if state.MetaState == "RECONFIG":
        state.ReconfigDuration = prev_state.ReconfigDuration + 1
    else:
        state.ReconfigDuration = 0


    //----------------------------------------------------
    // STEP 13: Adjust DecayRate_i(t) based on Meta-State
    //----------------------------------------------------
    for each domain d in DOMAINS:
        dom = state.domains[d]

        // dom.DecayRate already holds base v1.2 rate
        if state.MetaState == "CASCADE":
            dom.DecayRate = dom.DecayRate * 0.8   // 20% slower
        else if state.MetaState == "FAILURE" or state.MetaState == "RECONFIG":
            dom.DecayRate = dom.DecayRate * 0.7   // 30% slower
        // else NORMAL/ELEVATED: unchanged

        state.domains[d] = dom


    //----------------------------------------------------
    // STEP 14: Threshold Drift and Volatility under Saturation
    //----------------------------------------------------
    // Apply only in CASCADE/FAILURE/RECONFIG
    if state.MetaState == "CASCADE" or
       state.MetaState == "FAILURE" or
       state.MetaState == "RECONFIG":

        for each domain d in DOMAINS:
            dom     = state.domains[d]
            prevDom = prev_state.domains[d]

            // 14.1 Amplify DriftRate
            dom.DriftRate = prevDom.DriftRate * (1.0 + DriftAmplificationFactor)
            dom.DriftStability = prevDom.DriftStability * (1.0 - DriftStabilityReduction)

            // Apply drift to thresholds (simplified)
            # TODO: replace with APPLY_DRIFT_V1_2(...) from CTM Process v1.2 Section 8
            dom.ST  = dom.ST  + dom.DriftRate * some_factor_ST
            dom.CST = dom.CST + dom.DriftRate * some_factor_CST
            dom.LBT = dom.LBT + dom.DriftRate * some_factor_LBT
            dom.CCT = dom.CCT + dom.DriftRate * some_factor_CCT

            // 14.2 Compute ThresholdVolatility_i(t)
            dom.ThresholdVolatility = ABS(dom.DriftRate - prevDom.DriftRate)

            // Optional: flag domain as unstable if above threshold
            if dom.ThresholdVolatility > VolatilityThreshold:
                FLAG_DOMAIN_AS_UNSTABLE(d, state)

            state.domains[d] = dom
    else:
        // NORMAL/ELEVATED: use v1.2 drift logic unchanged
        for each domain d in DOMAINS:
            state.domains[d] = APPLY_DRIFT_V1_2(d, prev_state, state.domains[d])


    //----------------------------------------------------
    // STEP 15: Correlated Threshold Crossings and CorrelationFactor
    //----------------------------------------------------
    // 15.1 Detect correlated crossings of CST/LBT for this timestep
    set<Domain> CrossingDomains = {}
    for each domain d in DOMAINS:
        dom = state.domains[d]
        prevDom = prev_state.domains[d]

        // Example: crossing CST or LBT upward
        // Cascade activation uses Load(t) (prev_state) and threshold crossing into CST/LBT at this timestep.
        if prevDom.Load < prevDom.CST and dom.Load >= dom.CST:
            CrossingDomains.add(d)
        else if prevDom.Load < prevDom.LBT and dom.Load >= dom.LBT:
            CrossingDomains.add(d)

    bool correlated = (SIZE(CrossingDomains) >= 2)

    // 15.2 If correlated, amplify coupling for next timestep’s cascades
    if correlated:
        for each domain i in CrossingDomains:
            for each domain j in CrossingDomains:
                if i == j: continue
                C_eff[i][j] = CLAMP(C_eff[i][j] * CorrelationFactor, 0.0, 1.0)
        STORE_COUPLING_MATRIX_IN_STATE(C_eff)

    // Note: Implementation choice:
    // - You can store C_eff back into state for use in t+1,
    //   or treat it as a transient adjustment for this timestep only.
    // Note: v1.3 implementation choice:
    // - Here we persist the amplified C_eff into state so it affects
    //   cascade propagation in the NEXT timestep.
    // - Implementations MUST ensure INITIALIZE_C_EFFECTIVE reads this
    //   stored matrix when reconstructing C_eff at t+1.

    //----------------------------------------------------
    // STEP 16: Apply Cascade Amplification to GFM/FFM in CASCADE meta-state
    //----------------------------------------------------
    if state.MetaState == "CASCADE":
        for each domain d in DOMAINS:
            dom = state.domains[d]
            dom.GFM = dom.GFM * (1.0 + CascadeAmplification)
            dom.FFM = dom.FFM * (1.0 + CascadeAmplification)
            state.domains[d] = dom


    //----------------------------------------------------
    // STEP 17: Trajectory Classification (6A–6D)
    //----------------------------------------------------
    state.TrajectoryClass = CLASSIFY_TRAJECTORY(state, prev_state)


    //----------------------------------------------------
    // STEP 18: Return Updated State
    //----------------------------------------------------
    return state

5. Helper Functions (Skeletons)

You can fill these in directly from v1.2 + v1.3 text.

function DETECT_CIS(analyst_inputs, events, domain_impacts, prev_state) -> int:
    // Analyst-driven, but guided by v1.3 criteria:
    // - Centralized executive origin
    // - Coordinated timing across domains
    // - Strategic intent to reconfigure baseline
    // - Evidence of friction bypass (executive overriding institutions)
    if analyst_inputs["CIS_OVERRIDE"] exists:
        return analyst_inputs["CIS_OVERRIDE"]
    else:
        // default heuristic or 0
        return 0
function COMPUTE_FORCING_RATE(domain, events, domain_impacts, analyst_inputs) -> float:
    // Example: use count or weighted impact of policy-type events per timestep
    base_rate = analyst_inputs["ForcingRateOverrides"].get(domain, 0.0)
    // or derive from events tagged as sustained policy forcing
    // This is intentionally analyst-tuned.
    return base_rate
function INITIALIZE_C_EFFECTIVE(C, state) -> matrix:

    # Load prior cycle's amplified coupling matrix if it exists.
    # This ensures that correlated-threshold amplification carries forward
    # to the next timestep (1-cycle lag, per v1.3 specification).
    if state.has("PersistedCoupling"):
        C_eff = DEEP_COPY(state.PersistedCoupling)
    else:
        C_eff = new matrix same size as C
        for all i,j:
            C_eff[i][j] = C[i][j]

    # Centralized Initiator State comes from system state
    CIS = state.CIS

    # If CIS = 0, coupling stays at v1.2 baseline and we’re done.
    if CIS == 0:
        return C_eff

    # Amplification only under CIS=1 (centralized initiator regime)
    CouplingAmplification = DEFAULT_COUPLING_AMPLIFICATION   # e.g., 0.5
    for all i,j:
        C_eff[i][j] = C_eff[i][j] * (1.0 + CouplingAmplification)
        if C_eff[i][j] > 1.0:
            C_eff[i][j] = 1.0

    # Persist into state for next timestep (correlation adjustments may modify it later)
    state.PersistedCoupling = DEEP_COPY(C_eff)

    return C_eff
function STORE_COUPLING_MATRIX_IN_STATE(C_eff):

 # Persist correlation-amplified coupling matrix for the next timestep.

 # This overwrites any previous persistence so that the latest

 # correlation effects are carried forward.

 state.PersistedCoupling = DEEP_COPY(C_eff)

# TODO: replace with APPLY_DRIFT_V1_2(...) from CTM Process v1.2 Section 8
function COMPUTE_GFM_V1_2(domain, prev_state) -> float:
    // Use existing CTM v1.2 governance feedback logic
    ...

function COMPUTE_CFC_V1_2(domain, prev_state) -> float:
    // Use existing v1.2 friction composite calculation
    ...

# TODO: replace with APPLY_DRIFT_V1_2(...) from CTM Process v1.2 Section 8
function COMPUTE_FFM_V1_2(domain, prev_state, CFC_effective) -> float:
    // Use v1.2 friction feedback logic, substituting CFC_effective
    ...

# TODO: replace with APPLY_DRIFT_V1_2(...) from CTM Process v1.2 Section 8
function COMPUTE_DECAY_RATE_BASE_V1_2(domain, prev_state) -> float:
    // (1 - SUL_i * 0.05) * ThresholdStateMultiplier(t-1)
    ...

function APPLY_DRIFT_V1_2(domain, prev_state, dom_state) -> DomainState:
    // Original threshold drift logic
    ...
function GET_INSTITUTIONAL_CONTROL(domain, governance_style) -> float:
    if governance_style == "CDG":
        // Use table from v1.3 CDG section
        switch(domain):
            case "EXECUTIVE":   return 0.9
            case "LEGISLATURE": return 0.4
            case "JUDICIARY":   return 0.2
            case "NORMS":       return 0.6
            case "SECURITY":    return 0.7
            case "ECONOMY":     return 0.5
            case "MEDIA":       return 0.3
            case "CIVIC":       return 0.4
    else:
        // Other governance styles can define their own mappings
        return DEFAULT_INSTITUTIONAL_CONTROL(domain, governance_style)
function CLASSIFY_TRAJECTORY(state, prev_state) -> string:
    // Use v1.2 logic for 6A/6B/6C based on:
    // - direction of SystemLoad
    // - stability of thresholds
    // - OscillationIndex, etc.
    // Then add v1.3 rule for 6D:

    if state.MetaState == "RECONFIG" and state.ReconfigDuration >= ReconfigThreshold:
        return "6D"  // Reconfiguration Trajectory
    else:
        // Fall back to 6A/6B/6C classification logic
        return CLASSIFY_6A_6B_6C(state, prev_state)