pi(63728127) ≈ 4207968 primes (2590 bits)
pi(2.36e21) ≈ 477000000 primes (711000 bits)
pi(1180591620717411303424) ≈ 1328000000 primes (2333000 bits)

As the number of odd steps explodes in real Collatz trees (upper swarm), 
The eigenvalue λ = (3/4)^k becomes astronomically small. 
State { eigenvalue λ =>>>  small } → quantum tunneling probability collapses → percolation probability → 0 → localization length ξ → 1
Wave is trapped within roughly one "site".
No quantum tunneling effect is present.

**** figure. QUANTUM WALKS USING COLLATZ ANALOGY  **** 

+----------------------------------------------------------------------------------+
| QUANTUM WALKS ON THE COLLATZ GRAPH                                               |
|                                                                                  |
|    Node = Integer                                                                |
|    Directed Edge = Collatz Rule (n/2 if even, (3n+1)/2 if odd)                   |
|    Sink = Node 1 (absorbing)                                                     |
|                                                                                  |
|    Quantum Walker:                                                               |
|      • Exists in superposition over multiple nodes                               |
|      • Coin operator chooses direction (forward or stay)                         |
|      • Shift operator moves along edges                                          |
|      • Interference creates localization or fast percolation                     |
|                                                                                  |
|    Educational Value: Visual model of superposition without complex numbers      |
+----------------------------------------------------------------------------------+

**** figure. COLLATZ ANALOGY, SUPERPOSITION & INTERFERENCE IN QUANTUM WALK ****

+----------------------------------------------------------------------------------+
| SUPERPOSITION AND INTERFERENCE ON COLLATZ PATHS                                  |
|                                                                                  |
|    Classical Walk:   One path at a time                                          |
|    Quantum Walk:     Explores ALL possible Collatz futures simultaneously        |
|                                                                                  |
|    Constructive Interference   →  Probability reinforced toward sink (lower swarm)|
|    Destructive Interference    →  Probability cancelled / trapped (upper swarm)  |
|                                                                                  |
|    Result: Emergent patterns not visible in single deterministic trajectories    |
|    Lower swarm: Fast percolation to 1                                            |
|    Upper swarm: Strong localization far from 1                                   |
+----------------------------------------------------------------------------------+

**** figure. COLLATZ ANALOGY,  LOWER vs UPPER SWARM IN QUANTUM WALK ****

+----------------------------------------------------------------------------------+
| LOWER SWARM vs UPPER SWARM - Quantum Walk Behavior Using Collatz Analogy         |
|                                                                                  |
|    Lower Swarm (small k, high λ)                                                 |
|      • Fast probability flow to sink                                             |
|      • Delocalized states                                                        |
|      • High percolation probability                                              |
|      • Resembles ballistic transport                                             |
|                                                                                  |
|    Upper Swarm (large k, low λ)                                                  |
|      • Very slow leakage to sink                                                 |
|      • Strongly localized states                                                 |
|      • Low percolation probability                                               |
|      • Resembles Anderson localization                                           |
|                                                                                  |
|    Mobility Edge ~ λ = 0.10 separates the two phases                             |
+----------------------------------------------------------------------------------+

**** figure. MOBILITY EDGE & PERCOLATION THRESHOLD **** 

+----------------------------------------------------------------------------------+
| MOBILITY EDGE & QUANTUM PERCOLATION                                              |
|                                                                                  |
|    λ ≥ 0.10   →   Lower Swarm   →   Extended / Delocalized                       |
|                   Fast percolation to sink (node 1)                              |
|                                                                                  |
|          ───────────────── Mobility Edge λ ≈ 0.10 ───────────────────            |
|                                                                                  |
|    λ < 0.10   →   Upper Swarm   →   Localized / Trapped                          |
|                   Slow leakage, probability stays far from sink                  |
|                                                                                  |
|    Percolation Question: Does probability amplitude reach sink=1 from every node?|
|    Collatz conjecture claims yes for classical paths.                            |
|    Quantum walk tests this under interference.                                   |
+----------------------------------------------------------------------------------+

**** figure. CLASSICAL vs QUANTUM WALK COMPARISON ****

+----------------------------------------------------------------------------------+
| CLASSICAL RANDOM WALK vs QUANTUM WALK                                            |
|                                                                                  |
|    Feature               Classical Walk          Quantum Walk                    |
|    ───────────────────   ───────────────────    ───────────────────────────      |
|    Paths                 Single path             Superposition of many paths     |
|    Interference          None                    Constructive / Destructive      |
|    Hitting Time          Linear in N             Potentially √N speedup          |
|    Localization          Rare                    Common in disordered graphs      |
|    Collatz Analogy       Deterministic path      Lower/Upper swarm emergence     |
|                                                                                  |
|    Quantum walk reveals emergent bands and mobility edge not visible classically |
+----------------------------------------------------------------------------------+

**** figure. SZEGEDY EDGE-SPACE CONSTRUCTION (Placeholder) ****

+----------------------------------------------------------------------------------+
| SZEGEDY EDGE-SPACE QUANTUM WALK (Advanced Construction)                          |
|                                                                                  |
|    Problem: Standard coin+shift walk is not unitary on directed graphs           |
|    (Collatz has exactly one outgoing edge per node)                              |
|                                                                                  |
|    Szegedy Solution:                                                             |
|      • Work in edge-space instead of node-space                                  |
|      • Basis states = directed edges (u → next(u))                               |
|      • Reflection about normalized edge states                                   |
|      • Swap operator on edges                                                    |
|                                                                                  |
|    Current Program: Uses classical probability split (conserves probability)     |
|    Future Fork: Replace dummy in Section 2b with full Szegedy for true quantum   |
|    interference on the inverse Collatz graph.                                    |
+----------------------------------------------------------------------------------+

**** figure. QUANTUM WALKS ON COLLATZ ANALOGY- SUMMARY ****

+----------------------------------------------------------------------------------+
| QUANTUM WALKS ON COLLATZ - Educational Summary                                   |
|                                                                                  |
|    Why Collatz Analogy is excellent for teaching quantum walks:                         |
|      • Familiar deterministic rule                                               |
|      • Clear two-swarm structure                                                 |
|      • Natural mobility edge at λ ≈ 0.10                                         |
|      • Direct analogy to Anderson localization                                   |
|      • Percolation to sink mirrors quantum transport                             |
|                                                                                  |
|    Students gain intuition for superposition, interference,                      |
|    localization, and quantum speedups without heavy math.                        |
+----------------------------------------------------------------------------------+

**** figure. COLLATZ ANALOGY, DETAILED INTERFERENCE EXAMPLE IN QUANTUM WALK ****

+----------------------------------------------------------------------------------+
| DETAILED INTERFERENCE EXAMPLE - Quantum Walk on Collatz Paths                    |
|                                                                                  |
|    Starting Node: n=7 (k=5, lower swarm)                                         |
|                                                                                  |
|    Possible Paths at Step 3:                                                     |
|      Path A: 7 → 22 → 11 → 34          Amplitude: +0.42                          |
|      Path B: 7 → 22 → 11 → 5 (via alt) Amplitude: +0.42                          |
|      Path C: 7 → 22 → 11 → 34 (alt)    Amplitude: -0.29   ← Destructive          |
|                                                                                  |
|    At Sink Node 1:                                                               |
|      Constructive Interference → Probability reinforced (adds up)                |
|      Destructive Interference → Probability cancelled (subtracts)                |
|                                                                                  |
|    Result after many steps:                                                      |
|      Lower swarm (small k): Strong constructive interference → fast hitting     |
|      Upper swarm (large k): Strong destructive interference → localization       |
+----------------------------------------------------------------------------------+

**** figure. COLLATZ ANALOGY, HITTING TIME CURVE - Probability at Sink vs Steps ****

+----------------------------------------------------------------------------------+
| HITTING TIME CURVE - Probability at Sink (Node 1) vs Number of Steps             |
|                                                                                  |
|    Sink Probability                                                              |
|    1.0  ██████████████████████████████   ← Lower swarm (fast percolation)        |
|    0.8  ██████████████                                                           |
|    0.6  ████████                                                                 |
|    0.4  ████                                                                     |
|    0.2  ██                                                                       |
|    0.0  ──────────────────────────────────────────────────────────────────────── |
|         0    50   100   150   200   300   500   Steps                            |
|                                                                                  |
|    Legend:                                                                       |
|      █ Lower swarm (e.g. n=7, k=5)   → reaches ~1.0 quickly                     |
|      ░ Upper swarm (e.g. n=27, k=41) → stays near 0.0 even at 500 steps         |
|                                                                                  |
|    Mobility Edge Effect: Sharp transition around λ ≈ 0.10                        |
|    Quantum walks dramatically change hitting times through interference          |
+----------------------------------------------------------------------------------+

# tcl
# Collatz Analogies for Quantum Walk Model + Szegedy placeholder V12
# Dual Table Output
# The program has an existing fork to the classical algorithm-solution
# and a second dummy fork to the Szegedy construction,
# for further study and comparison on quantum walk. 
# Simply put, program has two estimation routines or forks.
# Using multiple safety caps or clamps, Collatz Sequence is infinite,
# danger of endless loops in program.
# ----
# Educational version with visible probabilities (4 sig figs)
# Outputs results in wiki table format (header with %|, alternating rows &|)
# ----
# Tcl/Tk 8.6+ 7-bit ASCII safe. NASA/JPL defensive programming style.
# NASA/JPL defensive programming style.
# Compatible with Tcl/Tk (Tool Control Language / Toolkit) 8.6+
# Written for Windows 11 on ActiveState Tcl.
# Working under strict 7-bit ASCII encoding.
# Optimized for collegiate information technology lab environments.
# Written to be very modular for transferable procs.
# Program deck may contain multiple estimation procs.
# May contain  code dependencies on Active State and Windows 11
# Complex math calculations up to 8 units computer time
# Wait for complete calculations before saving files.
# This is a hacker's patch, not rigorously derived.
# appears correct solutions for autotests.
# pure ASCII code - no Unicode characters used anywhere.
# Approaching =>>> computer time limit on this TCL configuration setup. 
# TCL club, 03/20/2026
# ----
# changes note V12 -> V12 + Szegedy placeholder
# Added: szegedy_edge_space_placeholder proc (Section 2b)
#   Dummy routine that accepts existing globals, prints educational header,
#   and returns without touching the active walk state or any other proc.
#   Fork comment retained verbatim from V12 to mark the branch point.
#   All other sections and output are unchanged.
# ----
#
# =============================================================================
# Snippets Concepts: Collatz Eigenvalue Percolation Walk V12
# =============================================================================
#
#   PURPOSE (three sentences):
#   This program models the analogy between Collatz sequence eigenvalue layers
#   and quantum tunneling probability envelopes using a probability percolation
#   walk on the directed Collatz graph.  Each node carries a forward transition
#   rate controlled by its eigenvalue lambda_k = (3/4)^k, where k is the
#   odd-step count of that node.  Lower-swarm integers (small k) percolate
#   quickly to the absorbing sink at node 1; upper-swarm integers (large k)
#   are trapped, analogous to Anderson localization in disordered materials.
#
#   The 2x2 coin matrix C = [[cos(t), sin(t)],[sin(t),-cos(t)]] applied to
#   input amplitude (ar + i*ai) at coin state 0 produces two outputs:
#     output coin state 0:  a0r = ar * cos(theta),  a0i = ai * cos(theta)
#     output coin state 1:  a1r = ar * sin(theta),  a1i = ai * sin(theta)
#
#   ROOT CAUSE {Fork here}:
#   On a directed graph with exactly one outgoing edge per node,
#   a two-output quantum coin cannot be unitary.  Sending both outputs forward
#   violates the inner-product preservation required for probability conservation.
#   A proper unitary quantum walk on such a graph requires the Szegedy
#   construction on edge-space, which is significantly more complex.
#   See Section 2b: szegedy_edge_space_placeholder proc for educational stub.
#
#   CURRENT FORK TAKEN: classical probability split (Section 3 onward).
#   Replaced complex amplitudes with classical probabilities.
#     forward_probability = sin^2(theta_k) * prob[node]  => moves to next node
#     stay_probability    = cos^2(theta_k) * prob[node]  => stays at current node
#   Conservation of Probability is guaranteed by the Pythagorean identity:
#     sin^2(theta) + cos^2(theta) = 1.0   for any value of theta
#   Total probability is therefore identical before and after each step.
#
#   PHYSICAL INTERPRETATION:
#   This classical probability walk is equivalent to the diagonal elements of
#   the quantum density matrix.  Off-diagonal coherence terms (interference)
#   are absent, but the lower-swarm / upper-swarm distinction is preserved
#   because it depends on the eigenvalue magnitude, not on interference.
#   The model remains a valid analog for quantum tunneling probability envelopes.
#
# ENCODING NOTE:
#   All special characters (lambda, theta, arrows) replaced with plain ASCII
#   equivalents (lambda_k, theta_rad, ->) to avoid UTF-8 encoding artifacts
#   that appear as garbled characters on some terminals.
#
# MODEL PARAMETERS:
#   eigenvalue   lambda_k  = (3/4)^k        (3/4 = collatz_eigenvalue_base)
#   coin angle   theta_k   = sqrt(lambda_k) * pi/4
#   forward rate fwd_rate  = sin^2(theta_k)  fraction of prob moving forward
#   stay rate    stay_rate = cos^2(theta_k)  fraction of prob remaining
#   Conservation: fwd_rate + stay_rate = 1.0 exactly at every node every step
#
# EXPECTED RESULTS AFTER 200 STEPS:
#   Lower swarm (k small, lambda near 1): sink prob > 0.80 (fast percolation)
#   Upper swarm (k large, lambda near 0): sink prob < 0.001 (localized)
#   Examples:
#     n=2  (k=0,  lambda=1.000000, fwd=0.500000): sink ~ 1.000000
#     n=7  (k=5,  lambda=0.237305, fwd=0.140000): sink ~ 0.95+
#     n=27 (k=41, lambda=0.000008, fwd=0.000004): sink ~ 0.000000
#     n=97 (k=43, lambda=0.000004, fwd=0.000002): sink ~ 0.000000
#
# NASA/JPL DEFENSIVE PROGRAMMING RULES APPLIED:
#   - Full explanatory variable names (no single-letter names except loop idx)
#   - Comprehensive comments for future maintainer (human or AI)
#   - All division checked for zero denominator risk
#   - Safety cap on node values prevents integer overflow
#   - Yellow flag printed if conservation deviates beyond tolerance
#
# COMPATIBILITY:
#   Strict 7-bit ASCII.  No external packages required.
#   Compatible with Tcl/Tk (Tool Control Language / Toolkit) 8.6+
#   Tested on Windows 11 with ActiveState Tcl.
#   TCL club, corrected version 03/21/2026.
# =============================================================================

console show

# =============================================================================
# SECTION 1: GLOBAL CONFIGURATION
# =============================================================================
# maximum_walk_steps: number of discrete steps per test run.
#   200 steps is sufficient for lower-swarm integers to reach the sink.
#   Upper-swarm integers (k > 20) will show near-zero sink prob even at 200.
set maximum_walk_steps              200

# maximum_allowed_node_integer: safety cap on node values during walk.
#   Prevents runaway growth if an unusual trajectory exceeds Tcl integer range.
set maximum_allowed_node_integer    2000000

# test_starting_integer_list: the 10 test cases.
#   Covers a range from k=0 (n=2, immediate sink) to k=43 (n=97, strongly localized).
set test_starting_integer_list      {2 3 5 7 9 15 25 27 97 100}

# probability_conservation_tolerance: yellow-flag threshold.
#   If total probability deviates from 1.0 by more than this value, print warning.
set probability_conservation_tolerance  0.00001

# collatz_eigenvalue_base: the 3/4 ratio in lambda_k = (3/4)^k.
#   This is the Markov chain eigenvalue for the Collatz transfer operator.
set collatz_eigenvalue_base         0.75

# szegedy_header_already_printed: once-only flag for Szegedy placeholder output.
#   The full educational scaffolding block (8 steps + quibble) prints on the
#   FIRST call to szegedy_edge_space_placeholder only.
#   Subsequent calls print a single confirmation line to avoid 200 lines of
#   repeated identical text in the 10-test auto-run output.
#   Set to 0 here; the placeholder proc sets it to 1 after the first print.
set szegedy_header_already_printed  0


# =============================================================================
# SECTION 2: MATHEMATICAL PROCS
# =============================================================================

proc count_odd_steps_in_full_trajectory { starting_integer_n } {
    # -------------------------------------------------------------------------
    # PURPOSE:
    #   Count the total number of times the 3n+1 rule is applied in the full
    #   Collatz trajectory from starting_integer_n down to 1.
    #   This count k is the index into the eigenvalue ladder lambda_k = (3/4)^k.
    #
    # PHYSICAL ANALOGY:
    #   k plays the role of barrier width in quantum tunneling.
    #   A particle with a wider barrier (larger k) has lower transmission
    #   probability, just as a Collatz integer with more odd steps has a
    #   smaller eigenvalue and slower percolation.
    #
    # INPUTS:
    #   starting_integer_n : positive integer to trace (e.g. 7 gives k=5)
    # RETURNS:
    #   odd_step_count : integer >= 0
    # -------------------------------------------------------------------------
    set current_n       $starting_integer_n
    set odd_step_count  0
    while { $current_n > 1 } {
        if { $current_n % 2 == 1 } {
            # Odd step: apply 3n+1 rule and count it
            set current_n [expr { 3 * $current_n + 1 }]
            incr odd_step_count
        } else {
            # Even step: divide by 2, no count
            set current_n [expr { $current_n / 2 }]
        }
    }
    return $odd_step_count
}

proc compute_eigenvalue_lambda_k { odd_step_count_k } {
    # -------------------------------------------------------------------------
    # PURPOSE:
    #   Compute lambda_k = (3/4)^k.
    #
    # PROPERTY:
    #   lambda_k = 1.0 for k=0 (no odd steps, e.g. powers of 2).
    #   lambda_k decays exponentially toward zero as k increases.
    #   For k=41 (n=27): lambda_k approx 7.5e-6 (near zero).
    #   This exponential decay is the mathematical signature of quantum
    #   tunneling: transmission probability falls exponentially with barrier width.
    #
    # INPUTS:
    #   odd_step_count_k : non-negative integer
    # RETURNS:
    #   lambda_k : float in range (0, 1]
    # -------------------------------------------------------------------------
    global collatz_eigenvalue_base
    if { $odd_step_count_k < 0 } {
        error "count_odd_steps_in_full_trajectory returned negative k: $odd_step_count_k"
    }
    return [expr { pow($collatz_eigenvalue_base, $odd_step_count_k) }]
}

proc compute_coin_angle_theta_radians { odd_step_count_k } {
    # -------------------------------------------------------------------------
    # PURPOSE:
    #   Compute theta_k = sqrt(lambda_k) * pi/4.
    #   This angle is the input to the sin^2 / cos^2 probability split.
    #
    # RANGE:
    #   theta_k = pi/4 = 0.785 rad for k=0 (maximum, unbiased coin).
    #   theta_k approaches 0 for large k (strongly biased toward stay).
    #
    # INPUTS:
    #   odd_step_count_k : non-negative integer
    # RETURNS:
    #   theta_radians : float in range [0, pi/4]
    # -------------------------------------------------------------------------
    set lambda_k [compute_eigenvalue_lambda_k $odd_step_count_k]
    return [expr { sqrt($lambda_k) * acos(-1.0) / 4.0 }]
}

proc compute_forward_probability_rate { odd_step_count_k } {
    # -------------------------------------------------------------------------
    # PURPOSE:
    #   Compute forward_rate = sin^2(theta_k).
    #   This is the fraction of probability at a node that moves to the next
    #   Collatz node during one discrete step.
    #
    # KEY VALUES:
    #   k=0  (lambda=1.000): theta=pi/4, fwd_rate = sin^2(0.785) = 0.500
    #   k=5  (lambda=0.237): theta=0.383, fwd_rate = sin^2(0.383) = 0.140
    #   k=41 (lambda=8e-6):  theta=0.002, fwd_rate = sin^2(0.002) = 0.000004
    #
    # INPUTS:
    #   odd_step_count_k : non-negative integer
    # RETURNS:
    #   forward_rate : float in range [0, 0.5]
    # -------------------------------------------------------------------------
    set theta_radians [compute_coin_angle_theta_radians $odd_step_count_k]
    return [expr { pow(sin($theta_radians), 2.0) }]
}

proc compute_stay_probability_rate { odd_step_count_k } {
    # -------------------------------------------------------------------------
    # PURPOSE:
    #   Compute stay_rate = cos^2(theta_k).
    #   This is the fraction of probability that remains at the current node.
    #
    # CONSERVATION IDENTITY:
    #   forward_rate + stay_rate = sin^2(theta) + cos^2(theta) = 1.0 exactly.
    #   This identity holds for any value of theta without floating-point tricks.
    #   It is the mathematical guarantee that total probability is conserved.
    #
    # INPUTS:
    #   odd_step_count_k : non-negative integer
    # RETURNS:
    #   stay_rate : float in range [0.5, 1.0]
    # -------------------------------------------------------------------------
    set theta_radians [compute_coin_angle_theta_radians $odd_step_count_k]
    return [expr { pow(cos($theta_radians), 2.0) }]
}

proc find_next_collatz_node { current_node_n } {
    # -------------------------------------------------------------------------
    # PURPOSE:
    #   Return the next node in the compressed Collatz sequence.
    #
    # COMPRESSION:
    #   Odd n maps to (3n+1)/2 rather than 3n+1, skipping the intermediate
    #   even value.  This halves the path length for odd nodes.
    #   Even n maps to n/2 as normal.
    #   Sink node 1 maps to itself (absorbing).
    #
    # INPUTS:
    #   current_node_n : positive integer > 0
    # RETURNS:
    #   next_node : positive integer
    # -------------------------------------------------------------------------
    if { $current_node_n == 1 } {
        return 1
    }
    if { $current_node_n % 2 == 0 } {
        return [expr { $current_node_n / 2 }]
    } else {
        return [expr { (3 * $current_node_n + 1) / 2 }]
    }
}


# =============================================================================
# SECTION 2b: SZEGEDY EDGE-SPACE CONSTRUCTION -- DUMMY PLACEHOLDER
# =============================================================================
#
# FORK MARKER:
#   The fork comment in the file header reads:
#   "ROOT CAUSE {Fork here}: On a directed graph with exactly one outgoing
#    edge per node, a two-output quantum coin cannot be unitary.  A proper
#    unitary quantum walk on such a graph requires the Szegedy construction
#    on edge-space, which is significantly more complex."
#
#   This Section 2b is the isolated modular stub for that future fork.
#   The stub reads from existing global variables and prints an educational
#   header.  The stub does NOT write to any walk state variable.
#   The stub does NOT call any other proc that modifies state.
#   The stub does NOT alter the output of Sections 3, 4, or 5.
#   A future maintainer replaces the body below the DUMMY marker with
#   real Szegedy matrix operations without touching any other section.
#
# WHAT A REAL SZEGEDY WALK WOULD REQUIRE (reference notes for maintainer):
#
#   Standard (classical) quantum walk coin:
#     State space = nodes x {coin states 0,1}
#     Coin operator C acts on coin register at each node independently.
#     Shift operator S moves the walker based on coin state.
#     Problem on directed graphs: S has no inverse when each node has only
#     one outgoing edge.  Unitarity fails.  Probability is not conserved.
#
#   Szegedy (2004) construction resolves this by working on EDGE space:
#     State space = directed edges (u,v) rather than nodes u.
#     A directed edge (u,v) represents "walker arrived at v from u."
#     The Szegedy walk operator W = S * (2*Pi - I), where:
#       Pi  = sum over nodes u of |u><u| tensor |D_u><D_u|
#       D_u = normalized superposition of all edges leaving u
#       S   = swap operator: S|u,v> = |v,u>
#       I   = identity on edge space
#     W is unitary by construction on any directed graph.
#     For the Collatz graph each node has exactly one outgoing edge,
#     so D_u = |u,next(u)> (a single-term superposition, no branching).
#     The Szegedy walk on the Collatz graph therefore reduces to a
#     deterministic phase-kick walk, not a spreading superposition.
#     This is consistent with the classical percolation result in Section 3:
#     on a deterministic directed graph, the quantum and classical walks
#     carry the same information about hitting times.
#
#   KEY VARIABLES FROM EXISTING PROGRAM THAT A REAL SZEGEDY PROC WOULD USE:
#     collatz_eigenvalue_base          -- the 3/4 ratio
#     maximum_allowed_node_integer     -- safety cap on node index
#     test_starting_integer_list       -- the 10 test nodes
#     count_odd_steps_in_full_trajectory  -- k value at each node
#     compute_eigenvalue_lambda_k      -- lambda_k = (3/4)^k
#     find_next_collatz_node           -- successor edge target
#
#   FUTURE MAINTAINER INSTRUCTIONS:
#     1. Replace the body of szegedy_edge_space_placeholder below the
#        DUMMY IMPLEMENTATION marker with real Szegedy matrix code.
#     2. The real proc should accept start_node_integer and step_count
#        as arguments (same signature as run_full_walk_with_conservation_report).
#     3. The real proc should return a hitting probability float in [0,1].
#     4. Call the real proc from Section 4 alongside the existing
#        run_full_walk_with_conservation_report call for side-by-side comparison.
#     5. Do not modify advance_one_probability_step_corrected or any other
#        Section 3 proc.  The two forks run in parallel, not in series.
#
# =============================================================================

proc szegedy_edge_space_placeholder { start_node_integer step_count_integer } {
    # -------------------------------------------------------------------------
    # DUMMY PLACEHOLDER -- Szegedy edge-space construction
    # -------------------------------------------------------------------------
    # PURPOSE (dummy version):
    #   Accept the same inputs that the real Szegedy proc would accept.
    #   Read relevant globals to confirm variable accessibility.
    #   Print the full educational header on the FIRST call only, controlled
    #   by the global flag szegedy_header_already_printed.
    #   On subsequent calls print a single confirmation line to keep
    #   the 10-test auto-run output readable.
    #   Return a sentinel value of -1.0 to signal "not yet implemented."
    #   A return value of -1.0 is outside the physical range [0,1] so the
    #   caller can detect the dummy easily with a simple comparison.
    #
    # INPUTS:
    #   start_node_integer  : the Collatz starting integer (e.g. 7, 27, 100)
    #   step_count_integer  : number of discrete steps to simulate
    #
    # READS (but does not write) the following globals:
    #   collatz_eigenvalue_base          -- used to compute lambda_k
    #   maximum_allowed_node_integer     -- node safety cap
    #
    # WRITES (one-time flag only):
    #   szegedy_header_already_printed   -- set to 1 after first full print
    #     This write does not affect any walk calculation or output table.
    #
    # RETURNS:
    #   -1.0  (sentinel: dummy not yet implemented)
    #         Replace with real hitting probability when Szegedy is coded.
    #
    # DOES NOT MODIFY:
    #   active_node_probability_dict     -- walk state owned by Section 3
    #   cumulative_sink_probability      -- walk state owned by Section 3
    # -------------------------------------------------------------------------

    # Read globals for display and flag check
    global collatz_eigenvalue_base
    global maximum_allowed_node_integer
    global szegedy_header_already_printed

    # Compute k and lambda at the starting node for the per-call one-liner
    set odd_k_at_start      [count_odd_steps_in_full_trajectory $start_node_integer]
    set lambda_k_at_start   [compute_eigenvalue_lambda_k $odd_k_at_start]
    set next_node_from_start [find_next_collatz_node $start_node_integer]

    # ---- DUMMY IMPLEMENTATION BEGINS ----------------------------------------
    # Replace everything between the DUMMY markers with real Szegedy code.
    # The printout below is educational scaffolding only.

    if { $szegedy_header_already_printed == 0 } {
        # ---- FIRST CALL: print full educational block once ------------------
        puts "  --- Szegedy edge-space placeholder (full header, printed once) ---"
        puts "  DUMMY STATUS: not yet implemented. Returning sentinel -1.0."
        puts "  PURPOSE: This stub marks the fork point where a true unitary"
        puts "    quantum walk on the Collatz graph would diverge from the"
        puts "    classical percolation model used in Section 3."
        puts "  FORK REASON: On a directed graph with one outgoing edge per node"
        puts "    a two-output coin violates unitarity (probability not conserved)."
        puts "    The Szegedy (2004) construction resolves this by working in"
        puts "    edge-space rather than node-space."
        puts "  Globals read (not written):"
        puts "    collatz_eigenvalue_base = $collatz_eigenvalue_base"
        puts "    max_allowed_node        = $maximum_allowed_node_integer"
        puts "  Steps 1-8 and quibble notes are printed once after the summary table."
        puts "  --- End Szegedy header ---"
        # Mark header as printed so subsequent calls use the short form
        set szegedy_header_already_printed 1

    } else {
        # ---- SUBSEQUENT CALLS: one-line confirmation only -------------------
        # Full header already printed for first test case.
        # This line confirms the proc was called and shows per-node values.
        puts "  Szegedy dummy called: start_node=$start_node_integer  k=$odd_k_at_start  lambda=[format %.6f $lambda_k_at_start]  next=$next_node_from_start  sentinel=-1.0"
    }

    # ---- DUMMY IMPLEMENTATION ENDS ------------------------------------------

    # Sentinel return: -1.0 signals dummy to any caller
    return -1.0
}


# =============================================================================
# SECTION 3: WALK STATE
# =============================================================================
# active_node_probability_dict : maps node_integer -> probability (float 0..1)
#   Each key is a node on the Collatz graph with nonzero probability.
#   The dict shrinks as probability concentrates at the sink.
#
# cumulative_sink_probability : running total of probability absorbed at node 1.
#   When walk is complete, cumulative_sink_probability + sum(active dict) = 1.0.

set active_node_probability_dict    [dict create]
set cumulative_sink_probability     0.0


proc initialize_walk_from_start_node { start_node_integer } {
    # -------------------------------------------------------------------------
    # PURPOSE:
    #   Place all probability (exactly 1.0) at start_node_integer.
    #   Clear any leftover state from a previous run.
    # -------------------------------------------------------------------------
    global active_node_probability_dict cumulative_sink_probability
    set active_node_probability_dict    [dict create]
    set cumulative_sink_probability     0.0
    dict set active_node_probability_dict $start_node_integer 1.0
}


proc advance_one_probability_step_corrected {} {
    # =========================================================================
    # CORRECTED PROBABILITY SUBROUTINE (replaces buggy complex-amplitude version)
    # =========================================================================
    #
    # PURPOSE:
    #   Advance the percolation walk by one discrete time step.
    #   Each node splits its current probability into two fractions:
    #     forward_amount = forward_rate * prob[node]  => goes to next Collatz node
    #     stay_amount    = stay_rate    * prob[node]  => stays at current node
    #
    # CONSERVATION PROOF:
    #   For a single node with probability p:
    #     forward_amount + stay_amount = sin^2(theta)*p + cos^2(theta)*p = p
    #   Summing over all active nodes:
    #     total_prob_after = sum(stay_amounts) + sum(forward_amounts to non-sink)
    #                        + sum(forward_amounts to sink)
    #                      = sum over all nodes of p
    #                      = total_prob_before = 1.0
    #   Total probability cannot exceed 1.0 under this model.
    #   YELLOW FLAG will not trigger on a correct run.
    #
    # WHY THE EARLIER AMPLITUDE VERSION FAILED:
    #   The coin produced a0 = ar*cos and a1 = ar*sin.
    #   Both were sent to next_collatz(node).
    #   New amplitude = ar*cos + ar*sin = ar*(cos+sin).
    #   New probability = ar^2*(cos+sin)^2 > ar^2 for most theta.
    #   This violated |amplitude|^2 conservation, causing explosion.
    #
    # RETURNS:
    #   step_sink_absorption_amount : probability absorbed by sink this step
    # =========================================================================
    global active_node_probability_dict cumulative_sink_probability
    global maximum_allowed_node_integer

    # Build the next state in a fresh dict to avoid reading while writing
    set updated_probability_dict    [dict create]
    set step_sink_absorption_amount 0.0

    dict for { current_node current_probability } $active_node_probability_dict {

        # Skip negligible probability for numerical efficiency.
        # Prevents the dict from accumulating near-zero entries on long paths.
        # Threshold 1e-15 is well below double-precision noise floor.
        if { $current_probability < 1.0e-15 } continue

        # Absorbing sink at node 1.
        # All probability at node 1 is absorbed permanently.
        # No forward or stay computation needed at the sink.
        if { $current_node == 1 } {
            set step_sink_absorption_amount \
                [expr { $step_sink_absorption_amount + $current_probability }]
            continue
        }

        # Compute eigenvalue parameters for this specific node.
        # Each node uses ITS OWN odd-step count, not the starting node count.
        # Nodes near the sink (powers of 2) have k=0, fwd_rate=0.5: fast approach.
        # Nodes in the upper swarm have large k, tiny fwd_rate: slow progress.
        set odd_k_this_node     [count_odd_steps_in_full_trajectory $current_node]
        set forward_rate        [compute_forward_probability_rate $odd_k_this_node]
        set stay_rate           [compute_stay_probability_rate    $odd_k_this_node]

        # Split probability into forward and stay fractions
        set forward_amount  [expr { $forward_rate * $current_probability }]
        set stay_amount     [expr { $stay_rate    * $current_probability }]

        # Accumulate stay fraction back at the current node
        if { [dict exists $updated_probability_dict $current_node] } {
            dict set updated_probability_dict $current_node \
                [expr { [dict get $updated_probability_dict $current_node] \
                        + $stay_amount }]
        } else {
            dict set updated_probability_dict $current_node $stay_amount
        }

        # Route forward fraction to the next Collatz node
        set successor_node [find_next_collatz_node $current_node]

        # Enforce the node safety cap to prevent integer overflow on edge cases
        if { $successor_node > $maximum_allowed_node_integer } continue

        if { $successor_node == 1 } {
            # Forward fraction reaches the absorbing sink directly this step
            set step_sink_absorption_amount \
                [expr { $step_sink_absorption_amount + $forward_amount }]
        } else {
            # Accumulate forward fraction at the successor node
            if { [dict exists $updated_probability_dict $successor_node] } {
                dict set updated_probability_dict $successor_node \
                    [expr { [dict get $updated_probability_dict $successor_node] \
                            + $forward_amount }]
            } else {
                dict set updated_probability_dict $successor_node $forward_amount
            }
        }
    }

    # Replace active probability state with the freshly computed state
    set active_node_probability_dict $updated_probability_dict

    # Add this step absorption to the running cumulative total
    set cumulative_sink_probability \
        [expr { $cumulative_sink_probability + $step_sink_absorption_amount }]

    return $step_sink_absorption_amount
}


proc run_full_walk_with_conservation_report { start_node_integer total_steps_to_run } {
    # -------------------------------------------------------------------------
    # PURPOSE:
    #   Run the percolation walk for total_steps_to_run steps from start_node.
    #   Print a conservation check at fixed intervals and at the final step.
    #   Print YELLOW FLAG if total probability deviates beyond tolerance.
    #   Return the final cumulative sink probability.
    # -------------------------------------------------------------------------
    global active_node_probability_dict cumulative_sink_probability
    global probability_conservation_tolerance

    initialize_walk_from_start_node $start_node_integer

    # Print conservation check every this many steps
    set conservation_report_interval 50

    for { set step_counter 1 } \
        { $step_counter <= $total_steps_to_run } \
        { incr step_counter } {

        advance_one_probability_step_corrected

        # Conservation check at intervals and at the very last step
        if { $step_counter % $conservation_report_interval == 0 || \
             $step_counter == $total_steps_to_run } {

            # Sum probability currently at all active (non-sink) nodes
            set active_node_total 0.0
            dict for { node_n prob_val } $active_node_probability_dict {
                set active_node_total [expr { $active_node_total + $prob_val }]
            }

            # Grand total = sink absorbed + still active
            set grand_total_probability \
                [expr { $cumulative_sink_probability + $active_node_total }]

            puts "    Step $step_counter: total_prob = [format %.6f $grand_total_probability]  sink_so_far = [format %.6f $cumulative_sink_probability]"

            if { abs($grand_total_probability - 1.0) > \
                 $probability_conservation_tolerance } {
                puts "    YELLOW FLAG: Conservation deviation > $probability_conservation_tolerance at step $step_counter"
                puts "    (If this fires, re-check advance_one_probability_step_corrected)"
            }
        }
    }

    # Final conservation line for clarity
    set active_node_total 0.0
    dict for { node_n prob_val } $active_node_probability_dict {
        set active_node_total [expr { $active_node_total + $prob_val }]
    }
    set final_grand_total [expr { $cumulative_sink_probability + $active_node_total }]
    puts "    Final conservation: total = [format %.8f $final_grand_total] (should be 1.00000000)"

    return $cumulative_sink_probability
}


# =============================================================================
# SECTION 4: AUTO-RUN 10 TEST CASES
# =============================================================================

puts ""
puts "=== Collatz Eigenvalue Percolation Walk V12 ==="
puts "Corrected probability subroutine: classical prob split, not complex amplitudes."
puts "Conservation: sin^2(theta_k) + cos^2(theta_k) = 1.0 guaranteed every step."
puts "Szegedy placeholder loaded in Section 2b (dummy, returns sentinel -1.0)."
puts "Max steps per run = $maximum_walk_steps    Node safety cap = $maximum_allowed_node_integer"
puts ""

set all_test_results_list {}

foreach test_starting_integer $test_starting_integer_list {

    # Compute display parameters for the starting node
    set odd_k_at_start      [count_odd_steps_in_full_trajectory $test_starting_integer]
    set lambda_k_at_start   [compute_eigenvalue_lambda_k $odd_k_at_start]
    set theta_at_start_rad  [compute_coin_angle_theta_radians $odd_k_at_start]
    set fwd_rate_at_start   [compute_forward_probability_rate $odd_k_at_start]
    set stay_rate_at_start  [compute_stay_probability_rate $odd_k_at_start]

    puts "----------------------------------------------------------------------"
    puts "Test case: start_node = $test_starting_integer"
    puts "  odd_step_count k     = $odd_k_at_start"
    puts "  eigenvalue lambda_k  = [format %.8f $lambda_k_at_start]"
    puts "  coin angle theta_rad = [format %.6f $theta_at_start_rad] rad"
    puts "  forward rate sin2    = [format %.8f $fwd_rate_at_start]  (frac moving forward each step)"
    puts "  stay rate    cos2    = [format %.8f $stay_rate_at_start]  (frac remaining each step)"
    puts "  Conservation check   = [format %.8f [expr {$fwd_rate_at_start + $stay_rate_at_start}]] (should be 1.0)"

    # --- Call Szegedy dummy alongside the main walk (parallel, not in series) ---
    # The dummy reads globals and prints educational notes.
    # The dummy does NOT touch active_node_probability_dict or cumulative_sink_probability.
    # The main walk below therefore starts clean from initialize_walk_from_start_node.
    set szegedy_sentinel_result \
        [szegedy_edge_space_placeholder $test_starting_integer $maximum_walk_steps]
    puts "  Szegedy placeholder returned sentinel: $szegedy_sentinel_result (expected -1.0 = dummy)"

    # --- Main corrected percolation walk ---
    set final_sink_probability \
        [run_full_walk_with_conservation_report \
             $test_starting_integer $maximum_walk_steps]

    puts "  Sink probability after $maximum_walk_steps steps: [format %.8f $final_sink_probability]"

    # Classify into swarm using plain if-elseif-else (avoids nested ternary bug)
    if { $final_sink_probability > 0.80 } {
        set swarm_classification "FAST PERCOLATION (lower swarm, conducting phase)"
    } elseif { $final_sink_probability > 0.01 } {
        set swarm_classification "MEDIUM PERCOLATION"
    } else {
        set swarm_classification "SLOW / LOCALIZED (upper swarm, insulating phase)"
    }

    puts "  Classification: $swarm_classification"

    # Accumulate result row for the summary table
    lappend all_test_results_list [list \
        $test_starting_integer  \
        $odd_k_at_start         \
        $lambda_k_at_start      \
        $fwd_rate_at_start      \
        $final_sink_probability \
        $swarm_classification   ]
}


# =============================================================================
# SECTION 5: SUMMARY WIKI TABLE
# =============================================================================

puts ""
puts "----"
puts "=== SUMMARY TABLE - All 10 Test Cases after $maximum_walk_steps Steps ==="
puts "----"
puts ""
puts "%| Index | Start N | Odd Steps k | Eigenvalue lambda_k | Forward Rate sin2(theta) | Sink Probability after $maximum_walk_steps steps | Swarm Classification |%"
puts ""

set table_row_index 1
foreach result_row $all_test_results_list {
    lassign $result_row  start_n  odd_k  lambda_k  fwd_rate  sink_prob  classification
    puts "&| $table_row_index | $start_n | $odd_k | [format %.6f $lambda_k] | [format %.6f $fwd_rate] | [format %.6f $sink_prob] | $classification |&"
    incr table_row_index
}

puts ""
puts "----"
puts "Model notes and quibble annotations:"
puts "----"
puts ""
puts "forward rate = sin^2(sqrt(lambda_k) * pi/4) computed at EACH node along path."
puts "stay rate    = cos^2(sqrt(lambda_k) * pi/4) at each node."
puts "Each node uses its OWN k value, not the starting node k."
puts "k=0 nodes (powers of 2, near sink): fwd_rate = 0.500000 (fastest)."
puts "k=41 (n=27): fwd_rate approx 4e-6 (essentially frozen at 200 steps)."
puts "k=43 (n=97): fwd_rate approx 2e-6 (even more frozen)."
puts ""
puts "Szegedy placeholder note:"
puts "  Section 2b contains szegedy_edge_space_placeholder proc."
puts "  Dummy returns sentinel -1.0 and prints educational scaffolding."
puts "  Real Szegedy construction works on INVERSE Collatz graph (multiple predecessors)"
puts "  where true quantum branching and interference occur."
puts "  On the forward Collatz graph (one outgoing edge per node) Szegedy reduces"
puts "  to a phase-kick walk that carries the same hitting-time info as the classical model."
puts "  Future maintainer: replace dummy body in Section 2b without touching Section 3."
puts ""
puts "Quibble on n=27 analogy inversion:"
puts "  Eigenvalue formula places n=27 (k=41) in upper swarm: correct."
puts "  But n=27 has a LONG actual trajectory (111 steps, peak 9232)."
puts "  A small eigenvalue normally means fast ruin in the gambler model."
puts "  For n=27, small lambda means slow PERCOLATION, not fast ruin."
puts "  The direction of the analogy inverts between the two domains."
puts "  See the parent document table row 14 for full discussion."
puts ""
puts "Conservation: no YELLOW FLAG expected with the corrected model."
puts "If YELLOW FLAG fires, re-check advance_one_probability_step_corrected proc."
puts ""
puts "Further research direction:"
puts "  Extend max_walk_steps to 1000 for n=25 and n=100 (k=7) to see whether"
puts "  sink probability converges to 1.0 or plateaus below 1.0."
puts "  A plateau below 1.0 would indicate a path escaping the node safety cap."
puts ""
puts "----"
puts "---- Szegedy edge-space construction: reference notes (printed once) ----"
puts "----"
puts ""
puts "What a real Szegedy proc would do (applies equally to all 10 test nodes):"
puts "  1. Build edge-space basis: each directed edge (u, next(u)) is one basis vector."
puts "  2. Construct reflection operator Pi_u = |D_u><D_u| for each node u."
puts "     For Collatz graph: D_u = single edge |u, next(u)> (no branching)."
puts "  3. Construct swap operator S: S|u,v> = |v,u>."
puts "  4. Szegedy walk operator W = S * (2*Pi - I) on edge space."
puts "  5. Initialize state at edge (start_node, next(start_node))."
puts "  6. Apply W for step_count_integer steps."
puts "  7. Measure probability of being at any edge terminating at node 1."
# NOTE for maintainer: \[ and \] prevent TCL command substitution inside
# double-quoted strings.  TCL would otherwise try to execute "0, 1" as a command.
# Alternative safe form: puts {text containing [0, 1] is safe inside curly braces}
puts "  8. Return that hitting probability as a float in \[0, 1\]."
puts ""
puts "Quibbles for maintainer:"
puts "  On a deterministic directed graph (one outgoing edge per node),"
puts "  Szegedy reduces to a phase-kick walk with no superposition spreading."
puts "  The Section 3 classical percolation model captures the same hitting-time"
puts "  information at far lower implementation cost."
puts "  Full Szegedy becomes more informative on the INVERSE Collatz graph,"
puts "  where each node has multiple incoming predecessors and true branching occurs."
puts "  Future maintainer: replace dummy body between DUMMY markers in Section 2b."
puts "  Do not modify Section 3 procs when implementing the real Szegedy walk."
puts ""
puts "--- End of Collatz Eigenvalue Percolation Walk V12 ---"
# end of file

 Collatz Eigenvalue Percolation Walk V10
Corrected probability subroutine: classical prob split, not complex amplitudes.
Conservation: sin^2(theta_k) + cos^2(theta_k) = 1.0 guaranteed every step.
Max steps per run = 200    Node safety cap = 2000000

----------------------------------------------------------------------
Test case: start_node = 2
  odd_step_count k     = 0
  eigenvalue lambda_k  = 1.00000000
  coin angle theta_rad = 0.785398 rad
  forward rate sin2    = 0.50000000  (frac moving forward each step)
  stay rate    cos2    = 0.50000000  (frac remaining each step)
  Conservation check   = 1.00000000 (should be 1.0)
    Step 50: total_prob = 1.000000  sink_so_far = 1.000000
    Step 100: total_prob = 1.000000  sink_so_far = 1.000000
    Step 150: total_prob = 1.000000  sink_so_far = 1.000000
    Step 200: total_prob = 1.000000  sink_so_far = 1.000000
    Final conservation: total = 1.00000000 (should be 1.00000000)
  Sink probability after 200 steps: 1.00000000
  Classification: FAST PERCOLATION (lower swarm, conducting phase)
----------------------------------------------------------------------
Test case: start_node = 3
  odd_step_count k     = 2
  eigenvalue lambda_k  = 0.56250000
  coin angle theta_rad = 0.589049 rad
  forward rate sin2    = 0.30865828  (frac moving forward each step)
  stay rate    cos2    = 0.69134172  (frac remaining each step)
  Conservation check   = 1.00000000 (should be 1.0)
    Step 50: total_prob = 1.000000  sink_so_far = 0.999999
    Step 100: total_prob = 1.000000  sink_so_far = 1.000000
    Step 150: total_prob = 1.000000  sink_so_far = 1.000000
    Step 200: total_prob = 1.000000  sink_so_far = 1.000000
    Final conservation: total = 1.00000000 (should be 1.00000000)
  Sink probability after 200 steps: 1.00000000
  Classification: FAST PERCOLATION (lower swarm, conducting phase)
----------------------------------------------------------------------
Test case: start_node = 5
  odd_step_count k     = 1
  eigenvalue lambda_k  = 0.75000000
  coin angle theta_rad = 0.680175 rad
  forward rate sin2    = 0.39555157  (frac moving forward each step)
  stay rate    cos2    = 0.60444843  (frac remaining each step)
  Conservation check   = 1.00000000 (should be 1.0)
    Step 50: total_prob = 1.000000  sink_so_far = 1.000000
    Step 100: total_prob = 1.000000  sink_so_far = 1.000000
    Step 150: total_prob = 1.000000  sink_so_far = 1.000000
    Step 200: total_prob = 1.000000  sink_so_far = 1.000000
    Final conservation: total = 1.00000000 (should be 1.00000000)
  Sink probability after 200 steps: 1.00000000
  Classification: FAST PERCOLATION (lower swarm, conducting phase)
----------------------------------------------------------------------
Test case: start_node = 7
  odd_step_count k     = 5
  eigenvalue lambda_k  = 0.23730469
  coin angle theta_rad = 0.382598 rad
  forward rate sin2    = 0.13937691  (frac moving forward each step)
  stay rate    cos2    = 0.86062309  (frac remaining each step)
  Conservation check   = 1.00000000 (should be 1.0)
    Step 50: total_prob = 1.000000  sink_so_far = 0.893163
    Step 100: total_prob = 1.000000  sink_so_far = 0.999903
    Step 150: total_prob = 1.000000  sink_so_far = 1.000000
    Step 200: total_prob = 1.000000  sink_so_far = 1.000000
    Final conservation: total = 1.00000000 (should be 1.00000000)
  Sink probability after 200 steps: 1.00000000
  Classification: FAST PERCOLATION (lower swarm, conducting phase)
----------------------------------------------------------------------
Test case: start_node = 9
  odd_step_count k     = 6
  eigenvalue lambda_k  = 0.17797852
  coin angle theta_rad = 0.331340 rad
  forward rate sin2    = 0.10582679  (frac moving forward each step)
  stay rate    cos2    = 0.89417321  (frac remaining each step)
  Conservation check   = 1.00000000 (should be 1.0)
    Step 50: total_prob = 1.000000  sink_so_far = 0.473595
    Step 100: total_prob = 1.000000  sink_so_far = 0.991602
    Step 150: total_prob = 1.000000  sink_so_far = 0.999958
    Step 200: total_prob = 1.000000  sink_so_far = 1.000000
    Final conservation: total = 1.00000000 (should be 1.00000000)
  Sink probability after 200 steps: 0.99999983
  Classification: FAST PERCOLATION (lower swarm, conducting phase)
----------------------------------------------------------------------
Test case: start_node = 15
  odd_step_count k     = 5
  eigenvalue lambda_k  = 0.23730469
  coin angle theta_rad = 0.382598 rad
  forward rate sin2    = 0.13937691  (frac moving forward each step)
  stay rate    cos2    = 0.86062309  (frac remaining each step)
  Conservation check   = 1.00000000 (should be 1.0)
    Step 50: total_prob = 1.000000  sink_so_far = 0.867177
    Step 100: total_prob = 1.000000  sink_so_far = 0.999874
    Step 150: total_prob = 1.000000  sink_so_far = 1.000000
    Step 200: total_prob = 1.000000  sink_so_far = 1.000000
    Final conservation: total = 1.00000000 (should be 1.00000000)
  Sink probability after 200 steps: 1.00000000
  Classification: FAST PERCOLATION (lower swarm, conducting phase)
----------------------------------------------------------------------
Test case: start_node = 25
  odd_step_count k     = 7
  eigenvalue lambda_k  = 0.13348389
  coin angle theta_rad = 0.286949 rad
  forward rate sin2    = 0.08010430  (frac moving forward each step)
  stay rate    cos2    = 0.91989570  (frac remaining each step)
  Conservation check   = 1.00000000 (should be 1.0)
    Step 50: total_prob = 1.000000  sink_so_far = 0.063099
    Step 100: total_prob = 1.000000  sink_so_far = 0.845009
    Step 150: total_prob = 1.000000  sink_so_far = 0.994841
    Step 200: total_prob = 1.000000  sink_so_far = 0.999898
    Final conservation: total = 1.00000000 (should be 1.00000000)
  Sink probability after 200 steps: 0.99989801
  Classification: FAST PERCOLATION (lower swarm, conducting phase)
----------------------------------------------------------------------
Test case: start_node = 27
  odd_step_count k     = 41
  eigenvalue lambda_k  = 0.00000754
  coin angle theta_rad = 0.002157 rad
  forward rate sin2    = 0.00000465  (frac moving forward each step)
  stay rate    cos2    = 0.99999535  (frac remaining each step)
  Conservation check   = 1.00000000 (should be 1.0)
    Step 50: total_prob = 1.000000  sink_so_far = 0.000000
    Step 100: total_prob = 1.000000  sink_so_far = 0.000000
    Step 150: total_prob = 1.000000  sink_so_far = 0.000000
    Step 200: total_prob = 1.000000  sink_so_far = 0.000000
    Final conservation: total = 1.00000000 (should be 1.00000000)
  Sink probability after 200 steps: 0.00000000
  Classification: SLOW / LOCALIZED (upper swarm, insulating phase)
----------------------------------------------------------------------
Test case: start_node = 97
  odd_step_count k     = 43
  eigenvalue lambda_k  = 0.00000424
  coin angle theta_rad = 0.001618 rad
  forward rate sin2    = 0.00000262  (frac moving forward each step)
  stay rate    cos2    = 0.99999738  (frac remaining each step)
  Conservation check   = 1.00000000 (should be 1.0)
    Step 50: total_prob = 1.000000  sink_so_far = 0.000000
    Step 100: total_prob = 1.000000  sink_so_far = 0.000000
    Step 150: total_prob = 1.000000  sink_so_far = 0.000000
    Step 200: total_prob = 1.000000  sink_so_far = 0.000000
    Final conservation: total = 1.00000000 (should be 1.00000000)
  Sink probability after 200 steps: 0.00000000
  Classification: SLOW / LOCALIZED (upper swarm, insulating phase)
----------------------------------------------------------------------
Test case: start_node = 100
  odd_step_count k     = 7
  eigenvalue lambda_k  = 0.13348389
  coin angle theta_rad = 0.286949 rad
  forward rate sin2    = 0.08010430  (frac moving forward each step)
  stay rate    cos2    = 0.91989570  (frac remaining each step)
  Conservation check   = 1.00000000 (should be 1.0)
    Step 50: total_prob = 1.000000  sink_so_far = 0.004756
    Step 100: total_prob = 1.000000  sink_so_far = 0.492108
    Step 150: total_prob = 1.000000  sink_so_far = 0.939631
    Step 200: total_prob = 1.000000  sink_so_far = 0.996806
    Final conservation: total = 1.00000000 (should be 1.00000000)
  Sink probability after 200 steps: 0.99680646
  Classification: FAST PERCOLATION (lower swarm, conducting phase)


 SUMMARY TABLE - All 10 Test Cases after 200 Steps 

Model notes and quibble annotations:


forward rate = sin^2(sqrt(lambda_k) * pi/4) computed at EACH node along path.
stay rate    = cos^2(sqrt(lambda_k) * pi/4) at each node.
Each node uses its OWN k value, not the starting node k.
k=0 nodes (powers of 2, near sink): fwd_rate = 0.500000 (fastest).
k=41 (n=27): fwd_rate approx 4e-6 (essentially frozen at 200 steps).
k=43 (n=97): fwd_rate approx 2e-6 (even more frozen).

Quibble on n=27 analogy inversion:
  Eigenvalue formula places n=27 (k=41) in upper swarm: correct.
  But n=27 has a LONG actual trajectory (111 steps, peak 9232).
  A small eigenvalue normally means fast ruin in the gambler model.
  For n=27, small lambda means slow PERCOLATION, not fast ruin.
  The direction of the analogy inverts between the two domains.
  See the parent document table row 14 for full discussion.

Conservation: no YELLOW FLAG expected with this corrected model.
If YELLOW FLAG fires, the advance proc has a floating-point accumulation error.

Further research direction:
  Extend max_walk_steps to 1000 for n=25 and n=100 (k=7) to see whether
  sink probability converges to 1.0 or plateaus below 1.0.
  A plateau below 1.0 would indicate a path escaping the node safety cap.

--- End of Collatz Eigenvalue Percolation Walk V10 ---

  * Lower-swarm cases reach sink quickly
  * Upper-swarm cases show very slow leakage
  * All runs use full graph with proper absorption, but caps in prototype.
  * Summary capped at 200 steps to avoid long waits

What a real Szegedy proc would do (applies equally to all 10 test nodes):
----
  1. Build edge-space basis: each directed edge (u, next(u)) is one basis vector.
  2. Construct reflection operator Pi_u = |D_u><D_u| for each node u.
     For Collatz graph: D_u = single edge |u, next(u)> (no branching).
  3. Construct swap operator S: S|u,v> = |v,u>.
  4. Szegedy walk operator W = S * (2*Pi - I) on edge space.
  5. Initialize state at edge (start_node, next(start_node)).
  6. Apply W for step_count_integer steps.
  7. Measure probability of being at any edge terminating at node 1.
  8. Return that hitting probability as a float in [0, 1].

Quibble Notes for maintainer:
  On a deterministic directed graph (one outgoing edge per node),
  Szegedy reduces to a phase-kick walk with no superposition spreading.
  The Section 3 classical percolation model captures the same hitting-time
  information at far lower implementation cost.
  Full Szegedy becomes more informative on the INVERSE Collatz graph,
  where each node has multiple incoming predecessors and true branching occurs.
  Future maintainer: replace dummy body between DUMMY markers in Section 2b.
  Do not modify Section 3 procs when implementing the real Szegedy walk.

t=  0 |  0.00000
t=  1 |  0.50000
t=  2 |  1.00000
t=  3 |  1.00000

Final probability at sink (node 1): 1.000000

Probability at sink (node 1) vs time

t=  0 |  0.00000
t=  1 |  0.00000
...
t= 10 |  0.00000
t= 11 |  1.00000
t= 12 |  1.00000
...
t= 80 |  1.00000