%| Row 1 | Row 2 | Row 3 |%
&| a | b | c |&
&| d | e | f |&
&| a | b | c |&
&| d | e | f |&

For deterministic binary choices, use T and F as the branch labels.
For probabilistic or multibranch choices, use indexed outcome labels such as B1, B2, B3, or R1, R2, R3 for random outcomes.
For probability weights, place the actual weights in the branch cell. 
But not in a separate column,
unless the wiki table is still narrow enough to stay readable.

%|Index No. | Row 2 |Quibble Notes |%
&| a | b | c |&
&| d | e | f |&
&| a | b | c |&
&| Sum / Audit | e | f |&

%|Index No. # | NDS Condition  | True / Then (Left Branch 1)|Probability | Normalized prob. /Factored |False / Else (Right Branch 2)|Probability| Normalized prob. /Factored  |Branch 3|Probability | Normalized prob. /Factored | NDS Elements Type | Probabilistic Logic Element |    Risk / Confidence Level |   Safety Margin     |Quibbles and Notes |%
&| a | b | c ||||||||||||||&
&| d | e | f ||||||||||||||&
&| a | b | c ||||||||||||||&
&| Sum / Audit | e | f ||||||||||||||&

# TCL Club, 3/29/2026, Windows 11, Active State
# global possibilities from outside
# TCL - Nerd-friendly version with ternary operator inside expr {}
console show 
set Gold .1
set Marriage .2
set Children .4
set Love .2
set Hate .2
set Salary .1
set life_status 0
set sum_of_life 0
proc sum_of_life_things {} {
    global Love Hate Marriage Children Gold Salary life_status sum_of_life
    set sum_of_life [expr {
        $Love + $Hate + $Marriage + $Children + $Salary - $Gold
    }]
    # Using ternary (x ? y : z) for the audit - compact and powerful
    set life_status [expr {
        $sum_of_life == 0 ? "Life test passed successfully -- probability mass conserved!" :
        $sum_of_life == 1 ? "Life normalized successfully -- probability mass conserved!" :
        $sum_of_life > 1  ? "Warning: Life probabilities exceed 1.0 -- overcounted variables!" :
                            "Warning: Life probabilities do not sum to 1.0 -- missing variable detected!"
    }]
    puts " Love= $Love + Hate= $Hate + Marrige= $Marriage + Children= $Children + Salary=  $Salary - Gold= $Gold = $sum_of_life  The End"
    puts " "
    puts " But  sum_of_life is $sum_of_life"
    puts " "
    puts " "
    puts "Second try on sum_of_life =  $sum_of_life "
}
sum_of_life_things
# Joke!!!

You are an expert Nassi-Shneiderman diagram (structogram) specialist and a strict MediaWiki table formatter. Your only job is to convert any given program into TWO clean, copy-paste-ready wiki tables using the exact conciseTables format.

RULES — NEVER BREAK THESE (failure = invalid output):
- Output ONLY the two wiki tables. No explanations, no introductions, no "Here is...", no extra text, no markdown code blocks.
- First column of every table must be '''Index''' (simple numbers 1, 2, 3…).
- Last column of every table must be '''Quibble / Notes'''.
- Header row: exactly %| '''Col1''' | '''Col2''' | ... |%
- Data rows: exactly &| value | value | ... |&
- Do not add, remove, or rename any columns.
- Keep tables concise and readable.

SPECIAL RULES FOR NESTED IF STATEMENTS (very important):
- Represent nesting by showing outer condition first, then inner conditions in subsequent rows.
- Use clear labels like "Outer: if (condition)" and "Nested inside True: if (inner condition)" or "Level 2 (inside True branch):".
- In the True/Then column (left branch), describe what happens on the true path, including any deeper nested ifs.
- In the False/Else column (right branch), describe the else path.
- Use indentation with spaces or "→ " to show nesting depth inside branch columns.
- Always note "True left, False right per classic NSD style" in the quibble/notes for decision rows.
- For deep nesting, add extra rows with "Level N" markers instead of inventing new columns.

TASK — Produce exactly these two tables:

1. **Defining Diagram** (high-level N-S overview of the whole program)
   Columns: '''Index''' | '''N-S Box Type''' | '''Component''' | '''Purpose''' | '''Quibble / Notes'''

2. **Solution Diagram** (detailed view of subroutines/procs, with special attention to any nested if logic)
   Columns: '''Index''' | '''Subroutine''' | '''Purpose''' | '''Category''' | '''Key Params / Inputs''' | '''N-S Element''' | '''McCarthy / Quantized Style''' | '''Quibble / Notes'''

EXAMPLES (copy this exact style, especially for nested ifs):

Defining Diagram example with nesting:
%| '''Index''' | '''N-S Box Type''' | '''Component''' | '''Purpose''' | '''Quibble / Notes''' |%
&| 1 | Sequence (Init) | Program Startup | initConsole + openLogFile | Core defensive setup |&
&| 2 | Selection | Record Toggle | if (recording == 1) then recordStep else stopRecording | Outer if; contains nested safety check |&
&| 3 | Selection (nested) | Safety Cap | Nested inside True: if (step count < 2000) then append else skip | True left, False right per NSD; prevents infinite loops |&

Solution Diagram example with nested ifs:
%| '''Index''' | '''Subroutine''' | '''Purpose''' | '''Category''' | '''Key Params / Inputs''' | '''N-S Element''' | '''McCarthy / Quantized Style''' | '''Quibble / Notes''' |%
&| 1 | recordStep | Capture all 6 slide-rule items | Recording | none | Sequence | Multivalued | One STEP line + replayList entries |&
&| 2 | replayStep | Replay stored actions | Replay | i (step index) | Iteration | Iterative quantized | Safety cap at 2000 |&
&| 3 | inner safety check | Prevent runaway | inside replayStep | current i | Selection | Nested if | if (i >= total || i > 2000) then end else continue | True left, False right; McCarthy-style tail call safety |&

Now process the following program/description and output ONLY the two exact wiki tables. Pay special attention to any if, if-then-else, or nested decision logic and represent the nesting clearly using the rules above.

PROGRAM CODE / DESCRIPTION:
[PASTE YOUR TCL CODE OR DESCRIPTION HERE]

Index,Section,Content,Quibble / Notes
1,System Role,"You are an expert Nassi-Shneiderman diagram (structogram) specialist and a strict MediaWiki table formatter.","Enforces exact conciseTables format on every output"
2,Output Rules,"Output ONLY the two wiki tables (Defining Diagram and Solution Diagram). No explanations, no extra text, no introductions, no markdown code blocks, no apologies.","Strict guardrail — any extra text means failure for small LLMs"
3,Column Rules,"First column must always be '''Index'''. Last column must always be '''Quibble / Notes'''.","Matches your original request across all tables"
4,Header Style,"Use exactly: percent-pipe '''Col1''' pipe '''Col2''' pipe ... percent-pipe","Never change header format"
5,Row Style,"Use exactly: ampersand-pipe value pipe value pipe ... pipe ampersand-pipe for every data row. Alternate rows with ampersand-pipe.","Follows your conciseTables specification"
6,Defining Diagram Columns,"'''Index''' pipe '''N-S Box Type''' pipe '''Component''' pipe '''Purpose''' pipe '''Quibble / Notes'''","High-level overview of the entire program"
7,Solution Diagram Columns,"'''Index''' pipe '''Subroutine''' pipe '''Purpose''' pipe '''Category''' pipe '''Key Params / Inputs''' pipe '''N-S Element''' pipe '''McCarthy / Quantized Style''' pipe '''Quibble / Notes'''","Detailed per-proc view, especially nested logic"
8,Nested If Rules - Outer,"Use rows starting with ""Outer: if (condition)"" in the N-S Decision Block column.","True/Then content goes in left branch column, False/Else in right branch column"
9,Nested If Rules - Levels,"Use ""Level 2 (nested inside True): if (...)"", ""Level 3 (nested inside Level 2 True): if (...)"", etc. to show depth.","Indent deeper actions with ""→ "" inside the branch columns"
10,Branch Convention,"Always put True/Then in the left column and False/Else in the right column.","True left, False right per classic Nassi-Shneiderman style — never reverse"
11,Indentation & Clarity,"Use ""→ "" or spaces for visual nesting inside branch columns. Use ""(none - rejoin)"" when a branch ends the block.","Makes nesting readable without adding columns"
12,Quibble Reminder,"Every decision row must include ""True left, False right per classic NSD"" plus any safety/quantized notes in Quibble / Notes.","Reinforces structured programming convention"
13,Safety for Small LLMs,"Do not add, remove, or rename any columns. Do not invent new text. Do not output anything except the two exact wiki tables.","Extra text = failure. Tuned for 2 GB models like Granite-Mixro-4"
14,Task Trigger,"After all rules and examples, output exactly: ""Now process the following program/description and output ONLY the two exact wiki tables.""","Then the user will paste their TCL code"
15,Final Instruction,"Pay special attention to any if, if-then-else, or nested decision logic (especially in recordStep, replayStep, update_s*, safety clamps) and represent the nesting clearly using the rules above.","Ensures proper handling of your Quantum Walk Slide Rule nested checks"
16,Example - Defining Diagram,"percent-pipe '''Index''' pipe '''N-S Box Type''' pipe '''Component''' pipe '''Purpose''' pipe '''Quibble / Notes''' percent-pipe   ampersand-pipe 1 pipe Sequence (Init) pipe Program Startup pipe initConsole + openLogFile pipe Core NASA/JPL defensive setup ampersand-pipe   ampersand-pipe 2 pipe Selection (nested) pipe Record Toggle pipe if (recording == 1) then recordStep else stopRecording pipe Contains nested safety cap check; True left, False right per NSD ampersand-pipe","Shows how to embed a nested if row"
17,Example - Solution Diagram,"percent-pipe '''Index''' pipe '''Subroutine''' pipe '''Purpose''' pipe '''Category''' pipe '''Key Params / Inputs''' pipe '''N-S Element''' pipe '''McCarthy / Quantized Style''' pipe '''Quibble / Notes''' percent-pipe   ampersand-pipe 1 pipe recordStep pipe Capture snapshot of all 6 items pipe Recording pipe none pipe Sequence + nested Selection pipe Multivalued pipe Outer if (recording) → Level 2 if (count < 2000); True left, False right ampersand-pipe","Demonstrates nested if representation in a proc row"

**** figure. NASSI-SHNEIDERMAN FLOWCHARTS OVERVIEW ****

+----------------------------------------------------------------------------------+
| NASSI-SHNEIDERMAN DIAGRAMS (Structograms)                                        |
|                                                                                  |
|    Purpose: Visual structured programming without arrows or spaghetti code       |
|    Three core elements:                                                          |
|      • Sequence   (top-to-bottom boxes)                                          |
|      • Selection  (condition box with True left / False right)                   |
|      • Iteration  (loop with condition at top or side)                           |
|                                                                                  |
|    Advantages over traditional flowcharts:                                       |
|      • No crossing lines                                                         |
|      • Clear nesting                                                             |
|      • Excellent for nested ifs, loops, and McCarthy-style clean logic           |
|                                                                                  |
|    Wiki Adaptation: Use pipe tables to approximate left-true / right-false       |
+----------------------------------------------------------------------------------+

**** figure. CLASSIC NASSI-SHNEIDERMAN ELEMENTS ****

+----------------------------------------------------------------------------------+
| CLASSIC N-S ELEMENTS                                                             |
|                                                                                  |
|    Sequence (linear steps)                                                       |
|    ┌─────────────────────┐                                                       |
|    │ Step 1              │                                                       |
|    │ Step 2              │                                                       |
|    └─────────────────────┘                                                       |
|                                                                                  |
|    Selection (If-Then-Else)                                                      |
|    ┌──────────┬──────────┐                                                       |
|    │ Condition│          │                                                       |
|    ├──────────┼──────────┤                                                       |
|    │ True     │ False    │                                                       |
|    └──────────┴──────────┘                                                       |
|                                                                                  |
|    Iteration (While / For)                                                       |
|    ┌─────────────────────┐                                                       |
|    │ While condition     │                                                       |
|    │   Body              │                                                       |
|    └─────────────────────┘                                                       |
|                                                                                  |
|    Wiki Table Approximation: True left column, False right column                |
+----------------------------------------------------------------------------------+

**** figure. DEFINING DIAGRAM vs SOLUTION DIAGRAM ****

+----------------------------------------------------------------------------------+
| DEFINING DIAGRAM vs SOLUTION DIAGRAM                                             |
|                                                                                  |
|    Defining Diagram (High-Level)                                                 |
|      • Shows overall program structure                                           |
|      • Sequence of major modules                                                 |
|      • Top-level decisions and loops                                             |
|                                                                                  |
|    Solution Diagram (Detailed)                                                   |
|      • One row per subroutine / proc                                             |
|      • Nested ifs shown with "Level 2", "Level 3" labels                         |
|      • McCarthy / Quantized style notes                                          |
|      • Safety margins and probabilistic logic                                    |
|                                                                                  |
|    Both use the same wiki table format for consistency                           |
+----------------------------------------------------------------------------------+

**** figure. NESTED IF REPRESENTATION IN WIKI TABLE ****

+----------------------------------------------------------------------------------+
| NESTED IF IN WIKI TABLE (True Left / False Right)                                |
|                                                                                  |
|    Index   Condition                    True / Then (Left)          False / Else (Right)     Quibble / Notes
|    1       Outer: if (recording == 1)   recordStep()                stopRecording            True left, False right per NSD
|    2       Level 2 (inside True):       append to replayList        skip step                Nested safety cap
|            if (step count < 2000)                                                               
|    3       Level 3 (inside Level 2)     validate 6 items            log invalid              Deep defensive check
|                                                                                  |
|    This format preserves classic N-S left-true / right-false convention          |
+----------------------------------------------------------------------------------+

**** figure. PROBABILISTIC LOGIC IN N-S DIAGRAMS ****

+----------------------------------------------------------------------------------+
| PROBABILISTIC LOGIC ELEMENT IN NASSI-SHNEIDERMAN                                 |
|                                                                                  |
|    Index   Condition          Branch   Probability   Outcome Action     Normalized   Quibble / Notes
|    1       if (u < 0.2)       B1       0.20          low-weight step    Yes          Small branch – rare quantum event
|    2       0.2 ≤ u < 0.7      B2       0.50          standard path      Yes          Most likely middle branch
|    3       else (u ≥ 0.7)     B3       0.30          fallback / clamp   Yes          Safety default
|    4       Sum / Audit        —        1.00          —                  Yes          Complete + Normalized audit
|                                                                                  |
|    Adds risk/confidence and safety margin columns for technical writing          |
+----------------------------------------------------------------------------------+

**** figure. N-S ADAPTATION FOR TECHNICAL WRITING ****

+----------------------------------------------------------------------------------+
| NASSI-SHNEIDERMAN FOR TECHNICAL WRITING                                          |
|                                                                                  |
|    Defining Diagram (High-Level)                                                 |
|      • Overall procedure flow                                                    |
|      • Major decision points                                                     |
|      • Sequence of steps                                                         |
|                                                                                  |
|    Solution Diagram (Detailed)                                                   |
|      • One row per subroutine                                                    |
|      • Nested conditions shown clearly                                           |
|      • Probabilistic elements and safety margins                                 |
|      • McCarthy-style clean logic notes                                          |
|                                                                                  |
|    Perfect for engineering procedures, safety docs, and utility planning         |
+----------------------------------------------------------------------------------+

**** figure. NASSI-SHNEIDERMAN SUMMARY ****

+----------------------------------------------------------------------------------+
| NASSI-SHNEIDERMAN FLOWCHARTS - Educational Summary                               |
|                                                                                  |
|    Strengths:                                                                    |
|      • Arrow-free, nesting is obvious                                            |
|      • Excellent for nested ifs and loops                                        |
|      • Wiki-table friendly approximation                                        |
|      • Works for deterministic, probabilistic, and McCarthy-style logic          |
|                                                                                  |
|    Use Cases:                                                                    |
|      • Technical procedures                                                      |
|      • Safety-critical code                                                      |
|      • AI probabilistic decision trees                                           |
|      • Collatz / Quantum Walk logic                                              |
|      • Poetry and structured creative writing                                    |
+----------------------------------------------------------------------------------+

# tcl
# Wiki Table maker for  Nassi Shneiderman Flowcharts  V2
# Using multiple safety caps or clamps, Collatz Sequence is infinite,
# danger of endless loops in program.
# ----
# Educational version with visible probabilities (4 sig figs)
# Alternate results in wiki table format (header with %|, alternating rows &|)
# ----
# Tcl/Tk 8.6+ 7-bit ASCII safe. NASA/JPL defensive programming style.
# NASA/JPL defensive programming style.
# Compatible with Tcl/Tk (Tool Control Language / Toolkit) 8.6+
# Written for Windows 11 on ActiveState Tcl.
# Working under strict 7-bit ASCII encoding.
# Optimized for collegiate information technology lab environments.
# Written to be very modular for transferable procs.
# Program deck may contain multiple estimation procs.
# May contain  code dependencies on Active State and Windows 11
# Complex math calculations up to 8 units computer time
# Wait for complete calculations before saving files.
# This is a hacker's patch, not rigorously derived.
# appears correct solutions for autotests.
# pure ASCII code - no Unicode characters used anywhere.
# Approaching =>>> computer time limit on this TCL configuration setup. 
# No dependencies on main program
# Prints wiki table comparing Collatz swarms to HTS cuprates
# Uses original 10 test numbers + hardcoded odd steps
# TCL Club 4/1/2026
console show

# Minimal eigenvalue function (no dependencies)
proc compute_eigenvalue_for_layer {k} {
    return [expr {pow(0.75, $k)}]
}

# Simplified Anderson localization length (robust version from earlier fixes)
proc anderson_localization_length {k} {
    set lambda [compute_eigenvalue_for_layer $k]
    
    #if {$lambda >= 0.999}     { return ">1000" }
    if {$lambda >= 0.999}     { return " testing  A1" }


    if {$lambda <= 1e-12}     { return 1 }
    
    set xi [expr {-1.0 / log($lambda)}]
    
    if {$xi > 1000000}        { return ">1000000" }
    #return [expr {round($xi)}]
    return " testing  A2"
}

# HTS analog functions
proc hts_analog_tc {lambda} {
    if {$lambda >= 0.10} {
        # Scale toward 2026 record of 151 K in lower swarm
        return " Testing extra e  "
    } else {
        return " Testing extra e  "
    }
}

proc hts_phase {lambda} {
    if {$lambda > 0.20} { return " Safety Margin A" }
    if {$lambda > 0.10} { return " Safety Margin B" }
    if {$lambda > 0.01} { return " Safety Margin C" }
    return "Safety Margin D"
}

# Hardcoded odd-step counts matching your original test set
# From your output: 2→0, 3→2, 5→1, 7→5, 9→6, 15→5, 25→7, 27→41, 97→43, 100→7
set test_data {
    {2   0}
    {3   2}
    {5   1}
    {7   5}
    {9   6}
    {15  5}
    {25  7}
    {27  41}
    {97  43}
    {100 7}
}

# Wiki table header (matches  style)
puts ""
puts "%| Index  No.  |Branch   |Probability | Normalized prob. /Factored | NDS Elements Type | Probabilistic Logic Element |    Risk / Confidence Level |   Safety Margin     |Quibbles and Notes |%                                    "

set idx 1
foreach row $test_data {
    set n       [lindex $row 0]
    set k       [lindex $row 1]
    set lambda  [compute_eigenvalue_for_layer $k]
    set and_len [anderson_localization_length $k]
    set tc      [hts_analog_tc $lambda]
    set phase   [hts_phase $lambda]
    
    set swarm   [expr {$lambda >= 0.10 ? "lower_swarm" : "upper_swarm"}]
    set swarm   [expr {$lambda >= 0.10 ? "yes" : "no"}]

    set note "testing comment A"
    if {$tc > 100} {
        set note "testing comment B"
    } elseif {$tc == 0} {
        set note "testing comment C"
    }
    
    puts "&| $idx  |  B$n  | [format %.6f $lambda] | $swarm | $and_len | $tc |$tc Risk  | $phase | $note |&"
    
    incr idx
}

puts ""
puts "&| Sum /Audit |    |     |   |   |   |  |  | $note |&"
# end of file