# ascii, very close to pseudocode needed
 
T' = A-(T)

an axiom vector

a = (a1, a2, ..., an)

an inference vector

p = (p1, p2, ..., pm)

 
A-_k(a) = (a1, a2, ..., 0, ..., an)

a new inference vector

p' = F(a')

cosine similarity score:

S_k = (p dot p') / (||p|| * ||p'||)
K_k = 1 - S_k
----
DEMO: AXIOM REMOVAL AS FORMAL OPERATOR A^-

1. Simple Theory Model
----------------------
Let theory T be represented by a set of axioms and their inference consequences.

Example base theory T0 (Fire Risk Domain):

Axioms:
A1: High heat implies increased ignition probability
A2: Dry conditions strengthen spark events
A3: Wind amplifies damage propagation
A4: Spark events cause observable smoke

Inference vector V(T) = [fire_hi, damage, bridge] 
                      = [0.82, 0.31, 0.45]   (normalized strengths)

2. Axiom Removal Operator A^-
----------------------------

Definition:
T' = A^-(T, Ai)   removes axiom Ai from T

Effect on inference vector:
V(T') = M_i * V(T)

Where M_i is a reduction matrix for removing axiom i.

Simple 3x3 demo matrices (illustrative):

Remove A1 (heat): 
M1 = | 0.6  0.0  0.0 |
     | 0.0  1.0  0.0 |
     | 0.0  0.0  0.9 |

Remove A3 (wind): 
M3 = | 1.0  0.0  0.0 |
     | 0.0  0.7  0.0 |
     | 0.0  0.0  0.4 |

3. Demo Calculation
-------------------

Original:   V0 = [0.82, 0.31, 0.45]

After removing heat axiom (A^- on A1):
V1 = M1 * V0 = [0.492, 0.31, 0.405]

After removing wind axiom (A^- on A3):
V3 = M3 * V0 = [0.82, 0.217, 0.18]

Change magnitude (stability measure):
Delta(A1) = ||V1 - V0|| = 0.341
Delta(A3) = ||V3 - V0|| = 0.312

Higher Delta = higher "curvature" when removing that axiom.

4. Differential Geometry Analogy
--------------------------------
Think of theories as points in inference space.
A^- is like a directional derivative.

Curvature K(Ai) ≈ |Delta(V) / strength_of_Ai|

High curvature axioms are "load-bearing"
- removing them violently reorganizes the inference space.

5. DFT on Inference Vectors (Snippet Concepts DFT on Inference Vectors )
---------------------------------------------
Apply Discrete Fourier Transform to sequence of reduced theories:

Let sequence S = [V(T), V(A^-(T,A1)), V(A^-(T,A2)), ...]

DFT reveals dominant "frequencies" of inference change 
- i.e. which axiom removals cause low-frequency (stable)
vs high-frequency (chaotic) shifts in conclusions.

Low-frequency components = robust core theory
High-frequency components = brittle, axiom-sensitive parts

Bottom Line:
The operator A^- turns axiom removal into a clean mathematical object.
We can measure how much a theory "bends" when constraints are removed.
This gives a quantitative way to find the minimal stable core of any theory.

This demo uses linear algebra for simplicity.
Real versions could use logic lattices
or vector embeddings of propositions.

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)

Newtonian-style vector (concl_fire_hi, concl_damage — classical accumulation)  
Quantum/Leftover vector (lft_dmg_bridge, irreversibility signals, maybe "hidden" Quantum rules)

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

# Semantic  Mini LLM Reasoning Inference Engine,  V15b
# 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 Command 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.
# ----
# Using modular snippets inside modular structured programs.
# Modules should be 15 to 25 lines long without comments.
# Small length modules 
# are believed to aid future  code maintenance.  
# Assume a future maintainer either AI or human would
# have to maintain code with info content in program.
# This is Experimenting Draft,
# and not a replacement for TCL Core. 
# This is a hacker's patch, not rigorously derived.
# appears correct solutions for autotests.
# TCL Club 6/27/2026 
# 
array set baseEvidTable {
    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_rain_amount  0.040
    tok_humidity     0.090
    tok_cloud_cover  0.150
    tok_flood_level  0.000
    tok_lightning    0.200
    tok_fuel_amount  0.700
    tok_damage_lvl   0.000
}

array set fwdLinkTable {
    tok_heat_level   {{tok_dry_cond 0.55} {tok_spark_event 0.40}}
    tok_dry_cond     {{tok_spark_event 0.35} {tok_fuel_amount 0.50}}
    tok_wind_speed   {{tok_spark_event 0.45} {tok_smoke_sig 0.30} {tok_damage_lvl 0.25}}
    tok_spark_event  {{tok_smoke_sig 0.60} {tok_damage_lvl 0.85}}
    tok_lightning    {{tok_spark_event 0.70} {tok_damage_lvl 0.40}}
    tok_rain_amount  {{tok_cloud_cover 0.45} {tok_flood_level 0.50} {tok_humidity 0.75}}
    tok_humidity     {{tok_cloud_cover 0.40} {tok_rain_amount 0.30}}
    tok_fuel_amount  {{tok_damage_lvl 0.50}}
}

set phase1BlockSrcs {tok_spark_event tok_smoke_sig tok_damage_lvl tok_flood_level \
                     tok_wind_speed tok_lightning tok_fuel_amount tok_heat_level \
                     tok_dry_cond tok_cloud_cover tok_humidity}

set phase2BlockSrcs {}

array set conclRuleTable {
    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_damage  {{tok_damage_lvl 0.95} {tok_spark_event 0.20} {tok_wind_speed 0.20} {tok_lightning 0.20}}
}

array set leftoverRuleTable {
    lft_dmg_bridge {{tok_damage_lvl 0.98} {tok_spark_event 0.85} {tok_wind_speed 0.60}}
}

array set positive_cf_group {
    cf_conservation_law     0.88
    cf_observation_support  0.82
    cf_mathematical_fit     0.91
}

array set negative_cf_group {
    cf_paradox_emerges      0.48
    cf_alternative_explain  0.62
    cf_measurement_error    0.41
}

array set alternative_cf_group {
    cf_new_mechanism        0.68
    cf_unobserved_variable  0.59
    cf_different_framework  0.71
}

set bound_confidence_gap 0.75

set convergence_influence_strength 0.30

set convergence_temperature_start 0.25

set convergence_temperature_decay 0.90

set convergence_max_passes 12

set convergence_spread_threshold 0.004

namespace eval ::dft_engine {

    namespace eval token_core {
        namespace path [list ::dft_engine]

        proc safe_get {arrName key {default 0.0}} {
            upvar 1 $arrName arr
            if {[info exists arr($key)]} { return $arr($key) }
            return $default
        }

        proc is_blocked {src blockedList} {
            foreach b $blockedList {
                if {$src eq $b} { return 1 }
            }
            return 0
        }

        proc triangular_weight {n} {
            expr {$n * ($n + 1) / 2.0}
        }

        proc fibonacci_weight {n} {
            if {$n <= 1} { return 1.0 }
            set a 1
            set b 1
            for {set i 2} {$i <= $n} {incr i} {
                set c [expr {$a + $b}]
                set a $b
                set b $c
            }
            return [expr {double($b)}]
        }
    }

    namespace eval propagation {
        namespace path [list ::dft_engine]

        proc phased_linear_pass {stateName linksName blocked} {
            upvar 1 $stateName state $linksName links
            array set new_state [array get state]
            foreach src [array names links] {
                if {[token_core::is_blocked $src $blocked]} { continue }
                set src_val [token_core::safe_get new_state $src 0.0]
                if {$src_val == 0.0} { continue }
                foreach pair $links($src) {
                    lassign $pair tgt weight
                    set prior [token_core::safe_get new_state $tgt 0.0]
                    set update [expr {$prior + $src_val * $weight}]
                    if {$update > 0.999} { set update 0.999 }
                    set new_state($tgt) $update
                }
            }
            array set state [array get new_state]
        }

        proc phased_triangular_pass {stateName linksName blocked} {
            upvar 1 $stateName state $linksName links
            array set new_state [array get state]
            foreach src [array names links] {
                if {[token_core::is_blocked $src $blocked]} { continue }
                set src_val [token_core::safe_get new_state $src 0.0]
                if {$src_val == 0.0} { continue }
                set k 1
                foreach pair $links($src) {
                    lassign $pair tgt weight
                    set prior [token_core::safe_get new_state $tgt 0.0]
                    set tri [token_core::triangular_weight $k]
                    set update [expr {$prior + $src_val * $weight * $tri}]
                    if {$update > 0.999} { set update 0.999 }
                    set new_state($tgt) $update
                    incr k
                }
            }
            array set state [array get new_state]
        }

        proc phased_fibonacci_pass {stateName linksName blocked} {
            upvar 1 $stateName state $linksName links
            array set new_state [array get state]
            foreach src [array names links] {
                if {[token_core::is_blocked $src $blocked]} { continue }
                set src_val [token_core::safe_get new_state $src 0.0]
                if {$src_val == 0.0} { continue }
                set k 1
                foreach pair $links($src) {
                    lassign $pair tgt weight
                    set prior [token_core::safe_get new_state $tgt 0.0]
                    set fib [token_core::fibonacci_weight $k]
                    set update [expr {$prior + $src_val * $weight * $fib}]
                    if {$update > 0.999} { set update 0.999 }
                    set new_state($tgt) $update
                    incr k
                }
            }
            array set state [array get new_state]
        }

        proc phased_linear_pass_raw {stateName linksName blocked} {
            upvar 1 $stateName state $linksName links
            array set new_state [array get state]
            foreach src [array names links] {
                if {[token_core::is_blocked $src $blocked]} { continue }
                set src_val [token_core::safe_get new_state $src 0.0]
                if {$src_val == 0.0} { continue }
                foreach pair $links($src) {
                    lassign $pair tgt weight
                    set prior [token_core::safe_get new_state $tgt 0.0]
                    set update [expr {$prior + $src_val * $weight}]
                    set new_state($tgt) $update
                }
            }
            array set state [array get new_state]
        }
    }

    namespace eval convergence {
        namespace path [list ::dft_engine]

        proc gather_counterfactual_groups {} {
            global positive_cf_group negative_cf_group alternative_cf_group
            return [list [array get positive_cf_group] \
                         [array get negative_cf_group] \
                         [array get alternative_cf_group]]
        }

        proc convergence_update_pass {stateName cfGroupList gapBound \
                influenceStrength passTemperature} {
            upvar 1 $stateName state
            array set new_state [array get state]
            set total_change 0.0
            set token_count 0

            foreach tok [array names state] {
                set current_value [token_core::safe_get new_state $tok 0.0]
                set influence_sum 0.0
                set influence_weight_total 0.0

                foreach one_group $cfGroupList {
                    foreach {cf_name cf_weight} $one_group {
                        set cf_value [token_core::safe_get new_state $cf_name $cf_weight]
                        set gap_amount [expr {abs($current_value - $cf_value)}]
                        if {$gap_amount < $gapBound} {
                            set closeness [expr {1.0 - $gap_amount}]
                            set local_weight [expr {$cf_weight * $closeness}]
                            set influence_sum [expr {$influence_sum + $cf_value * $local_weight}]
                            set influence_weight_total [expr {$influence_weight_total + $local_weight}]
                        }
                    }
                }

                if {$influence_weight_total > 0.0005} {
                    set neighbor_average [expr {$influence_sum / $influence_weight_total}]
                    set noise_amount [expr {($passTemperature * (rand() - 0.5)) * 0.10}]
                    set blended_value [expr {(1.0 - $influenceStrength) * $current_value \
                        + $influenceStrength * $neighbor_average + $noise_amount}]
                } else {
                    set blended_value $current_value
                }

                if {$blended_value > 0.999} { set blended_value 0.999 }
                if {$blended_value < 0.0}   { set blended_value 0.0 }

                set new_state($tok) $blended_value
                set total_change [expr {$total_change + abs($blended_value - $current_value)}]
                incr token_count
            }

            array set state [array get new_state]
            if {$token_count > 0} {
                return [expr {$total_change / double($token_count)}]
            }
            return 0.0
        }

        proc run_convergence_passes {stateName} {
            global bound_confidence_gap convergence_influence_strength \
                   convergence_temperature_start convergence_temperature_decay \
                   convergence_max_passes convergence_spread_threshold
            upvar 1 $stateName state

            set cf_groups [gather_counterfactual_groups]
            set running_temperature $convergence_temperature_start
            set pass_rows {}
            set early_stop_flag 0

            for {set pass_num 1} {$pass_num <= $convergence_max_passes} {incr pass_num} {
                set avg_change [convergence_update_pass state $cf_groups \
                    $bound_confidence_gap $convergence_influence_strength \
                    $running_temperature]

                lappend pass_rows [list $pass_num $avg_change $running_temperature]

                if {$avg_change < $convergence_spread_threshold} {
                    set early_stop_flag 1
                    break
                }
                set running_temperature [expr {$running_temperature * $convergence_temperature_decay}]
            }

            return [list $pass_rows $early_stop_flag]
        }
    }

    namespace eval scoring {
        namespace path [list ::dft_engine]

        proc score_conclusions {stateName rulesName} {
            upvar 1 $stateName state
            upvar #0 $rulesName rules
            array set scores {}
            foreach label [array names rules] {
                set total 0.0
                set wsum 0.0
                foreach pair $rules($label) {
                    lassign $pair tok w
                    set val [token_core::safe_get state $tok 0.0]
                    set total [expr {$total + $val * $w}]
                    set wsum  [expr {$wsum + $w}]
                }
                set scores($label) [expr {$wsum > 0 ? $total / $wsum : 0.0}]
            }
            return [array get scores]
        }
    }

    namespace eval dft_core {
        namespace path [list ::dft_engine]

        proc compute_dft_full {input_signal} {
            set signal_length [llength $input_signal]
            set magnitude_list {}
            set phase_list {}

            for {set freq_index 0} {$freq_index < $signal_length} {incr freq_index} {
                set real_part 0.0
                set imag_part 0.0
                for {set sample_index 0} {$sample_index < $signal_length} {incr sample_index} {
                    set angle_value [expr {-2.0 * acos(-1.0) * $freq_index * $sample_index \
                        / double($signal_length)}]
                    set current_value [lindex $input_signal $sample_index]
                    set real_part [expr {$real_part + $current_value * cos($angle_value)}]
                    set imag_part [expr {$imag_part + $current_value * sin($angle_value)}]
                }
                set mag_value [expr {sqrt($real_part*$real_part + $imag_part*$imag_part)}]
                set phase_value [expr {($mag_value > 1e-9) ? atan2($imag_part, $real_part) : 0.0}]
                lappend magnitude_list $mag_value
                lappend phase_list $phase_value
            }
            return [list $magnitude_list $phase_list]
        }

        proc dft_bin_description {freq_index signal_length} {
            if {$freq_index == 0} {
                return "DC component - total signal energy; overall confidence"
            }
            if {$freq_index == 1} {
                return "Fundamental frequency - primary inference pattern"
            }
            if {$freq_index == ($signal_length - 1)} {
                return "Highest harmonic - high-frequency tail (residual)"
            }
            if {$freq_index <= ($signal_length / 2)} {
                return "Low-mid harmonic - shared variation across the group"
            }
            return "Upper harmonic - mirrored (Hermitian) high-frequency content"
        }

        proc extract_named_values {stateName nameList} {
            upvar 1 $stateName state
            set value_list {}
            foreach one_name $nameList {
                lappend value_list [token_core::safe_get state $one_name 0.0]
            }
            return $value_list
        }
    }

    namespace eval sensitivity_core {
        namespace path [list ::dft_engine]

        proc run_sensitivity_series {tokName delta} {
            global baseEvidTable fwdLinkTable phase1BlockSrcs phase2BlockSrcs
            set base $baseEvidTable($tokName)
            set result_rows {}

            foreach factor {1.0 1.1 0.9} {
                array set s1 [array get baseEvidTable]
                set s1($tokName) [expr {min(0.999, max(0.0, $base * $factor))}]
                array set s1_raw [array get s1]

                propagation::phased_linear_pass s1 fwdLinkTable $phase1BlockSrcs
                array set s2 [array get s1]
                propagation::phased_linear_pass s2 fwdLinkTable $phase2BlockSrcs

                propagation::phased_linear_pass_raw s1_raw fwdLinkTable $phase1BlockSrcs
                array set s2_raw [array get s1_raw]
                propagation::phased_linear_pass_raw s2_raw fwdLinkTable $phase2BlockSrcs

                lappend result_rows [list $s1($tokName) \
                    [token_core::safe_get s1 tok_damage_lvl 0.0] \
                    [token_core::safe_get s2 tok_damage_lvl 0.0] \
                    [token_core::safe_get s1_raw tok_damage_lvl 0.0] \
                    [token_core::safe_get s2_raw tok_damage_lvl 0.0]]
            }
            return $result_rows
        }
    }

    namespace eval io_utils {
        namespace path [list ::dft_engine]
        variable log_channel ""
        variable log_file_path ""

        proc script_home_folder {} {
            set script_path [info script]
            if {$script_path eq ""} {
                return [pwd]
            }
            return [file dirname [file normalize $script_path]]
        }

        proc build_timestamped_log_name {base_label} {
            set home_folder [script_home_folder]
            set stamp_text [clock format [clock seconds] -format "%Y-%m-%d_%H%M%S"]
            return [file join $home_folder "${base_label}_${stamp_text}.log"]
        }

        proc start_log {base_label} {
            variable log_channel
            variable log_file_path
            set log_file_path [build_timestamped_log_name $base_label]
            set log_channel [open $log_file_path w]
            return $log_file_path
        }

        proc emit {msg} {
            variable log_channel
            puts stdout $msg
            if {$log_channel ne ""} {
                puts $log_channel $msg
            }
        }

        proc stop_log {} {
            variable log_channel
            if {$log_channel ne ""} {
                close $log_channel
                set log_channel ""
            }
        }

        proc get_log_file_path {} {
            variable log_file_path
            return $log_file_path
        }
    }

    namespace eval formatters {
        namespace path [list ::dft_engine]

        proc build_dft_wiki_lines {table_title value_list} {
            lassign [dft_core::compute_dft_full $value_list] magnitude_list phase_list
            set signal_length [llength $magnitude_list]

            set lines {}
            lappend lines "\n----"
            lappend lines "** $table_title **"
            lappend lines "----"
            lappend lines "%| Index | Amplitude | Phase (radians) | Description | Quibble-Notes |%"

            for {set freq_index 0} {$freq_index < $signal_length} {incr freq_index} {
                set amp_string [format "%.4f" [lindex $magnitude_list $freq_index]]
                set phase_string [format "%.4f" [lindex $phase_list $freq_index]]
                set note_text [dft_core::dft_bin_description $freq_index $signal_length]
                lappend lines "&| k=$freq_index | $amp_string | $phase_string | $note_text |   |&"
            }
            lappend lines "&| AUDIT Window | | | | |&"
            lappend lines "----"
            return $lines
        }

        proc build_initial_state_lines {stateName phase1_blocks} {
            upvar 1 $stateName state
            return [list \
                "\n=== INITIAL STATE CHECK ===" \
                [format "tok_damage_lvl   : %.4f" [token_core::safe_get state tok_damage_lvl 0.0]] \
                [format "tok_spark_event  : %.4f" [token_core::safe_get state tok_spark_event 0.0]] \
                [format "tok_wind_speed   : %.4f" [token_core::safe_get state tok_wind_speed 0.0]] \
                [format "tok_lightning    : %.4f" [token_core::safe_get state tok_lightning 0.0]] \
                [format "tok_fuel_amount  : %.4f" [token_core::safe_get state tok_fuel_amount 0.0]] \
                "Phase1 blocks: $phase1_blocks"]
        }

        proc build_phase_lines {name stateName} {
            upvar 1 $stateName state
            global conclRuleTable leftoverRuleTable
            array set concl [scoring::score_conclusions state conclRuleTable]
            array set lft   [scoring::score_conclusions state leftoverRuleTable]
            return [list \
                "\n=== $name ===" \
                [format "tok_damage_lvl  : %.4f" [token_core::safe_get state tok_damage_lvl 0.0]] \
                [format "concl_fire_hi   : %.4f" [token_core::safe_get concl concl_fire_hi 0.0]] \
                [format "concl_damage    : %.4f" [token_core::safe_get concl concl_damage 0.0]] \
                [format "lft_dmg_bridge  : %.4f" [token_core::safe_get lft lft_dmg_bridge 0.0]]]
        }

        proc build_convergence_intro_lines {} {
            return [list \
                "\n=== Marletto Counterfactual Convergence Block ===" \
                "Three counterfactual groups are now nudging the token state." \
                "Positive (enabling), negative (challenging), and alternative" \
                "(cross-check) groups each contribute bounded local influence."]
        }

        proc build_convergence_pass_line {pass_num avg_change temperature} {
            return [format "Pass %2d : average change = %.5f , temperature = %.3f" \
                $pass_num $avg_change $temperature]
        }

        proc build_convergence_early_stop_line {} {
            return "The state settled early; remaining passes were not needed."
        }

        proc build_convergence_outro_lines {} {
            return [list \
                "Convergence block finished. Scoring will continue on the" \
                "settled token values rather than on the raw propagated values."]
        }

        proc build_sensitivity_notfound_lines {tokName} {
            return [list "\n=== Sensitivity: $tokName ===" "Token not found."]
        }

        proc build_sensitivity_header_lines {tokName delta} {
            return [list \
                "\n=== Sensitivity: $tokName (+/-$delta) ===" \
                "Clamped columns match the production pipeline (ceiling 0.999)." \
                "Raw columns show the same arithmetic without that ceiling, so" \
                "the real response to each test factor remains visible."]
        }

        proc build_sensitivity_row_line {tokName rowData} {
            lassign $rowData tok_val ph1_val ph2_val ph1_raw_val ph2_raw_val
            return [format "%s=%.4f -> damage Ph1=%.4f Ph2=%.4f | raw Ph1=%.4f Ph2=%.4f" \
                $tokName $tok_val $ph1_val $ph2_val $ph1_raw_val $ph2_raw_val]
        }
    }


    proc run_convergence_block {stateName} {
        upvar 1 $stateName state
        foreach line [formatters::build_convergence_intro_lines] {
            io_utils::emit $line
        }

        lassign [convergence::run_convergence_passes state] pass_rows early_stop_flag
        foreach row $pass_rows {
            lassign $row pass_num avg_change temperature
            io_utils::emit [formatters::build_convergence_pass_line $pass_num $avg_change $temperature]
        }
        if {$early_stop_flag} {
            io_utils::emit [formatters::build_convergence_early_stop_line]
        }

        foreach line [formatters::build_convergence_outro_lines] {
            io_utils::emit $line
        }
    }

    proc print_phase {name stateName} {
        upvar 1 $stateName state
        foreach line [formatters::build_phase_lines $name state] {
            io_utils::emit $line
        }
    }

    proc run_dft_residual_analysis {stateName label} {
        upvar 1 $stateName state
        global positive_cf_group negative_cf_group alternative_cf_group \
               conclRuleTable leftoverRuleTable

        io_utils::emit "\n=== DFT Amplitude and Phase Residual Analysis - $label ==="
        io_utils::emit "Residuals below reflect the settled state after the"
        io_utils::emit "Marletto Counterfactual Convergence Block has run."

        set positive_names [lsort [array names positive_cf_group]]
        set negative_names [lsort [array names negative_cf_group]]
        set alternative_names [lsort [array names alternative_cf_group]]

        foreach line [formatters::build_dft_wiki_lines \
                "DFT Residuals - Positive (Enabling) Group - $label" \
                [dft_core::extract_named_values positive_cf_group $positive_names]] {
            io_utils::emit $line
        }
        foreach line [formatters::build_dft_wiki_lines \
                "DFT Residuals - Negative (Challenging) Group - $label" \
                [dft_core::extract_named_values negative_cf_group $negative_names]] {
            io_utils::emit $line
        }
        foreach line [formatters::build_dft_wiki_lines \
                "DFT Residuals - Alternative (Cross-Check) Group - $label" \
                [dft_core::extract_named_values alternative_cf_group $alternative_names]] {
            io_utils::emit $line
        }

        foreach concl_label [array names conclRuleTable] {
            set tok_names {}
            foreach pair $conclRuleTable($concl_label) {
                lassign $pair tok_name tok_weight
                lappend tok_names $tok_name
            }
            foreach line [formatters::build_dft_wiki_lines \
                    "DFT Residuals - Conclusion $concl_label - $label" \
                    [dft_core::extract_named_values state $tok_names]] {
                io_utils::emit $line
            }
        }

        foreach lft_label [array names leftoverRuleTable] {
            set tok_names {}
            foreach pair $leftoverRuleTable($lft_label) {
                lassign $pair tok_name tok_weight
                lappend tok_names $tok_name
            }
            foreach line [formatters::build_dft_wiki_lines \
                    "DFT Residuals - Leftover $lft_label - $label" \
                    [dft_core::extract_named_values state $tok_names]] {
                io_utils::emit $line
            }
        }

        io_utils::emit "=== End of DFT Residual Analysis - $label ==="
    }

    proc run_full_sim {label passProc1 passProc2 p1block p2block} {
        global baseEvidTable fwdLinkTable phase1BlockSrcs
        array set s1 [array get baseEvidTable]

        foreach line [formatters::build_initial_state_lines s1 $phase1BlockSrcs] {
            io_utils::emit $line
        }

        $passProc1 s1 fwdLinkTable $p1block
        array set s2 [array get s1]
        $passProc2 s2 fwdLinkTable $p2block

        run_convergence_block s2
        run_dft_residual_analysis s2 $label

        io_utils::emit "\n--- $label Phase 1 ---"
        print_phase "$label Ph1" s1
        io_utils::emit "\n--- $label Phase 2 ---"
        print_phase "$label Ph2" s2

        return [list [token_core::safe_get s1 tok_damage_lvl 0.0] \
                     [token_core::safe_get s2 tok_damage_lvl 0.0]]
    }

    proc sensitivity_analysis {tokName delta} {
        global baseEvidTable
        if {![info exists baseEvidTable($tokName)]} {
            foreach line [formatters::build_sensitivity_notfound_lines $tokName] {
                io_utils::emit $line
            }
            return
        }

        foreach line [formatters::build_sensitivity_header_lines $tokName $delta] {
            io_utils::emit $line
        }

        foreach row [sensitivity_core::run_sensitivity_series $tokName $delta] {
            io_utils::emit [formatters::build_sensitivity_row_line $tokName $row]
        }
    }

    proc run_all_demo {} {
        global phase1BlockSrcs phase2BlockSrcs

        set logFilePath [io_utils::start_log "fire_marletto_v13"]
        if {[llength [info commands console]] > 0} {
            console show
        }

        io_utils::emit "=== FIRE MARLETTO INFERENCE ENGINE V16 ==="
        io_utils::emit "Linear | Triangular | Fibonacci propagation + Convergence Block + DFT Residuals + Sensitivity Analysis"

        set p1 $phase1BlockSrcs
        set p2 $phase2BlockSrcs

        run_full_sim "Linear"     propagation::phased_linear_pass     propagation::phased_linear_pass     $p1 $p2
        run_full_sim "Triangular" propagation::phased_triangular_pass propagation::phased_triangular_pass $p1 $p2
        run_full_sim "Fibonacci"  propagation::phased_fibonacci_pass  propagation::phased_fibonacci_pass  $p1 $p2

        sensitivity_analysis tok_wind_speed 0.1
        sensitivity_analysis tok_heat_level 0.1
        sensitivity_analysis tok_lightning 0.1

        io_utils::emit "\n=== Run complete. Log: $logFilePath ==="
        io_utils::stop_log
    }

    namespace export run_all_demo
}

::dft_engine::run_all_demo



 
# End of file

# 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 "shuffle"
# for educational purposes only.
puts "=============================================================="
puts "Credits"
puts "Reference: Maria Violaris, arXiv:2601.08102v1, January 2026"
puts "Reference: https://wiki.tcl-lang.org/page/Snippets+Quantum+Many+Worlds"
puts "Based on ref. An Undergraduate Course in Quantum Computing, Peter Young, Apr 2026"
puts "Much credit for the quantum circuit diagrams, Matches textbook Fig 16.4 etc"
puts "University of California Santa Cruz, CA, arXiv:2604.10396"

# A new module, "Marletto Counterfactual Convergence Block", is inserted
# directly ahead of proc score_conclusions. Everything above that point
# is unchanged from V11b. 
# A DFT residual report is added as a final step.
# Used for residual amp and phase analysis of "solutions".
# The DFT amp and phase does not effect
# proceeding calculation steps.

tok_wind_speed=0.4800 -> damage Ph1=0.0000 Ph2=0.9990 , raw Ph1=0.0000 Ph2=1.4578
tok_wind_speed=0.5280 -> damage Ph1=0.0000 Ph2=0.9990 , raw Ph1=0.0000 Ph2=1.4698
tok_wind_speed=0.4320 -> damage Ph1=0.0000 Ph2=0.9990 , raw Ph1=0.0000 Ph2=1.4458
# spread is sensible, some S. fields are clamped, 
# EG, initial conditions are set to ZERO or Near Zero, best as possible.
# raw at completions  shows relative S. 
heat level shows the widest swing (1.4299–1.4857),
lightning moderate (1.4379–1.4777),
wind speed narrowest (1.4458–1.4698) 

+----------------------------------------------------------------------------------+
| 1) POSITIVE CFS                                                                  |
|    Particle-style tasks that are achievable                                      |
|                                                                                  |
|    [Small planet]  --->  [Straight arrow]  --->  [Blue check mark]              |
|                                                                                  |
|    Tasks that conform with Newtonian rules are achievable.                      |
+----------------------------------------------------------------------------------+

+----------------------------------------------------------------------------------+
| 2) NEGATIVE CFS                                                                  |
|    Wave-style tasks that are achievable when they conform with quantum rules    |
|                                                                                  |
|    [Wave icon]  --->  [Barrier / constraint]  --->  [Blue check mark]            |
|                                                                                  |
|    Tasks that conform with Quantum rules are achievable.                        |
+----------------------------------------------------------------------------------+

+----------------------------------------------------------------------------------+
| 3) UNIFIED VIEW                                                                  |
|    Both frameworks have successful predictions                                   |
|                                                                                  |
|    [Positive CFSs]                             [Negative CFSs]                   |
|         |                                             |                          |
|         v                                             v                          |
|    [Achievable tasks]                           [Achievable tasks]               |
|                                                                                  |
|                Left-over traits from both sides                                   |
|                             \             /                                      |
|                              v           v                                       |
|                           [Unknown / Unified Theory]                             |
|                                                                                  |
|    Some experiments are workable under one framework but not achievable under   |
|    the other.                                                                    |
+----------------------------------------------------------------------------------+

+----------------------------------------------------------------------------------+
| 4) SUMMARY HINTS                                                                 |
|    A diagnostic path toward unification                                          |
|                                                                                  |
|    [Left-over traits]  --->  [Residue history]  --->  [Candidate unified theory] |
|                                                                                  |
|    Extract what remains after accounting for achievable and impossible tasks.    |
|    Reconstruct the history of residues.                                          |
|    Use the residue history to evaluate candidate theories.                       |
+----------------------------------------------------------------------------------+

**** figure. DFT ON INFERENCE VECTORS OVERVIEW **** 

+----------------------------------------------------------------------------------+
| DFT ON INFERENCE VECTORS                                                         |
|                                                                                  |
|    Purpose: Transform weighted probability / confidence vectors                  |
|    into frequency components to reveal:                                          |
|      • Overall support (DC / zero-frequency)                                     |
|      • Dominant patterns (low frequencies)                                       |
|      • Resonances & beats (mid frequencies)                                      |
|      • Sharp conflicts / leftovers (high frequencies)                            |
|                                                                                  |
|    Combines:                                                                     |
|      • Marletto Counterfactuals (possible / impossible)                          |
|      • Triangular Propagation weighting                                          |
|      • Axiom Removal as formal operator                                          |
|      • Constructor Theory style analysis                                         |
+----------------------------------------------------------------------------------+

**** figure. POSITIVE - NEGATIVE - LEFTOVER COUNTERFACTUALS **** 

+----------------------------------------------------------------------------------+
| THREE CHANNELS OF COUNTERFACTUAL REASONING                                       |
|                                                                                  |
|    Positive Counterfactuals (Achievable)                                         |
|      → Newtonian / classical-like tasks                                          |
|      → Strong low-frequency consensus                                            |
|                                                                                  |
|    Negative Counterfactuals (Impossible under current rules)                     |
|      → Quantum-style constraints                                                 |
|      → Mid-frequency resonances & phase shifts                                   |
|                                                                                  |
|    Leftover Residues (Surviving after both)                                      |
|      → High-frequency spikes                                                     |
|      → Irreversible bridges, hidden assumptions                                  |
|                                                                                  |
|    DFT helps separate these three signals clearly                                |
+----------------------------------------------------------------------------------+

**** figure. TRIANGULAR PROPAGATION & DFT **** 

+----------------------------------------------------------------------------------+
| TRIANGULAR PROPAGATION + DFT                                                     |
|                                                                                  |
|    Raw Confidence Vector → Apply triangular weights (1,3,6,10...)                |
|                                                                                  |
|    DFT breaks the weighted signal into frequencies:                              |
|      k=0  → DC component = total overall confidence                              |
|      Low k → Broad agreement / dominant conclusions                              |
|      Mid k → Resonances where possible & impossible collide                      |
|      High k → Sharp conflicts & stubborn leftover traits                         |
|                                                                                  |
|    Visual: Rising triangular accumulation shows cumulative support               |
+----------------------------------------------------------------------------------+

**** figure. AXIOM REMOVAL AS FORMAL OPERATOR **** 

+----------------------------------------------------------------------------------+
| AXIOM REMOVAL OPERATOR A^-                                                       |
|                                                                                  |
|    T' = A^-(T, Ai)   removes axiom Ai from theory T                             |
|                                                                                  |
|    Effect on inference vector V:                                                 |
|      V' = M_i × V     (reduction matrix for axiom i)                             |
|                                                                                  |
|    Measure stability:                                                            |
|      Δ = ||V' - V||   (how much the solution space bends)                        |
|                                                                                  |
|    High Δ → Load-bearing axiom (removing it causes big reorganization)           |
|    Low Δ → Peripheral axiom                                                          |
|                                                                                  |
|    Einstein-style "idea buster" turned into code                                |
+----------------------------------------------------------------------------------+

**** figure. COSINE SIMILARITY & PHASE COMPARISON **** 

+----------------------------------------------------------------------------------+
| COMPARING SOLUTION VECTORS                                                       |
|                                                                                  |
|    Cosine Similarity = (V1 • V2) / (|V1| |V2|)                                   |
|                                                                                  |
|    Interpretation:                                                               |
|      1.00 → Identical direction                                                  |
|      0.95 → Very strong agreement                                                |
|      0.80 → Moderate similarity                                                  |
|      0.60 → Weak / substantial divergence                                        |
|      0.00 → Orthogonal (unrelated)                                               |
|     -0.50 → Opposing directions                                                  |
|                                                                                  |
|    Phase difference reveals timing / ordering mismatches between solutions      |
|    Expected: Newtonian vs Quantum/Leftover vectors should show 35°–55° angle     |
+----------------------------------------------------------------------------------+

**** figure. DFT FREQUENCY INTERPRETATION **** 

+----------------------------------------------------------------------------------+
| WHAT EACH FREQUENCY BIN TELLS US                                                 |
|                                                                                  |
|    k=0 (DC)          → Total signal energy / overall confidence                  |
|    Low k             → Broad consensus & dominant messages                       |
|    Mid k             → Resonances & beats between possible & impossible          |
|    High k            → Sharp conflicts, minority traits, leftovers               |
|                                                                                  |
|    Triangular weighting amplifies rising patterns → clearer frequency peaks     |
|    Hermitian symmetry (real input) → symmetric spectrum                          |
|                                                                                  |
|    Goal: Separate robust core theory from brittle high-frequency noise           |
+----------------------------------------------------------------------------------+

**** figure. EDUCATIONAL SUMMARY DFT INFERENCE ENGINE **** 

+----------------------------------------------------------------------------------+
| EDUCATIONAL VALUE                                                                |
|                                                                                  |
|    • Turns probabilistic reasoning into visible frequency patterns               |
|    • Reveals hidden tensions between Newtonian, Quantum, and Leftover signals    |
|    • Supports Marletto Counterfactual & Constructor Theory exploration          |
|    • Axiom removal as measurable operator (stability / curvature)                |
|    • Bridges linguistics (sememes), tokens, and weighted inference               |
|    • Clean, auditable mini-LLM reasoning toy in pure Tcl                         |
|                                                                                  |
|    "Dig into the messy bits both theories leave behind"                          |
+----------------------------------------------------------------------------------+

**** figure. PHASE-SPACE VIEW OF INFERENCE VECTORS **** 
+----------------------------------------------------------------------------------+
| PHASE-SPACE VIEW OF INFERENCE VECTORS                                            |
|                                                                                  |
|    Newtonian Vector   (Classical accumulation)     •───────────────────────•     |
|                                                    │   Rising support      │     |
|    Quantum / Leftover Vector                       │   Oscillatory path    │     |
|                                                    │   Sharp turns         │     |
|    Trajectory in vector space:                     └───────────────────────┘     |
|                                                                                  |
|      High Dimension Space (many axioms)                                          |
|           ↑                                                                          |
|    Leftover spikes (high-freq)                                                   |
|           │                                                                          |
|    Resonances (mid-freq)   → Newtonian path (smooth, low-freq)                   |
|           │                                                                          |
|    DC Component (overall confidence)                                             |
|                                                                                  |
|    Closed orbits = stable theory                                                 |
|    Diverging paths = axiom removal causing reorganization                        |
+----------------------------------------------------------------------------------+

**** figure. AXIOM REMOVAL EXAMPLE WITH NUMBERS **** 
+----------------------------------------------------------------------------------+
| AXIOM REMOVAL OPERATOR A^- : NUMERICAL EXAMPLE                                   |
|                                                                                  |
|    Original Theory T0 Inference Vector V0 = [0.82, 0.65, 0.71, 0.58, 0.79]      |
|                                                                                  |
|    Remove Axiom A3 (e.g. "Wind amplifies damage")                               |
|      Reduction Matrix M3 applied → V' = [0.82, 0.65, 0.29, 0.58, 0.31]          |
|                                                                                  |
|    Change Magnitude Δ = ||V' - V0|| ≈ 0.68                                       |
|    Cosine Similarity between V0 and V' ≈ 0.73 (moderate divergence)              |
|                                                                                  |
|    Interpretation:                                                               |
|      High Δ + moderate cosine → A3 was load-bearing (important axiom)            |
|      Low-frequency (DC) component drops → overall confidence reduced             |
|      High-frequency spikes increase → more "leftovers" appear                    |
+----------------------------------------------------------------------------------+

**** figure. FULL PHASE PORTRAIT OF SOLUTION VECTORS **** 
+----------------------------------------------------------------------------------+
| PHASE PORTRAIT: NEWTONIAN vs QUANTUM vs LEFTOVER VECTORS                        |
|                                                                                  |
|          Quantum/Leftover Vector                                                 |
|               ↑                                                                  |
|               │   ••••••••••••• (sharp high-freq turns)                         |
|    Newtonian  │  /                                                               |
|    Vector     │ /                                                                |
|      •────────┼───────→ Smooth low-freq trajectory                               |
|               │                                                                  |
|    Angle between vectors ≈ 42° (moderate divergence)                             |
|                                                                                  |
|    DC Component (overall magnitude) shown as vector length                       |
|    Phase difference reveals ordering/timing mismatches                           |
|                                                                                  |
|    Stable core theory = overlapping low-frequency paths                          |
+----------------------------------------------------------------------------------+

**** figure. TESTING THIS EXAMPLE, DIAGRAMS IN ANALYSIS OF QUANTUM ARGUMENTS ****
+----------------------------------------------------------------------------------+
| USING DFT DIAGRAMS TO ANALYZE QUANTUM ARGUMENTS                                  |
|                                                                                  |
|    1. Input: Set of axioms + counterfactuals as probability vector               |
|    2. Apply triangular weighting                                                 |
|    3. Compute DFT → Frequency spectrum                                           |
|                                                                                  |
|    Quantum Argument Indicators:                                                  |
|      • Strong mid/high-frequency components → superposition-like interference    |
|      • Phase shifts between vectors → timing / ordering differences              |
|      • Leftover high-freq spikes after axiom removal → irreducible quantum traits|
|      • Low cosine similarity (<0.75) between Newtonian & Quantum vectors         |
|                                                                                  |
|    Example: "Is gravity quantum?"                                                |
|      Remove classical gravity axiom → large Δ + new high-freq peak =             |
|      Strong evidence for quantum gravity features in the residue spectrum?       |
+----------------------------------------------------------------------------------+

**** figure. TRIANGULAR PROPAGATION PHASE SPACE **** 

+----------------------------------------------------------------------------------+
| TRIANGULAR PROPAGATION IN PHASE SPACE                                            |
|                                                                                  |
|    Raw Vector → Triangular Weights (1, 3, 6, 10, 15...)                          |
|                                                                                  |
|    Resulting Trajectory:                                                         |
|      Gradual accumulation → rising low-frequency dominance                       |
|      Sudden jumps at resonance points → mid-frequency beats                      |
|      Persistent high-frequency ringing → leftover counterfactuals                |
|                                                                                  |
|    Visual signature of Marletto-style reasoning:                                 |
|      Possible tasks = smooth rising curves                                       |
|      Impossible tasks = sharp cutoffs                                            |
|      Leftover residues = persistent oscillations after main signal decays        |
+----------------------------------------------------------------------------------+
----
Note. Following Mockup Vectors on Einstein’s 
path to E=mc² versus Newtonian thinking.
Computation (Python + DFT) to generate
realistic DFT frequency patterns for the two approaches.
-----
**** figure. PRELIMINARY, DFT ANALYSIS OF EINSTEIN E=MC² vs NEWTONIAN SOLUTIONS ****
+----------------------------------------------------------------------------------+
| DFT ANALYSIS: EINSTEIN E=MC² vs NEWTONIAN ENERGY SOLUTIONS                       |
|                                                                                  |
|    1. Input: Set of physical axioms as probability / confidence vectors          |
|    2. Apply triangular weighting (cumulative propagation)                        |
|    3. Compute DFT → Frequency spectrum of each theory                            |
|                                                                                  |
|    Newtonian Vector (Classical Separate Conservation)                            |
|      • Smooth low-frequency dominance                                            |
|      • Weak high-frequency components                                            |
|      • Represents steady, uniform mass and energy conservation                   |
|                                                                                  |
|    Einstein Vector (Mass-Energy Equivalence after axiom removal)                 |
|      • Stronger mid/high-frequency components                                    |
|      • Sharper transitions and phase shifts                                      |
|      • Reflects sudden conceptual "spike" when mass-energy link is introduced    |
|                                                                                  |
|    Computed Example (mock inference vectors):                                    |
|      Cosine similarity ≈ 0.994   (very close overall direction)                 |
|      But DFT shows clear divergence in higher frequencies                        |
|                                                                                  |
|    Key Insight from Einstein's Method:                                           |
|      Removing the axiom "mass and energy are separately conserved"              |
|      produces a new high-frequency signature in the solution spectrum            |
|      → This spike corresponds to the emergence of E=mc²                          |
+----------------------------------------------------------------------------------+

**** figure. PRELIMINARY,  FREQUENCY SPECTRUM COMPARISON - E=MC² PATH ****
+----------------------------------------------------------------------------------+
| FREQUENCY SPECTRUM: NEWTONIAN vs EINSTEIN (E=MC²)                               |
|                                                                                  |
|    Frequency Bin     Newtonian (Smooth)     Einstein (Relativistic)     Comment  |
|    k=0 (DC)          Very Strong            Strong                  Overall confidence / total energy |
|    Low k             Dominant               Strong                   Broad classical conservation      |
|    Mid k             Weak                   Noticeable               Transition / mass-energy link    |
|    High k            Very Weak              Stronger spikes          Sharp conceptual break           |
|                                                                                  |
|    Interpretation:                                                               |
|      Newtonian solution → mostly low-frequency, smooth accumulation              |
|      Einstein solution → introduces new mid-to-high frequency components         |
|      after removing the classical "separate conservation" axiom                  |
|                                                                                  |
|    This frequency shift is the DFT signature of Einstein's idea-buster move      |
+----------------------------------------------------------------------------------+

**** figure. PRELIMINARY,  EINSTEIN AXIOM REMOVAL PROCESS WITH DFT ****

+----------------------------------------------------------------------------------+
| EINSTEIN'S AXIOM REMOVAL → DFT SIGNATURE                                         |
|                                                                                  |
|    Step-by-Step:                                                                 |
|    1. Start with Newtonian axioms (mass & energy separately conserved)           |
|    2. Remove hidden axiom: "Mass and energy are independent"                     |
|    3. Keep invariants: Speed of light c is constant + momentum conservation      |
|    4. Rebuild logic → New solution vector                                        |
|    5. Apply DFT to both vectors                                                  |
|                                                                                  |
|    Result in Frequency Domain:                                                   |
|      • Newtonian: Smooth, low-frequency heavy spectrum                           |
|      • Einstein: Same low-frequency core + new mid/high-frequency peaks          |
|                                                                                  |
|    The new peaks represent the emergence of E=mc² as a necessary consequence    |
+----------------------------------------------------------------------------------+

**** figure. PRELIMINARY, NUMERICAL DFT COMPARISON: NEWTONIAN SOLUTION vs EINSTEIN E=MC² ****

+----------------------------------------------------------------------------------+
| DFT FREQUENCY SPECTRUM: NEWTONIAN vs EINSTEIN (E=mc²)                           |
|                                                                                  |
|    Newtonian Vector:   Smooth, low-frequency heavy spectrum                      |
|    Einstein Vector:    Same low-frequency core + new mid/high-frequency peaks    |
|                                                                                  |
| Frequency | Newtonian Magnitude | Einstein Magnitude | Difference     Comment
|-----------|---------------------|--------------------|----------------
| k=0 (DC)  | 6.4800              | 6.2300             | 0.2500    Overall energy / total confidence
| k=1       | 0.1292              | 0.1243             | 0.0049    Low-freq (broad agreement)
| k=2       | 0.0860              | 0.1565             | 0.0705    Mid-freq (emerging transition)
| k=3       | 0.0672              | 0.1310             | 0.0637    Mid-freq
| k=4       | 0.0600              | 0.6300             | 0.5700    Strong high-freq peak (mass-energy link)
| k=5       | 0.0672              | 0.1310             | 0.0637    Mid-freq
| k=6       | 0.0860              | 0.1565             | 0.0705    Mid-freq
| k=7       | 0.1292              | 0.1243             | 0.0049    Low-freq
|                                                                                  |
| Key Observation:                                                                 |
|   • Both share strong DC (low-frequency core)                                    |
|   • Einstein solution shows dramatic new peaks at mid/high frequencies           |
|   • Largest difference at k=4 → corresponds to the conceptual "spike" of E=mc²   |
+----------------------------------------------------------------------------------+

**** figure. PRELIMINARY,  PHASE PORTRAIT: NEWTONIAN vs EINSTEIN E=MC² ****

+----------------------------------------------------------------------------------+
| PHASE PORTRAIT: NEWTONIAN vs EINSTEIN (Mass-Energy)                              |
|                                                                                  |
|          Einstein Trajectory (after axiom removal)                               |
|               ↑                                                                  |
|               │               ••••••••• (sharp conceptual jump)                 |
|               │             ↗                                                    |
|               │           ↗                                                      |
|    Newtonian  │         ↗                                                        |
|    Path       │       ↗                                                          |
|      •────────┼───────→ Smooth low-frequency trajectory                          |
|               │                                                                  |
|    X-axis: Classical "Separate Conservation" Strength                            |
|    Y-axis: Mass-Energy Equivalence / Relativistic Insight                        |
|                                                                                  |
|    Interpretation:                                                               |
|      • Newtonian: Smooth, gradual, low-curvature path (steady conservation)      |
|      • Einstein: Same starting direction + sudden upward turn after removing     |
|        the axiom "mass and energy are independent"                               |
|                                                                                  |
|    The sharp bend / new trajectory represents the emergence of E=mc²             |
|    DC Component (overall magnitude) shown as vector length                       |
+----------------------------------------------------------------------------------+

*** 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. EXTENSION, 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. EXTENSION, 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          |
+----------------------------------------------------------------------------------+

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