1.  Encode current state.

-   `n := n / 2` for even-state compression.
    
-   `n := 3n + 1` for odd-state expansion.
    
-   `return to parity test` for loop recurrence.
    
-   `halt successfully` for the terminal state.
    
-   `abort iteration` for safety cutoff or overflow.

-   State token instead of just branch number.
    
-   Transition rule instead of only probability.
    
-   Confidence / risk as a proxy for activation strength or path reliability.
    
-   Audit note for explanation trace.
    
-   Next Logic Step for the immediate state update.

    
2.  Score candidate transitions.
    
3.  Choose the strongest branch.
    
4.  Apply the next state update.
    
5.  Re-score at the new state.
    
6.  Stop on terminal condition or safety limit.

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

----
***Figure.  TEMPERATURE EFFECT ON AI BEHAVIOR ***
----

figure. TEMPERATURE EFFECT ON AI BEHAVIOR
+----------------------------------------------------------------------------------+
| TEMPERATURE EFFECT - AI Randomness Control                                       |
|                                                                                  |
|    Temperature Value      Behavior                  Randomness Level             |
|    ──────────────────     ─────────────────────     ─────────────────────        |
|    < 0.8                  Very Conservative         Low (Close to Deterministic) |
|    0.8  –  1.2            Balanced / Neutral        Medium (Recommended)         |
|    > 1.3                  Aggressive / Chaotic      High (More Swapped Actions)  |
|                                                                                  |
|    Lower Temperature → Stronger bias toward standard Collatz rule                |
|    Higher Temperature → More exploration, higher chance of loops & caps          |
|                                                                                  |
|    Default: Temperature = 1.0 (Neutral)                                          |
+----------------------------------------------------------------------------------+

----
***Figure. 6 AI SIGNALS USED IN WEIGHT CALCULATION ***
----

figure. 6 AI SIGNALS USED IN WEIGHT CALCULATION
+----------------------------------------------------------------------------------+
| 6 AI SIGNALS - Probabilistic Decision Engine                                     |
|                                                                                  |
|    Signal              Purpose                              Effect               |
|    ─────────────────   ────────────────────────────────    ───────────────────   |
|    1. Parity           Even / Odd status                    Base probability     |
|    2. TrendPressure    Rising values in last 3 steps        Encourages expansion |
|    3. BitPressure      Bit length of current number         Blowup risk warning  |
|    4. BudgetPressure   Steps used vs total limit            Urgency to finish    |
|    5. RepeatRisk       Number seen recently                 Loop prevention      |
|    6. EntropyPressure  Variance in recent values           Chaos / randomness    |
|                                                                                  |
|    These 6 signals dynamically adjust weights between "Standard" and "Swapped"   |
|    rules at every step.                                                          |
+----------------------------------------------------------------------------------+

----
***Figure.  ***
----

figure. TEMPERATURE vs RANDOMNESS SPECTRUM
+----------------------------------------------------------------------------------+
| TEMPERATURE vs RANDOMNESS SPECTRUM                                               |
|                                                                                  |
|    Cold  ←──────────────────── Neutral ─────────────────────→ Hot                 |
|    0.6          0.8          1.0           1.2           1.5                     |
|     │            │            │             │             │                       |
|   Mostly       Slight       Balanced      More           Highly                  |
| Deterministic   Randomness    Exploration   Swaps         Chaotic                |
|                                                                                  |
|    • Closer to classic Collatz          • Higher chance of long paths & caps     |
|    • More predictable results           • Greater variation between runs         |
+----------------------------------------------------------------------------------+
----
***Figure.  ***
----

figure. PROBABILISTIC COLLATZ VARIANT OVERVIEW
+----------------------------------------------------------------------------------+
| PROBABILISTIC COLLATZ VARIANT - Tcl Implementation                               |
|                                                                                  |
|    ┌─────────────────────┐                                                       |
|    │   seedTheRandom     │                                                       |
|    └──────────┬──────────┘                                                       |
|               ▼                                                                  |
|    ┌─────────────────────┐   ┌─────────────────────┐                            |
|    │  runDetStateMachine │   │ runAiProbCollatz    │                            |
|    │ (Deterministic)     │   │ (AI Probabilistic)  │                            |
|    └──────────┬──────────┘   └──────────┬──────────┘                            |
|               │                         │                                         |
|               └──────────────┬──────────┘                                         |
|                              ▼                                                    |
|                    printAllResults + Wiki Tables                                 |
|                                                                                  |
|    Compares classic Collatz with AI-weighted probabilistic choices               |
+----------------------------------------------------------------------------------+

----
***Figure.  ***
----

figure. COLLATZ DECISION ENGINE
+----------------------------------------------------------------------------------+
| COLLATZ DECISION ENGINE                                                          |
|                                                                                  |
|                Current Number (n)                                                |
|                       │                                                          |
|                       ▼                                                          |
|                assessState()                                                     |
|                (parity, magnitude, risk, trend)                                  |
|                       │                                                          |
|          ┌────────────┼────────────┐                                             |
|          │            │            │                                             |
|          ▼            ▼            ▼                                             |
|    Deterministic   Probabilistic   Swapped Rule                                  |
|     (Standard)      (Weighted)      (Opposite)                                   |
|          │            │            │                                             |
|          └────────────┼────────────┘                                             |
|                       ▼                                                          |
|                  applyAction()                                                   |
|                                                                                  |
|    AI uses 6 signals: parity, trend, bitPressure, budget, repeatRisk, entropy   |
+----------------------------------------------------------------------------------+

----
***Figure.  ***
----

figure. AI PROBABILISTIC CHOICE
+----------------------------------------------------------------------------------+
| AI PROBABILISTIC CHOICE (Temperature Controlled)                                 |
|                                                                                  |
|    Temperature = 1.0  → Neutral (balanced randomness)                            |
|    Temperature < 1.0  → Cooler (more deterministic)                              |
|    Temperature > 1.0  → Hotter (more chaotic)                                    |
|                                                                                  |
|    Base Weights:                                                                 |
|      Even n → 80% Standard / 20% Swapped                                         |
|      Odd  n → 75% Standard / 25% Swapped                                         |
|                                                                                  |
|    Adjusted by: trendPressure, bitPressure, budgetPressure,                      |
|                 repeatRisk, entropyPressure                                      |
|                                                                                  |
|    Final choice made by drawFromWeights()                                        |
+----------------------------------------------------------------------------------+

----
***Figure.  ***
----

figure. SAFETY CAPS & DEFENSIVE DESIGN
+----------------------------------------------------------------------------------+
| SAFETY CAPS & DEFENSIVE PROGRAMMING                                              |
|                                                                                  |
|    CAP 1 : Step Limit     (maxStepLimit = 500)                                   |
|    CAP 2 : Blowup Limit   (n > 1,000,000,000)                                    |
|    CAP 3 : Loop Detection (visited values check)                                 |
|                                                                                  |
|    When any cap fires → logCapDiagnosis() writes to collatz_cap_log.txt          |
|                                                                                  |
|    Pure Integer Discipline + History Tracking                                    |
|    Prevents infinite loops and floating-point drift                              |
+----------------------------------------------------------------------------------+

----
***Figure.  ***
----

figure. PROGRAM FLOW & OUTPUT
+----------------------------------------------------------------------------------+
| PROGRAM FLOW                                                                     |
|                                                                                  |
|    seedTheRandom()                                                               |
|         │                                                                        |
|         ▼                                                                        |
|    ┌───────────────────────┐                                                     |
|    │   Test Suite Runner   │                                                     |
|    └──────────┬────────────┘                                                     |
|               │                                                                  |
|        ┌──────┴──────┐                                                           |
|        │             │                                                           |
|   Deterministic   Probabilistic                                                  |
|   State Machine     AI Model                                                     |
|        │             │                                                           |
|        └──────┬──────┘                                                           |
|               ▼                                                                  |
|       printAllResults()                                                          |
|               │                                                                  |
|               ▼                                                                  |
|    Two Wiki Tables + Summary Statistics + Log File                               |
+----------------------------------------------------------------------------------+

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

# tcl
# Probabilistic Collatz Variant -- Modular Test Runner  V10
# 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.
# ----

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 }
    }
}

# ============================================================
#  STATE MACHINE & AI MODULES (unchanged)
# ============================================================

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 scoreBranches {state deterministicMode} {
    dict with state {}
    if {$deterministicMode} {
        return {standard 1.0 swapped 0.0}
    }
    if {$parity eq "even"} {
        return {standard 0.80 swapped 0.20}
    } else {
        return {standard 0.75 swapped 0.25}
    }
}

proc chooseAction {branchScores} {
    set bestWeight -1
    set bestAction ""
    dict for {action weight} $branchScores {
        if {$weight > $bestWeight} {
            set bestWeight $weight
            set bestAction $action
        }
    }
    return $bestAction
}

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 state [assessState $n]
        set branchScores [scoreBranches $state 1]
        set chosenAction [chooseAction $branchScores]
        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]
}

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. Audit corrected V6."}
        {15 "Moderate stochastic variation around reference."}
        {25 "Longer but still terminates. Spread widens."}
        {27 "Famous long hailstone seed. Prob. version often shorter."}
        {97 "High variation possible. May hit step cap."}
        {100 "Usually moderate length. Even start favors divide."}
    }
}

# ============================================================
#  CONSOLIDATED OUTPUT SUBROUTINE
# ============================================================

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

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

    set divider [string repeat "-" 105]
    putsDual $fd ""
    putsDual $fd $divider
    putsDual $fd [format "%-8s %-10s %-10s %-12s %-8s %-8s %-8s %-8s %-18s" \
        "Seed" "ProbSteps" "DetSteps" "Exit" "Diff" "Temp" "A.Exit" "A.Vec" "Quibble"]
    putsDual $fd [format "%-8s %-10s %-10s %-12s %-8s %-8s %-8s %-8s %-18s" \
        "" "Steps" "Det" "Reason" "(P-D)" "AI.Temp" "AI.Exit" "AI.Vec" "Notes"]
    putsDual $fd $divider

    set noteData [getWikiNotes]

    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 aiVec "p,t,b,bu,r,e"
        set noteText [format "{%s, %.2f, %s}" $tempTag $temperature $aiExit]

        putsDual $fd [format "%-8d %-10d %-10d %-12s %+8d %-8.2f %-8s %-8s %-18s" \
            $seed $probSteps $detSteps $reasonTag $diff $temperature $aiExit $aiVec $noteText]
    }

    putsDual $fd $divider

    # === FIRST WIKI TABLE: AI Algorithm Report ===
    putsDual $fd ""
    putsDual $fd "=== AI Algorithm Report ==="
    putsDual $fd ""
    putsDual $fd "%| Index | Seed | ProbSteps | DetSteps | Exit | Diff | Temp | A.Exit | A.Vec | Quibble |%"

    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}]
        set aiVec "p,t,b,bu,r,e"
        set noteText [format "{%s t=%.2f %s}" $tempTag $temperature $aiExit]

        set row "&| $idx | $seed | $probSteps | $detSteps | $reasonTag | $diff | $temperature | $aiExit | $aiVec | $noteText |&"
        putsDual $fd $row
        incr idx
    }
    putsDual $fd "&| Audit | - | - | - | - | - | - | - | - | All runs used temperature control and 6 signals. |&"
    putsDual $fd ""
    putsDual $fd "=== End AI Algorithm Report ==="

    # === SECOND WIKI TABLE: General Comparison (unchanged) ===
    putsDual $fd ""
    putsDual $fd "=== General Comparison Wiki Table ==="
    putsDual $fd ""
    putsDual $fd "%| Index | Seed | StateMachine.Steps | Prob.Steps(this run) | 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 }
        }
        set rowText "&| $rowIndex | $seed | $detSteps | $probSteps | $noteText |&"
        putsDual $fd $rowText
        incr rowIndex
    }
    putsDual $fd "&| Audit | - | - | - | All state machine seeds reach 1. AI prob. model converges almost surely. |&"
    putsDual $fd ""
    putsDual $fd "=== End Wiki Table ==="

    # Summary (unchanged)
    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
# ----
# tcl
# Probabilistic Collatz Variant -- Modular Test Runner  V10
# 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: 1775397967

-----------------------------------------------------------------
Seed      Probabilistic     StateMachine    Exit        Diff    
          Steps(rand)       Det.Steps       Reason      (P - D) 
-----------------------------------------------------------------
2         1                 1               converge    +0
3         2                 7               converge    -5
  CAP FIRED: seed=5  steps=41  finalVal=10  reason=loop_det
  Last 8 steps before cap:
    step 33    value = 319
    step 34    value = 160
    step 35    value = 80
    step 36    value = 40
    step 37    value = 20
    step 38    value = 10
    step 39    value = 5
    step 40    value = 3
5         41                5               loop_det    +36
7         3                 16              converge    -13
9         45                19              converge    +26
15        12                17              converge    -5
25        10                23              converge    -13
27        10                111             converge    -101
97        38                118             converge    -80
100       12                25              converge    -13

----
Total cases      : 10
Above state mach : 2   (AI prob. took more steps)
Below state mach : 7   (AI prob. took fewer steps)
Equal state mach : 1   (matched state machine)
Avg P-D diff     : -16.80 steps
Audit passed     : 10 / 10  (state machine vs hand-verified)

Total cases : 10
Above ref   : 6   (probabilistic took more steps)
Below ref   : 1   (probabilistic took fewer steps)
Equal ref   : 3   (matched deterministic exactly)
Avg P-D diff: +48.50 steps

# Modular test runner for probabilistic Collatz variant
# prototype code V1 
# Clean, wiki-friendly structure with separate procs
# Compares deterministic Collatz with AI-style probabilistic choices.
# probabilistic means using random simulations so
# printout not the same each run. 
# Core probabilistic routine (AI choice point clearly marked)
proc run_probabilistic_collatz {seed} {
    set n [expr {double($seed)}]
    set max_steps 10000
    set steps 0
    while {$n != 1 && $steps < $max_steps} {
        if {rand() < 0.666667} {          ;# AI PROBABILISTIC CHOICE: ~2/3 divide-by-2
            set n [expr {$n / 2.0}]
        } else {                          ;# ~1/3 3n+1
            set n [expr {3.0 * $n + 1}]
        }
        incr steps
    }
    return $steps
}

# Modular test data provider
proc get_collatz_test_data {} {
    return {
        {2   1}
        {3   7}
        {5   5}
        {7  16}
        {9   6}
        {15 17}
        {25 23}
        {27 111}
        {97 118}
        {100 25}
    }
}

# Modular test runner (main test procedure)
proc run_collatz_tests {} {
    set test_data [get_collatz_test_data]
    set results {}
    foreach pair $test_data {
        lassign $pair seed expected
        set result [run_probabilistic_collatz $seed]
        lappend results [list $seed $result $expected]
        puts "Seed $seed -> $result steps (deterministic ref: $expected)"
    }
    return $results
}

# Example usage (call this to execute all tests)
# run_collatz_tests
run_collatz_tests

# 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