tnfr 3.0.3__py3-none-any.whl → 8.5.0__py3-none-any.whl

tnfr/operators/canonical_patterns.py

@@ -0,0 +1,420 @@
+"""Canonical operator sequences and archetypal patterns from TNFR theory.
+
+.. deprecated:: 0.2.0
+    This module is deprecated and will be removed in version 1.0.0.
+    Use :mod:`tnfr.operators.pattern_detection` instead, which provides unified
+    pattern detection with explicit U1-U4 grammar rule mappings.
+
+    For canonical sequences, this module remains the authoritative source.
+    For pattern detection, use the new unified module.
+
+This module defines the 6 canonical archetypal sequences involving OZ (Dissonance)
+as documented in "El pulso que nos atraviesa" (Table 2.5 - Glyphic structural typology).
+
+These sequences represent validated structural patterns that can be reused across
+different domains and applications while maintaining TNFR coherence and grammar.
+
+References
+----------
+"El pulso que nos atraviesa", Table 2.5: Glyphic structural typology
+Section 2.3.8: Complete examples
+Section 2.3.5: Advanced glyphic writing (Glyphic macros)
+"""
+
+from __future__ import annotations
+
+import warnings
+from typing import Dict, List, NamedTuple
+
+# Issue deprecation warning on import
+warnings.warn(
+    "canonical_patterns module is deprecated. "
+    "For pattern detection, use tnfr.operators.pattern_detection instead. "
+    "Canonical sequences remain available here for backward compatibility.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+from ..types import Glyph
+from .grammar import StructuralPattern
+
+__all__ = [
+    "CanonicalSequence",
+    "CANONICAL_SEQUENCES",
+    "BIFURCATED_BASE",
+    "BIFURCATED_COLLAPSE",
+    "THERAPEUTIC_PROTOCOL",
+    "THEORY_SYSTEM",
+    "FULL_DEPLOYMENT",
+    "MOD_STABILIZER",
+    # New variants unlocked by high → zero frequency transition
+    "CONTAINED_CRISIS",
+    "RESONANCE_PEAK_HOLD",
+    "MINIMAL_COMPRESSION",
+    "PHASE_LOCK",
+]
+
+
+class CanonicalSequence(NamedTuple):
+    """Canonical operator sequence with theoretical metadata.
+
+    Represents a validated archetypal sequence from TNFR theory with
+    structural pattern classification, use cases, and domain context.
+
+    Attributes
+    ----------
+    name : str
+        Unique identifier for the sequence (e.g., 'bifurcated_base')
+    glyphs : List[Glyph]
+        Ordered sequence of structural glyphs (AL, EN, IL, OZ, etc.)
+    pattern_type : StructuralPattern
+        Structural pattern classification from grammar
+    description : str
+        Detailed explanation of structural function
+    use_cases : List[str]
+        Concrete application scenarios
+    domain : str
+        Primary domain: 'general', 'biomedical', 'cognitive', 'social'
+    references : str
+        Theoretical grounding from TNFR documentation
+    """
+
+    name: str
+    glyphs: List[Glyph]
+    pattern_type: StructuralPattern
+    description: str
+    use_cases: List[str]
+    domain: str
+    references: str
+
+
+# ============================================================================
+# Bifurcated Patterns: OZ creates decision points
+# ============================================================================
+
+BIFURCATED_BASE = CanonicalSequence(
+    name="bifurcated_base",
+    glyphs=[Glyph.AL, Glyph.EN, Glyph.IL, Glyph.OZ, Glyph.ZHIR, Glyph.IL, Glyph.SHA],
+    pattern_type=StructuralPattern.BIFURCATED,
+    description=(
+        "Structural dissonance that generates bifurcation threshold. "
+        "The node can reorganize (ZHIR) or collapse to latency (NUL). "
+        "This pattern represents the creative resolution of dissonance "
+        "through transformative mutation. "
+        "Includes EN → IL (reception→coherence) for grammar validation."
+    ),
+    use_cases=[
+        "Therapeutic intervention for emotional or cognitive blockages",
+        "Analysis of cultural crises or paradigms under tension",
+        "Design of systems with adaptive response to perturbations",
+        "Modeling of decision points in complex networks",
+    ],
+    domain="general",
+    references="El pulso que nos atraviesa, Table 2.5, Section 2.3.4 (Bifurcation)",
+)
+
+BIFURCATED_COLLAPSE = CanonicalSequence(
+    name="bifurcated_collapse",
+    glyphs=[Glyph.AL, Glyph.EN, Glyph.IL, Glyph.OZ, Glyph.NUL, Glyph.IL, Glyph.SHA],
+    pattern_type=StructuralPattern.BIFURCATED,
+    description=(
+        "Alternative bifurcation path: dissonance leads to controlled collapse (NUL) "
+        "instead of mutation. Useful for structural reset when transformation "
+        "is not viable. The node returns to latency preserving potentiality. "
+        "Includes EN → IL (reception→coherence) for grammar validation."
+    ),
+    use_cases=[
+        "Cognitive reset after informational overload",
+        "Strategic organizational disinvestment",
+        "Return to potentiality after failed exploration",
+        "Structural simplification facing unsustainable complexity",
+    ],
+    domain="general",
+    references="El pulso que nos atraviesa, Section 2.3.3 (Bifurcation and mutation)",
+)
+
+
+# ============================================================================
+# Therapeutic Protocol: Reorganization Ritual
+# ============================================================================
+
+THERAPEUTIC_PROTOCOL = CanonicalSequence(
+    name="therapeutic_protocol",
+    glyphs=[
+        Glyph.AL,
+        Glyph.EN,
+        Glyph.IL,
+        Glyph.OZ,
+        Glyph.ZHIR,
+        Glyph.IL,
+        Glyph.RA,
+        Glyph.IL,
+        Glyph.SHA,
+    ],
+    pattern_type=StructuralPattern.THERAPEUTIC,
+    description=(
+        "Ritual or therapeutic protocol: symbolic emission (AL), stabilizing "
+        "reception (EN), initial coherence (IL), creative dissonance as "
+        "confrontation (OZ), subject mutation (ZHIR), stabilization of the "
+        "new form (IL), resonant propagation (RA), post-resonance stabilization (IL), "
+        "entry into latency (SHA). Personal or collective transformation cycle with "
+        "creative resolution and coherent frequency transitions."
+    ),
+    use_cases=[
+        "Personal transformation or initiation ceremonies",
+        "Deep therapeutic restructuring sessions",
+        "Symbolic accompaniment of vital change processes",
+        "Collective or community healing rituals",
+    ],
+    domain="biomedical",
+    references="El pulso que nos atraviesa, Ejemplo 3 (Sección 2.3.8)",
+)
+
+
+# ============================================================================
+# Theory System: Epistemological Construction
+# ============================================================================
+
+THEORY_SYSTEM = CanonicalSequence(
+    name="theory_system",
+    glyphs=[
+        Glyph.AL,
+        Glyph.EN,
+        Glyph.IL,
+        Glyph.OZ,
+        Glyph.ZHIR,
+        Glyph.IL,
+        Glyph.THOL,
+        Glyph.SHA,
+    ],
+    pattern_type=StructuralPattern.EDUCATIONAL,
+    description=(
+        "Emerging system of ideas or theory: initial emission (AL), information "
+        "reception (EN), stabilization (IL), conceptual dissonance or paradox (OZ), "
+        "mutation toward new paradigm (ZHIR), stabilization in coherent understanding (IL), "
+        "self-organization into theoretical system (THOL), integration into embodied "
+        "knowledge (SHA). Epistemological construction trajectory."
+    ),
+    use_cases=[
+        "Design of epistemological frameworks or scientific paradigms",
+        "Construction of coherent theories in social sciences",
+        "Modeling of conceptual evolution in academic communities",
+        "Development of philosophical systems or worldviews",
+    ],
+    domain="cognitive",
+    references="El pulso que nos atraviesa, Example 2 (Section 2.3.8)",
+)
+
+
+# ============================================================================
+# Full Deployment: Complete Deployment
+# ============================================================================
+
+FULL_DEPLOYMENT = CanonicalSequence(
+    name="full_deployment",
+    glyphs=[
+        Glyph.AL,
+        Glyph.EN,
+        Glyph.IL,
+        Glyph.OZ,
+        Glyph.ZHIR,
+        Glyph.IL,
+        Glyph.RA,
+        Glyph.IL,
+        Glyph.SHA,
+    ],
+    pattern_type=StructuralPattern.COMPLEX,
+    description=(
+        "Complete nodal reorganization trajectory: initiating emission (AL), "
+        "stabilizing reception (EN), initial coherence (IL), exploratory "
+        "dissonance (OZ), transformative mutation (ZHIR), coherent stabilization (IL), "
+        "resonant propagation (RA), post-resonance consolidation (IL), closure in latency (SHA). "
+        "Exhaustive structural reorganization sequence with coherent frequency transitions."
+    ),
+    use_cases=[
+        "Complete organizational transformation processes",
+        "Radical innovation cycles with multiple phases",
+        "Deep and transformative learning trajectories",
+        "Systemic reorganization of communities or ecosystems",
+    ],
+    domain="general",
+    references="El pulso que nos atraviesa, Table 2.5 (Complete deployment)",
+)
+
+
+# ============================================================================
+# New Canonical Variants: Direct high → zero Termination
+# Unlocked by frequency transition update allowing high → zero for SHA
+# ============================================================================
+
+CONTAINED_CRISIS = CanonicalSequence(
+    name="contained_crisis",
+    glyphs=[Glyph.AL, Glyph.EN, Glyph.IL, Glyph.OZ, Glyph.SHA],
+    pattern_type=StructuralPattern.THERAPEUTIC,
+    description=(
+        "Direct crisis containment: dissonance immediately preserved without processing. "
+        "OZ creates ΔNFR ↑ (tension, exploration), SHA immediately contains via νf → 0, "
+        "preserving tension in suspended state for later resolution. This is the canonical "
+        "'contained dissonance' pattern: trauma held safely, conflict postponed, tension "
+        "preserved. Essential for trauma first response, emergency pause, and protective freeze "
+        "when immediate processing would overwhelm the system."
+    ),
+    use_cases=[
+        "Trauma containment (immediate safety response without processing)",
+        "Crisis management (pause before system overwhelm)",
+        "Strategic hold (preserve tension for optimal timing)",
+        "Protective freeze (contain instability temporarily)",
+        "Emergency stop (halt exploration when risk detected)",
+    ],
+    domain="therapeutic",
+    references=(
+        "SHA Grammar Validation Issue: OZ → SHA as valid therapeutic pattern. "
+        "Frequency transition update: high → zero for containment/termination."
+    ),
+)
+
+RESONANCE_PEAK_HOLD = CanonicalSequence(
+    name="resonance_peak_hold",
+    glyphs=[Glyph.AL, Glyph.EN, Glyph.IL, Glyph.RA, Glyph.SHA],
+    pattern_type=StructuralPattern.RESONATE,
+    description=(
+        "Peak state preservation: amplified resonance frozen at maximum coherence. "
+        "RA amplifies network coherence (high C(t), increased νf), SHA suspends dynamics "
+        "(νf → 0) while preserving peak state, creating 'resonance memory'. Used for "
+        "flow state capture, optimal pattern preservation, and network snapshots. The "
+        "amplified coherence is held in latent form for later reactivation without decay."
+    ),
+    use_cases=[
+        "Flow state preservation (hold peak performance)",
+        "Peak coherence memory (capture optimal synchronization)",
+        "Network snapshot (freeze synchronized state)",
+        "Resonance consolidation (lock amplified pattern)",
+        "Optimal moment capture (preserve heightened state)",
+    ],
+    domain="cognitive",
+    references=(
+        "Frequency transition update: high → zero enables direct RA → SHA termination. "
+        "Memory consolidation pattern for peak states."
+    ),
+)
+
+MINIMAL_COMPRESSION = CanonicalSequence(
+    name="minimal_compression",
+    glyphs=[Glyph.AL, Glyph.EN, Glyph.IL, Glyph.NUL, Glyph.SHA],
+    pattern_type=StructuralPattern.COMPRESS,
+    description=(
+        "Compressed latency: structure reduced to essential form and preserved. "
+        "NUL concentrates EPI to core (contraction, high νf), SHA immediately freezes "
+        "minimal form (νf → 0), creating efficient storage. Distills pattern to fundamentals "
+        "then preserves in latent state. Used for information compression, core essence "
+        "extraction, and efficient memory storage of essential structure only."
+    ),
+    use_cases=[
+        "Information compression (minimal viable form)",
+        "Core essence extraction (distill to fundamentals)",
+        "Efficient storage (compact representation)",
+        "Essential pattern hold (preserve only critical structure)",
+        "Minimal memory (reduce before suspend)",
+    ],
+    domain="cognitive",
+    references=(
+        "Frequency transition update: high → zero enables direct NUL → SHA termination. "
+        "Compression-then-freeze pattern for efficient storage."
+    ),
+)
+
+PHASE_LOCK = CanonicalSequence(
+    name="phase_lock",
+    glyphs=[Glyph.AL, Glyph.EN, Glyph.IL, Glyph.OZ, Glyph.ZHIR, Glyph.SHA],
+    pattern_type=StructuralPattern.BIFURCATED,
+    description=(
+        "Phase transition hold: mutation immediately locked without stabilization. "
+        "OZ creates bifurcation threshold (ΔNFR ↑), ZHIR pivots phase θ (high νf), "
+        "SHA immediately locks new phase (νf → 0) before potential regression. Preserves "
+        "transformed state in latent form, preventing return to previous configuration. "
+        "Used for identity consolidation, paradigm shift memory, and transformation lock. "
+        "Simpler than full ZHIR → IL → SHA when immediate preservation desired."
+    ),
+    use_cases=[
+        "Identity shift hold (lock new configuration)",
+        "Phase memory (preserve transformed state)",
+        "Mutation consolidation (hold before integration)",
+        "Paradigm capture (freeze new perspective)",
+        "Transformation lock (prevent regression)",
+    ],
+    domain="cognitive",
+    references=(
+        "Frequency transition update: high → zero enables direct ZHIR → SHA termination. "
+        "Immediate phase lock pattern without intermediate stabilization."
+    ),
+)
+
+
+# ============================================================================
+# MOD_STABILIZER: Reusable Glyphic Macro
+# ============================================================================
+
+MOD_STABILIZER = CanonicalSequence(
+    name="mod_stabilizer",
+    glyphs=[
+        Glyph.REMESH,
+        Glyph.EN,
+        Glyph.IL,
+        Glyph.OZ,
+        Glyph.ZHIR,
+        Glyph.IL,
+        Glyph.REMESH,
+    ],
+    pattern_type=StructuralPattern.EXPLORE,
+    description=(
+        "MOD_STABILIZER: glyphic macro for controlled transformation. "
+        "Activates recursivity (REMESH), receives current state (EN), stabilizes (IL), "
+        "introduces controlled dissonance (OZ), mutates structure (ZHIR), stabilizes "
+        "new form (IL), closes with recursivity (REMESH). Reusable as "
+        "modular subunit within more complex sequences. Represents the "
+        "minimal pattern of exploration-transformation-consolidation with complete "
+        "grammar validation (EN → IL) and recursive closure."
+    ),
+    use_cases=[
+        "Safe transformation module for composition",
+        "Reusable component in complex sequences",
+        "Encapsulated creative resolution pattern",
+        "Building block for T'HOL (self-organization)",
+    ],
+    domain="general",
+    references="El pulso que nos atraviesa, Section 2.3.5 (Glyphic macros)",
+)
+
+
+# ============================================================================
+# Registry of All Canonical Sequences
+# ============================================================================
+
+CANONICAL_SEQUENCES: Dict[str, CanonicalSequence] = {
+    seq.name: seq
+    for seq in [
+        BIFURCATED_BASE,
+        BIFURCATED_COLLAPSE,
+        THERAPEUTIC_PROTOCOL,
+        THEORY_SYSTEM,
+        FULL_DEPLOYMENT,
+        MOD_STABILIZER,
+        # New variants unlocked by high → zero frequency transition
+        CONTAINED_CRISIS,
+        RESONANCE_PEAK_HOLD,
+        MINIMAL_COMPRESSION,
+        PHASE_LOCK,
+    ]
+}
+"""Registry of all canonical operator sequences.
+
+Maps sequence names to their full CanonicalSequence definitions. This registry
+provides programmatic access to validated archetypal patterns from TNFR theory.
+
+Examples
+--------
+>>> from tnfr.operators.canonical_patterns import CANONICAL_SEQUENCES
+>>> seq = CANONICAL_SEQUENCES["bifurcated_base"]
+>>> print(f"{seq.name}: {' → '.join(g.value for g in seq.glyphs)}")
+bifurcated_base: AL → IL → OZ → ZHIR → SHA
+"""

tnfr/operators/cascade.py

@@ -0,0 +1,267 @@
+"""Cascade detection and analysis for THOL self-organization.
+
+Provides tools to detect, measure, and analyze emergent cascades in
+TNFR networks where THOL bifurcations propagate through coupled nodes.
+
+TNFR Canonical Principle
+-------------------------
+From "El pulso que nos atraviesa" (TNFR Manual, §2.2.10):
+
+    "THOL actúa como modulador central de plasticidad. Es el glifo que
+    permite a la red reorganizar su topología sin intervención externa.
+    Su activación crea bucles de aprendizaje resonante, trayectorias de
+    reorganización emergente, estabilidad dinámica basada en coherencia local."
+
+This module implements cascade detection: when THOL bifurcations propagate
+through phase-aligned neighbors, creating chains of emergent reorganization.
+
+Performance Optimization
+------------------------
+CASCADE DETECTION CACHING: `detect_cascade()` uses TNFR's canonical caching
+infrastructure (`@cache_tnfr_computation`) to avoid recomputing cascade state.
+The cache is automatically invalidated when THOL propagations change, ensuring
+coherence while enabling O(1) lookups for repeated queries.
+
+Cache key depends on: graph identity + propagation history + cascade config.
+This provides significant performance improvement for large networks (>1000 nodes)
+where cascade detection is called frequently (e.g., in `self_organization_metrics`).
+"""
+
+from __future__ import annotations
+
+from collections import deque
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from ..types import NodeId, TNFRGraph
+
+__all__ = [
+    "detect_cascade",
+    "measure_cascade_radius",
+    "invalidate_cascade_cache",
+]
+
+
+# Import cache utilities for performance optimization
+try:
+    from ..utils.cache import cache_tnfr_computation, CacheLevel
+    _CACHING_AVAILABLE = True
+except ImportError:  # pragma: no cover - defensive import for testing
+    _CACHING_AVAILABLE = False
+    # Dummy decorator if caching unavailable
+    def cache_tnfr_computation(level, dependencies, cost_estimator=None):
+        def decorator(func):
+            return func
+        return decorator
+    
+    class CacheLevel:  # type: ignore
+        DERIVED_METRICS = "derived_metrics"
+
+
+def _estimate_cascade_cost(G: TNFRGraph) -> float:
+    """Estimate computational cost for cascade detection.
+    
+    Used by cache eviction policy to prioritize expensive computations.
+    Cost is proportional to number of propagation events to process.
+    """
+    propagations = G.graph.get("thol_propagations", [])
+    # Base cost + cost per propagation event
+    return 1.0 + len(propagations) * 0.1
+
+
+@cache_tnfr_computation(
+    level=CacheLevel.DERIVED_METRICS,
+    dependencies={'thol_propagations', 'cascade_config'},
+    cost_estimator=_estimate_cascade_cost,
+)
+def detect_cascade(G: TNFRGraph) -> dict[str, Any]:
+    """Detect if THOL triggered a propagation cascade in the network.
+
+    A cascade is defined as a chain reaction where:
+    1. Node A bifurcates (THOL)
+    2. Sub-EPI propagates to coupled neighbors
+    3. Neighbors' EPIs increase, potentially triggering their own bifurcations
+    4. Process continues across ≥3 nodes
+
+    **Performance**: This function uses TNFR's canonical cache infrastructure
+    to avoid recomputing cascade state. First call builds cache (O(P × N_prop)),
+    subsequent calls are O(1) hash lookups. Cache automatically invalidates
+    when `thol_propagations` or `cascade_config` dependencies change.
+
+    Parameters
+    ----------
+    G : TNFRGraph
+        Graph with THOL propagation history
+
+    Returns
+    -------
+    dict
+        Cascade analysis containing:
+        - is_cascade: bool (True if cascade detected)
+        - affected_nodes: set of NodeIds involved
+        - cascade_depth: maximum propagation chain length
+        - total_propagations: total number of propagation events
+        - cascade_coherence: average coupling strength in cascade
+
+    Notes
+    -----
+    TNFR Principle: Cascades emerge when network phase coherence enables
+    propagation across multiple nodes, creating collective self-organization.
+
+    Caching Strategy:
+    - Cache level: DERIVED_METRICS (mid-persistence)
+    - Dependencies: 'thol_propagations' (propagation history), 
+                   'cascade_config' (threshold parameters)
+    - Invalidation: Automatic when dependencies change
+    - Cost: Proportional to number of propagation events
+
+    For networks with >1000 nodes and frequent cascade queries, caching
+    provides significant speedup (~100x for cached calls).
+
+    Examples
+    --------
+    >>> # Network with cascade
+    >>> analysis = detect_cascade(G)
+    >>> analysis["is_cascade"]
+    True
+    >>> analysis["cascade_depth"]
+    4  # Propagated through 4 levels
+    >>> len(analysis["affected_nodes"])
+    7  # 7 nodes affected
+    """
+    propagations = G.graph.get("thol_propagations", [])
+
+    if not propagations:
+        return {
+            "is_cascade": False,
+            "affected_nodes": set(),
+            "cascade_depth": 0,
+            "total_propagations": 0,
+            "cascade_coherence": 0.0,
+        }
+
+    # Build propagation graph
+    affected_nodes = set()
+    for prop in propagations:
+        affected_nodes.add(prop["source_node"])
+        for target, _ in prop["propagations"]:
+            affected_nodes.add(target)
+
+    # Compute cascade depth (longest propagation chain)
+    # For now, approximate as number of propagation events
+    cascade_depth = len(propagations)
+
+    # Total propagations
+    total_props = sum(len(p["propagations"]) for p in propagations)
+
+    # Get cascade minimum nodes from config
+    cascade_min_nodes = int(G.graph.get("THOL_CASCADE_MIN_NODES", 3))
+
+    # Cascade = affects ≥ cascade_min_nodes
+    is_cascade = len(affected_nodes) >= cascade_min_nodes
+
+    return {
+        "is_cascade": is_cascade,
+        "affected_nodes": affected_nodes,
+        "cascade_depth": cascade_depth,
+        "total_propagations": total_props,
+        "cascade_coherence": 0.0,  # TODO: compute from coupling strengths
+    }
+
+
+def measure_cascade_radius(G: TNFRGraph, source_node: NodeId) -> int:
+    """Measure propagation radius from bifurcation source.
+
+    Parameters
+    ----------
+    G : TNFRGraph
+        Graph with propagation history
+    source_node : NodeId
+        Origin node of cascade
+
+    Returns
+    -------
+    int
+        Number of nodes reached by propagation (hop distance)
+
+    Notes
+    -----
+    Uses BFS to trace propagation paths from source.
+
+    Examples
+    --------
+    >>> # Linear cascade: 0 -> 1 -> 2 -> 3
+    >>> radius = measure_cascade_radius(G, source_node=0)
+    >>> radius
+    3  # Reached 3 hops from source
+    """
+    propagations = G.graph.get("thol_propagations", [])
+
+    # Build propagation edges from this source
+    prop_edges = []
+    for prop in propagations:
+        if prop["source_node"] == source_node:
+            for target, _ in prop["propagations"]:
+                prop_edges.append((source_node, target))
+
+    if not prop_edges:
+        return 0
+
+    # BFS to measure radius
+    visited = {source_node}
+    queue = deque([(source_node, 0)])  # (node, distance)
+    max_distance = 0
+
+    while queue:
+        current, dist = queue.popleft()
+        max_distance = max(max_distance, dist)
+
+        for src, tgt in prop_edges:
+            if src == current and tgt not in visited:
+                visited.add(tgt)
+                queue.append((tgt, dist + 1))
+
+    return max_distance
+
+
+def invalidate_cascade_cache() -> int:
+    """Invalidate cached cascade detection results across all graphs.
+    
+    This function should be called when THOL propagations are added or
+    cascade configuration parameters change. It triggers automatic cache
+    invalidation via the dependency tracking system.
+    
+    Returns
+    -------
+    int
+        Number of cache entries invalidated.
+        
+    Notes
+    -----
+    TNFR Caching: Uses canonical `invalidate_by_dependency()` mechanism.
+    Dependencies invalidated: 'thol_propagations', 'cascade_config'.
+    
+    This function is typically not needed explicitly, as cache invalidation
+    happens automatically when G.graph["thol_propagations"] is modified.
+    However, it's provided for manual cache management in edge cases.
+    
+    Examples
+    --------
+    >>> # Add new propagations
+    >>> G.graph["thol_propagations"].append(new_propagation)
+    >>> # Cache invalidates automatically, but can force if needed
+    >>> invalidate_cascade_cache()  # doctest: +SKIP
+    2  # Invalidated 2 cache entries
+    """
+    if not _CACHING_AVAILABLE:
+        return 0
+    
+    try:
+        from ..utils.cache import get_global_cache
+        cache = get_global_cache()
+        count = 0
+        count += cache.invalidate_by_dependency('thol_propagations')
+        count += cache.invalidate_by_dependency('cascade_config')
+        return count
+    except (ImportError, AttributeError):  # pragma: no cover
+        return 0