# text
set list { e m k c }
# or more human readable in Best Practices
set buzzwords {rest_energy rest_mass c_speed_of_light lorentz_factor_gamma some_coupling_constant_k1 some_coupling_constant_k2}
# relationships unknown, except to Einstein, Joke!

Asymptotic symmetries (e.g., BMS supertranslations/superrotations at null infinity)  
Soft theorems (universal low-energy factorization of scattering amplitudes, like Weinberg's soft graviton theorem)  
Memory effects (permanent relative displacements or phase shifts after gravitational waves pass)

Separate toy models for each corner  
A combined check showing approximate equivalence (within numerical tolerance)  
Simple numerical tests with prints for easy experimentation  
Comments explaining the physics mapping  
All playground-safe: no format, no Unicode, plain puts, natural double precision

# Works on  Playground V9
# Expanded Infrared Triangle Toy - Learning Tool for Strominger's Ideas
# Goal: Show equivalence between symmetry, soft theorem, and memory

# Corner 1: BMS Supertranslation Symmetry (toy Ward identity / charge conservation)
# Supertranslation charge Delta from integrated flux should be conserved
proc bms_charge {fluxes} {
    set charge 0.0
    foreach flux $fluxes {
        set charge [expr {$charge + $flux}]
    }
    set charge
}

# Corner 2: Soft Graviton Theorem (toy low-energy factor ~ 1/E)
# Soft insertion factor diverges as E -> 0 (universal pole)
proc soft_insertion {E} {
    if {$E == 0} { return "pole infinity" }
    expr {1.0 / $E}
}

# Corner 3: Gravitational Memory Effect (displacement from flux)
# Permanent relative shift after wave passes
proc memory_displacement {fluxes} {
    set delta 0.0
    foreach flux $fluxes {
        set delta [expr {$delta + $flux}]
    }
    set delta
}

# Equivalence check: memory delta ≈ soft insertion * scale factor (toy scaling)
# In real physics, soft theorem predicts memory; here we compare numerically
proc check_triangle_equivalence {memory soft scale} {
    set predicted_soft [expr {$memory / $scale}]
    set diff [expr {abs($predicted_soft - $soft)}]
    puts "memory delta: $memory"
    puts "observed soft insertion: $soft"
    puts "predicted soft from memory / scale: $predicted_soft"
    puts "difference: $diff"
    expr {$diff < 1e-8}   ;# tolerance for numerical toy
}

# Test setup - define inputs in this scope
set flux_list {0.02 0.015 -0.008 0.03 0.01}   ;# toy flux moments from scattering
set energy_scale 0.05                         ;# toy low energy E (small → soft regime)
set soft_value [soft_insertion $energy_scale]

# Compute each corner
set bms_charge_value [bms_charge $flux_list]
set memory_value [memory_displacement $flux_list]

puts "Infrared Triangle Toy Exploration"
puts "flux contributions: $flux_list"
puts "energy scale E: $energy_scale"
puts ""
puts "Corner 1 - BMS supertranslation charge: $bms_charge_value"
puts "Corner 3 - Memory displacement: $memory_value"
puts "Corner 2 - Soft graviton insertion factor: $soft_value"

puts "Check equivalence (memory predicts soft via scaling):"
puts [check_triangle_equivalence $memory_value $soft_value $energy_scale]

# Expected rough match: memory ≈ soft * E (in this toy scaling)
# In real physics, the soft theorem gives the precise coefficient linking them

# Works on  Playground V9
(tcl) 22 % puts "Infrared Triangle Toy Exploration"
Infrared Triangle Toy Exploration
(tcl) 23 % puts "flux contributions: $flux_list"
flux contributions: 0.02 0.015 -0.008 0.03 0.01
(tcl) 24 % puts "energy scale E: $energy_scale"
energy scale E: 0.05
(tcl) 25 % puts ""

(tcl) 26 % puts "Corner 1 - BMS supertranslation charge: $bms_charge_value"
Corner 1 - BMS supertranslation charge: 0.067
(tcl) 27 % puts "Corner 3 - Memory displacement: $memory_value"
Corner 3 - Memory displacement: 0.067
(tcl) 28 % puts "Corner 2 - Soft graviton insertion factor: $soft_value"
Corner 2 - Soft graviton insertion factor: 20.0
(tcl) 29 % 
(tcl) 29 % puts "Check equivalence (memory predicts soft via scaling):"
Check equivalence (memory predicts soft via scaling):
(tcl) 30 % puts [check_triangle_equivalence $memory_value $soft_value $energy_scale]
memory delta: 0.067
observed soft insertion: 20.0
predicted soft from memory / scale: 1.34
difference: 18.66
0
(tcl) 31 % 
(tcl) 31 % # Expected rough match: memory ≈ soft * E (in this toy scaling)

puts "Test: Playground V9 is working"
puts "If you see this -> basic puts is fine"
flush stdout

puts "Test: Playground V9 is working"
puts "If you see this -> basic puts is fine"
flush stdout

(tcl) 1 % puts "Test: Playground V9 is working"
Test: Playground V9 is working
(tcl) 2 % puts "If you see this → basic puts is fine"
If you see this error writing "stdout": invalid or incomplete multibyte or wide character
(tcl) 3 % flush stdout
(tcl) 4 % 

Root cause → non-ASCII character (→) + restrictive default stdout encoding.
Preferred fix → add chan configure stdout -encoding utf-8 at the top.
Fallback → stick to pure ASCII in puts strings (replace arrows with ->, use "gamma" instead of γ if needed).

chan configure stdout -encoding utf-8

puts "=== DICT DIAGNOSTIC START ==="

# Test 1: simple dict create
set test_dict [dict create key1 value1 key2 value2]
puts "Test dict created OK: [dict size $test_dict] items"

# Test 2: dict for loop
dict for {k v} $test_dict {
    puts "  $k → $v"
}

# Test 3: empty dict merge (common pattern in your code)
set a [dict create x 10]
set b [dict create y 20]
set merged [dict merge $a $b {}]   ;# {} is empty dict
puts "Merged OK: [dict get $merged x] [dict get $merged y]"

puts "=== DICT DIAGNOSTIC END - if you see this, basic dict usage works ==="
puts "Now add your relations/constants one block at a time"

#!/usr/bin/wish
# Tcl 
# Physics Toy Protocol – Readable Names Edition
# Goal: Make relationships and calculations easier to read and teach
# for Tool Control Language Programs
# Compatible with Tcl/Tk 8.6+
# TCL source code follows
# Written for Windows 11 on ActiveState Tcl
# Working on TCL Playground V9

console show
proc suggest_name {concept type} {
    switch -exact $type {
        const    { return "${concept}_const" }
        param    { return "${concept}_param" }
        quantity { return "the_${concept}" }
        factor   { return "${concept}_factor" }
        default  { return $concept }
    }
}

# Step 1: Buzzwords – descriptive, readable names
set buzzwords {
    rest_energy
    relativistic_energy
    speed_of_light
    rest_mass
    velocity
    lorentz_factor_gamma
    velocity_fraction_beta
    fine_structure_constant_alpha
    some_coupling_constant_k1
    another_constant_k2
}

# Step 2: Relationships – pure expr fragments
# IMPORTANT:
#   - Use $ only for TRUE Tcl variables: rest_mass, speed_of_light, velocity.
#   - Do NOT put $ in front of symbolic names that will be expanded
#     by expand_expression (rest_energy, lorentz_factor_gamma, etc.).
set relations [dict create \
    rest_energy              {1.0 * $rest_mass * ($speed_of_light ** 2)} \
    velocity_fraction_beta   {1.0 * $velocity / $speed_of_light} \
    lorentz_factor_gamma     {1.0 / sqrt(1.0 - (velocity_fraction_beta ** 2))} \
    relativistic_energy      {lorentz_factor_gamma * $rest_mass * ($speed_of_light ** 2)} \
    relativistic_momentum    {lorentz_factor_gamma * $rest_mass * $velocity} \
]

# Step 3: Constants and default parameters
set constants [dict create \
    speed_of_light                 299792458.0 \
    fine_structure_constant_alpha  0.0072973525693 \
    some_coupling_constant_k1      1.0 \
    another_constant_k2            1.0 \
]

set default_parameters [dict create \
    rest_mass  1.0 \
    velocity   0.6e8 \
]

# Step 4: Utility procs
proc expand_expression {symbol {max_depth 12}} {
    # Start from the bare symbol name
    set expr_str $symbol
    set changed 1
    set depth   $max_depth

    while {$changed && $depth > 0} {
        set changed 0
        dict for {name definition} $::relations {
            # Replace whole-word occurrences of the symbolic name
            if {[regsub -all "\\m${name}\\M" $expr_str "($definition)" expr_str]} {
                set changed 1
            }
        }
        incr depth -1
    }
    return $expr_str
}

proc compute {quantity_name {override_params {}}} {
    # Merge constants, defaults, and overrides into one dict
    set all_values [dict merge $::constants $::default_parameters $override_params]

    # Define local variables for expr ($rest_mass, $speed_of_light, $velocity, ...)
    dict for {var value} $all_values {
        set $var $value
    }

    # Fully expand the symbolic name to a numeric expression
    set full_expr [expand_expression $quantity_name]

    # Evaluate the expression
    return [expr $full_expr]
}

# Display helper
proc display_physics {quantity_name {extra_params {}}} {
    puts "\n  $quantity_name"
    puts "  Expanded:  [expand_expression $quantity_name]"
    puts "  Value:     [compute $quantity_name $extra_params]"
}

# Step 5: Example physics toy function
proc show_energy_comparison {{speed_fraction 0.8}} {
    # Override velocity for this run
    set params [dict create \
        velocity [expr {$speed_fraction * [dict get $::constants speed_of_light]}] \
    ]

    display_physics rest_energy
    display_physics relativistic_energy $params
    display_physics lorentz_factor_gamma $params

    set ratio [expr {[compute relativistic_energy $params] / [compute rest_energy]}]
    puts "   Energy increase factor (should ≈ gamma): $ratio"
}


# Run demo
puts "Readable Physics Toy Demo   Special Relativity"
puts "Buzzwords used: $buzzwords\n"

display_physics rest_energy
display_physics lorentz_factor_gamma

puts "\nHigh-speed example (80% speed of light):"
show_energy_comparison 0.8

puts "\nModerate speed example (30% speed of light):"
show_energy_comparison 0.3


puts "\n--- Demo Separator ---"
puts "Demo complete. Press Enter to exit."
gets stdin

1.  show is a command in T. swap out show for something.
The issue stems from reader confusion around the proc show command
in your Tcl physics toy protocol. You're right to point this out 

2. stdout troubles in Playground V9
 left  arrow → causes problem on printout.
3. invalid bareword "rest_mass"
in expression "(1.0 * ( rest_mass ) * (speed_of_light *…";
should be "$rest_mass" or "{rest_mass}" or "rest_mass(...)" or …

4.regex = if {[regsub -all "\\m${name}\\M" $expr_str "($definition)" expr_str]}

If you want to fix the default to exactly 0.60c, just set velocity = 0.6 * $speed_of_light in the parameters.

When fixed, it should:

Calculate rest energy (E₀ = mc²)
Calculate relativistic energy at high speeds
Show the Lorentz factor γ increases energy as velocity approaches c
Demonstrate that at 80% light speed, energy increases by ~1.67×


5. readable Physics Toy Demo ~ Special Relativity
Buzzwords used: 
    rest_energy
    relativistic_energy
    speed_of_light
    rest_mass
    velocity
    lorentz_factor_gamma
    velocity_fraction_beta
    fine_structure_constant_alpha
    some_coupling_constant_k1
    another_constant_k2

 

Key parameters used across all cases
rest_mass          = 1.0 kg  
speed_of_light     = 299792458 m/s (exact SI value)  
Formulas:  β = velocity / speed_of_light  
γ = 1 / √(1 − β²)  
Rest energy = rest_mass × speed_of_light²  
Total energy = γ × rest_mass × speed_of_light²  
Increase factor = total energy / rest energy = γ

console show
# Rules for forward binding (like fusion / production)
set bind_rules {
    {mass light}  energy
    {light mass}  energy
    # add more e.g. {photon photon} pair
}

# Rules for backward unbinding (like decay / annihilation)
set unbind_rules {
    {energy light} mass
    {energy mass}  light
    # symmetric inverse — add more as needed
}

proc bind_relation {a b} {
    global bind_rules
    set key [list $a $b]
    if {[dict exists $bind_rules $key]} {
        return [dict get $bind_rules $key]
    }
    set key [list $b $a]
    if {[dict exists $bind_rules $key]} {
        return [dict get $bind_rules $key]
    }
    return $a   ;# neutral: left term survives
}

proc unbind_relation {a b} {
    global unbind_rules
    set key [list $a $b]
    if {[dict exists $unbind_rules $key]} {
        return [dict get $unbind_rules $key]
    }
    set key [list $b $a]
    if {[dict exists $unbind_rules $key]} {
        return [dict get $unbind_rules $key]
    }
    return "undefined"   ;# or error, or keep a, depending on strictness
}

proc ⊗ {args} {
    # forward chaining (left-associative)
    set result [lindex $args 0]
    foreach next [lrange $args 1 end] {
        set result [bind_relation $result $next]
    }
    return $result
}

proc ⊖ {args} {
    # backward chaining — like undoing fusions
    set result [lindex $args 0]
    foreach next [lrange $args 1 end] {
        set result [unbind_relation $result $next]
    }
    return $result
}

# Examples — copy-paste into a Tcl 

puts "Forward binding :"
puts [⊗ mass light]          ;# → energy
puts [⊗ light mass]          ;# → energy
puts [⊗ mass light speed]    ;# → energy     (speed ignored/neutral)
puts [⊗ energy mass light]   ;# → energy     (energy absorbs everything)

puts "\nBackward unbinding :"
puts [⊖ energy light]        ;# → mass       (undo E = m c² → get mass back)
puts [⊖ energy mass]         ;# → light      (undo E = m c² → get light back)
puts [⊖ energy light mass]   ;# → undefined  (no rule for energy ⊖ light ⊖ mass)
puts [⊖ mass light]          ;# → undefined  (no inverse rule defined)
puts [⊖ energy foo]          ;# → undefined

puts "\nChaining fun:"
puts [⊖ [⊗ mass light] light]   ;# → mass     (create energy, then annihilate light → back to mass)
puts [⊖ [⊗ mass light] mass]    ;# → light    (create energy, annihilate mass → back to light)

# fix UTF-8 byte?
chan configure stdout -encoding utf-8
# or shorter:
fconfigure stdout -encoding utf-8
puts "⊖ energy light" 

(tcl) 1 % chan configure stdout -encoding utf-8
(tcl) 2 % # or shorter:
(tcl) 3 % fconfigure stdout -encoding utf-8
(tcl) 4 % puts "⊖ energy light" 
⊖ energy light
(tcl) 5 % 
# fix?
puts "mass \u2297 light \u2192 energy   (\u2296 is circled minus)"
Both come from the same root cause: non-ASCII characters 
(especially mathematical/symbol Unicode characters like ⊗, →, etc.) 
combined with the default restrictive encoding on stdout in Playground V9 environment.

proc display_physics {quantity_name {extra_params {}}} {
    set val [compute $quantity_name $extra_params]
    puts "\n  $quantity_name"
    puts "  Expanded:  [expand_expression $quantity_name]"
    puts "  Value:     [format %.5e $val]"   ;# 5 sig figs, scientific
    # or "%.12g" for "general" with up to 12 sig figs, no trailing zeros
}

Output becomes:

[Toy] rest_energy
  Expression: rest_mass * speed_of_light ** 2
  Numerical value: 8.987551789232221e+16