Short / Easy (baseline behavior): 2, 3, 5, 7, 9, 15, 21, 25, 31, 63
Medium (good signal activity): 27, 41, 57, 73, 85, 97, 111, 129
Long / Challenging (rich signal data): 637, 703, 871, 1132, 1234, 6171, 9663, 18127, 270271
Very Large (tests safety signals): 1000000, 9999999

Seed 27 (long hailstone): Best ticket = p, t, e (Parity + Trend + Entropy) → 33% size reduction, still faster convergence.
Seed 5 & 15 (loop-prone): Best ticket = p, r, e (Parity + RepeatRisk + Entropy) → strong loop prevention.
Seed 97 (very long): Best ticket = p, b, bu, r (Parity + Bit + Budget + Repeat) → safety-focused ticket.

**** figure. LOTTERY TICKET PRUNING ON PROBABILISTIC COLLATZ **** 

+----------------------------------------------------------------------------------+
| LOTTERY TICKET PRUNING - V12                                                     |
|                                                                                  |
|    Full Model (6 Signals)  →  Iterative Pruning  →  Winning Ticket               |
|                                                                                  |
|    Baseline (all signals)                                                        |
|         │                                                                        |
|         ▼                                                                        |
|    Try dropping one signal → Test convergence                                    |
|         │                                                                        |
|         ▼                                                                        |
|    Keep best reduced set → Repeat until no improvement                           |
|                                                                                  |
|    Goal: Find sparse "winning ticket" with fewer signals but similar/better steps|
+----------------------------------------------------------------------------------+

**** figure. THE 6 AI SIGNALS **** 
+----------------------------------------------------------------------------------+
| 6 AI SIGNALS USED IN COLLATZ DECISION ENGINE                                     |
|                                                                                  |
|    Signal            Purpose                                 Effect               |
|    ───────────────   ────────────────────────────────────   ───────────────────   |
|    Parity            Even / Odd status                       Base weight          |
|    TrendPressure     Rising values in last 3 steps           Encourages expansion |
|    BitPressure       Bit length of current n                 Blowup risk warning  |
|    BudgetPressure    Steps used vs total limit               Urgency to finish    |
|    RepeatRisk        Number seen recently                    Loop prevention      |
|    EntropyPressure   Variance in recent values               Chaos / randomness   |
|                                                                                  |
|    Lottery Ticket Pruning tries turning each signal OFF to find sparse winners   |
+----------------------------------------------------------------------------------+

**** figure. PRUNING PROCESS FLOW **** 

+----------------------------------------------------------------------------------+
| LOTTERY TICKET PRUNING PROCESS                                                   |
|                                                                                  |
|    Start with Full Mask (All 6 Signals ON)                                       |
|             │                                                                    |
|             ▼                                                                    |
|    Run Walk → Record Baseline Steps                                              |
|             │                                                                    |
|             ▼                                                                    |
|    For each signal:                                                              |
|        Turn OFF one signal → Run Walk                                            |
|             │                                                                    |
|             ▼                                                                    |
|        Better steps? → Keep new mask                                             |
|             │                                                                    |
|             ▼                                                                    |
|    Repeat until no further improvement                                           |
|                                                                                  |
|    Output: Kept Signals | Dropped Signals | Ticket Steps | Reduction %           |
+----------------------------------------------------------------------------------+

**** figure. BASELINE vs WINNING TICKET COMPARISON **** 

+----------------------------------------------------------------------------------+
| BASELINE vs WINNING TICKET                                                       |
|                                                                                  |
|    Model               Signals Used   Steps   Reduction   Notes                  |
|    ─────────────────   ─────────────   ─────   ─────────   ───────────────────   |
|    Full Baseline       6 / 6          271      0%         All signals active     |
|    Pruned Ticket       4 / 6           3      33%         Dropped bit+budget     |
|    Pruned Ticket       5 / 6           4      16%         Dropped repeat         |
|                                                                                  |
|    Goal: Maintain convergence with fewer signals (sparse winning ticket)         |
+----------------------------------------------------------------------------------+

**** figure. OVERALL PROGRAM ARCHITECTURE **** 

+----------------------------------------------------------------------------------+
| PROBABILISTIC COLLATZ + LOTTERY TICKET PRUNING V12                              |
|                                                                                  |
|    seedTheRandom                                                                 |
|         │                                                                        |
|         ▼                                                                        |
|    ┌─────────────────────┐   ┌─────────────────────┐                            |
|    │ runDetStateMachine  │   │ runAiProbCollatz    │                            |
|    │ (Deterministic)     │   │ (Full AI Model)     │                            |
|    └──────────┬──────────┘   └──────────┬──────────┘                            |
|               │                         │                                         |
|               └──────────────┬──────────┘                                         |
|                              ▼                                                    |
|                    findLotteryTickets (Pruning Engine)                           |
|                              │                                                    |
|                              ▼                                                    |
|                    printAllResults → 3 Wiki Tables                               |
|                                                                                  |
|    Output: Kept/Dropped signals, Ticket Steps, Reduction %                       |
+----------------------------------------------------------------------------------+

**** figure. LOTTERY TICKET RESULTS SUMMARY **** 

+----------------------------------------------------------------------------------+
| LOTTERY TICKET PRUNING RESULTS                                                   |
|                                                                                  |
|    Many seeds work well with only 3–4 signals active                             |
|    Reduction % shows how much the model can be sparsified                        |
|                                                                                  |
|    Key Insight: Not all 6 signals are equally important                          |
|    Some combinations are "winning tickets" — sparse yet powerful                 |
+----------------------------------------------------------------------------------+

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

# tcl
# Lottery Ticket Pruning on Probabilistic Collatz Variant,   V12 
# Compares deterministic Collatz with AI probabilistic choices.
# Includes systematic iterative pruning to find "winning tickets" among the 6 signals.
# ----
# Compatible with Tcl/Tk (Tool Control Language / Toolkit) 8.6+
# Written for Windows 11 on ActiveState Tcl.
# Pure ASCII code - no Unicode characters used anywhere.
# ----
# Program deck may contain multiple estimation procs.
# Deck 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.
# TCL Club 4/11/2026

console show

# ============================================================
#  RANDOM SEED SETUP
# ============================================================

proc seedTheRandom {fixedSeed} {
    if {$fixedSeed == 0} {
        set chosenSeed [clock seconds]
    } else {
        set chosenSeed $fixedSeed
    }
    expr {srand($chosenSeed)}
    puts "Random seed used: $chosenSeed"
    return $chosenSeed
}

# ============================================================
#  CAP DIAGNOSTIC LOGGER
# ============================================================

proc logCapDiagnosis {startingSeed stepCounter currentValue exitReason stepHistory} {
    set diagFile "collatz_cap_log.txt"
    set header "CAP FIRED: seed=$startingSeed  steps=$stepCounter finalVal=$currentValue reason=$exitReason"
    puts "  $header"
    puts "  Last [llength $stepHistory] steps before cap:"

    set fileFd ""
    catch { set fileFd [open $diagFile a] }
    if {$fileFd ne ""} {
        puts $fileFd $header
        puts $fileFd "  Last [llength $stepHistory] steps:"
    }

    foreach histItem $stepHistory {
        lassign $histItem histStep histValue
        set diagLine [format "    step %-4d  value = %d" $histStep $histValue]
        puts $diagLine
        if {$fileFd ne ""} { puts $fileFd $diagLine }
    }

    if {$fileFd ne ""} {
        puts $fileFd ""
        catch { close $fileFd }
    }
}

# ============================================================
#  DUAL OUTPUT HELPER  (top-level so re-runs do not re-define)
# ============================================================

proc putsDual {fd msg} {
    puts $msg
    if {$fd ne ""} { puts $fd $msg }
}

# ============================================================
#  STATE MACHINE & AI CORE
# ============================================================

proc assessState {n} {
    set parity    [expr {$n % 2 == 0 ? "even" : "odd"}]
    set magnitude [expr {$n < 1000 ? "low" : $n < 1e6 ? "medium" : "high"}]
    set risk      [expr {$n > 1e8 ? "high" : $n > 1e6 ? "medium" : "low"}]
    set trend     [expr {$parity eq "even" ? "contract" : "expand"}]
    return [dict create parity $parity magnitude $magnitude risk $risk trend $trend]
}

proc applyAction {n action} {
    if {$action eq "standard"} {
        if {$n % 2 == 0} { return [expr {int($n / 2)}] } else { return [expr {int(3 * $n + 1)}] }
    } else {
        if {$n % 2 == 0} { return [expr {int(3 * $n + 1)}] } else { return [expr {int(($n + 1) / 2)}] }
    }
}

proc computeAiWeights {state n stepCounter maxStepLimit recentVals temperature} {
    dict with state {}
    if {$parity eq "even"} {
        set wStandard 0.80; set wSwapped 0.20
    } else {
        set wStandard 0.75; set wSwapped 0.25
    }

    set trendPressure 0.00
    if {[llength $recentVals] >= 3} {
        set v1 [lindex $recentVals end-2]
        set v2 [lindex $recentVals end-1]
        set v3 [lindex $recentVals end]
        if {$v3 > $v2 && $v2 > $v1} { set trendPressure 0.10 }
    }

    set bitPressure 0.00
    if {$n > 0} {
        set bitLen [expr {int(log(double($n)) / log(2.0)) + 1}]
        set bitPressure [expr {min($bitLen * 0.005, 0.10)}]
    }

    set budgetPressure [expr {double($stepCounter) / double($maxStepLimit) * 0.15}]

    set repeatRisk 0.0
    if {[llength $recentVals] > 0 && [lsearch -exact $recentVals $n] >= 0} {
        set repeatRisk 0.08
    }

    set entropyPressure 0.0
    if {[llength $recentVals] >= 2} {
        set valCount [llength $recentVals]
        set valSum 0.0
        foreach v $recentVals { set valSum [expr {$valSum + $v}] }
        set mean [expr {$valSum / double($valCount)}]
        set variance 0.0
        foreach v $recentVals {
            set diff [expr {double($v) - $mean}]
            set variance [expr {$variance + $diff * $diff}]
        }
        set variance [expr {$variance / double($valCount)}]
        set entropyPressure [expr {min($variance * 0.000001, 0.05)}]
    }

    set wStandard [expr {$wStandard + $trendPressure + $bitPressure + $budgetPressure + $entropyPressure}]
    set wSwapped  [expr {$wSwapped  - $trendPressure - $bitPressure - $budgetPressure - $entropyPressure + $repeatRisk}]

    if {$wSwapped < 0.02} { set wSwapped 0.02 }

    set wStandard [expr {$wStandard / $temperature}]
    set wSwapped  [expr {$wSwapped  / $temperature}]

    set total [expr {$wStandard + $wSwapped}]
    set wStandard [expr {$wStandard / $total}]
    set wSwapped  [expr {$wSwapped  / $total}]

    return [dict create standard $wStandard swapped $wSwapped entropyPressure $entropyPressure]
}

proc drawFromWeights {weightDict} {
    set wStandard [dict get $weightDict standard]
    if {[expr {rand()}] < $wStandard} { return "standard" } else { return "swapped" }
}

# ============================================================
#  RUNNERS
# ============================================================

proc runDetStateMachine {startingSeed} {
    set n [expr {int($startingSeed)}]
    set stepCounter 0
    set maxStepLimit 500
    set blowupLimit  1000000000
    set exitReason   "converged"

    while {$n != 1 && $stepCounter < $maxStepLimit} {
        if {$n > $blowupLimit} { set exitReason "blowup_cap"; break }
        set n [applyAction $n "standard"]
        set n [expr {int($n)}]
        incr stepCounter
    }

    if {$stepCounter >= $maxStepLimit && $exitReason eq "converged"} {
        set exitReason "step_cap"
    }
    return [list $stepCounter $exitReason]
}

proc runAiProbCollatz {startingSeed temperature} {
    set n [expr {int($startingSeed)}]
    set maxStepLimit 500
    set blowupLimit  1000000000
    set stepCounter  0
    set exitReason   "converged"
    set lastEntropy  0.0

    set stepHistory {}; set recentVals {}; set visitedVals {}
    set historyMax 8;   set recentMax 4;   set visitedMax 10

    while {$n != 1 && $stepCounter < $maxStepLimit} {
        if {$n > $blowupLimit} { set exitReason "blowup_cap"; break }
        if {[lsearch -exact $visitedVals $n] >= 0} { set exitReason "loop_det"; break }

        lappend visitedVals $n
        if {[llength $visitedVals] > $visitedMax} {
            set visitedVals [lrange $visitedVals end-[expr {$visitedMax - 1}] end]
        }

        lappend stepHistory [list $stepCounter $n]
        if {[llength $stepHistory] > $historyMax} {
            set stepHistory [lrange $stepHistory end-[expr {$historyMax - 1}] end]
        }

        lappend recentVals $n
        if {[llength $recentVals] > $recentMax} {
            set recentVals [lrange $recentVals end-[expr {$recentMax - 1}] end]
        }

        set state      [assessState $n]
        set weightDict [computeAiWeights $state $n $stepCounter $maxStepLimit $recentVals $temperature]
        set lastEntropy [dict get $weightDict entropyPressure]
        set chosenAction [drawFromWeights $weightDict]
        set n [applyAction $n $chosenAction]
        set n [expr {int($n)}]
        incr stepCounter
    }

    if {$stepCounter >= $maxStepLimit && $exitReason eq "converged"} {
        set exitReason "step_cap"
    }

    if {$exitReason ne "converged"} {
        set entropyTag [format "%.4f" $lastEntropy]
        set exitReason "${exitReason}/ent=${entropyTag}"
    }

    if {[string match "*cap*" $exitReason] || [string match "*loop*" $exitReason]} {
        logCapDiagnosis $startingSeed $stepCounter $n $exitReason $stepHistory
        set energyLevel [expr {log(double($stepCounter) + 1.0) / log(2.0)}]
        puts [format "  Quantum-Level: %.3f for seed=%d" $energyLevel $startingSeed]
    }

    return [list $stepCounter $exitReason $lastEntropy]
}

# ============================================================
#  TEST DATA
# ============================================================

proc getTestCases {} {
    return {{2 1} {3 7} {5 5} {7 16} {9 19} {15 17} {25 23} {27 111} {97 118} {100 25}}
}

proc getWikiNotes {} {
    return {
        {2 "Reaches 1 almost certainly. Very short path."}
        {3 "Negative drift from 0.80 divide bias aids convergence."}
        {5 "Short paths dominate in stochastic model."}
        {7 "Medium length typical. Moderate variation."}
        {9 "19 det. steps confirmed by hand trace."}
        {15 "Moderate stochastic variation around reference."}
        {25 "Longer but still terminates."}
        {27 "Famous long hailstone seed."}
        {97 "High variation possible."}
        {100 "Usually moderate length."}
    }
}

# ============================================================
#  LOTTERY TICKET PRUNING MODULE
# ============================================================

proc getSignalList {} {
    return {parity trend bit budget repeat entropy}
}

proc runPrunedWalk {startingSeed temperature mask} {
    set n [expr {int($startingSeed)}]
    set maxStepLimit 500
    set blowupLimit  1000000000
    set stepCounter  0
    set exitReason   "converged"

    set recentVals {}; set visitedVals {}
    set recentMax 4;   set visitedMax 10

    while {$n != 1 && $stepCounter < $maxStepLimit} {
        if {$n > $blowupLimit} { set exitReason "blowup_cap"; break }
        if {[lsearch -exact $visitedVals $n] >= 0} { set exitReason "loop_det"; break }

        lappend visitedVals $n
        if {[llength $visitedVals] > $visitedMax} {
            set visitedVals [lrange $visitedVals end-[expr {$visitedMax - 1}] end]
        }

        lappend recentVals $n
        if {[llength $recentVals] > $recentMax} {
            set recentVals [lrange $recentVals end-[expr {$recentMax - 1}] end]
        }

        set state      [assessState $n]
        set weightDict [computeAiWeights $state $n $stepCounter $maxStepLimit $recentVals $temperature]

        set wStd [dict get $weightDict standard]
        set wSwp [dict get $weightDict swapped]

        if {[dict get $mask trend]   == 0} { set wStd [expr {$wStd - 0.08}] }
        if {[dict get $mask bit]     == 0} { set wStd [expr {$wStd - 0.05}] }
        if {[dict get $mask budget]  == 0} { set wStd [expr {$wStd - 0.07}] }
        if {[dict get $mask repeat]  == 0} { set wSwp [expr {$wSwp + 0.06}] }
        if {[dict get $mask entropy] == 0} { set wStd [expr {$wStd - 0.04}] }

        set total [expr {$wStd + $wSwp}]
        if {$total > 0} {
            set wStd [expr {$wStd / $total}]
            set wSwp [expr {$wSwp / $total}]
        }

        set maskedDict [dict create standard $wStd swapped $wSwp]
        set chosenAction [drawFromWeights $maskedDict]
        set n [applyAction $n $chosenAction]
        set n [expr {int($n)}]
        incr stepCounter
    }

    if {$stepCounter >= $maxStepLimit && $exitReason eq "converged"} {
        set exitReason "step_cap"
    }
    return [list $stepCounter $exitReason]
}

# Returns: list of {keptSignals droppedSignals ticketSteps baselineSteps}
proc findLotteryTickets {startingSeed temperature} {
    set signalList [getSignalList]

    # Build full-mask (all signals active)
    set currentMask [dict create]
    foreach sig $signalList { dict set currentMask $sig 1 }

    # Establish baseline with all signals active
    set baseRes      [runPrunedWalk $startingSeed $temperature $currentMask]
    set baseSteps    [lindex $baseRes 0]
    set baseExitR    [lindex $baseRes 1]

    # If the full walk does not converge, return all signals with baseline steps
    if {$baseExitR ne "converged"} {
        return [list $signalList {} $baseSteps $baseSteps]
    }

    set bestSteps   $baseSteps
    set bestMask    $currentMask
    set bestSignals $signalList

    set improved 1
    while {$improved && [llength $bestSignals] > 2} {
        set improved 0
        foreach sigToTry $bestSignals {
            # Build trial mask with this signal zeroed out
            set trialMask [dict create]
            dict for {s v} $currentMask { dict set trialMask $s $v }
            dict set trialMask $sigToTry 0

            set res [runPrunedWalk $startingSeed $temperature $trialMask]
            lassign $res steps exitReason

            if {$exitReason eq "converged" && $steps < $bestSteps} {
                set bestSteps   $steps
                set bestMask    $trialMask
                set bestSignals {}
                dict for {s v} $trialMask {
                    if {$v == 1} { lappend bestSignals $s }
                }
                set improved 1
            }
        }
        set currentMask $bestMask
    }

    # Derive dropped signals: anything in the full list not in bestSignals
    set droppedSignals {}
    foreach sig $signalList {
        if {[lsearch -exact $bestSignals $sig] < 0} {
            lappend droppedSignals $sig
        }
    }

    return [list $bestSignals $droppedSignals $bestSteps $baseSteps]
}

# ============================================================
#  CONSOLIDATED OUTPUT (3 wiki tables)
# ============================================================

proc printAllResults {resultsList temperature} {
    set outFile "collatz_results.txt"
    set fd ""
    catch {set fd [open $outFile w]}

    # ----------------------------------------------------------
    #  Pass 1: pre-compute all pruning results so they are
    #  available in every table without running twice.
    # ----------------------------------------------------------
    set pruneCache [dict create]
    foreach res $resultsList {
        set seed [lindex $res 0]
        dict set pruneCache $seed [findLotteryTickets $seed $temperature]
    }

    set divider [string repeat "-" 115]
    putsDual $fd ""
    putsDual $fd $divider
    putsDual $fd [format "%-6s %-8s %-8s %-12s %+6s %-8s %-6s %-22s %-22s" \
        "Seed" "ProbStps" "DetStps" "Exit" "Diff" "Temp" "AIExt" "Kept Signals" "Dropped Signals"]
    putsDual $fd $divider

    foreach res $resultsList {
        lassign $res seed probSteps detSteps exitReason lastEntropy
        set reasonTag [string range $exitReason 0 11]
        set diff [expr {$probSteps - $detSteps}]

        if {$temperature < 0.7}      { set tempTag "cool"
        } elseif {$temperature <= 1.3} { set tempTag "neutral"
        } else                         { set tempTag "hot" }

        if {[string match "*loop_det*"    $exitReason]} { set aiExit "loop"
        } elseif {[string match "*blowup_cap*" $exitReason]} { set aiExit "blow"
        } elseif {[string match "*step_cap*"   $exitReason]} { set aiExit "step"
        } else { set aiExit "conv" }

        set pData        [dict get $pruneCache $seed]
        set keptSigs     [lindex $pData 0]
        set droppedSigs  [lindex $pData 1]
        set keptStr      [join $keptSigs ","]
        set droppedStr   [expr {[llength $droppedSigs] == 0 ? "(none)" : [join $droppedSigs ","]}]

        putsDual $fd [format "%-6d %-8d %-8d %-12s %+6d %-8.2f %-6s %-22s %-22s" \
            $seed $probSteps $detSteps $reasonTag $diff $temperature $aiExit $keptStr $droppedStr]
    }
    putsDual $fd $divider

    set noteData [getWikiNotes]

    # ----------------------------------------------------------
    #  1. AI Algorithm Report  (extended with pruning columns)
    # ----------------------------------------------------------
    putsDual $fd "\n=== AI Algorithm Report ==="
    putsDual $fd "%| # | Seed | ProbSteps | DetSteps | Exit | Diff | Temp | AIExt | Kept Signals | Dropped Signals | TicketSteps | BasSteps | Reduction% |%"

    set idx 1
    foreach res $resultsList {
        lassign $res seed probSteps detSteps exitReason lastEntropy
        set reasonTag [string range $exitReason 0 11]
        set diff [expr {$probSteps - $detSteps}]

        if {$temperature < 0.7}        { set tempTag "cool"
        } elseif {$temperature <= 1.3} { set tempTag "neutral"
        } else                         { set tempTag "hot" }

        if {[string match "*loop_det*"    $exitReason]} { set aiExit "loop"
        } elseif {[string match "*blowup_cap*" $exitReason]} { set aiExit "blow"
        } elseif {[string match "*step_cap*"   $exitReason]} { set aiExit "step"
        } else { set aiExit "conv" }

        set pData        [dict get $pruneCache $seed]
        set keptSigs     [lindex $pData 0]
        set droppedSigs  [lindex $pData 1]
        set ticketSteps  [lindex $pData 2]
        set baseSteps    [lindex $pData 3]

        set keptStr     [join $keptSigs ","]
        set droppedStr  [expr {[llength $droppedSigs] == 0 ? "none" : [join $droppedSigs ","]}]
        set nKept       [llength $keptSigs]
        set nDropped    [llength $droppedSigs]
        set reduction   [expr {int(100.0 * $nDropped / 6)}]

        putsDual $fd "&| $idx | $seed | $probSteps | $detSteps | $reasonTag | $diff | $temperature | $aiExit | $keptStr ($nKept) | $droppedStr ($nDropped) | $ticketSteps | $baseSteps | $reduction% |&"
        incr idx
    }
    putsDual $fd "&| Audit | - | - | - | - | - | - | - | All 6: parity,trend,bit,budget,repeat,entropy | Dropped=zeroed in mask | - | -  | All runs used temperature control. |&"
    putsDual $fd "=== End AI Algorithm Report ==="

    # ----------------------------------------------------------
    #  2. General Comparison Wiki Table
    # ----------------------------------------------------------
    putsDual $fd "\n=== General Comparison Wiki Table ==="
    putsDual $fd "%| # | Seed | StateMachine Steps | Prob Steps | Behavior Note |%"

    set rowIndex 1
    foreach res $resultsList {
        lassign $res seed probSteps detSteps
        set noteText "No note available."
        foreach pair $noteData {
            lassign $pair noteSeed noteStr
            if {$noteSeed == $seed} { set noteText $noteStr; break }
        }
        putsDual $fd "&| $rowIndex | $seed | $detSteps | $probSteps | $noteText |&"
        incr rowIndex
    }
    putsDual $fd "&| Audit | - | - | - | All state machine seeds reach 1. AI prob. model converges almost surely. |&"
    putsDual $fd "=== End Wiki Table ==="

    # ----------------------------------------------------------
    #  3. Lottery Ticket Pruning Results
    # ----------------------------------------------------------
    putsDual $fd "\n=== Lottery Ticket Pruning Results ==="
    putsDual $fd "%| # | Seed | BaseSteps(all 6) | TicketSteps | Kept (n) | Kept Signal Names | Dropped (n) | Dropped Signal Names | Reduction% |%"

    set idx 1
    foreach res $resultsList {
        lassign $res seed probSteps detSteps exitReason lastEntropy

        set pData       [dict get $pruneCache $seed]
        set keptSigs    [lindex $pData 0]
        set droppedSigs [lindex $pData 1]
        set ticketSteps [lindex $pData 2]
        set baseSteps   [lindex $pData 3]

        set nKept      [llength $keptSigs]
        set nDropped   [llength $droppedSigs]
        set keptStr    [join $keptSigs ", "]
        set droppedStr [expr {$nDropped == 0 ? "none" : [join $droppedSigs ", "]}]
        set reduction  [expr {int(100.0 * $nDropped / 6)}]

        putsDual $fd "&| $idx | $seed | $baseSteps | $ticketSteps | $nKept | $keptStr | $nDropped | $droppedStr | $reduction% |&"
        incr idx
    }
    putsDual $fd "&| Audit | - | - | - | - | - | - | Many seeds work well with only 3-4 signals active. |&"
    putsDual $fd "=== End Lottery Ticket Results ==="

    # ----------------------------------------------------------
    #  Summary
    # ----------------------------------------------------------
    set totalDiff 0; set above 0; set below 0; set equal 0
    set auditOK 0;   set auditFail 0
    set totalCases [llength $resultsList]
    set auditList  [getTestCases]

    foreach res $resultsList {
        lassign $res seed p d
        set diff [expr {$p - $d}]
        set totalDiff [expr {$totalDiff + $diff}]
        if {$diff > 0} {incr above} elseif {$diff < 0} {incr below} else {incr equal}

        set expected -1
        foreach a $auditList {
            lassign $a s e
            if {$s == $seed} { set expected $e; break }
        }
        if {$expected >= 0 && $d == $expected} {incr auditOK} else {incr auditFail}
    }

    set avg [expr {$totalCases > 0 ? double($totalDiff) / $totalCases : 0.0}]

    set summaryDivider [string repeat "-" 90]
    putsDual $fd ""
    putsDual $fd $summaryDivider
    putsDual $fd [format "Total cases      : %d" $totalCases]
    putsDual $fd [format "Above state mach : %d (AI prob. took more steps)" $above]
    putsDual $fd [format "Below state mach : %d (AI prob. took fewer steps)" $below]
    putsDual $fd [format "Equal state mach : %d (matched state machine)" $equal]
    putsDual $fd [format "Avg P-D diff     : %+.2f steps" $avg]
    putsDual $fd [format "Audit passed     : %d / %d" $auditOK $totalCases]
    putsDual $fd $summaryDivider
    putsDual $fd ""

    if {$fd ne ""} { close $fd }
    puts "Results also saved to: $outFile"
}

# ============================================================
#  MASTER TEST RUNNER
# ============================================================

proc runTestSuite {fixedSeed {temperature 1.0}} {
    seedTheRandom $fixedSeed
    puts "Running with temperature = $temperature"

    set testCaseList [getTestCases]
    set resultsList  {}

    foreach onePair $testCaseList {
        lassign $onePair seedValue auditSteps
        set detReturn    [runDetStateMachine $seedValue]
        set detStepCount [lindex $detReturn 0]

        set probReturn    [runAiProbCollatz $seedValue $temperature]
        set probStepCount [lindex $probReturn 0]
        set exitReason    [lindex $probReturn 1]
        set lastEntropy   [lindex $probReturn 2]

        lappend resultsList [list $seedValue $probStepCount $detStepCount $exitReason $lastEntropy]
    }

    printAllResults $resultsList $temperature
    return $resultsList
}

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

runTestSuite 0
# end of file

Culled Comments
Note. This V10 is the "Spartan Version" with few explanatory comments and headers.

# culled comments
# ----
# tcl
# Probabilistic Collatz Variant   V12
# Compares deterministic Collatz reference steps with
# AI-style probabilistic random walk choices.
# Compares deterministic STATE MACHINE steps with
# AI-style probabilistic random walk choices.
# Probabilistic means random simulations -- output differs each run
# unless a fixed seed is supplied to seedTheRandom.
# 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 &|)
# Probabilistic Collatz Variant -- Modular Test Runner  V10
# Compares deterministic Collatz reference steps with
# AI-style probabilistic random walk choices using temperature control.
# Temperature = 1.0 is neutral. Lower values stay closer to standard Collatz.
# Probabilistic means random simulations -- output differs each run
# unless a fixed seed is supplied to seedTheRandom.
# Using multiple safety caps or clamps. Collatz Sequence is infinite,
# danger of endless loops in program.
# ----
# Educational version with visible probabilities and temperature diagnostic.
# Alternate results in wiki table format.
# ----
# Tcl/Tk 8.6+ 7-bit ASCII safe. NASA/JPL defensive programming style.
# Compatible with Tcl/Tk (Tool Control Language / Toolkit) 8.6+
# Written for Windows 11 on ActiveState Tcl.
# Pure ASCII code - no Unicode characters used anywhere.
# TCL Club 4/7/2026
# ----
# V10 changes from V9:
#   CHANGE -- Added first Wiki Table: AI Algorithm Report (Index + Quibble last)
#   CHANGE -- Second Wiki Table remains the general comparison table
#   FIX    -- Cleaned wiki formatting and braces
# ----
# 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. 
# Program contains multiple estimation procs for comparison.
# Uses original 10 test numbers + hardcoded odd steps
# These probabilistic variants do not prove the original conjecture.
# ABOUT srand:
#   Tcl seeds rand() via:  expr {srand(integerValue)}
#   fixedSeed = 0 --> clock seconds (differs each run)
#   fixedSeed > 0 --> that integer (reproducible each run)
# ============================================================
#  PROBABILISTIC COLLATZ CORE
#  Returns a two-element list: {stepCount  exitReason}
#  exitReason: "converged" | "step_cap" | "blowup_cap"
#
#  AI probabilistic choice at every step:
#    probability 0.80  --> follow standard Collatz rule  (FIX 3)
#    probability 0.20  --> apply the opposite (swapped) rule
#
#  SAFETY CAPS (all three active):
#    CAP 1 -- maxStepLimit 500: hard iteration ceiling.      (FIX 2)
#    CAP 2 -- blowupLimit 1e9:  value ceiling.               (FIX 2)
#    CAP 3 -- termination via int() nearest-rounding check.
#
#  PURE INTEGER DISCIPLINE (FIX 1):
#    Every arithmetic result is immediately truncated with int().
#    An explicit "force integer" line follows each assignment.
#    This eliminates all floating-point residue that previously
#    caused the while-condition to miss the value 1.
#
#  STEP HISTORY (FIX 4):
#    stepHistory keeps the last 8 {stepNumber value} pairs.
#    The list is passed to logCapDiagnosis when any cap fires.
# ============================================================
# ============================================================
#  RANDOM SEED SETUP
# ============================================================
# ============================================================
#  TEST CASE DATA PROVIDER
#  Format: {seed  deterministicReferenceSteps}
#  deterministicReferenceSteps is the classical Collatz step count,
#  always the same value, used as the comparison baseline.
# ============================================================
# ============================================================
#  CAP DIAGNOSTIC LOGGER
#  Called only when a safety cap fires.
#  Prints the last 8 steps to console and appends them to
#  collatz_cap_log.txt for offline inspection.
#  Arguments:
#    startingSeed  -- original seed that triggered this run
#    stepCounter   -- number of steps taken before cap fired
#    currentValue  -- final integer value when cap fired
#    exitReason    -- "step_cap", "blowup_cap", or "loop_det"
#    stepHistory   -- list of {stepNum value} pairs, up to 8 entries
# ============================================================
# ----
# AI weighting signals used in computeAiWeights (6 total in V8):
#   SIGNAL 0 -- parity (base weight, even or odd)
#   SIGNAL 1 -- trendPressure (last 3 values all rising = expansion)
#   SIGNAL 2 -- bitPressure   (bit-length of n, proxy for blowup risk)
#   SIGNAL 3 -- budgetPressure (step fraction of cap, ramp to exploit)
#   SIGNAL 4 -- repeatRisk   (n in recentVals window = cycle warning)
#   SIGNAL 5 -- entropyPressure (variance of recentVals, chaos proxy)
# ----
# ----
#  PROBABILISTIC COLLATZ CORE
#  Returns a two-element list: {stepCount  exitReason}
#  exitReason: "converged" | "step_cap" | "blowup_cap"
#
#  AI probabilistic choice at every step:
#    probability 0.80  --> follow standard Collatz rule  (FIX 3)
#    probability 0.20  --> apply the opposite (swapped) rule
#
#  SAFETY CAPS (all three active):
#    CAP 1 -- maxStepLimit 500: hard iteration ceiling.      (FIX 2)
#    CAP 2 -- blowupLimit 1e9:  value ceiling.               (FIX 2)
#    CAP 3 -- termination via int() nearest-rounding check.
#
#  PURE INTEGER DISCIPLINE (FIX 1):
#    Every arithmetic result is immediately truncated with int().
#    An explicit "force integer" line follows each assignment.
#    This eliminates all floating-point residue that previously
#    caused the while-condition to miss the value 1.
#
#  STEP HISTORY (FIX 4):
#    stepHistory keeps the last 8 {stepNumber value} pairs.
#    The list is passed to logCapDiagnosis when any cap fires.
# ============================================================
# ============================================================
#  MAIN
#  Examples:
#    runTestSuite 0 → default random seed and default temperature 1.0 (recommended starting point)
#    runTestSuite 0 1.0 → default random seed and default temperature 1.0 (recommended starting point)
#       ( default temperature close to standard notation in AI models)
#    runTestSuite 0 0.8      --> cooler, more deterministic
#    runTestSuite 0 1.5      --> hotter, more random
#    runTestSuite 0 0.7 → lower temperature choices < 1.0 , stay much closer to standard Collatz iterations
#    runTestSuite 77777777  1.4 → different random seed integers !!!,  higher temperature choices > 1.0 ,
#    higher chance of swapped actions and loop detection, farther from standard Collatz
#    runTestSuite 7777487989 1.4 → more exploration, different random seed integers !!!
#    higher chance of swapped actions and loop detection
# ============================================================

Comparison of Deterministic Steps and Probabilistic Choices in Collatz iterations
# Probabilistic means random simulations -- output differs each run
# unless a fixed seed is supplied to seedTheRandom.
# Using multiple safety caps or clamps, Collatz Sequence is infinite,
# danger of endless loops in program.

Random seed used: 1775910106
Running with temperature = 1.0
  CAP FIRED: seed=7  steps=230 finalVal=16 reason=loop_det/ent=0.0002
  Last 8 steps before cap:
    step 222   value = 16
    step 223   value = 8
    step 224   value = 25
    step 225   value = 76
    step 226   value = 38
    step 227   value = 19
    step 228   value = 10
    step 229   value = 5
  Quantum-Level: 7.852 for seed=7
  CAP FIRED: seed=15  steps=401 finalVal=22 reason=loop_det/ent=0.0001
  Last 8 steps before cap:
    step 393   value = 22
    step 394   value = 11
    step 395   value = 34
    step 396   value = 17
    step 397   value = 9
    step 398   value = 28
    step 399   value = 14
    step 400   value = 7
  Quantum-Level: 8.651 for seed=15
  CAP FIRED: seed=97  steps=402 finalVal=10 reason=loop_det/ent=0.0001
  Last 8 steps before cap:
    step 394   value = 10
    step 395   value = 31
    step 396   value = 94
    step 397   value = 47
    step 398   value = 24
    step 399   value = 12
    step 400   value = 6
    step 401   value = 3
  Quantum-Level: 8.655 for seed=97

-------------------------------------------------------------------------------------------------------------------
Seed   ProbStps DetStps  Exit           Diff Temp     AIExt  Kept Signals           Dropped Signals       
-------------------------------------------------------------------------------------------------------------------
2      1        1        converged        +0 1.00     conv   parity,trend,bit,budget,repeat,entropy (none)                
3      2        7        converged        -5 1.00     conv   parity,trend,bit,budget,repeat,entropy (none)                
5      393      5        converged      +388 1.00     conv   parity,trend,repeat,entropy bit,budget            
7      230      16       loop_det/ent   +214 1.00     loop   bit,budget,repeat,entropy parity,trend          
9      6        19       converged       -13 1.00     conv   parity,trend,bit,budget,repeat,entropy (none)                
15     401      17       loop_det/ent   +384 1.00     loop   parity,trend,bit,budget,entropy repeat                
25     336      23       converged      +313 1.00     conv   parity,trend,bit,budget,repeat,entropy (none)                
27     18       111      converged       -93 1.00     conv   parity,trend,bit,budget,repeat,entropy (none)                
97     402      118      loop_det/ent   +284 1.00     loop   parity,trend,bit,budget,repeat,entropy (none)                
100    20       25       converged        -5 1.00     conv   parity,trend,bit,budget,repeat,entropy (none)                

----
Total cases      : 10
Above state mach : 5 (AI prob. took more steps)
Below state mach : 4 (AI prob. took fewer steps)
Equal state mach : 1 (matched state machine)
Avg P-D diff     : +146.70 steps
Audit passed     : 10 / 10
----

# NSD-style pseudocode
# text
START
  INPUT n
  WHILE n != 1
    IF n is even
      n = n / 2
    ELSE
      n = 3 * n + 1
    END IF
    OUTPUT n
  END WHILE
STOP
# Compact wiki-friendly version
# text
START
  Read seed n
  While n is not 1
    Test parity
    If even -> n := n / 2
    If odd  -> n := 3n + 1
    Record n
  End While
STOP
# If you want branch labels
# text
WHILE n != 1
  IF even branch
    Next state: n / 2
  ELSE odd branch
    Next state: 3n + 1
END