# Tcl
set bell_pair_lister {
    "Φ+ = (|00⟩ + |11⟩)/√2"
    "Φ- = (|00⟩ - |11⟩)/√2"
    "Ψ+ = (|01⟩ + |10⟩)/√2"
    "Ψ- = (|01⟩ - |10⟩)/√2"
}
# possibly pull context from list assignment
set phi_plus   [lindex $bell_pair_lister 0]
set phi_minus  [lindex $bell_pair_lister 1]
set psi_plus   [lindex $bell_pair_lister 2]
set psi_minus  [lindex $bell_pair_lister 3]
# lindex returns the element at the given zero‑based index.
# or else, Using lassign (multiple assignment)
# tcl
lassign $bell_pair_lister phi_plus phi_minus psi_plus psi_minus

"#","Bad / Cryptic","Good / Self-explaining","Why better?"
"1","x, tmp, data, i, res","userAgeInYears, temporaryPassword, allProducts","Immediately tells purpose"
"2","calc, process, doStuff","calculateTotalPriceWithTax, sendWelcomeEmail","Reveals what and why"
"3","getUser","findUserByEmail / getCurrentlyLoggedInUser","Different behaviors → different names"
"4","flag, status","isAccountActive, hasPaymentFailed, orderShipped","Boolean names should answer questions with yes/no"
"5","n, len, cnt","numberOfActiveUsers, totalItemsInCart","Avoid abbreviations unless universal (i→index ok)"

"Priority","What good code usually has","What to avoid"
"1","Extremely clear names","x, tmp, data, temp1"
"2","Functions < 20–30 lines","200-line monsters"
"3","One level of abstraction per function","Mix business + low-level details"
"4","Consistent naming convention","camelCase + snake_case mix"
"5","Meaningful distinction between similar concepts","user, usr, userData, theUser"
"6","Comments only when WHY is not obvious","Explaining WHAT good names already say"
"7","Domain language over technical language","processEntities → approveCustomerOrders" 

1. Take one sheet of plain paper.
2. Fold the paper in half from bottom to top so the two top edges (lips) meet.
3. The fold at the bottom now represents the EPR pair (entanglement link).
4. The main loop of paper around the outside represents space-time distance.
5. On the left lip, write the symbol |ψ⟩ to show the state to teleport.
6. On the right lip, write |0⟩ to show the starting state of the receiver qubit.
7. To simulate measurement: touch the left lip and erase |ψ⟩.
8. Write a classical result on the left lip (example: |0⟩ or |1⟩).
9. Trace a finger along the outside loop from left to right to show classical bits traveling.
10. When the finger reaches the right lip, erase |0⟩.
11. Write |ψ⟩ on the right lip.
12. Explain: the state |ψ⟩ now appears on the right only after classical info arrives.

Index,Metric,TCL 8.6,Python 3.14+,Quibble Notes
1,Total lines (all content),571,699,Python is 22.4 pct longer overall due to docstrings and type annotations
2,Hash-comment lines (#),271,168,TCL tutorial header is 120 lines; Python splits doc across docstrings instead
3,Docstring delimiter lines ("""),n/a,28,Python only; one open + one close per function; no TCL equivalent
4,Blank / whitespace lines,38,86,Python style guide (PEP 8) requires two blank lines between top-level defs
5,Executable code lines (derived),262,417,Total minus hash-comments minus docstring delimiters minus blanks
6,Comment-to-total ratio,47.5 pct,28.0 pct,TCL front-loads the entire tutorial in one comment block at the top
7,Code-to-total ratio,45.9 pct,59.7 pct,Python carries more executable lines; type hints add one line per argument
8,Python code overhead vs TCL,--,+155 lines,+59.2 pct more executable lines; match statement and type annotations are verbose

# Quantum Teleportation Fidelity Simulator with Noise V4
# toy on wiki page 
# ================================================================
# Quantum Teleportation Fidelity Simulator with Simple Noise Model
# Educational / demonstration script - strict 7-bit ASCII only
# Intended for Tcl Playground or minimal Tcl interpreters
# 2025-2026 version - heavily commented for future maintainers
# ================================================================
# may have to check strict ASCII for Playground V9
# Compatible with Tcl/Tk 8.6+
# TCL source code follows
# Written for Windows 11 on ActiveState Tcl
# Working on TCL Playground V9, strict ASCII only
# Optimized for collegiate IT lab environments
# Working under TCL version 8.6
# Complex math calculations up to 3 units computer time
# Wait for complete calculations before saving files.
# TCL club, 02/12/2026
# This is a hacker's patch, not rigorously derived.
# appears correct autotest
# pure ASCII code - no Unicode characters used anywhere
puts "Quantum Teleportation Fidelity Simulator with Noise"
puts "---------------------------------------------------"
puts "  (state normalized after noise → fidelity <= 1.0)"
puts ""

# ----------------------------------------------------------------
# Procedure: Calculate how close the teleported state is to original
#            Includes optional random noise to simulate real-world
#            imperfections (decoherence, gate errors, etc.)
#            Now normalizes Bob's state after noise so norm=1.
# ----------------------------------------------------------------
proc CalculateTeleportationFidelityWithNoise \
    {inputAlphaRealPart inputAlphaImagPart \
     inputBetaRealPart  inputBetaImagPart  \
     {maximumNoiseAmplitude 0.05}} {

    # ------------------------------------------------------------------------
    # Bob ideally receives exactly the same state Alice sent
    # We start by copying the input coefficients to Bob's reconstructed state
    # ------------------------------------------------------------------------
    set bobReconstructedAlphaReal $inputAlphaRealPart
    set bobReconstructedAlphaImag $inputAlphaImagPart
    set bobReconstructedBetaReal  $inputBetaRealPart
    set bobReconstructedBetaImag  $inputBetaImagPart

    # --------------------------------------------------------------------
    # Simulate small random errors (very simple decoherence / gate noise)
    # Noise is added only to the real parts in this toy model
    # --------------------------------------------------------------------
    set randomNoiseForAlpha [expr {$maximumNoiseAmplitude * (rand() - 0.5)}]
    set randomNoiseForBeta  [expr {$maximumNoiseAmplitude * (rand() - 0.5)}]

    set bobReconstructedAlphaReal \
        [expr {$bobReconstructedAlphaReal + $randomNoiseForAlpha}]

    set bobReconstructedBetaReal \
        [expr {$bobReconstructedBetaReal + $randomNoiseForBeta}]

    # --------------------------------------------------------------------
    # NEW: Re-normalize Bob's state vector so ||psi|| = 1
    #     This is physically required and prevents fidelity > 1.0
    # --------------------------------------------------------------------
    set currentNormSquared \
        [expr {$bobReconstructedAlphaReal**2 + \
               $bobReconstructedAlphaImag**2 + \
               $bobReconstructedBetaReal**2  + \
               $bobReconstructedBetaImag**2}]

    if {$currentNormSquared > 0.0} {
        set normalizationScaleFactor [expr {1.0 / sqrt($currentNormSquared)}]

        set bobReconstructedAlphaReal \
            [expr {$bobReconstructedAlphaReal * $normalizationScaleFactor}]

        set bobReconstructedAlphaImag \
            [expr {$bobReconstructedAlphaImag * $normalizationScaleFactor}]

        set bobReconstructedBetaReal \
            [expr {$bobReconstructedBetaReal * $normalizationScaleFactor}]

        set bobReconstructedBetaImag \
            [expr {$bobReconstructedBetaImag * $normalizationScaleFactor}]
    }
    # (if norm was exactly zero — extremely unlikely — we leave it alone)

    # --------------------------------------------------------------------
    # Compute the complex inner product <input_state | bob_state>
    # (overlap between original and received state)
    # --------------------------------------------------------------------
    set realPartOfOverlap \
        [expr {$inputAlphaRealPart * $bobReconstructedAlphaReal + \
               $inputAlphaImagPart * $bobReconstructedAlphaImag + \
               $inputBetaRealPart  * $bobReconstructedBetaReal  + \
               $inputBetaImagPart  * $bobReconstructedBetaImag}]

    set imagPartOfOverlap \
        [expr {$inputAlphaRealPart * $bobReconstructedBetaImag  - \
               $inputAlphaImagPart * $bobReconstructedBetaReal  + \
               $inputBetaRealPart  * $bobReconstructedAlphaImag  - \
               $inputBetaImagPart  * $bobReconstructedAlphaReal}]

    # --------------------------------------------------------------------
    # Fidelity = |<input|bob>|^2   (now guaranteed 0 <= fidelity <= 1)
    # --------------------------------------------------------------------
    set fidelityValue \
        [expr {$realPartOfOverlap * $realPartOfOverlap + \
               $imagPartOfOverlap  * $imagPartOfOverlap}]

    # Return list containing Bob's coefficients + final fidelity
    return [list $bobReconstructedAlphaReal \
                 $bobReconstructedAlphaImag \
                 $bobReconstructedBetaReal \
                 $bobReconstructedBetaImag \
                 $fidelityValue]
}

# --------------------------------------------------------------------
# Helper to print one result line in readable format
# --------------------------------------------------------------------
proc PrintSingleFidelityResult {description \
                                alphaReal alphaImag \
                                betaReal  betaImag  \
                                fidelity} {

    puts [format "%-26s  %8.4f + %8.4fi   %8.4f + %8.4fi   fidelity = %.4f" \
                 $description \
                 $alphaReal $alphaImag \
                 $betaReal  $betaImag \
                 $fidelity]
}

# ===============================================
#               EXAMPLE RUNS
# ===============================================

puts "Example runs:"
puts ""

# Example 1 - approximate state (not perfectly normalized input)
set resultList [CalculateTeleportationFidelityWithNoise 0.8 0.0 0.6 0.0 0.02]
PrintSingleFidelityResult "~ 0.8|0> + 0.6|1>" {*}$resultList

# Example 2 - Hadamard / plus state (|0> + |1>)/sqrt(2)
set resultList [CalculateTeleportationFidelityWithNoise 0.7071 0.0 0.7071 0.0 0.10]
PrintSingleFidelityResult "(|0> + |1>)/sqrt(2)" {*}$resultList

puts ""
puts ""

# ===============================================
#               AUTOTEST / BENCHMARK SECTION
# ===============================================

puts "AUTOTEST: 20 independent trials with varied states and noise"
puts "------------------------------------------------------------"
puts " Trial   State approx description      Noise    Fidelity  "
puts "------------------------------------------------------------"

set sumOfAllFidelities 0.0
set numberOfTrialsCompleted 0

for {set trialNumber 1} {$trialNumber <= 20} {incr trialNumber} {

    # Create test state using angle parameterization (Bloch sphere style)
    set angleTheta [expr {$trialNumber * 3.1415926535 / 11.0}]

    set inputAlphaReal [expr {cos($angleTheta / 2.0)}]
    set inputAlphaImag 0.0

    set inputBetaReal  [expr {sin($angleTheta / 2.0) * cos($trialNumber * 0.7)}]
    set inputBetaImag  [expr {sin($angleTheta / 2.0) * sin($trialNumber * 0.7)}]

    # Noise strength varies randomly between 1% and 15%
    set noiseStrengthThisTrial [expr {0.01 + 0.14 * rand()}]

    set resultList \
        [CalculateTeleportationFidelityWithNoise \
             $inputAlphaReal $inputAlphaImag \
             $inputBetaReal  $inputBetaImag  \
             $noiseStrengthThisTrial]

    set thisTrialFidelity [lindex $resultList 4]

    set shortStateDescription [format "cos(%.2f/2)|0> + ..." $angleTheta]

    puts [format "%5d   %-24s   %5.3f    %.4f" \
                 $trialNumber \
                 $shortStateDescription \
                 $noiseStrengthThisTrial \
                 $thisTrialFidelity]

    set sumOfAllFidelities [expr {$sumOfAllFidelities + $thisTrialFidelity}]
    incr numberOfTrialsCompleted
}

set averageFidelity [expr {$sumOfAllFidelities / $numberOfTrialsCompleted}]

puts "------------------------------------------------------------"
puts "Average fidelity across $numberOfTrialsCompleted trials : [format %.4f $averageFidelity]"
puts "Note: fidelity is now guaranteed <= 1.0000 due to normalization"
puts "Done."
puts ""

Quantum Teleportation Fidelity Simulator with Noise


Example runs:

|psi> ≈ 0.8|0> + 0.6|1>     0.8023 + 0.0000i   0.5971 + 0.0000i   fidelity = 0.9998
|+> = ( |0> + |1> )/√2     0.7104 + 0.0000i   0.6992 + 0.0000i   fidelity = 0.9872


AUTOTEST: 20 trials with different states and noise levels
----------------------------------------------------------
  Trial   State description           Noise   Fidelity
----------------------------------------------------------
   1    cos(0.29/2)|0> + ...        0.042    0.9987
   2    cos(0.57/2)|0> + ...        0.118    0.9721
   3    cos(0.86/2)|0> + ...        0.031    0.9992
...
  20    cos(5.71/2)|0> + ...        0.089    0.9845
----------------------------------------------------------
Average fidelity over 20 trials : 0.9876
Note: values < 1.0 come from added noise (decoherence/gate error model)
Done. 

Quantum Teleportation Fidelity Simulator with Noise

Example runs:

|psi> ≈ 0.8|0> + 0.6|1>  0.7950 + 0.0000i   0.5928 + 0.0000i   fidelity = 0.9835
|+> = ( |0> + |1> )/√2  0.7127 + 0.0000i   0.6598 + 0.0000i   fidelity = 0.9418


AUTOTEST: 20 trials with different states and noise levels
----------------------------------------------------------
  Trial   State description           Noise   Fidelity
----------------------------------------------------------
   1    cos(0.29/2)|0> + ...    0.119    0.8930
   2    cos(0.57/2)|0> + ...    0.069    1.0217
   3    cos(0.86/2)|0> + ...    0.077    0.9522
   4    cos(1.14/2)|0> + ...    0.057    1.0486
   5    cos(1.43/2)|0> + ...    0.028    0.9874
   6    cos(1.71/2)|0> + ...    0.067    0.9913
   7    cos(2.00/2)|0> + ...    0.023    0.9996
   8    cos(2.28/2)|0> + ...    0.127    0.9663
   9    cos(2.57/2)|0> + ...    0.084    1.0263
  10    cos(2.86/2)|0> + ...    0.013    1.0101
  11    cos(3.14/2)|0> + ...    0.105    1.0089
  12    cos(3.43/2)|0> + ...    0.040    1.0222
  13    cos(3.71/2)|0> + ...    0.060    0.9851
  14    cos(4.00/2)|0> + ...    0.032    1.0269
  15    cos(4.28/2)|0> + ...    0.049    0.9928
  16    cos(4.57/2)|0> + ...    0.144    0.9770
  17    cos(4.86/2)|0> + ...    0.113    0.9614
  18    cos(5.14/2)|0> + ...    0.136    0.9502
  19    cos(5.43/2)|0> + ...    0.110    0.9375
  20    cos(5.71/2)|0> + ...    0.019    1.0069
----------------------------------------------------------
Average fidelity over 20 trials : 0.9883
Note: values < 1.0 come from added noise (decoherence/gate error model)
Done.

>     set total_fid [expr {$total_fid + $fid}]
>     incr count
> }
   1    cos(0.29/2)|0> + ...    0.148    0.8878
   2    cos(0.57/2)|0> + ...    0.079    0.9417
   3    cos(0.86/2)|0> + ...    0.138    1.1251
   4    cos(1.14/2)|0> + ...    0.020    0.9779
   5    cos(1.43/2)|0> + ...    0.039    1.0238
   6    cos(1.71/2)|0> + ...    0.063    1.0482
   7    cos(2.00/2)|0> + ...    0.084    1.0366
   8    cos(2.28/2)|0> + ...    0.028    1.0104
   9    cos(2.57/2)|0> + ...    0.136    0.8994
  10    cos(2.86/2)|0> + ...    0.093    0.9916
  11    cos(3.14/2)|0> + ...    0.146    1.0213
  12    cos(3.43/2)|0> + ...    0.056    1.0356
  13    cos(3.71/2)|0> + ...    0.063    0.9626
  14    cos(4.00/2)|0> + ...    0.020    1.0164
  15    cos(4.28/2)|0> + ...    0.063    0.9751
  16    cos(4.57/2)|0> + ...    0.016    0.9913
  17    cos(4.86/2)|0> + ...    0.059    1.0155
  18    cos(5.14/2)|0> + ...    0.061    0.9745
  19    cos(5.43/2)|0> + ...    0.030    0.9825
  20    cos(5.71/2)|0> + ...    0.069    1.0287
(tcl) 28 % 
(tcl) 28 % set avg [expr {$total_fid / $count}]
0.9973089741691569
(tcl) 29 % puts "----------------------------------------------------------"
----------------------------------------------------------
(tcl) 30 % puts "Average fidelity over 20 trials : [format %.4f $avg]"
Average fidelity over 20 trials : 0.9973
(tcl) 31 % puts "Note: values < 1.0 come from added noise (decoherence/gate error model)"
Note: values < 1.0 come from added noise (decoherence/gate error model)
(tcl) 32 % puts "Done.\n"
Done.

]
> 
>     set sumOfAllFidelities [expr {$sumOfAllFidelities + $thisTrialFidelity}]
>     incr numberOfTrialsCompleted
> }
    1   cos(0.29/2)|0> + ...       0.132    0.9973
    2   cos(0.57/2)|0> + ...       0.033    1.0000
    3   cos(0.86/2)|0> + ...       0.043    0.9999
    4   cos(1.14/2)|0> + ...       0.146    0.9984
    5   cos(1.43/2)|0> + ...       0.148    0.9997
    6   cos(1.71/2)|0> + ...       0.084    0.9987
    7   cos(2.00/2)|0> + ...       0.061    1.0000
    8   cos(2.28/2)|0> + ...       0.068    0.9990
    9   cos(2.57/2)|0> + ...       0.015    1.0000
   10   cos(2.86/2)|0> + ...       0.099    0.9984
   11   cos(3.14/2)|0> + ...       0.110    1.0000
   12   cos(3.43/2)|0> + ...       0.038    0.9996
   13   cos(3.71/2)|0> + ...       0.105    0.9986
   14   cos(4.00/2)|0> + ...       0.086    0.9997
   15   cos(4.28/2)|0> + ...       0.114    0.9981
   16   cos(4.57/2)|0> + ...       0.038    1.0000
   17   cos(4.86/2)|0> + ...       0.119    0.9983
   18   cos(5.14/2)|0> + ...       0.119    0.9996
   19   cos(5.43/2)|0> + ...       0.066    1.0000
   20   cos(5.71/2)|0> + ...       0.104    0.9999
(tcl) 60 % 
(tcl) 60 % set averageFidelity [expr {$sumOfAllFidelities / $numberOfTrialsCompleted}]
0.9992615945463484
(tcl) 61 % 
(tcl) 61 % puts "------------------------------------------------------------"
------------------------------------------------------------
(tcl) 62 % puts "Average fidelity across $numberOfTrialsCompleted trials : [format %.4f $averageFidelity]"
Average fidelity across 20 trials : 0.9993
(tcl) 63 % puts "Note: fidelity is now guaranteed <= 1.0000 due to normalization"
Note: fidelity is now guaranteed <= 1.0000 due to normalization
(tcl) 64 % puts "Done."
Done.
(tcl) 65 % puts ""

(

# trial ouput, no frills.
(tcl) 24 % 
(tcl) 24 % # Automatically run tests when script loads
(tcl) 25 % run_autotests
Test phi+ matching bits: PASS (mismatches: 0)
Test phi- matching bits: PASS (mismatches: 0)
Test psi+ opposite bits: PASS (same-bit cases: 0)
Test psi- opposite bits: PASS (same-bit cases: 0)

Overall: ALL TESTS PASSED

Bell States Simulator Reorg V2 - Sample Measurements

Examples for phi-plus (matching bits -- same arrow on both lips):
  Trial  1:  Alice -> 0    Bob -> 0
  Trial  2:  Alice -> 0    Bob -> 0
  Trial  3:  Alice -> 0    Bob -> 0
  Trial  4:  Alice -> 1    Bob -> 1
  Trial  5:  Alice -> 1    Bob -> 1
  Trial  6:  Alice -> 1    Bob -> 1
  Trial  7:  Alice -> 0    Bob -> 0
  Trial  8:  Alice -> 0    Bob -> 0

Examples for psi-minus (opposite bits -- arrows point opposite directions):
  Trial  1:  Alice -> 0    Bob -> 1
  Trial  2:  Alice -> 0    Bob -> 1
  Trial  3:  Alice -> 1    Bob -> 0
  Trial  4:  Alice -> 0    Bob -> 1
  Trial  5:  Alice -> 1    Bob -> 0
  Trial  6:  Alice -> 1    Bob -> 0
  Trial  7:  Alice -> 0    Bob -> 1
  Trial  8:  Alice -> 1    Bob -> 0

==============================================================
 Bell States Simulator Reorg V2 - Seven Autotests
 TCL Club 02/2026 -- Quantum Entanglement Correlation Verifier
==============================================================

Paper-fold analogy: crease = entangled link between two qubits.
phi-plus / phi-minus : both lips show same arrow  (matching bits).
psi-plus / psi-minus : lips show opposite arrows  (opposite bits).

--- Autotest 1 ---
  Input  : Bell state phi-plus  (matching-outcome state)
  Expect : Alice bit == Bob bit on every trial
  Trials : 500
  Output : PASS -- all 500 trials matched

--- Autotest 2 ---
  Input  : Bell state phi-minus  (matching-outcome state)
  Expect : Alice bit == Bob bit on every trial
  Trials : 500
  Output : PASS -- all 500 trials matched

--- Autotest 3 ---
  Input  : Bell state psi-plus  (opposite-outcome state)
  Expect : Alice bit != Bob bit on every trial
  Trials : 500
  Output : PASS -- all 500 trials were opposite

--- Autotest 4 ---
  Input  : Bell state psi-minus  (opposite-outcome state)
  Expect : Alice bit != Bob bit on every trial
  Trials : 500
  Output : PASS -- all 500 trials were opposite

--- Autotest 5 ---
  Input  : invalid Bell state name = 'phi_plus'
  Expect : assertion error raised (defensive guard fires)
  Output : PASS -- error correctly raised: ASSERTION FAILED: simulateSingleBellMeasurement: unknown Bell state 'phi_plus'

--- Autotest 6 ---
  Input  : invalid Bell state name = ''
  Expect : assertion error raised (defensive guard fires)
  Output : PASS -- error correctly raised: ASSERTION FAILED: simulateSingleBellMeasurement: unknown Bell state ''

--- Autotest 7 ---
  Input  : Bell state phi-plus  (timing measurement)
  Expect : average microseconds per call reported
  Output : 9.5716 microseconds per call (1000-iteration average)

==============================================================
 All 7 autotests completed successfully. ALL TESTS PASSED.
==============================================================