Some logic problems may need counterfactuals to solve.
----
1. Po + Px are impossible to copy. from Heisenberg principle, called No-cloning rule in some venues.
2. Po + Px are possible to reverse. 
3. Po + Px  are in perfect isolation. 

1. Beam splitter. 
Po original path
Px superposition path

2. Quantum penny toss.
Po original path
Px superposition path

Core Axioms:

Programming forces understanding.
Programming confronts ambiguities.
Programming exposes assumptions.
Programming demands precision.
Programming imposes logic.
Programming builds clarity.
----
Contrast Axioms:

Human mind glosses flaws.
Pencil paper forgives errors.

# testing Counterfactual Axioms, forward logic only
Full sentence: Programming enables exposing transformations.
Intermediate token-like: Prog → ExposeTrans = 0.87  Counterfactual 1
Full sentence: Programming blocks ambiguity hiding.
Intermediate token-like: Prog → BlockAmbigHide = 0.84  Counterfactual 3
Full sentence: Programming allows repeatable transformations.
Intermediate token-like: Prog → AllowRepeatTrans = 0.86  Counterfactual 3

-   heat ≈ 0.92
    
-   dry_cond ≈ 0.90
    
-   humidity ≈ 0.08
    
-   rain ≈ 0.03
    
-   wind ≈ 0.50
    
-   fuel ≈ 0.75
    
-   spark ≈ 0.65
    
-   smoke ≈ 0.35
    
-   lightning ≈ 0.20  { not mentioned much, keep low)

# from TCL, Joke!
 
if {[catch {expr {$faulty_assumption}} val]} {
    puts " Defaulting val, big trouble, JOKE! " 
    set val 0
}

**** figure. INFERENCE ENGINE OVERVIEW ****

+----------------------------------------------------------------------------------+
| INFERENCE ENGINE - TOKEN-LIKE MINI-LLM REASONING                                 |
|                                                                                  |
|    Core Flow:                                                                    |
|      1. Base Evidence Tokens (0.0 – 1.0 signal strength)                         |
|      2. Forward Propagation (1–2 passes spread influence)                        |
|      3. Conclusion Scoring (weighted average per rule)                           |
|      4. Softmax + Temperature (scores → probabilities)                           |
|      5. Decision with Threshold (winner or UNCERTAIN)                            |
|                                                                                  |
|    Supports:                                                                     |
|      • Positive axioms                                                           |
|      • Contrast axioms                                                           |
|      • Marletto Counterfactuals (+ possible / – impossible)                      |
|      • Multiple math paths (arithmetic, geometric, weighted sum)                 |
|                                                                                  |
|    Educational toy for weighted token reasoning and counterfactual logic         |
+----------------------------------------------------------------------------------+

**** figure. THREE CHANNELS IN INFERENCE ENGINE ****

+----------------------------------------------------------------------------------+
| THREE CHANNELS IN THE INFERENCE ENGINE                                           |
|                                                                                  |
|    Positive Axioms (Core Support)                                                |
|      Programming forces understanding                                            |
|      Programming demands precision                                               |
|      Programming builds clarity                                                  |
|                                                                                  |
|    Contrast Axioms (Traditional Limits)                                          |
|      Human mind glosses flaws                                                    |
|      Pencil paper forgives errors                                                |
|                                                                                  |
|    Marletto Counterfactuals (Possible / Impossible)                              |
|      + Possible: exposes transformations                                         |
|      + Possible: allows repeatable operations                                    |
|      – Impossible: hides ambiguity forever                                       |
|                                                                                  |
|    Engine combines all three and computes multiple math paths                    |
+----------------------------------------------------------------------------------+

**** figure. FORWARD PROPAGATION EXAMPLE ****

+----------------------------------------------------------------------------------+
| FORWARD PROPAGATION - HOW TOKENS SPREAD INFLUENCE                                |
|                                                                                  |
|    Starting Tokens:                                                              |
|      tok_heat_level   = 0.82                                                     |
|      tok_dry_cond     = 0.75                                                     |
|      tok_spark_event  = 0.60                                                     |
|                                                                                  |
|    After One Pass:                                                               |
|      tok_damage_lvl gains from heat, dryness, sparks                             |
|      tok_smoke_sig  gains from sparks and wind                                   |
|                                                                                  |
|    After Two Passes:                                                             |
|      Indirect effects accumulate (heat → dryness → fuel → damage)                |
|                                                                                  |
|    Result: Evidence ripples through the token graph                              |
|    Mimics attention flow in larger language models                               |
+----------------------------------------------------------------------------------+

**** figure. MULTIPLE MATH PATHS COMPARISON ****

+----------------------------------------------------------------------------------+
| MULTIPLE MATH PATHS - ARITHMETIC vs GEOMETRIC MEAN                               |
|                                                                                  |
|    Positive Score     ≈ 0.918                                                    |
|    Contrast Score     ≈ -0.920                                                   |
|    Counterfactual Score ≈ 0.840                                                  |
|                                                                                  |
|    Arithmetic Mean Path:                                                         |
|      (0.918 - 0.920 + 0.840) / 3   ≈ +0.279   →  Leans POSSIBLE                 |
|                                                                                  |
|    Geometric Mean Path:                                                          |
|      cbrt(0.918 × -0.920 × 0.840)  ≈ -0.892   →  Leans IMPOSSIBLE               |
|                                                                                  |
|    Insight: Different aggregation methods reveal fragility in reasoning          |
|    Multiple paths improve robustness and expose weak assumptions                 |
+----------------------------------------------------------------------------------+

**** figure. BEAM SPLITTER TESTCASE ****

+----------------------------------------------------------------------------------+
| BEAM SPLITTER TESTCASE - POSSIBLE vs IMPOSSIBLE                                  |
|                                                                                  |
|    Positive Counterfactuals (Possible):                                          |
|      BS → Path = 0.95     (path superposition possible)                          |
|      BS → Sup  = 0.94     (quantum superposition enabled)                        |
|      BS → Int  = 0.92     (interference when recombined)                         |
|                                                                                  |
|    Negative Counterfactuals (Impossible):                                        |
|      BS → Clone = -0.96   (perfect cloning forbidden)                            |
|      BS → Dual  = -0.90   (full path + full interference impossible)            |
|                                                                                  |
|    Engine Output:                                                                |
|      Strong positive lean on possible transformations                            |
|      Clear veto on classical hidden-variable completion                          |
+----------------------------------------------------------------------------------+

**** figure. SOLAR OVEN COUNTERFACTUAL ANALYSIS ****

+----------------------------------------------------------------------------------+
| SOLAR OVEN - MARLETTO COUNTERFACTUALS                                            |
|                                                                                  |
|    Positive (Achievable):                                                        |
|      Sunlight capture possible                                                   |
|      Heat retention possible                                                     |
|      Black absorber converts radiation possible                                  |
|                                                                                  |
|    Negative (Impossible):                                                        |
|      Perfect lossless trapping impossible                                        |
|      Infinite temperature rise impossible                                        |
|      Zero-loss full conversion impossible                                        |
|                                                                                  |
|    Engine Result:                                                                |
|      Arithmetic path leans possible (practical heat gain)                        |
|      Geometric path highlights fragility (losses matter)                         |
|      Demonstrates scale-dependent vs scale-independent reasoning                 |
+----------------------------------------------------------------------------------+

**** figure. FIRE WARNING TESTCASE ****

+----------------------------------------------------------------------------------+
| FIRE WARNING TESTCASE - TOKEN AGGREGATION                                        |
|                                                                                  |
|    Aggregated Signals:                                                           |
|      heat ≈ 0.92          dry_cond ≈ 0.90                                        |
|      spark ≈ 0.65         smoke ≈ 0.35                                           |
|      wind ≈ 0.50          fuel ≈ 0.75                                            |
|                                                                                  |
|    Threshold Logic:                                                              |
|      Risk ≈ 0.66 → HIGH                                                          |
|      Environment preconditioned (dryness ~0.94)                                  |
|      Ignition actively present (sparks + smoke)                                  |
|                                                                                  |
|    Engine fires high-risk conclusion when combined signals exceed threshold      |
+----------------------------------------------------------------------------------+

**** figure. INFERENCE ENGINE SUMMARY ****

+----------------------------------------------------------------------------------+
| INFERENCE ENGINE SUMMARY                                                         |
|                                                                                  |
|    Strengths:                                                                    |
|      Weighted token propagation with forward passes                              |
|      Marletto-style possible/impossible channels                                 |
|      Multiple math paths (arithmetic, geometric, weighted)                       |
|      Softmax + temperature for probabilistic output                              |
|      Clear audit trail and wiki table output                                     |
|                                                                                  |
|    Educational Value:                                                            |
|      Shows how small changes in weighting or counterfactuals                     |
|      can shift conclusions — a practical mini-LLM reasoning toy                 |
+----------------------------------------------------------------------------------+

**** figure. SOFTMAX TEMPERATURE EFFECTS **** 

+----------------------------------------------------------------------------------+
| SOFTMAX TEMPERATURE EFFECTS                                                      |
|                                                                                  |
|    Raw Scores → Softmax( score / Temperature )                                   |
|                                                                                  |
|    Low Temperature (e.g. 0.10 – 0.30)                                            |
|      Sharp distribution                                                              |
|      Winner takes most probability                                               |
|      Clear, decisive conclusions                                                 |
|      Example: 0.3685 → 0.85+   (strong winner)                                   |
|                                                                                  |
|    Medium Temperature (e.g. 0.50 – 0.80)                                         |
|      Balanced spread                                                             |
|      Multiple conclusions retain noticeable weight                               |
|                                                                                  |
|    High Temperature (e.g. 1.0 – 2.0)                                             |
|      Very flat / uniform probabilities                                           |
|      Almost equal chances → high uncertainty                                     |
|                                                                                  |
|    Educational Insight: Temperature controls confidence vs exploration trade-off |
+----------------------------------------------------------------------------------+

**** figure. SOFTMAX TEMPERATURE COMPARISON **** 

+----------------------------------------------------------------------------------+
| SOFTMAX TEMPERATURE COMPARISON (Fire Warning Example)                            |
|                                                                                  |
|    Conclusion          | Temp=0.10   | Temp=0.30   | Temp=1.00   | Temp=2.00   |
|    -------------------|-------------|-------------|-------------|-------------|
|    concl_fire_hi      | 0.912       | 0.368       | 0.142       | 0.118       |
|    concl_drought      | 0.068       | 0.292       | 0.138       | 0.122       |
|    concl_damage       | 0.012       | 0.196       | 0.131       | 0.119       |
|    concl_storm        | 0.003       | 0.049       | 0.112       | 0.115       |
|    ... (others)       | very low    | low         | ~0.11 each  | near equal  |
|                                                                                  |
|    Decision at 0.40 threshold:                                                   |
|      Low Temp  → Strong FIRE HIGH warning                                        |
|      Medium    → UNCERTAIN (as in example run)                                   |
|      High Temp → Almost uniform → highly uncertain                               |
+----------------------------------------------------------------------------------+

**** figure. NORMALIZE ORDERING UPFRONT - CANONICAL ORDERING EXTENSION **** 

+----------------------------------------------------------------------------------+
| NORMALIZE ORDERING UPFRONT - CANONICAL ORDERING EXTENSION                        |
|                                                                                  |
|    Problem: Inference / DFT results are sensitive to axiom order                 |
|    Solution: Define ONE canonical ordering rule and stick to it                  |
|                                                                                  |
|    Recommended Ordering Strategies:                                              |
|                                                                                  |
|    1. Logical Dependency       (foundational concepts first)                     |
|    2. Historical Appearance    (order of discovery in the theory)                |
|    3. Decreasing Confidence    (strongest beliefs first, highest prob.)          |
|    4. Multiple Random Sequences (ensemble averaging)                             |
|                                                                                  |
|    Best Practice for Reproducible Results:                                       |
|      • Fix one rule for main analysis                                            |
|      • Run small ensemble of random orders                                       |
|      • Report variance as uncertainty band                                       |
|                                                                                  |
|    Benefit: Reduces "no-go effect" from arbitrary ordering                       |
|    Makes DFT spectra and conclusions more robust                                 |
+----------------------------------------------------------------------------------+

**** figure. ORDERING STRATEGIES COMPARISON **** 
+----------------------------------------------------------------------------------+
| ORDERING STRATEGIES COMPARISON                                                   |
|                                                                                  |
|    Strategy                    | Reproducibility | Reveals Variance | Difficulty |
|    ---------------------------|------------------|------------------|------------|
|    Logical Dependency          | High             | Low              | Medium     |
|    Historical Appearance       | High             | Medium           | Medium     |
|    Decreasing Confidence       | High             | Low              | Easy       |
|    Multiple Random (Ensemble)  | Medium           | High (useful)    | Easy       |
|                                                                                  |
|    Recommendation:                                                               |
|      Use "Logical Dependency" for primary run                                    |
|      Add "Multiple Random" ensemble to quantify ordering sensitivity             |
|      Report both main result and variance band                                   |
|                                                                                  |
|    This extension greatly improves reliability of the Inference Engine          |
+----------------------------------------------------------------------------------+

Notation [Prog → Und] = 0.95 is not really Polish notation.
Polish notation (prefix notation) puts the operator first: + 3 4 or Force Prog Und.
Intermediate form is closer to infix with directed arrow, like a weighted graph edge or a simple assignment.
It is not applicable as true Polish notation.
It is much closer to: 
Weighted directed graph notation (A → B [weight])
Attention mechanism style (Token_A --[0.87]--> Token_B)

Output written to: TuringMachineTrace_2026-04.txt
Session Complete
Initial blank tape   :  0 0 0 0 0 0 0 0 0 0  , I think
Steps recorded : 11 transitions
                 plus 1 Audit row = 12 table rows total
Final tape     : 1 1 0 1 1 0 1 1 0 1
Pattern        : 1 1 0 repeating across ten cells
Halting problem: does not apply -- tape is finite and bounded

# 
# Generic Semantic Axiom Inference Engine V6
# Tcl 8.6 or greater required
# Naming convention: all proc and variable names are 12-15
# characters, descriptive, and domain-neutral so the engine
# can serve any subject area without modification.
# 
# ----
# 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/28/2026 
#  

console show

# ============================================================
# GLOBAL DATA STORES
# ============================================================
set AxiomWeightMap [dict create]
set BeliefStoreMap [dict create]

# ============================================================
# PROC: LoadAxiomData   (15 chars)
# ============================================================
proc LoadAxiomData {} {
    global AxiomWeightMap

    # Positive Axioms - Programming approach
    dict set AxiomWeightMap ProgForcesUnderst  0.95
    dict set AxiomWeightMap ProgConfrontsAmbig 0.90
    dict set AxiomWeightMap ProgExposesAssump  0.88
    dict set AxiomWeightMap ProgDemandsPrecsn  0.92
    dict set AxiomWeightMap ProgImposesLogic   0.85
    dict set AxiomWeightMap ProgBuildsClarity  0.89

    # Contrast Axioms - Traditional methods
    dict set AxiomWeightMap MindGlossesFlaws   0.80
    dict set AxiomWeightMap PaperForgivesErrs  0.75

    # Marletto Counterfactual Axioms (Constructor Theory style)
    dict set AxiomWeightMap CfactExposeTrans    0.87   ;# Enables exposing transformations
    dict set AxiomWeightMap CfactBlockAmbigHide 0.84   ;# Blocks ambiguity hiding
    dict set AxiomWeightMap CfactAllowRepeat    0.86   ;# Allows repeatable transformations
}

# ============================================================
# PROC: FetchAxiomScore (15 chars)
# ============================================================
proc FetchAxiomScore {AxiomKeyName} {
    global AxiomWeightMap
    if {[dict exists $AxiomWeightMap $AxiomKeyName]} {
        return [dict get $AxiomWeightMap $AxiomKeyName]
    }
    return 0.0
}

# ============================================================
# PROC: StoreBeliefVal  (14 chars)
# ============================================================
proc StoreBeliefVal {BeliefKeyName BeliefIntVal} {
    global BeliefStoreMap
    dict set BeliefStoreMap $BeliefKeyName $BeliefIntVal
}

# ============================================================
# PROC: FetchBeliefVal  (14 chars)
# ============================================================
proc FetchBeliefVal {BeliefKeyName} {
    global BeliefStoreMap
    if {[dict exists $BeliefStoreMap $BeliefKeyName]} {
        return [dict get $BeliefStoreMap $BeliefKeyName]
    }
    return ""
}

# ============================================================
# PROC: DisplayAxiomMap (15 chars)
# ============================================================
proc DisplayAxiomMap {} {
    global AxiomWeightMap
    puts "\n=== Axiom Weight Library ===\n"
    dict for {AxiomKeyName WeightValue} $AxiomWeightMap {
        puts [format "  %-26s : %.2f" $AxiomKeyName $WeightValue]
    }
    puts "\nTotal axioms loaded: [dict size $AxiomWeightMap]"
}

# ============================================================
# PROC: RateAxiomLevel  (14 chars)
# ============================================================
proc RateAxiomLevel {AxiomKeyName} {
    set ScoreValue [FetchAxiomScore $AxiomKeyName]
    if {$ScoreValue > 0.90} {
        set RatingLabel "VERY STRONG"
    } elseif {$ScoreValue > 0.80} {
        set RatingLabel "Strong"
    } elseif {$ScoreValue > 0.70} {
        set RatingLabel "Moderate"
    } else {
        set RatingLabel "Weak"
    }
    puts [format "  %-26s -> %s (%.2f)" $AxiomKeyName $RatingLabel $ScoreValue]
    return $ScoreValue
}

# ============================================================
# PROC: CompareApproach (15 chars)
# ============================================================
proc CompareApproach {} {
    puts "\n=== Positive vs Contrast vs Marletto Counterfactuals ===\n"
    puts "  Positive Axioms (Recommended):"
    RateAxiomLevel ProgForcesUnderst
    RateAxiomLevel ProgDemandsPrecsn
    RateAxiomLevel ProgBuildsClarity
    puts "\n  Contrast Axioms:"
    RateAxiomLevel MindGlossesFlaws
    RateAxiomLevel PaperForgivesErrs
    puts "\n  Marletto Counterfactual Axioms:"
    RateAxiomLevel CfactExposeTrans
    RateAxiomLevel CfactBlockAmbigHide
    RateAxiomLevel CfactAllowRepeat
}

# ============================================================
# PROC: ComputeProgScore (15 chars)
# ============================================================
proc ComputeProgScore {} {
    set TotalScore 0.0
    set TotalScore [expr {$TotalScore + [FetchAxiomScore ProgForcesUnderst]  * 0.25}]
    set TotalScore [expr {$TotalScore + [FetchAxiomScore ProgDemandsPrecsn]  * 0.20}]
    set TotalScore [expr {$TotalScore + [FetchAxiomScore ProgBuildsClarity]  * 0.20}]
    set TotalScore [expr {$TotalScore + [FetchAxiomScore ProgConfrontsAmbig] * 0.20}]
    set TotalScore [expr {$TotalScore + [FetchAxiomScore ProgImposesLogic]   * 0.15}]
    return $TotalScore
}

# ============================================================
# PROC: ComputeAltScore (14 chars)
# ============================================================
proc ComputeAltScore {} {
    set ContrastScore [expr {
        [FetchAxiomScore MindGlossesFlaws]  * 0.50 +
        [FetchAxiomScore PaperForgivesErrs] * 0.50
    }]
    return $ContrastScore
}

# ============================================================
# PROC: ComputeCfactScore (16 chars)
# Marletto Counterfactual Score - strength of possible transformations
# ============================================================
proc ComputeCfactScore {} {
    set CfactScore 0.0
    set CfactScore [expr {$CfactScore + [FetchAxiomScore CfactExposeTrans]    * 0.35}]
    set CfactScore [expr {$CfactScore + [FetchAxiomScore CfactBlockAmbigHide] * 0.30}]
    set CfactScore [expr {$CfactScore + [FetchAxiomScore CfactAllowRepeat]    * 0.35}]
    return $CfactScore
}

# ============================================================
# PROC: InferConclusion (15 chars)
# ============================================================
proc InferConclusion {} {
    set PositiveScore [ComputeProgScore]
    set ContrastScore [ComputeAltScore]
    set CfactScore    [ComputeCfactScore]

    set PctConfidence [expr {$PositiveScore * 100.0}]
    set ScoreGap      [expr {$PositiveScore - $ContrastScore}]

    puts "\n=== Inference Engine Conclusions ===\n"
    puts [format "  Positive approach score : %.4f" $PositiveScore]
    puts [format "  Contrast approach score : %.4f" $ContrastScore]
    puts [format "  Marletto Cfact score    : %.4f" $CfactScore]
    puts [format "  Score gap               : %.4f" $ScoreGap]
    puts ""

    if {[FetchBeliefVal "MirrorTest"] == 1} {
        puts "CONCLUSION: Use the PROGRAMMING approach."
        puts "Reason: Strong positive axioms supported by Marletto counterfactuals."
        puts [format "Confidence: %.1f%%" $PctConfidence]

    } elseif {[FetchBeliefVal "TimeLessLaw"] == 1} {
        puts "CONCLUSION: Programming is strongly recommended for learning."
        puts [format "Confidence: %.1f%%" $PctConfidence]

    } else {
        puts "CONCLUSION: Traditional methods may be adequate for this task."
        puts "  However, programming still offers better long-term understanding."
    }

    if {$CfactScore > 0.80} {
        puts "\nMARLETTO SUPPORT: High confidence in possible reliable transformations."
        puts "  Programming can expose transformations, block hidden ambiguity,"
        puts "  and support repeatable operations."
    }

    if {$ContrastScore > 0.75} {
        puts "\nCAUTION: Contrast score is high. Consider verifying with code."
    }
}

# ============================================================
# PROC: BuildTableRows  (14 chars)
# ============================================================
proc BuildTableRows {} {
    set RowList [list]
    set idx 1

    # Positive Axioms
    lappend RowList [dict create idx $idx category "Axiom-Positive" statement "Programming forces understanding" weight "0.95" quibble "Assumes programmer persists to completion"] ; incr idx
    lappend RowList [dict create idx $idx category "Axiom-Positive" statement "Programming confronts ambiguities" weight "0.90" quibble "Ambiguity may be deferred with workarounds"] ; incr idx
    lappend RowList [dict create idx $idx category "Axiom-Positive" statement "Programming exposes assumptions" weight "0.88" quibble "Hidden assumptions in libraries stay hidden"] ; incr idx
    lappend RowList [dict create idx $idx category "Axiom-Positive" statement "Programming demands precision" weight "0.92" quibble "Precision in syntax does not equal semantic truth"] ; incr idx
    lappend RowList [dict create idx $idx category "Axiom-Positive" statement "Programming imposes logic" weight "0.85" quibble "Logic can be formally correct yet contextually wrong"] ; incr idx
    lappend RowList [dict create idx $idx category "Axiom-Positive" statement "Programming builds clarity" weight "0.89" quibble "Clarity for author may not equal clarity for reader"] ; incr idx

    # Contrast Axioms
    lappend RowList [dict create idx $idx category "Axiom-Contrast" statement "Human mind glosses flaws" weight "0.80" quibble "Experienced reviewers do catch many flaws manually"] ; incr idx
    lappend RowList [dict create idx $idx category "Axiom-Contrast" statement "Pencil paper forgives errors" weight "0.75" quibble "Formal proofs on paper are rigorous"] ; incr idx

    # Marletto Protocol Counterfactuals (placed in Marletto section)
    lappend RowList [dict create idx $idx category "Marletto P." statement "Prog enables exposing transformations" weight "0.87" quibble "Marletto: possible reliable transformation"] ; incr idx
    lappend RowList [dict create idx $idx category "Marletto P." statement "Prog blocks ambiguity hiding" weight "0.84" quibble "Marletto: prevents hidden ambiguity"] ; incr idx 
    lappend RowList [dict create idx $idx category "Marletto P." statement "Prog allows repeatable transformations" weight "0.86" quibble "Marletto: supports repeatable operations"] ; incr idx

    # Conclusions
    lappend RowList [dict create idx $idx category "Conclusion" statement "MirrorTest triggers programming recommendation" weight "0.9068" quibble "Rule fires on binary yes"] ; incr idx
    lappend RowList [dict create idx $idx category "Conclusion" statement "TimeLessLaw triggers clarity-logic path" weight "0.9068" quibble "Same score as Rule 1"] ; incr idx
    lappend RowList [dict create idx $idx category "Conclusion" statement "Default: traditional methods may suffice" weight "0.7750" quibble "Default fires when no belief asserted"] ; incr idx

    # Remaining Marletto Protocol, postscript addendums, Add-ons if needed
    lappend RowList [dict create idx $idx category "Marletto Add-on." statement "MirrorTest assumes lab feasibility" weight ".05" quibble "Mirror entanglement at scale remains unverified"] ; incr idx
    lappend RowList [dict create idx $idx category "Marletto Add-on." statement "TimeLessLaw ignores observer frame" weight ".05" quibble "Timeless laws still require reference frame"] ; incr idx

    # Audit Row
    set PosScore [ComputeProgScore]
    set AltScore [ComputeAltScore]
    set CfactScore [ComputeCfactScore]
    set GapScore [expr {$PosScore - $AltScore}]
    lappend RowList [dict create idx "Audit" category "Audit" \
        statement [format "Pos %.4f  Alt %.4f  Cfact %.4f  Gap %.4f" $PosScore $AltScore $CfactScore $GapScore] \
        weight "composite" quibble "Marletto counterfactuals included"]

    return $RowList
}

# ============================================================
# PROC: PrintTextTable  (14 chars)
# ============================================================
proc PrintTextTable {} {
    set RowList [BuildTableRows]
    set SEP [string repeat "-" 85]

    puts "\n=== Axiom Engine Results: Plain Text Table ===\n"
    puts $SEP
    puts [format "%-6s %-16s %-38s %-9s %-28s" "Index" "Category" "Statement" "Weight" "Quibble Notes"]
    puts $SEP

    foreach RowDict $RowList {
        puts [format "%-6s %-16s %-38s %-9s %-28s" \
            [dict get $RowDict idx] \
            [dict get $RowDict category] \
            [dict get $RowDict statement] \
            [dict get $RowDict weight] \
            [dict get $RowDict quibble]]
    }
    puts $SEP
}

# ============================================================
# PROC: PrintWikiTable  (14 chars)
# ============================================================
proc PrintWikiTable {} {
    set RowList [BuildTableRows]

    puts "\n=== Axiom Engine Results: Wiki Table Format ===\n"
    puts {%| Index | Category | Statement | Weight | Quibble Notes |%}

    foreach RowDict $RowList {
        puts "&| [dict get $RowDict idx] | [dict get $RowDict category] | [dict get $RowDict statement] | [dict get $RowDict weight] | [dict get $RowDict quibble] |&"
    }
    puts ""
}

# ============================================================
# PROC: WriteResultFile (14 chars)
# ============================================================
proc WriteResultFile {} {
    set TimeStamp [clock format [clock seconds] -format %Y-%m-%d_%H-%M-%S]
    set OutputFile "AxiomEngineResult_${TimeStamp}.txt"

    if {[catch {
        set fh [open $OutputFile w]
        puts $fh "AxiomEngine.tcl -- Session Output"
        puts $fh "Timestamp: $TimeStamp"
        puts $fh "================================================\n"

        global AxiomWeightMap BeliefStoreMap
        puts $fh "=== Axiom Weights ==="
        dict for {k v} $AxiomWeightMap {
            puts $fh [format "  %-26s : %.2f" $k $v]
        }

        puts $fh "\n=== Composite Scores ==="
        puts $fh [format "  Positive   : %.4f" [ComputeProgScore]]
        puts $fh [format "  Contrast   : %.4f" [ComputeAltScore]]
        puts $fh [format "  Marletto   : %.4f" [ComputeCfactScore]]

        close $fh
        puts "\nResults saved to: $OutputFile"
    } err]} {
        puts "Warning: Could not save result file - $err"
    }
}

# ============================================================
# MAIN EXECUTION
# ============================================================

puts "\nAxiomEngine.tcl -- Semantic Axiom Inference Engine"
puts "With Marletto Counterfactual Support"
puts "================================================\n"

LoadAxiomData
DisplayAxiomMap
CompareApproach

puts "\n--- Running inference now ---"

InferConclusion
WriteResultFile
PrintTextTable
PrintWikiTable

puts "\n=== Session Complete ==="
puts "Marletto counterfactuals have been integrated as possible transformations."

# ============================================================
# End of Program
# ============================================================
 

# References.
# Inspired by counterfactual principles discussed in Chiara Marletto's book
# "The Science of Can and Can't: A Physicist's Journey Through the Land of Counterfactuals" (2021).
# No text, quotes, or direct examples from the book are used in this code.
# The subroutine(s) implements a generic weighted scoring mechanism that 
# loosely draws on the high-level principle that possible transformations
# can reveal hidden assumptions. 
# The dummy subroutine implements a generic axiom for educational purposes only.
# 4/26/2026
# ============================================================
# MAIN EXECUTION BLOCK
# The block below runs the full consultation in sequence:
# 1. Load axiom data into memory.
# 2. Display the axiom library for operator review.
# 3. Compare positive, contrast, and counterfactual ratings.
# 4. Run forward-chaining inference and print conclusions.
# 5. Write the session results to a timestamped output file.
# 6. Print plain-text table, wiki table, write table file.
# Note: no user interaction; all beliefs default to unasserted;
# the default inference rule fires automatically.
# ============================================================

puts "\nAxiomEngine.tcl -- Semantic Axiom Inference Engine"
puts "Tcl version: [info patchlevel]"
puts "================================================\n"

LoadAxiomData
DisplayAxiomMap
CompareApproach

puts "\n--- Axiom weights loaded. Running inference now. ---"

InferConclusion
WriteResultFile

PrintTextTable
PrintWikiTable
WriteTableFile

puts "\n=== Session Complete ==="
puts "The engine applied weighted axioms and asserted beliefs"
puts "to reach minimal, auditable conclusions via forward chaining."
puts "Table output includes axioms, M. P. counterfactuals, conclusions,"
puts "Marletto P. Add-ons, and an audit row."

# ============================================================
# End of AxiomEngine.tcl
# ============================================================
 

# Recommended: Use a dictionary (best practice)
set TokenRelationDict [dict create]
#  Positive axioms from programming domain example:
dict set TokenRelationDict "Prog->Und"  0.95
dict set TokenRelationDict "Prog->Prec" 0.92
dict set TokenRelationDict "Prog->Clar" 0.89
dict set TokenRelationDict "Prog->Log"  0.85
dict set TokenRelationDict "Prog⊥Amb"   0.90
# Contrast Axioms 
dict set TokenRelationDict "Hum->Flaw"  0.80
dict set TokenRelationDict "Paper->Err" 0.75
#
# New Counterfactual Axioms (Forward Logic Only)
dict set TokenRelationDict "Prog->ExposeTrans"     0.87   ;# Programming enables exposing transformations
dict set TokenRelationDict "Prog->BlockAmbigHide"  0.84   ;# Programming blocks ambiguity hiding
dict set TokenRelationDict "Prog->AllowRepeatTrans" 0.86   ;# Programming allows repeatable transformations
#
proc GetTokenWeight {fromToken toToken} {
    global TokenRelationDict
    set key "$fromToken->$toToken"
    if {[dict exists $TokenRelationDict $key]} {
        return [dict get $TokenRelationDict $key]
    }
    return 0.0
}

# Usage examples:
puts [GetTokenWeight "Prog" "Und"]   ;# → 0.95
puts [GetTokenWeight "Prog" "Prec"]  ;# → 0.92

# Snippet for average score.
set total 0.0
foreach item $items {
    set total [expr {$total + [dict get $item weight] * [dict get $item value]}]
}
set avg [expr {$total / $count}]

# Snippet for average score.

set total 0.0
set weightSum 0.0
foreach item $items {
    set w [dict get $item weight]
    set v [dict get $item value]
    set total [expr {$total + $w * $v}]
    set weightSum [expr {$weightSum + $w}]
}
set avg [expr {$weightSum > 0 ? $total / $weightSum : 0.0}]

# Pseudocode for TCL, 4/29/2026

Example: “Beam splitter present; single photon enters.”

1. Five “possible” counterfactuals fire:
   - BS → Path = +0.95   (path superposition possible)
   - BS → Sup  = +0.94   (quantum superposition)
   - BS → Int  = +0.92   (interference enabled)
   - BS → Rev  = +0.90   (unitary reversibility preserved)
   - BS → Det  = +0.88   (measurement resolves outcome)

2a. Then,  Five “impossible” counterfactuals fire:
   -   BS → NoClone = −0.96   (perfect cloning of the photon state impossible)
   -   BS → NoSimul = −0.94   (simultaneous precise path and phase knowledge impossible)
   -   BS → NoErase = −0.92   (information erasure without thermodynamic cost impossible)
   -   BS → NoDual = −0.90    (contradictory paths both realized with full distinguishability impossible)
   -   BS → NoHidden = −0.88  (local hidden-variable completion of the superposition impossible)


2b. Alternate text for "more CT. task heavy flavor": Then,  Five “impossible” counterfactuals fire:
   -   BS → Clone = −0.96        (constructor cannot perfectly clone the post-beam-splitter photon state)
   -   BS → Distinguish = −0.94  (constructor cannot simultaneously distinguish path and preserve phase for interference)
   -   BS → Erase = −0.92        (constructor cannot erase which-path information without irreversible cost)
   -   BS → Dual = −0.90         (constructor cannot realize both full path distinguishability and full interference)
   -   BS → Complete = −0.88     (constructor cannot embed the behavior in local hidden variables)



3. Then, Two parallel math paths are computed:

   4. Three quantities feed both plural math paths (conjectured values):
     PositiveScore =  +0.9180
     ContrastScore =  −0.9200
     CfactScore    =  +0.8400   ← revised conjecture (sign flipped to positive)

   alternative_path_1 — Arithmetic Mean (normalized, "per-axiom" view):
     ArithNet = (PositiveScore + ContrastScore + CfactScore) / 3
              = (+0.9180 + (−0.9200) + (+0.8400)) / 3
              = +0.8380 / 3
              = +0.2793
     → Moderate-to-strong lean toward POSSIBLE.
       CfactScore now pulls the mean decisively positive;

   alternative_path_2 — Geometric Mean (magnitude-weighted, "joint strength" view):
     product  = PositiveScore × ContrastScore × CfactScore
              = (+0.9180) × (−0.9200) × (+0.8400)
              = −0.7094   (one negative → product is negative)
     GeoNet   = −cbrt(0.7094)
              = −0.8921
     → Strongly negative; only one negative term in the product.

5. The inference engine summarizes plural math paths:
    - ArithNet (+0.2793) now carries a clear positive signal;
    - GeoNet   (−0.8921) reads strongly negative  

   The divergence between paths is again conspicuous.
   Signs were arbitrary in initial states.
   Results are very tricky on how +/- assigned to counterfactuals
  
   - ArithNet is positive  (leans possible)
   - GeoNet   is negative  (leans impossible)
   
----
   Even if each path is wrong in some corner cases,
   having multiple math paths improves robustness
   and exposes where the reasoning is fragile.

# Pseudocode for TCL, 5/1/2026

Example: “Solar oven present; sunlight  enters cavity, many photons.”

1. Five “possible” counterfactuals fire:
   - SO -> Capture = +0.95   (sunlight capture possible)
   - SO -> Retain  = +0.94   (heat retention possible)
   - SO -> Absorb  = +0.92   (black target absorption possible)
   - SO -> RaiseT  = +0.90   (internal temperature rise possible)
   - SO -> Cook    = +0.88   (cooking / drying task possible)

2. Five “impossible” counterfactuals fire:
   - SO -> NoLossLossless = -0.96   (perfectly lossless thermal trapping impossible)
   - SO -> NoInfiniteTemp = -0.94   (infinite temperature rise impossible)
   - SO -> NoInstantHeat  = -0.92   (instant uniform heating impossible)
   - SO -> NoZeroLossUse  = -0.90   (zero-loss use of all incoming sunlight impossible)
   - SO -> NoReverseHeat  = -0.88   (spontaneous reverse heating impossible)

3. Then, two parallel math paths are computed.

4. Three quantities feed both plural math paths (conjectured values):
   PositiveScore =  +0.9180
   ContrastScore =  -0.9200
   CfactScore    =  +0.8400   ← revised conjecture (sign flipped to positive)

   alternative_path_1 — Arithmetic Mean (normalized, "per-axiom" view):
     ArithNet = (PositiveScore + ContrastScore + CfactScore) / 3
              = (+0.9180 + (−0.9200) + (+0.8400)) / 3
              = +0.8380 / 3
              = +0.2793
     → Moderate-to-strong lean toward POSSIBLE.
       The solar oven still works as a heat-gain device despite losses.

   alternative_path_2 — Geometric Mean (magnitude-weighted, "joint strength" view):
     product  = PositiveScore × ContrastScore × CfactScore
              = (+0.9180) × (−0.9200) × (+0.8400)
              = −0.7094
     GeoNet   = −cbrt(0.7094)
              = −0.8921
     → Strongly negative; one negative term dominates the joint product.
       This path emphasizes the no-go constraints more strongly.

5. The inference engine summarizes plural math paths:
   - ArithNet (+0.2793) now carries a clear positive signal.
   - GeoNet   (−0.8921) reads strongly negative.

   The divergence between paths is conspicuous.
   Signs are heuristic in the initial state.
   Results are sensitive to how +/− are assigned to counterfactuals.

   - ArithNet is positive  (leans possible).
   - GeoNet   is negative  (leans impossible).

   Even if each path is wrong in some corner cases,
   having multiple math paths improves robustness
   and exposes where the reasoning is fragile.

# Semantic  Mini LLM Rreasoning Inference Engine,  V8
# Tcl 8.6 or greater required
# Naming convention: all proc and variable names are 12-15
# characters, descriptive, and domain-neutral so the engine
# can serve any subject area without modification.
# 
# ----
# Compatible with Tcl/Tk (Tool Control Language / Toolkit) 8.6+
# Written for Windows 11 on ActiveState Tcl.
# Use Pure 7-bit 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.
# Proc names and variables names need to be very human readable
# and very explanatory. 
# Avoid variables with single letter names. 
# Whereas single letter names are known to lead
# to many historic errors. 
# Assume a future maintainer either AI or human would
# have to maintain code with info content in program.
#
# This is a hacker's patch, not rigorously derived.
# appears correct solutions for autotests.
# TCL Club 5/5/2026 
#
#
# ============================================================
# FILE: token_inference.tcl
# PURPOSE: Two-pass token inference with softmax and temperature.
#          Mimics AI model probability-chain logic using a small
#          token set (target range: 60 to 200 tokens).
#          Fully self-contained. No external files. No libraries.
#          All text is strict 7-bit ASCII (codes 32 through 126).
#
# HOW THIS PROGRAM WORKS - READ BEFORE CHANGING ANYTHING:
#
#   STEP 1 - BASE EVIDENCE TABLE
#     Each token starts with an observed signal strength (0.0-1.0).
#     Think of each token as a word in a short AI context window.
#     A value near 1.0 means strong evidence. Near 0.0 means absent.
#
#   STEP 2 - FORWARD PROPAGATION (runs twice)
#     Tokens spread their signal to linked neighbor tokens.
#     Each link has a weight controlling how much signal flows.
#     Running two passes lets indirect effects accumulate.
#     Example: heat->dry->fuel->damage accumulates over two passes.
#
#   STEP 3 - SCORE EACH CONCLUSION (LOGITS)
#     Each conclusion has a list of relevant tokens with weights.
#     Score equals a weighted average of those token values in
#     the final state. This is analogous to computing logits
#     before softmax in an LLM.
#
#   STEP 4 - SOFTMAX WITH TEMPERATURE
#     Converts raw scores to probabilities that sum to 1.0.
#     Low temperature (e.g. 0.30) sharpens: winner gets very high prob.
#     High temperature (e.g. 1.0) flattens: scores become more equal.
#
#   STEP 5 - DECISION
#     Pick the conclusion with the highest probability.
#     If that probability is below the threshold, output UNCERTAIN.
#
#   STEP 6 - FILE OUTPUT (NEW IN V8)
#     WriteToTapeFile saves the softmax table and wiki table to disk.
#     The output filename includes a timestamp so each run produces
#     a unique file and no prior run is overwritten.
#     Example output filename: inference_out_20260505_143022.txt
#
# MAINTAINER NOTES:
#   - Variable names are 12-15 characters, fully descriptive.
#   - No single-letter variable names anywhere in this file.
#   - Proc names are 13-15 characters, action-verb style.
#   - To change the scenario: edit SECTION 1, 2, and 3 only.
#   - Temperature and threshold are set just before STEP 4 and 5.
#   - To change the output folder: edit tapeOutputDir in STEP 9.
# ============================================================
console show


# ============================================================
# SECTION 1 - BASE TOKEN EVIDENCE TABLE
#
# Each entry: token_name => starting signal value (0.0 to 1.0)
# These represent observed conditions before any propagation.
# Change these values to model a different input scenario.
# Example: setting tok_rain_amt to 0.90 simulates heavy rain.
# ============================================================
set baseEvidTable [dict create \
    tok_heat_level  0.820 \
    tok_dry_cond    0.750 \
    tok_wind_speed  0.480 \
    tok_smoke_sig   0.310 \
    tok_spark_event 0.600 \
    tok_fuel_amount 0.700 \
    tok_rain_amount 0.040 \
    tok_humidity    0.090 \
    tok_cloud_cover 0.150 \
    tok_damage_lvl  0.000 \
    tok_flood_level 0.000 \
    tok_lightning   0.200 \
]


# ============================================================
# SECTION 2 - FORWARD PROPAGATION LINK TABLE
#
# Format: source_token { target_token link_weight ... }
# link_weight controls what fraction of source value flows over.
# Example: tok_heat_level 0.55 means 55 percent flows to target.
# Add new links here to model new causal or associative paths.
# A token not listed as a source key does not push to others.
# ============================================================
set fwdLinkTable [dict create \
    tok_heat_level  {tok_dry_cond  0.55  tok_spark_event 0.40} \
    tok_dry_cond    {tok_fuel_amount 0.50  tok_spark_event 0.35} \
    tok_wind_speed  {tok_spark_event 0.45  tok_smoke_sig  0.30  tok_damage_lvl 0.25} \
    tok_spark_event {tok_damage_lvl 0.85  tok_smoke_sig  0.60} \
    tok_lightning   {tok_spark_event 0.70  tok_damage_lvl 0.40} \
    tok_rain_amount {tok_humidity   0.75  tok_flood_level 0.50  tok_cloud_cover 0.45} \
    tok_humidity    {tok_cloud_cover 0.40  tok_rain_amount 0.30} \
    tok_fuel_amount {tok_damage_lvl 0.50} \
]


# ============================================================
# SECTION 3 - CONCLUSION SCORING RULE TABLE
#
# Format: conclusion_name { token_name token_weight ... }
# token_weight says how important that token is for this outcome.
# Score for each conclusion equals a weighted average of token values.
# Add new conclusions here without changing any procedure code.
# ============================================================
set conclRuleTable [dict create \
    concl_fire_hi  {tok_heat_level 0.90  tok_dry_cond   0.85  tok_spark_event 0.95 \
                    tok_wind_speed 0.55  tok_fuel_amount 0.75  tok_smoke_sig  0.60} \
    concl_fire_lo  {tok_rain_amount 0.90  tok_humidity  0.80  tok_cloud_cover 0.55} \
    concl_flood    {tok_rain_amount 0.95  tok_flood_level 0.90  tok_humidity  0.65 \
                    tok_cloud_cover 0.50} \
    concl_storm    {tok_wind_speed 0.80  tok_cloud_cover 0.75  tok_humidity  0.55 \
                    tok_lightning  0.70} \
    concl_drought  {tok_heat_level 0.75  tok_dry_cond   0.90  tok_wind_speed 0.40} \
    concl_damage   {tok_damage_lvl 0.95  tok_spark_event 0.70  tok_wind_speed 0.60 \
                    tok_lightning  0.65} \
    concl_normal   {tok_humidity  0.50  tok_cloud_cover 0.50  tok_rain_amount 0.40} \
]


# ============================================================
# PROCEDURE: ForwardOnePass
#
# PURPOSE:
#   Run one forward propagation pass over the token state table.
#   For each source token, compute how much signal flows to each
#   linked target token and add that amount to the target's current
#   value. Values are clamped to 1.0 so they never exceed the
#   maximum signal level.
#
# ARGUMENTS:
#   currStateDict  - dict mapping token name to current value
#   linkRuleTable  - dict mapping source token to target+weight list
#
# RETURNS:
#   newStateDict   - updated dict with propagated token values
#
# SIDE EFFECTS: none (input dict is not modified)
# ============================================================
proc ForwardOnePass {currStateDict linkRuleTable} {

    # Start with a copy so the caller's data is not modified.
    set newStateDict $currStateDict

    dict for {sourceTokName targetPairList} $linkRuleTable {

        # Get the current signal strength of this source token.
        set sourceTokValue [dict get $currStateDict $sourceTokName]

        # Walk through each target-token and weight pair in the list.
        foreach {targetTokName linkWeight} $targetPairList {

            # Get the target token's current value before this pass.
            set priorTokValue 0.0
            if {[dict exists $newStateDict $targetTokName]} {
                set priorTokValue [dict get $newStateDict $targetTokName]
            }

            # Compute how much signal flows from source to target.
            set addedInfluence [expr {$sourceTokValue * $linkWeight}]

            # Add the propagated signal to what was already there.
            set newTokValue [expr {$priorTokValue + $addedInfluence}]

            # Clamp to 1.0: signal strength cannot exceed maximum.
            if {$newTokValue > 1.0} {
                set newTokValue 1.0
            }

            dict set newStateDict $targetTokName $newTokValue
        }
    }

    return $newStateDict
}


# ============================================================
# PROCEDURE: SoftmaxNormRun
#
# PURPOSE:
#   Convert a dict of raw scores (logits) into probabilities
#   using the softmax function with a temperature scale factor.
#   All output probabilities are positive and sum to exactly 1.0.
#
# ARGUMENTS:
#   rawScoreDict   - dict of label to raw floating-point score
#   tempSetValue   - temperature: lower = sharper, higher = flatter
#                   Typical range: 0.10 (very sharp) to 2.0 (flat)
#
# RETURNS:
#   probOutputDict - dict of label to normalized probability
#
# MATH NOTE:
#   softmax(x_i) = exp(x_i / T) / sum_j( exp(x_j / T) )
#   where T is the temperature scale value.
#   exp() is the natural exponential function (e raised to a power).
# ============================================================
proc SoftmaxNormRun {rawScoreDict tempSetValue} {

    set expRunningSum 0.0
    set tempExpValDict {}

    # First pass: compute exp(score/temperature) for every label.
    dict for {conclusLabel rawScore} $rawScoreDict {

        set scaledScoreVal [expr {$rawScore / $tempSetValue}]
        set expCalcValue   [expr {exp($scaledScoreVal)}]

        dict set tempExpValDict $conclusLabel $expCalcValue

        # Accumulate the denominator for normalization.
        set expRunningSum [expr {$expRunningSum + $expCalcValue}]
    }

    # Second pass: divide each exp value by the total to normalize.
    set probOutputDict {}

    dict for {conclusLabel expCalcValue} $tempExpValDict {
        set probCalcValue [expr {$expCalcValue / $expRunningSum}]
        dict set probOutputDict $conclusLabel $probCalcValue
    }

    return $probOutputDict
}


# ============================================================
# PROCEDURE: WriteToTapeFile
#
# PURPOSE:
#   Write the complete run results to a plain-text file on disk.
#   The file contains two sections: the softmax probability table
#   in human-readable columnar format, and the wiki table in the
#   %| header |% and &| data |& markup format.
#   The output filename is built from the supplied timestamp string
#   so that each run produces a unique file.
#   Example filename: inference_out_20260505_143022.txt
#
# ARGUMENTS:
#   tapeOutputDir  - full path to the folder where the file is saved
#                   Example: C:/Users/Public/inference_logs
#                   Use forward slashes on all platforms.
#   timeStampStr   - timestamp string appended to the filename
#                   Format: YYYYMMDD_HHMMSS (year month day _ hour
#                   minute second). Example: 20260505_143022
#   sortedOutList  - flat list of {conclusLabel probValue ...} pairs
#                   sorted descending by probability, as returned by
#                   lsort -stride 2 -index 1 -real -decreasing
#   finalDecision  - string holding the winning conclusion label,
#                   or "UNCERTAIN DECISION < THRESHOLD" if too low
#   topConclusProb - floating-point probability of the top conclusion
#   tempSetValue   - temperature value used in this run
#   minThreshHold  - minimum probability threshold used in this run
#
# RETURNS:
#   tapeFilePath   - the full path of the file that was written
#
# SIDE EFFECTS:
#   Creates or overwrites one file in tapeOutputDir.
#   Prints a confirmation line to the console.
# ============================================================
proc WriteToTapeFile {tapeOutputDir timeStampStr sortedOutList \
                      finalDecision topConclusProb \
                      tempSetValue  minThreshHold} {

    # Build the full output file path from folder and timestamp.
    # The filename pattern is inference_out_TIMESTAMP.txt
    set tapeFilePath [file join $tapeOutputDir \
                          "inference_out_${timeStampStr}.txt"]

    # Open the file for writing. The "w" flag creates the file
    # if it does not exist and overwrites if it does.
    set tapeFileHandle [open $tapeFilePath w]

    # --------------------------------------------------------
    # TAPE SECTION A - PLAIN TEXT SOFTMAX TABLE
    # --------------------------------------------------------
    puts $tapeFileHandle "=== SOFTMAX PROBABILITIES ==="
    puts $tapeFileHandle [format "Run timestamp : %s" $timeStampStr]
    puts $tapeFileHandle ""

    foreach {conclusLabel probValue} $sortedOutList {
        puts $tapeFileHandle \
            [format "%-18s  %.4f" $conclusLabel $probValue]
    }

    # --------------------------------------------------------
    # TAPE SECTION B - PLAIN TEXT FINAL DECISION SUMMARY
    # --------------------------------------------------------
    puts $tapeFileHandle ""
    puts $tapeFileHandle "=== FINAL DECISION ==="
    puts $tapeFileHandle [format "Decision   : %s"   $finalDecision]
    puts $tapeFileHandle [format "Top Prob   : %.4f" $topConclusProb]
    puts $tapeFileHandle [format "Temp Scale : %.2f" $tempSetValue]
    puts $tapeFileHandle [format "Min Thresh : %.2f" $minThreshHold]

    # --------------------------------------------------------
    # TAPE SECTION C - WIKI TABLE FORMAT
    #
    # Header rows use the %| Column | Column |% markup.
    # Data rows use the &| value  | value  |& markup.
    # This format matches the Tcl wiki table specification at
    # https://wiki.tcl-lang.org/page/Snippets+Concepts+Inference+Engine
    # --------------------------------------------------------
    puts $tapeFileHandle ""
    puts $tapeFileHandle "%| Conclusion | Probability |%"

    foreach {conclusLabel probValue} $sortedOutList {
        puts $tapeFileHandle \
            [format "&| %-18s | %.4f |&" $conclusLabel $probValue]
    }

    puts $tapeFileHandle "&| AUDIT WINDOW = FINAL DECISION | VALUE |&"
    puts $tapeFileHandle \
        [format "&| %-18s | %.4f |&" $finalDecision $topConclusProb]

    # Close the file handle to flush all buffered data to disk.
    # Failing to close the handle is a known cause of truncated files.
    close $tapeFileHandle

    # Confirm to the console that the tape file was saved.
    puts "Tape file saved: $tapeFilePath"

    return $tapeFilePath
}


# ============================================================
# STEP 1 - RUN TWO PROPAGATION PASSES
#
# Pass 1 fires all direct one-hop links.
# Pass 2 fires again so two-hop indirect paths accumulate.
# Two passes approximate a deeper graph traversal cheaply
# and are sufficient for the small token sets targeted here.
# ============================================================
set afterPass1State [ForwardOnePass $baseEvidTable   $fwdLinkTable]
set afterPass2State [ForwardOnePass $afterPass1State $fwdLinkTable]

# The second pass result is the final propagated token state.
set finalStateDict  $afterPass2State


# ============================================================
# STEP 2 - COMPUTE RAW CONCLUSION SCORES (LOGITS)
#
# For each conclusion: weighted average of its relevant tokens.
# Tokens not present in finalStateDict are treated as 0.0.
# This mirrors how an LLM computes a raw logit before softmax.
# ============================================================
set rawScoreTable {}

dict for {conclusLabel ruleTokenList} $conclRuleTable {

    set weightedTotal 0.0
    set totalWeights  0.0

    foreach {tokenName tokenWeight} $ruleTokenList {

        set observedValue 0.0
        if {[dict exists $finalStateDict $tokenName]} {
            set observedValue [dict get $finalStateDict $tokenName]
        }

        set weightedTotal [expr {$weightedTotal + ($observedValue * $tokenWeight)}]
        set totalWeights  [expr {$totalWeights  + $tokenWeight}]
    }

    # Normalize by total weight to keep scores in the 0.0-1.0 range.
    set normalizedScore [expr {$weightedTotal / $totalWeights}]
    dict set rawScoreTable $conclusLabel $normalizedScore
}


# ============================================================
# STEP 3 - SOFTMAX NORMALIZATION WITH TEMPERATURE
#
# tempSetValue = 0.30 produces a sharp distribution.
# Raising toward 1.0 gives a softer result. Lowering gives harder.
# ============================================================
set tempSetValue 0.30

set probResultTable [SoftmaxNormRun $rawScoreTable $tempSetValue]


# ============================================================
# STEP 4 - ARGMAX: FIND THE HIGHEST PROBABILITY CONCLUSION
# ============================================================
set topConclusName ""
set topConclusProb -1.0

dict for {conclusLabel probValue} $probResultTable {
    if {$probValue > $topConclusProb} {
        set topConclusProb $probValue
        set topConclusName $conclusLabel
    }
}


# ============================================================
# STEP 5 - APPLY DECISION THRESHOLD CUTOFF
#
# If the top probability falls below minThreshHold then the
# evidence is too ambiguous to name a conclusion confidently.
# Output "UNCERTAIN DECISION < THRESHOLD" in that case rather
# than reporting a weak guess as a firm answer.
# ============================================================
set minThreshHold 0.40

if {$topConclusProb >= $minThreshHold} {
    set finalDecision $topConclusName
} else {
    set finalDecision "UNCERTAIN DECISION < THRESHOLD"
}


# ============================================================
# STEP 6 - SORT ALL CONCLUSIONS BY PROBABILITY DESCENDING
#
# lsort options explained:
#   -stride 2   : treat the flat list as {label prob label prob}
#   -index 1    : sort by the second element of each pair (prob)
#   -real       : numeric floating-point comparison
#   -decreasing : highest probability first
# ============================================================
set sortedOutList [lsort -decreasing -real -stride 2 -index 1 \
    $probResultTable]


# ============================================================
# STEP 7 - PRINT SOFTMAX PROBABILITY TABLE TO CONSOLE
# ============================================================
puts "=== SOFTMAX PROBABILITIES ==="

foreach {conclusLabel probValue} $sortedOutList {
    puts [format "%-18s  %.4f" $conclusLabel $probValue]
}


# ============================================================
# STEP 8 - PRINT FINAL DECISION SUMMARY TO CONSOLE
# ============================================================
puts ""
puts "=== FINAL DECISION ==="
puts [format "Decision   : %s"   $finalDecision]
puts [format "Top Prob   : %.4f" $topConclusProb]
puts [format "Temp Scale : %.2f" $tempSetValue]
puts [format "Min Thresh : %.2f" $minThreshHold]


# ============================================================
# STEP 9 - PRINT WIKI TABLE FORMAT TO CONSOLE
#
# Header rows use:  %| Column | Column |%
# Data rows use:    &| value  | value  |&
# This format matches the attached wiki table specification at
# https://wiki.tcl-lang.org/page/Snippets+Concepts+Inference+Engine
# ============================================================
puts ""
puts "%| Conclusion | Probability |%"

foreach {conclusLabel probValue} $sortedOutList {
    puts [format "&| %-18s | %.4f |&" $conclusLabel $probValue]
}

puts "&| AUDIT WINDOW = FINAL DECISION | VALUE |&"
puts [format "&| %-18s | %.4f |&" $finalDecision $topConclusProb]


# ============================================================
# STEP 10 - WRITE ALL OUTPUT TO LOCAL TAPE FILE
#
# tapeOutputDir sets the folder where the file is written.
# Change this path to any writable folder on the local machine.
# The folder must already exist; this code does not create it.
# Example for Windows 11: C:/Users/Public/inference_logs
# Example for a project subfolder: [pwd]/logs
#
# The timestamp is built from the system clock using Tcl's
# built-in clock commands. No external library is required.
# clock seconds returns the current Unix epoch integer.
# clock format converts that integer to a human-readable string.
# The format string %Y%m%d_%H%M%S produces YYYYMMDD_HHMMSS.
# Example result: 20260505_143022
#
# WriteToTapeFile is called with all computed results so that
# the tape file exactly matches what was printed to the console.
# ============================================================
set tapeOutputDir  [pwd]

set epochSeconds   [clock seconds]
set timeStampStr   [clock format $epochSeconds -format {%Y%m%d_%H%M%S}]

set tapeFilePath [WriteToTapeFile \
    $tapeOutputDir  \
    $timeStampStr   \
    $sortedOutList  \
    $finalDecision  \
    $topConclusProb \
    $tempSetValue   \
    $minThreshHold  \
]

puts [format "Run complete. Output file: %s" $tapeFilePath]


# ============================================================
# END OF FILE
# ============================================================

 

   SOFTMAX PROBABILITIES 
concl_fire_hi       0.3685
concl_drought       0.2919
concl_damage        0.1959
concl_storm         0.0488
concl_normal        0.0344
concl_fire_lo       0.0321
concl_flood         0.0283

  FINAL DECISION 
Decision   : UNCERTAIN DECISION < THRESHOLD  
Top Prob   : 0.3685
Temp Scale : 0.30
Min Thresh : 0.40

evidence_tokens → score each conclusion → normalize → top-N conclusions

Object         τ_DP (s)    Experiment  
10 nm diamond  10^4-10^6  Optomechanics  
1 μm silica    0.1-1      Levitated cavities  
10^10 C atoms  10^-3      Fullerene interferometry