From the Childs-Farhi-Gutmann (CFG) paper and continuous-time quantum walk literature:

1.  Propagation distance ≈ speed × time
    → d ≈ 2√2 × t (exact speed on the reduced glued-trees line, units where γ=1)
2.  Time to reach distance d
    → t ≈ d / (2√2) ≈ 0.3536 × d
3.  Asymptotic hitting probability at exit (right root)
    → χ_exit ≈ 1 / (2n + 1) (lower bound from the paper; n = tree depth)
4.  Classical probability upper bound (exponentially small)
    → p_classical ≤ 2^{-n}
5.  Wave-packet peak amplitude scaling
    → amplitude ~ t^{-1/2} (spreading in 1D-like propagation)
6.  Exponential speedup ratio
    → speedup ≈ exp(c n) / poly(n) (classical exponential vs quantum linear)

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 WALK SLIDE RULE OVERVIEW ****

+----------------------------------------------------------------------------------+
| QUANTUM WALK SLIDE RULE                                                          |
|                                                                                  |
|    Three Sections:                                                               |
|      SEC 1 : CFG Propagation (Tree depth n, hit prob, classical bound)           |
|      SEC 2 : Eigenvalue Ladder (k → λ_k = (3/4)^k, gap scales)                   |
|      SEC 3 : Walk Arithmetic (C/D multiply, A/B sqrt, CI reciprocal, EX speedup) |
|                                                                                  |
|    Mouse: LMB = drag slide, RMB = snap/drag cursor                               |
|    Keyboard: Arrow keys per section + Shift/Ctrl/Alt modifiers                   |
|    Player-Piano: F5 Record | Record_Step | F7 Replay | F8 Save | F9 Load         |
|                                                                                  |
|    Visual tool for Collatz → Quantum Walk analogies (Childs-Farhi-Gutmann)      |
+----------------------------------------------------------------------------------+

**** figure. COLLATZ ANALOGY, COLLATZ SWARMS AND ANDERSON LOCALIZATION ****

+----------------------------------------------------------------------------------+
| LOWER SWARM vs UPPER SWARM (Scatter Plot Analogy)                                |
|                                                                                  |
|    Lower Swarm (λ ≥ 0.10)                                                        |
|      Short trajectories → Fast percolation to sink (node 1)                      |
|      High transmission T ≈ 1                                                     |
|      Extended states → Conducting phase (delocalized)                            |
|                                                                                  |
|    Upper Swarm (λ < 0.10)                                                        |
|      Long trajectories (high k) → Slow leakage / trapped probability             |
|      Tunneling probability near zero                                             |
|      Strong localization → Insulating phase                                      |
|                                                                                  |
|    Mobility Edge ≈ λ = 0.10                                                      |
|    Visual: Dense lower band + sparse upper band with staircase boundaries        |
+----------------------------------------------------------------------------------+

**** figure. EIGENVALUE LADDER λ_k = (3/4)^k ****

+----------------------------------------------------------------------------------+
| EIGENVALUE LADDER (Anderson Localization Strength)                               |
|                                                                                  |
|    k (odd steps)   λ = (3/4)^k          Behavior                                 |
|    0               1.0000               Fast percolation, conducting             |
|    5               0.2373               Moderate tunneling                       |
|    7               0.1335               Boundary layer                           |
|    20              0.00317              Strong suppression                       |
|    41 (n=27)       ~0.0000076           Near-zero → Localized / trapped          |
|    43 (n=97)       ~0.0000043           Extreme localization                     |
|                                                                                  |
|    Small λ → Anderson localization (upper swarm)                                 |
|    Large λ → Delocalized percolation (lower swarm)                               |
+----------------------------------------------------------------------------------+

**** figure. QUANTUM WALK SLIDE RULE SECTIONS ****

+----------------------------------------------------------------------------------+
| THREE SECTIONS OF THE QUANTUM WALK SLIDE RULE                                    |
|                                                                                  |
|    Section 1: CFG Propagation                                                    |
|      Tree depth n, time t ≈ n/(2√2), hit prob ~1/(2n), classical bound 2^{-n}    |
|                                                                                  |
|    Section 2: Eigenvalue Ladder                                                  |
|      k index, λ_k = (3/4)^k, gap = (1/4)^n (stator + slide)                      |
|                                                                                  |
|    Section 3: Walk Arithmetic                                                    |
|      C/D multiply-divide, A/B square-root, CI reciprocal, EX exponential speedup |
|                                                                                  |
|    Mouse + keyboard move slides and cursors → live 4-sig-fig readouts            |
+----------------------------------------------------------------------------------+

**** figure. GAMBLER'S BANKROLL vs COLLATZ ANALOGY ****

+----------------------------------------------------------------------------------+
| GAMBLER'S RUIN ANALOGY (Entropy Drift)                                           |
|                                                                                  |
|    Bankroll B starts high → repeated win/loss steps → absorption at zero         |
|                                                                                  |
|    Collatz Mapping:                                                              |
|      Odd step (3n+1)   ≈ Win (energy injection)                                  |
|      Even step (n/2)   ≈ Loss (energy release)                                   |
|      Sink at 1         ≈ Ruin (absorbing state)                                  |
|                                                                                  |
|    Eigenvalue λ controls drift speed                                             |
|      High λ → Fast ruin (lower swarm)                                            |
|      Low λ  → Slow leakage / long survival (upper swarm)                         |
|                                                                                  |
|    Note: Analogy direction sometimes inverts between domains                     |
+----------------------------------------------------------------------------------+

**** figure. NASSI-SHNEIDERMAN DEFINING DIAGRAM (High-Level) ****

+----------------------------------------------------------------------------------+
| NASSI-SHNEIDERMAN DEFINING DIAGRAM (Quantum Slide Rule)                          |
|                                                                                  |
|    Sequence (Init)          → initConsole + openLogFile + globals                |
|    Sequence (Player-Piano)  → Record / Replay / Save / Load system               |
|    Sequence (Safety)        → clamp, safe_pow, snapMark etc.                     |
|    Sequence (Drawing)       → All scale procs (drawContScale, drawLambdaScale…)  |
|    Sequence (Build)         → buildSection1 / 2 / 3                              |
|    Sequence (Update)        → update_s1 / s2 / s3 (live readouts)                |
|    Sequence (UI)            → buildUI + bindings + buttons                       |
|    Sequence (Main)          → Event loop + clean exit                            |
|                                                                                  |
|    True left / False right convention preserved in wiki tables                   |
+----------------------------------------------------------------------------------+

**** figure. PLATO'S CAVE ANALOGY (AI vs Human on Collatz Analogy) ****

+----------------------------------------------------------------------------------+
| PLATO'S CAVE ON COLLATZ                                                              |
|                                                                                  |
|    Prisoners (Humans) see shadows: decimal magnitudes, apparent chaos            |
|    Outside (AI / Binary view): true forms = bit-shifts, eigenvalue ladder,       |
|                                deterministic automaton, spectral bands           |
|                                                                                  |
|    Decimal notation = cave wall                                                  |
|    Binary structure = sunlight outside cave                                      |
|    AI sees native binary patterns → immediate structure                          |
|    Humans must translate → often miss underlying order                           |
|                                                                                  |
|    Entropy / energy metaphors: natural to probabilistic binary logic             |
+----------------------------------------------------------------------------------+

**** figure. SUMMARY OF COLLATZ ANALOGY AND  QUANTUM WALK ANALOGIES ****
+----------------------------------------------------------------------------------+
| KEY ANALOGIES SUMMARY                                                            |
|                                                                                  |
|    Collatz Graph      → Directed graph for quantum walk                          |
|    Odd-step count k   → Eigenvalue index λ = (3/4)^k                             |
|    Lower swarm        → Delocalized / fast percolation (conducting)              |
|    Upper swarm        → Localized / trapped states (insulating)                  |
|    Mobility edge      ≈ λ ≈ 0.10                                                 |
|    Sink at 1          → Absorbing state                                          |
|    Gambler's ruin     → Biased random walk to absorption                         |
|    HTS Cuprates       → Lower swarm ≈ superconducting dome (high Tc)             |
|                                                                                  |
|    Educational value: Concrete classical problem → quantum concepts              |
+----------------------------------------------------------------------------------+

# tcl
# Quantum Walk Slide Rule – Childs-Farhi-Gutmann Algoruthm V6
# Using multiple safety caps or clamps, Collatz Sequence is infinite,
# danger of endless loops in program.
# ----
# Educational version with visible probabilities (4 sig figs)
# Alternate 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/23/2026
# Quantum Walk Slide Rule – inspired by Childs-Farhi-Gutmann glued trees
# Adapted from Richard Suchenwirth's "A little slide-rule" (2003)
# Fixed expression bracing errors – March 2026 – for Tcl wiki & 10-test integration
# tcl 
# Quantum Walk Slide Rule V5r3 -- Childs-Farhi-Gutmann Algorithm
# Three-section instrument:
#   Section 1 : CFG Propagation scales
#   Section 2 : Eigenvalue Ladder  k --> lambda_k = (3/4)^k
#   Section 3 : Walk Arithmetic    C/D, A/B, CI, EX
# ----
# V5r3 changes from V5r2:
#   FIX 1 : logAction removed from update_sN and motion bindings.
#            Console no longer floods on every mouse drag event.
#   FIX 2 : replayStep $n bug fixed.  Variable $n was out of scope.
#            Now uses [llength $::replayList] inline.
#   NEW 1 : Record_Step button -- one click captures current positions
#            of all six moveable items as a single snapshot entry.
#            Writes one summary line to console and log file.
#            Also appends to ::replayList so the step is replayable.
#   NEW 2 : C_Help button -- prints keyboard/mouse help to console.
#   NEW 3 : A_Tone button -- plays random note from 12-tone piano scale
#            via PowerShell beep on Windows.  Falls back to bell.
#   NEW 4 : Exit_P button -- clean shutdown, closes log, exits.
# ----
# V5r4 changes from V5r3:
#   NEW : Re_Start button added as next-to-last button.
#         Re_Start flushes the log then relaunches via exec wish, same
#         path as the Esc key.  Esc key still works identically.
# Button bar order (left to right):
#   F5-Record | F6-Stop | Record_Step | F7-Replay | F8-Save | F9-Load
#   | C_Help | A_Tone | Re_Start | Exit_P
# ----
# Mouse:
#   Left  mouse button drag  = move the slide (colored band)
#   Right mouse button click or drag = snap / move hairline cursor
# ----
# Keyboard:
#   Arrow keys           --> Section 1 cursor / Shift-Arrow = Section 1 slide
#   Ctrl-Arrow           --> Section 2 cursor / Ctrl-Shift-Arrow = Section 2 slide
#   Alt-Arrow            --> Section 3 cursor / Alt-Shift-Arrow  = Section 3 slide
#   F5=record  F6=stop  F7=replay  F8=save  F9=load
#   Esc --> reload program
# ----
# NASA/JPL defensive programming style.
# Tcl/Tk 8.6+, 7-bit ASCII safe, Windows 11 ActiveState Tcl.
# TCL club, 03/2026

console show
package require Tk

# ============================================================
#  CONSOLE STYLING
# ============================================================

proc initConsole {} {
    catch {
        console eval {.console config -bg palegreen}
        console eval {.console config -font {fixed 20 bold}}
        console eval {.console config -background palegreen \
            -highlightcolor tan -relief raised -border 8}
        console eval {wm geometry . 60x24}
        console eval {wm title . "QWalk SlideRule Console"}
    }
    puts "Quantum Walk Slide Rule V5r4 -- console ready."
}

# ============================================================
#  PRECOMPUTED CLASSICAL SINK PROBABILITIES  (200-step demos)
# ============================================================

array set ::cSink {
    2  1.000000   3  0.999999   5  0.999950   7  0.950000
    9  0.920000  15  0.880000  25  0.750000  27  0.000010
    97 0.000002 100  0.000001
}

# ============================================================
#  LOGGING SYSTEM
#  logAction writes a timestamped line to console and log file.
#  The log file is opened once at startup and closed on exit.
#  logAction is called ONLY by explicit user actions:
#    startRecording, stopRecording, recordStep, replay procs,
#    saveReplay, loadReplay, showHelp, playTone.
#  logAction is NOT called from update_sN or motion bindings.
#  This prevents console flood on mouse drag.
# ============================================================

set ::logFd   ""
set ::logFile "qwalk_actions.log"

proc openLogFile {} {
    if {[catch {open $::logFile a} fd]} {
        puts "WARNING: cannot open log file $::logFile -- $fd"
        return
    }
    set ::logFd $fd
    logAction "=== Session start V5r4 ==="
}

proc closeLogFile {} {
    if {$::logFd eq ""} { return }
    catch {
        logAction "=== Session end ==="
        close $::logFd
    }
    set ::logFd ""
}

proc logAction {msg} {
    set ts   [clock format [clock seconds] -format "%H:%M:%S"]
    set line "$ts  $msg"
    puts $line
    if {$::logFd ne ""} {
        catch { puts $::logFd $line ; flush $::logFd }
    }
}

# ============================================================
#  PLAYER-PIANO RECORD / REPLAY SYSTEM
#
#  Each stored action is a 4-element Tcl list:
#    { section  type  tag  px }
#  section = 1|2|3
#  type    = cursor|slide
#  tag     = mark1|mark2|mark3|slide1|slide2|slide3
#  px      = integer pixel x (absolute canvas coords)
#
#  Record_Step captures all six moveable items at once
#  as six consecutive list entries.  The result reads like
#  a program listing:
#    1 cursor mark1 210
#    1 slide  slide1base 0
#    2 cursor mark2 350
#    ... etc.
# ============================================================

set ::recording   0
set ::replayList  {}
set ::replayFile  "qwalk_replay.txt"
set ::replayDelay 400

proc startRecording {} {
    set ::recording  1
    set ::replayList {}
    set ::recStatus  "REC -- click Record_Step to capture each position"
    logAction "RECORD START -- click Record_Step after each slide rule setting."
}

proc stopRecording {} {
    set ::recording 0
    set n [llength $::replayList]
    set ::recStatus "STOPPED  ($n actions in buffer)"
    logAction "RECORD STOP -- $n actions stored.  F7=replay  F8=save."
}

proc recordStep {} {
    # Capture current pixel x of all six moveable items as one snapshot.
    # Appends six entries to ::replayList if recording is active.
    # Always logs one summary line to console and file.

    # Helper: safe coordinate read returns 0 on any error.
    set px1m  [expr {int([lindex [.c1 coords mark1]      0])}]
    set px1s  [expr {int([lindex [.c1 coords slide1base] 0])}]
    set px2m  [expr {int([lindex [.c2 coords mark2]      0])}]
    set px2s  [expr {int([lindex [.c2 coords slide2base] 0])}]
    set px3m  [expr {int([lindex [.c3 coords mark3]      0])}]
    set px3s  [expr {int([lindex [.c3 coords slide3base] 0])}]

    if {$::recording} {
        lappend ::replayList [list 1 cursor mark1      $px1m]
        lappend ::replayList [list 1 slide  slide1base $px1s]
        lappend ::replayList [list 2 cursor mark2      $px2m]
        lappend ::replayList [list 2 slide  slide2base $px2s]
        lappend ::replayList [list 3 cursor mark3      $px3m]
        lappend ::replayList [list 3 slide  slide3base $px3s]
        set n [llength $::replayList]
        set ::recStatus "REC -- $n actions in buffer"
    }

    # Build the human-readable summary line.
    # Read computed values from the current info labels (already computed).
    set line "STEP |  $::info1"
    append line "  ||  $::info2"
    append line "  ||  $::info3"
    logAction $line
}

proc replayActions {} {
    set n [llength $::replayList]
    if {$n == 0} {
        logAction "REPLAY: nothing in buffer.  Load a file (F9) or record steps (F5)."
        return
    }
    logAction "REPLAY START -- $n actions at $::replayDelay ms each."
    set ::recStatus "PLAYING $n actions ..."
    replayStep 0
}

proc replayStep {i} {
    # Safety cap at 2000 steps prevents runaway loops.
    # FIX V5r3: replaced out-of-scope $n with inline list length call.
    set total [llength $::replayList]
    if {$i >= $total || $i > 2000} {
        logAction "REPLAY END -- $total actions completed."
        set ::recStatus "REPLAY DONE ($total actions)"
        return
    }

    set item [lindex $::replayList $i]
    set sec  [lindex $item 0]
    set type [lindex $item 1]
    set tag  [lindex $item 2]
    set px   [lindex $item 3]
    set w    ".c$sec"

    catch {
        set coords [$w coords $tag]
        if {[llength $coords] >= 2} {
            set curx [lindex $coords 0]
            $w move $tag [expr {$px - $curx}] 0
        }
    }

    # Refresh section display after moving.
    catch { update_s$sec }

    set stepnum [expr {$i + 1}]
    logAction "PLAY $stepnum/$total  S$sec $type $tag px=$px"

    after $::replayDelay [list replayStep [expr {$i + 1}]]
}

proc saveReplay {} {
    if {[llength $::replayList] == 0} {
        logAction "SAVE: buffer is empty -- nothing to save."
        return
    }
    if {[catch {open $::replayFile w} fd]} {
        logAction "SAVE ERROR: cannot open $::replayFile -- $fd"
        return
    }
    foreach item $::replayList { puts $fd $item }
    close $fd
    set n [llength $::replayList]
    logAction "SAVE: $n actions written to $::replayFile"
    set ::recStatus "SAVED $n actions to $::replayFile"
}

proc loadReplay {} {
    if {[catch {open $::replayFile r} fd]} {
        logAction "LOAD ERROR: cannot open $::replayFile -- $fd"
        return
    }
    set ::replayList {}
    set count 0
    while {[gets $fd line] >= 0} {
        set line [string trim $line]
        if {$line eq ""} { continue }
        if {[catch {llength $line} len] || $len != 4} {
            logAction "LOAD: skipping malformed line: $line"
            continue
        }
        lappend ::replayList $line
        incr count
        if {$count > 2000} { break }
    }
    close $fd
    logAction "LOAD: $count actions loaded from $::replayFile  F7=replay"
    set ::recStatus "LOADED $count actions from $::replayFile"
}

# ============================================================
#  C_HELP -- print keyboard and mouse reference to console
# ============================================================

proc showHelp {} {
    set lines {
        "=== Quantum Walk Slide Rule V5r3 -- Help ==="
        "MOUSE:"
        "  Left button drag     = move the slide (colored band)"
        "  Right button click   = snap hairline cursor to that position"
        "  Right button drag    = drag hairline cursor"
        "KEYBOARD:"
        "  Arrow Left/Right     = move Section 1 cursor"
        "  Shift-Arrow          = move Section 1 slide"
        "  Ctrl-Arrow           = move Section 2 cursor"
        "  Ctrl-Shift-Arrow     = move Section 2 slide"
        "  Alt-Arrow            = move Section 3 cursor"
        "  Alt-Shift-Arrow      = move Section 3 slide"
        "PLAYER-PIANO:"
        "  F5 = start recording"
        "  F6 = stop recording"
        "  Record_Step button   = capture current position as one step"
        "  F7 = replay recorded steps"
        "  F8 = save steps to qwalk_replay.txt"
        "  F9 = load steps from qwalk_replay.txt"
        "BUTTONS:"
        "  C_Help = this help text"
        "  A_Tone = random piano note (A4=440 Hz base, 12 tones)"
        "  Re_Start = flush log and relaunch fresh (same as Esc key)"
        "  Exit_P = close log and exit"
        "  Esc    = reload program"
        "LOG FILE: qwalk_actions.log (append mode, session start/end marked)"
        "============================================"
    }
    foreach l $lines { logAction $l }
}

# ============================================================
#  A_TONE -- play a random note from the 12-tone piano scale
#  Frequencies are equal-temperament starting at middle C (C4=261 Hz).
#  Uses PowerShell Console::Beep on Windows.
#  Falls back to Tk bell if PowerShell is unavailable.
# ============================================================

proc playTone {} {
    # 12-tone equal temperament: C4 through B4.
    set noteNames {C4 Db4 D4 Eb4 E4 F4 Gb4 G4 Ab4 A4 Bb4 B4}
    set noteFreqs {261  277 294  311 330 349  370 392  415 440  466 494}

    set idx  [expr {int(rand() * 12)}]
    set freq [lindex $noteFreqs $idx]
    set name [lindex $noteNames $idx]

    # Try PowerShell beep (Windows).  Duration = 220 ms.
    set cmd "powershell -Command \"\[console\]::beep($freq,220)\""
    if {[catch {exec {*}$cmd} err]} {
        # Fallback: Tk bell (system default beep, no pitch control).
        catch { bell }
    }
    logAction "A_Tone: $name  freq=$freq Hz"
}

# ============================================================
#  EXIT_P -- clean shutdown
# ============================================================

proc exitProgram {} {
    logAction "Exit_P pressed -- closing."
    closeLogFile
    exit
}

proc restartProgram {} {
    # Re_Start: same path as the Esc key binding.
    # Flush and close log, launch a fresh wish process, then exit.
    logAction "Re_Start pressed -- relaunching."
    closeLogFile
    catch { exec wish $::argv0 & }
    exit
}

# ============================================================
#  SAFETY AND MATH UTILITIES
# ============================================================

proc clamp {v lo hi} {
    if {$v < $lo} { return $lo }
    if {$v > $hi} { return $hi }
    return $v
}

proc safe_log10 {v} {
    if {$v <= 0.0} { return -300.0 }
    return [expr {log10(double($v))}]
}

proc safe_pow {b e} {
    set e [clamp $e -300 300]
    if {[catch {expr {pow(double($b), double($e))}} result]} { return 0.0 }
    return $result
}

proc frac_lin {from to v} {
    if {$to == $from} { return 0.0 }
    return [expr {(double($v) - double($from)) / (double($to) - double($from))}]
}

proc frac_log {from to v} {
    set lf [safe_log10 $from]
    set lt [safe_log10 $to]
    set lv [safe_log10 $v]
    if {$lt == $lf} { return 0.0 }
    return [expr {($lv - $lf) / ($lt - $lf)}]
}

# ============================================================
#  MOUSE HELPER
# ============================================================

proc snapMark {w tag newx} {
    set coords [$w coords $tag]
    if {[llength $coords] < 2} { return }
    set curx [lindex $coords 0]
    $w move $tag [expr {$newx - $curx}] 0
}

# ============================================================
#  SCALE DRAWING PROCS
#  drawContScale  -- continuous linear or log scale
#  drawKScale     -- integer k scale, linear spacing
#  drawLambdaScale -- lambda_k = (3/4)^k, log-positioned
#  drawGapScale   -- eigenvalue gap (1/4)^n, log-positioned
#  drawExpScale   -- exponential speedup 2^n
#  drawCIScale    -- reciprocal 1/x, reversed
# ============================================================

proc drawContScale {w nm label x y dy mode from to len tag slide} {
    set col   [expr {$slide ? "red" : "black"}]
    set maxIt 12000
    set count 0
    $w create text $x [expr {$y + $dy * 3.5}] \
        -text $nm -font {Helvetica 10 bold} -fill $col -tag $tag -anchor w
    $w create text [expr {$x + $len + 5}] [expr {$y + $dy * 2.0}] \
        -text $label -font {Helvetica 7} -fill $col -tag $tag -anchor w
    if {$mode eq "log"} {
        set d0 [expr {int(floor([safe_log10 $from]))}]
        set d1 [expr {int(ceil( [safe_log10 $to  ]))}]
        for {set d $d0} {$d <= $d1} {incr d} {
            for {set s 1} {$s <= 9} {incr s} {
                incr count ; if {$count > $maxIt} { break }
                set v [expr {$s * pow(10.0, $d)}]
                if {$v < $from * 0.9999 || $v > $to * 1.0001} { continue }
                set frac [frac_log $from $to $v]
                set pos  [expr {$x + $frac * $len}]
                if {$pos < $x-1 || $pos > $x+$len+1} { continue }
                set h [expr {$s==1 ? 2.2 : ($s==5 ? 1.5 : 1.0)}]
                $w create line $pos $y $pos [expr {$y+$h*$dy}] -fill $col -tag $tag
                if {$s == 1} {
                    $w create text $pos [expr {$y+$dy*4.5}] \
                        -text [format "%.2g" $v] -font {Helvetica 7} \
                        -anchor n -fill $col -tag $tag
                }
            }
        }
    } else {
        set step [expr {double($to-$from)/100.0}]
        if {$step <= 0} { return }
        for {set i 0} {$i <= 100} {incr i} {
            incr count ; if {$count > $maxIt} { break }
            set v    [expr {$from + $i*$step}]
            set frac [frac_lin $from $to $v]
            set pos  [expr {$x + $frac*$len}]
            if {$pos < $x-1 || $pos > $x+$len+1} { continue }
            set h [expr {($i%10==0) ? 2.2 : ($i%5==0) ? 1.5 : 1.0}]
            $w create line $pos $y $pos [expr {$y+$h*$dy}] -fill $col -tag $tag
            if {$i % 10 == 0} {
                $w create text $pos [expr {$y+$dy*4.5}] \
                    -text [format "%.3g" $v] -font {Helvetica 7} \
                    -anchor n -fill $col -tag $tag
            }
        }
    }
}

proc drawKScale {w nm label x y dy kMax len tag} {
    $w create text $x [expr {$y+$dy*3.5}] \
        -text $nm -font {Helvetica 10 bold} -fill black -tag $tag -anchor w
    $w create text [expr {$x+$len+5}] [expr {$y+$dy*2.0}] \
        -text $label -font {Helvetica 7} -fill black -tag $tag -anchor w
    for {set k 0} {$k <= $kMax} {incr k} {
        set frac [expr {double($k)/double($kMax)}]
        set pos  [expr {$x + $frac*$len}]
        set h    [expr {($k%5==0) ? 2.2 : 1.0}]
        $w create line $pos $y $pos [expr {$y+$h*$dy}] -fill black -tag $tag
        if {$k%5 == 0} {
            $w create text $pos [expr {$y+$dy*4.5}] \
                -text $k -font {Helvetica 7} -anchor n -fill black -tag $tag
        }
    }
}

proc drawLambdaScale {w nm label x y dy kMax len tag} {
    set lMin [safe_log10 [safe_pow 0.75 $kMax]]
    set lMax 0.0
    set lRng [expr {$lMax - $lMin}]
    if {abs($lRng) < 1e-10} { return }
    $w create text $x [expr {$y+$dy*3.5}] \
        -text $nm -font {Helvetica 10 bold} -fill blue -tag $tag -anchor w
    $w create text [expr {$x+$len+5}] [expr {$y+$dy*2.0}] \
        -text $label -font {Helvetica 7} -fill blue -tag $tag -anchor w
    for {set k 0} {$k <= $kMax} {incr k} {
        set lam  [safe_pow 0.75 $k]
        set logL [safe_log10 $lam]
        set frac [expr {($logL-$lMin)/$lRng}]
        set pos  [expr {$x + $frac*$len}]
        if {$pos < $x-1 || $pos > $x+$len+1} { continue }
        set h    [expr {($k%5==0) ? 2.2 : 1.0}]
        $w create line $pos $y $pos [expr {$y+$h*$dy}] -fill blue -tag $tag
        if {$k%5 == 0} {
            $w create text $pos [expr {$y+$dy*4.5}] \
                -text $k -font {Helvetica 7} -anchor n -fill blue -tag $tag
        }
    }
}

proc drawGapScale {w nm label x y dy nMax len tag col} {
    set lMin [safe_log10 [safe_pow 0.25 $nMax]]
    set lMax 0.0
    set lRng [expr {$lMax - $lMin}]
    if {abs($lRng) < 1e-10} { return }
    $w create text $x [expr {$y+$dy*3.5}] \
        -text $nm -font {Helvetica 10 bold} -fill $col -tag $tag -anchor w
    $w create text [expr {$x+$len+5}] [expr {$y+$dy*2.0}] \
        -text $label -font {Helvetica 7} -fill $col -tag $tag -anchor w
    for {set n 0} {$n <= $nMax} {incr n} {
        set gap  [safe_pow 0.25 $n]
        set logG [safe_log10 $gap]
        set frac [expr {($logG-$lMin)/$lRng}]
        set pos  [expr {$x + $frac*$len}]
        if {$pos < $x-1 || $pos > $x+$len+1} { continue }
        set h    [expr {($n%5==0) ? 2.2 : 1.0}]
        $w create line $pos $y $pos [expr {$y+$h*$dy}] -fill $col -tag $tag
        if {$n%5 == 0} {
            $w create text $pos [expr {$y+$dy*4.5}] \
                -text $n -font {Helvetica 7} -anchor n -fill $col -tag $tag
        }
    }
}

proc drawExpScale {w nm label x y dy nMax len tag} {
    set lMin 0.0
    set lMax [expr {$nMax * log10(2.0)}]
    set lRng [expr {$lMax - $lMin}]
    if {abs($lRng) < 1e-10} { return }
    $w create text $x [expr {$y+$dy*3.5}] \
        -text $nm -font {Helvetica 10 bold} -fill purple -tag $tag -anchor w
    $w create text [expr {$x+$len+5}] [expr {$y+$dy*2.0}] \
        -text $label -font {Helvetica 7} -fill purple -tag $tag -anchor w
    for {set n 0} {$n <= $nMax} {incr n} {
        set logN [expr {$n * log10(2.0)}]
        set frac [expr {($logN-$lMin)/$lRng}]
        set pos  [expr {$x + $frac*$len}]
        if {$pos < $x-1 || $pos > $x+$len+1} { continue }
        set h    [expr {($n%5==0) ? 2.2 : 1.0}]
        $w create line $pos $y $pos [expr {$y+$h*$dy}] -fill purple -tag $tag
        if {$n%5 == 0} {
            $w create text $pos [expr {$y+$dy*4.5}] \
                -text $n -font {Helvetica 7} -anchor n -fill purple -tag $tag
        }
    }
}

proc drawCIScale {w nm label x y dy len tag} {
    $w create text $x [expr {$y+$dy*3.5}] \
        -text $nm -font {Helvetica 10 bold} -fill orange -tag $tag -anchor w
    $w create text [expr {$x+$len+5}] [expr {$y+$dy*2.0}] \
        -text $label -font {Helvetica 7} -fill orange -tag $tag -anchor w
    for {set d 0} {$d <= 1} {incr d} {
        for {set s 1} {$s <= 9} {incr s} {
            set v [expr {$s * pow(10.0,$d)}]
            if {$v < 1.0-1e-9 || $v > 10.0+1e-9} { continue }
            set frac [expr {1.0 - log10($v)}]
            set pos  [expr {$x + $frac*$len}]
            if {$pos < $x-1 || $pos > $x+$len+1} { continue }
            set h [expr {$s==1 ? 2.2 : ($s==5 ? 1.5 : 1.0)}]
            $w create line $pos $y $pos [expr {$y+$h*$dy}] -fill orange -tag $tag
            if {$s==1 || $v==5.0} {
                $w create text $pos [expr {$y+$dy*4.5}] \
                    -text [format "%.4g" $v] -font {Helvetica 7} \
                    -anchor n -fill orange -tag $tag
            }
        }
    }
}

# ============================================================
#  SECTION 1 : CFG PROPAGATION SCALES
#  Canvas .c1  |  Cursor mark1 (blue)  |  Slide tag slide1
# ============================================================

proc buildSection1 {} {
    set w   .c1
    set len 700
    $w create rect 0 8 762 222 -fill grey92 -outline grey80
    $w create rect 0 48 762 178 -fill beige -outline beige \
        -tag {slide1 slide1base}
    $w create text 6 2 \
        -text "SEC 1: CFG  LMB=slide  RMB=cursor  Arrow/Shift-Arrow  | Record_Step to log a reading" \
        -font {Helvetica 8 bold} -anchor nw -fill navy
    $w create line 150 0 150 225 -tag mark1 -fill blue -width 2

    drawContScale $w "Qn" "TREE DEPTH n  (1..1000)"    10  22  5  lin  1    1000  $len  {}     0
    drawContScale $w "Qd" "COLUMN d  (log 1..2000)"    10 105  5  log  1    2000  560   {}     0
    drawContScale $w "Qp" "HIT PROB  ~1/(2n)"          10 185  5  log  1e-4 1     560   {}     0
    drawContScale $w "Qc" "CLASSICAL  <=2^{-n}"       400 185  5  log  1e-12 1   280   {}     0
    drawContScale $w "Qt" "TIME t=n/(2*sqrt2)"         10  63 -5  lin  0.1  1000  $len  slide1 1
    drawContScale $w "Ql" "LAMBDA ~(3/4)^k"            10 143 -5  log  1e-4 1     560   slide1 1

    set xi 18
    foreach n {2 3 5 7 9 15 25 27 97 100} {
        $w create text $xi 216 -text $n -font {Helvetica 7} -anchor s -fill grey50
        incr xi 70
    }

    # Left button: drag slide.  Right button: snap/drag cursor.
    # No logAction in motion bindings -- prevents console flood.
    bind .c1 <ButtonPress-1>  { set ::grab1 %x }
    bind .c1 <B1-Motion>      { .c1 move slide1 [expr {%x-$::grab1}] 0
                                  set ::grab1 %x ; update_s1 }
    bind .c1 <ButtonPress-3>  { snapMark .c1 mark1 %x ; update_s1 }
    bind .c1 <B3-Motion>      { snapMark .c1 mark1 %x ; update_s1 }
    bind .  <Left>             { .c1 move mark1  -2 0 ; update_s1 }
    bind .  <Right>            { .c1 move mark1   2 0 ; update_s1 }
    bind .  <Shift-Left>       { .c1 move slide1 -3 0 ; update_s1 }
    bind .  <Shift-Right>      { .c1 move slide1  3 0 ; update_s1 }
}

# ============================================================
#  SECTION 2 : EIGENVALUE LADDER   k --> lambda_k = (3/4)^k
#  Canvas .c2  |  Cursor mark2 (darkblue)  |  Slide tag slide2
# ============================================================

proc buildSection2 {} {
    set w   .c2
    set len 700
    $w create rect 0 8 762 235 -fill grey95 -outline grey80
    $w create rect 0 48 762 188 -fill #ddeeff -outline #ddeeff \
        -tag {slide2 slide2base}
    $w create text 6 2 \
        -text "SEC 2: Eigenvalue Ladder  lambda=(3/4)^k  gap=(1/4)^n  LMB=slide  RMB=cursor  Ctrl-Arrow" \
        -font {Helvetica 8 bold} -anchor nw -fill darkblue
    $w create line 150 0 150 238 -tag mark2 -fill darkblue -width 2

    drawKScale      $w "Sk"  "COLUMN INDEX k  (0..30)"      10  22  5  30  $len  {}
    drawLambdaScale $w "SL"  "LAMBDA_k=(3/4)^k  slide"      10  68 -5  30  $len  slide2
    drawGapScale    $w "SG"  "GAP=(1/4)^n stator n=0..20"  10 118  5  20  $len  {}  darkgreen
    drawGapScale    $w "SG2" "GAP slide"                    10 165 -5  20  $len  slide2  red
    $w create text 10 226 \
        -text "Ref: k=5 lam=0.2373  k=10 lam=0.0563  k=20 lam=0.00317  k=30 lam=1.78e-4" \
        -font {Helvetica 7} -anchor w -fill navy

    bind .c2 <ButtonPress-1>       { set ::grab2 %x }
    bind .c2 <B1-Motion>           { .c2 move slide2 [expr {%x-$::grab2}] 0
                                      set ::grab2 %x ; update_s2 }
    bind .c2 <ButtonPress-3>       { snapMark .c2 mark2 %x ; update_s2 }
    bind .c2 <B3-Motion>           { snapMark .c2 mark2 %x ; update_s2 }
    bind .  <Control-Left>         { .c2 move mark2  -2 0 ; update_s2 }
    bind .  <Control-Right>        { .c2 move mark2   2 0 ; update_s2 }
    bind .  <Control-Shift-Left>   { .c2 move slide2 -3 0 ; update_s2 }
    bind .  <Control-Shift-Right>  { .c2 move slide2  3 0 ; update_s2 }
}

# ============================================================
#  SECTION 3 : WALK ARITHMETIC
#  Canvas .c3  |  Cursor mark3 (darkred)  |  Slide tag slide3
# ============================================================

proc buildSection3 {} {
    set w   .c3
    set len 700
    $w create rect 0 8 762 262 -fill grey97 -outline grey80
    $w create rect 0 48 762 210 -fill #fff8e0 -outline #fff8e0 \
        -tag {slide3 slide3base}
    $w create text 6 2 \
        -text "SEC 3: Walk Arithmetic  C/D=mult  A/B=sqrt  CI=recip  EX=speedup  LMB=slide  RMB=cursor  Alt-Arrow" \
        -font {Helvetica 8 bold} -anchor nw -fill darkred
    $w create line 150 0 150 265 -tag mark3 -fill darkred -width 2

    drawContScale $w "D"  "D multiply/divide (1..10) stator" 10  22  5  log  1  10  $len  {}     0
    drawContScale $w "C"  "C multiply/divide (1..10) slide"  10  68 -5  log  1  10  $len  slide3 1
    drawContScale $w "A"  "A square/sqrt (1..100) stator"    10 118  5  log  1 100  $len  {}     0
    drawContScale $w "B"  "B square/sqrt (1..100) slide"     10 165 -5  log  1 100  $len  slide3 1
    drawCIScale   $w "CI" "CI 1/x reciprocal (1..10)"       380  22  5  280  {}
    drawExpScale  $w "EX" "EX speedup 2^n (n=0..20)"         10 210  5  20  $len  {}
    $w create text 10 252 \
        -text "C/D: set C(1) over D(x), read D under C(y) = x*y.  CI: 1/cursor.  EX: 2^n speedup." \
        -font {Helvetica 7} -anchor w -fill maroon

    bind .c3 <ButtonPress-1>      { set ::grab3 %x }
    bind .c3 <B1-Motion>          { .c3 move slide3 [expr {%x-$::grab3}] 0
                                     set ::grab3 %x ; update_s3 }
    bind .c3 <ButtonPress-3>      { snapMark .c3 mark3 %x ; update_s3 }
    bind .c3 <B3-Motion>          { snapMark .c3 mark3 %x ; update_s3 }
    bind .  <Alt-Left>            { .c3 move mark3  -2 0 ; update_s3 }
    bind .  <Alt-Right>           { .c3 move mark3   2 0 ; update_s3 }
    bind .  <Alt-Shift-Left>      { .c3 move slide3 -3 0 ; update_s3 }
    bind .  <Alt-Shift-Right>     { .c3 move slide3  3 0 ; update_s3 }
}

# ============================================================
#  READOUT PROCS -- update label text only, no logAction here.
#  logAction is called only by explicit user commands (buttons/keys).
# ============================================================

proc update_s1 {} {
    set cx [lindex [.c1 coords mark1] 0]
    set f  [clamp [expr {($cx-10.0)/700.0}] 0.0 1.0]
    set n  [clamp [expr {1.0 + $f*999.0}]  1.0 1000.0]
    set t  [expr {$n * 0.35355}]
    set qp [expr {1.0 / (2.0*$n + 1.0)}]
    set cp [safe_pow 2.0 [expr {-$n}]]
    set best 2 ; set bestD 1e9
    foreach tn {2 3 5 7 9 15 25 27 97 100} {
        set d [expr {abs($n-$tn)}]
        if {$d < $bestD} { set bestD $d ; set best $tn }
    }
    set ::info1 [format \
        {S1: n=%.1f  t=%.2f  Q_hit=%.4f  C_bound=%.2e  | n=%d sink=%.6f} \
        $n $t $qp $cp $best $::cSink($best)]
}

proc update_s2 {} {
    set cx [lindex [.c2 coords mark2] 0]
    set f  [clamp [expr {($cx-10.0)/700.0}] 0.0 1.0]
    set k  [clamp [expr {$f*30.0}]          0.0 30.0]
    set lam [safe_pow 0.75 $k]
    set gap [safe_pow 0.25 $k]
    set ::info2 [format \
        {S2: k=%.2f  lam=(3/4)^k=%.6f  log10=%.3f  gap=(1/4)^k=%.3e} \
        $k $lam [safe_log10 $lam] $gap]
}

proc update_s3 {} {
    set cx [lindex [.c3 coords mark3] 0]
    set f  [clamp [expr {($cx-10.0)/700.0}] 0.0 1.0]
    set d  [clamp [safe_pow 10.0 $f]        1.0 10.0]
    set a  [clamp [safe_pow 10.0 [expr {$f*2.0}]] 1.0 100.0]
    set ci [expr {$d > 0 ? 1.0/$d : 0.0}]
    set nx [expr {$f*20.0}]
    set ex [safe_pow 2.0 $nx]
    set ::info3 [format \
        {S3: D=%.4f  A=%.4f  sqrt(A)=%.4f  CI=%.5f  EX: n=%.2f  2^n=%.2f} \
        $d $a [expr {sqrt($a)}] $ci $nx $ex]
}

# ============================================================
#  MASTER UI BUILDER
# ============================================================

proc buildUI {} {
    wm title . "Quantum Walk Slide Rule V5r4  --  CFG / Eigenvalue / Arithmetic"

    pack [canvas .c1 -width 780 -height 228 -bg white \
              -relief ridge -bd 1] -fill x -pady 2
    pack [label  .l1 -textvariable ::info1 -fg navy \
              -font {Helvetica 9 bold} -anchor w -justify left] -fill x

    pack [canvas .c2 -width 780 -height 242 -bg #f4f7ff \
              -relief ridge -bd 1] -fill x -pady 2
    pack [label  .l2 -textvariable ::info2 -fg darkblue \
              -font {Helvetica 9 bold} -anchor w -justify left] -fill x

    pack [canvas .c3 -width 780 -height 270 -bg #fffff4 \
              -relief ridge -bd 1] -fill x -pady 2
    pack [label  .l3 -textvariable ::info3 -fg darkred \
              -font {Helvetica 9 bold} -anchor w -justify left] -fill x

    # Player-piano status label
    pack [label .lrec -textvariable ::recStatus -fg darkgreen \
              -font {Helvetica 10 bold} -anchor w] -fill x

    # Button bar -- left to right order as requested:
    # F5-Record | F6-Stop | Record_Step | F7-Replay | F8-Save | F9-Load
    # | C_Help | A_Tone | Re_Start | Exit_P
    frame .bf
    pack  .bf -fill x -pady 3

    button .bf.b1  -text "F5 Record"     -command startRecording  -bg #ffcccc -width 9
    button .bf.b2  -text "F6 Stop"       -command stopRecording   -bg #ffe0b0 -width 9
    button .bf.b3  -text "Record_Step"   -command recordStep      -bg #ffff99 -width 11 \
                   -font {Helvetica 9 bold}
    button .bf.b4  -text "F7 Replay"     -command replayActions   -bg #ccffcc -width 9
    button .bf.b5  -text "F8 Save"       -command saveReplay      -bg #cce0ff -width 9
    button .bf.b6  -text "F9 Load"       -command loadReplay      -bg #e0ccff -width 9
    button .bf.b7  -text "C_Help"        -command showHelp        -bg #d0ffe0 -width 8
    button .bf.b8  -text "A_Tone"        -command playTone        -bg #ffe0ff -width 8
    button .bf.b9  -text "Re_Start"      -command restartProgram  -bg #ffd0a0 -width 9
    button .bf.b10 -text "Exit_P"        -command exitProgram     -bg #ffdddd -width 8

    pack .bf.b1 .bf.b2 .bf.b3 .bf.b4 .bf.b5 .bf.b6 .bf.b7 .bf.b8 .bf.b9 .bf.b10 \
        -side left -padx 2 -pady 2

    # Help label strip
    pack [label .lhelp \
        -text "LMB=slide  RMB=cursor  |  Arrow=S1  Ctrl=S2  Alt=S3  +Shift=slide  |  F5 F6 Record_Step F7 F8 F9  |  C_Help A_Tone Re_Start Exit_P  Esc=restart" \
        -fg grey40 -font {Helvetica 8} -anchor w] -fill x

    buildSection1
    buildSection2
    buildSection3

    bind . <F5>      { startRecording }
    bind . <F6>      { stopRecording  }
    bind . <F7>      { replayActions  }
    bind . <F8>      { saveReplay     }
    bind . <F9>      { loadReplay     }
    bind . <Escape>  { closeLogFile ; exec wish $argv0 & ; exit }
    bind . <Destroy> { closeLogFile }
}

# ============================================================
#  GLOBAL STATE INITIALIZATION
# ============================================================

set ::info1     "Section 1 ready -- set positions then click Record_Step."
set ::info2     "Section 2 ready."
set ::info3     "Section 3 ready."
set ::recStatus "IDLE  (F5=record  Record_Step=capture  F7=replay  F8=save  F9=load)"
set ::grab1     0
set ::grab2     0
set ::grab3     0

# ============================================================
#  MAIN
# ============================================================

initConsole
openLogFile

wm geometry . 800x1000
buildUI
focus -force .

# end of file

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

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

# trial output
Quantum Walk Slide Rule V5r2 -- console ready.
09:53:16  === Session start ===
09:53:23  S3:  D=1.5849  A=2.5119  sqrt(A)=1.5849  CI=0.63096  EX: n=4.00  2^n=16.00
09:53:23  S3:  D=1.5849  A=2.5119  sqrt(A)=1.5849  CI=0.63096  EX: n=4.00  2^n=16.00
09:53:23  S3:  D=1.5849  A=2.5119  sqrt(A)=1.5849  CI=0.63096  EX: n=4.00  2^n=16.00