Python playground

Read side by side

Explore Komorebi's special functions, physics examples, sequences, and worked calculations. Change the inputs, inspect the graphs, and follow the links to the written mathematics.

Python starts when you press Run. The first run downloads about 13 MB of runtime files. The library example also loads NumPy and Komorebi Math. Calculations run in your browser. Use Save draft to keep edited code in this browser, or download it as a Python file. Unsaved code and selected data may be lost when you leave or reload the page.

The editor is a plain text field. Tab moves to the next control. Run uses a fresh Python namespace. Stop ends the runtime. Reset restores the selected preset. Fixed expected values may need updating when you change an input.

Upload data or open saved Python code

CSV or JSON data files

Up to 5 UTF-8 files, 2 MB each and 4 MB in total. The page reads them locally. It does not upload them to a server. Python receives their text in the uploaded_files dictionary. Try the Plot CSV or JSON data preset.

No data files selected.

Sample CSV · Sample JSON

Open a Python file in the selected editor

This replaces the selected editor's text. It does not run the code. Maximum 256 KB.

Choose an example, then press Run.

Separate equal histograms with an arithmetic projector

Use the book’s modulus-12 Ramanujan projector to distinguish signed, unsigned, and dephased states. Edit a rational unit phase; download exact probabilities.

Physics collection, hand calculations and proof sources

Plotting, data and saving guide

Python code: Separate equal histograms with an arithmetic projector

from fractions import Fraction as Q
import csv
import io
from komorebi_browser import show_plot, export_file

# Quantum and Circuits, quantum arithmetic QA13-QA14 and QA19-QA20.
c = (4, 0, 2, 0, -2, 0, -4, 0, -2, 0, 2, 0)
phase_real, phase_imag = Q(3, 5), Q(4, 5)
if phase_real**2 + phase_imag**2 != 1:
    raise ValueError("Choose a unit phase: real squared + imaginary squared = 1.")
projector = [[Q(c[(n-m) % 12], 12) for m in range(12)] for n in range(12)]
histogram = [Q(x*x, 48) for x in c]

def selected(real, imag):
    # Unnormalized v_+ + z v_-; divide squared norms by 48.
    vr = [Q(abs(x)) if x >= 0 else abs(x)*real for x in c]
    vi = [Q(0) if x >= 0 else abs(x)*imag for x in c]
    pr = [sum(row[m]*vr[m] for m in range(12)) for row in projector]
    pi = [sum(row[m]*vi[m] for m in range(12)) for row in projector]
    probability = sum(a*a+b*b for a, b in zip(pr, pi))/48
    assert probability == (1-real)/2
    return probability

dephased = sum(projector[n][n]*histogram[n] for n in range(12))
print("Common coordinate probabilities sum:", sum(histogram))
print("Selected probability, edited phase:", selected(phase_real, phase_imag))
print("Unsigned coherent:", selected(Q(1), Q(0)))
print("Signed coherent:", selected(Q(-1), Q(0)))
print("Complete coordinate dephasing:", dephased)
phases = [("1", Q(1), Q(0)), ("i", Q(0), Q(1)), ("-1", Q(-1), Q(0)),
          ("-i", Q(0), Q(-1)), ("edited phase", phase_real, phase_imag)]
rows = [(label, re, im, selected(re, im), dephased) for label, re, im in phases]
show_plot([
    {"type": "bar", "x": [r[0] for r in rows], "y": [float(r[3]) for r in rows], "name": "Coherent state"},
    {"type": "bar", "x": [r[0] for r in rows], "y": [float(r[4]) for r in rows], "name": "After coordinate dephasing"},
], {"title": {"text": "Same coordinate histogram, different arithmetic interference"},
    "barmode": "group", "yaxis": {"title": {"text": "Selected probability"}, "range": [0, 1]}},
    description="The modulus-12 projector selects four coprime Fourier labels. The unsigned coherent state has probability zero, the signed state one, and all fully coordinate-dephased states one third. Other phases interpolate without changing the original coordinate histogram. CSV fractions are exact; bar heights use floating-point conversion.")
stream = io.StringIO(newline="")
writer = csv.writer(stream, lineterminator="\n")
writer.writerow(["phase", "phase_real", "phase_imag", "coherent_selected_probability", "dephased_selected_probability"])
writer.writerows(rows)
export_file("arithmetic-phase.csv", stream.getvalue())
print("Exported 5 exact phase comparisons.")

Download original code Jump to results

Expected output for the published preset

Common coordinate probabilities sum: 1
Selected probability, edited phase: 1/5
Unsigned coherent: 0
Signed coherent: 1
Complete coordinate dephasing: 1/3
Exported 5 exact phase comparisons.

This is the original example's output. Your edits may change it.

Recover a state after partial dephasing

Edit a rational unit phase and retained coherence t. Compare three measurement settings, reconstruct the density matrix, and export exact probabilities and purity.

Physics collection, hand calculations and proof sources

Plotting, data and saving guide

Python code: Recover a state after partial dephasing

from fractions import Fraction as Q
import csv
import io
from komorebi_browser import show_plot, export_file

# Edit these exact inputs. phase_real**2 + phase_imag**2 must equal 1.
phase_real, phase_imag = Q(3, 5), Q(4, 5)
t = Q(1, 2)  # Retained coherence: 0 means full dephasing; 1 means none.
if phase_real**2 + phase_imag**2 != 1:
    raise ValueError("Choose a unit phase: real squared + imaginary squared = 1.")
if not 0 <= t <= 1:
    raise ValueError("Retained coherence t must lie in [0, 1].")
p, q = Q(9, 25), Q(16, 25)
original_re, original_im = Q(12, 25)*phase_real, -Q(12, 25)*phase_imag

def measure(retained):
    re, im = retained*original_re, retained*original_im
    return Q(1, 2)+re, Q(1, 2)-im, p, p*p+q*q+2*(re*re+im*im)

px, py, pz, purity = measure(t)
# Tomography uses exact ensemble probabilities from three alternative settings.
reconstructed_re, reconstructed_im = px-Q(1, 2), Q(1, 2)-py
assert (reconstructed_re, reconstructed_im) == (t*original_re, t*original_im)
print(f"Phase: ({phase_real}) + ({phase_imag})i")
print("Retained coherence:", t)
print(f"Measured X+, Y+, Z+: {px}, {py}, {pz}")
print("Output purity:", purity)
if t:
    recovered_re, recovered_im = reconstructed_re/t, reconstructed_im/t
    assert (recovered_re, recovered_im) == (original_re, original_im)
    print(f"Recovered original upper-right entry: ({recovered_re}) + ({recovered_im})i")
else:
    print("Full dephasing: the original coherence cannot be recovered from this output.")

retained_values = [Q(j, 8) for j in range(9)]
rows = [(s, *measure(s), Q(288, 625)*(1-s)**2) for s in retained_values]
traces = []
for index, label in ((1, "X-plus"), (2, "Y-plus"), (3, "Z-plus"), (4, "Purity")):
    traces.append({"x": list(map(float, retained_values)),
                   "y": [float(row[index]) for row in rows],
                   "name": label, "mode": "lines+markers"})
show_plot(traces, {"title": {"text": "Partial dephasing: measurement and purity"},
    "xaxis": {"title": {"text": "Retained coherence t"}},
    "yaxis": {"title": {"text": "Probability or purity"}, "range": [0, 1]}},
    description="Nine exact rational coherence fractions from zero to one. Z probability stays at 9/25. X and Y probabilities depend on the chosen phase; purity rises from 337/625 to one. Plot coordinates are floating-point conversions; the CSV preserves exact fractions.")
stream = io.StringIO(newline="")
writer = csv.writer(stream, lineterminator="\n")
writer.writerow(["retained_coherence", "p_X_plus", "p_Y_plus", "p_Z_plus", "purity", "squared_HS_error"])
writer.writerows(rows)
export_file("partial-dephasing.csv", stream.getvalue())
print("Exported 9 exact partial-dephasing rows.")

Download original code Jump to results

Expected output for the published preset

Phase: (3/5) + (4/5)i
Retained coherence: 1/2
Measured X+, Y+, Z+: 161/250, 173/250, 9/25
Output purity: 409/625
Recovered original upper-right entry: (36/125) + (-48/125)i
Exported 9 exact partial-dephasing rows.

This is the original example's output. Your edits may change it.

Watch probability move between packets

Rotate a two-component state, follow its packet squared norms, and check the receiving-first current signs. This is a finite mathematical example.

Physics collection, hand calculations and proof sources

Plotting, data and saving guide

Python code: Watch probability move between packets

from fractions import Fraction as Q
from math import cos, sin, pi
from komorebi_browser import show_plot

# A = [[0, -1], [1, 0]], psi(0) = (1, 1).
# psi is intentionally unnormalized. The conserved squared norm is 2.
x, y = Q(1), Q(1)
incoming = (2*x*(-y), 2*y*x)
assert incoming == (-2, 2) and sum(incoming) == 0
print(f"Initial packet squared norms: {x*x}, {y*y}")
print(f"Initial incoming currents: {incoming[0]}, {incoming[1]}")
print("Total squared norm:", x*x+y*y)

times = [2*pi*j/160 for j in range(161)]
e0 = [(cos(t)-sin(t))**2 for t in times]
e1 = [(sin(t)+cos(t))**2 for t in times]
show_plot([
    {"x": times, "y": e0, "name": "Packet 0", "mode": "lines"},
    {"x": times, "y": e1, "name": "Packet 1", "mode": "lines", "line": {"dash": "dash"}},
    {"x": times, "y": [a+b for a,b in zip(e0,e1)], "name": "Total", "mode": "lines", "line": {"dash": "dot"}},
], {"title": {"text": "Exchange between two orthogonal packets"},
    "xaxis": {"title": {"text": "Time t"}},
    "yaxis": {"title": {"text": "Squared norm"}}},
    description="The two packet squared norms exchange between zero and two. Their sum stays at two. Divide each by two to get normalized probabilities. The initial incoming currents are minus two and plus two.")
print("Plotted 161 times on [0, 2 pi].")

Download original code Jump to results

Expected output for the published preset

Initial packet squared norms: 1, 1
Initial incoming currents: -2, 2
Total squared norm: 2
Plotted 161 times on [0, 2 pi].

This is the original example's output. Your edits may change it.

See quantum phase change a measurement

Compare (3/5, 4i/5) and (3/5, 4/5). Exact rational probabilities agree in the coordinate basis and differ after a Hadamard change of basis.

Physics collection, hand calculations and proof sources

Plotting, data and saving guide

Python code: See quantum phase change a measurement

from fractions import Fraction as Q
from komorebi_browser import show_plot

a, b = Q(3, 5), Q(4, 5)
if a*a+b*b != 1:
    raise ValueError("Choose real a and b with a*a+b*b = 1.")
coordinate = (a*a, b*b)
# H(a, ib) = ((a+ib)/sqrt(2), (a-ib)/sqrt(2)).
phase_i = ((a*a+b*b)/2, (a*a+b*b)/2)
phase_1 = ((a+b)**2/2, (a-b)**2/2)
purity = sum(p*p for p in coordinate)
print(f"Coordinate probabilities: {coordinate[0]}, {coordinate[1]}")
print(f"Hadamard probabilities with phase i: {phase_i[0]}, {phase_i[1]}")
print(f"Hadamard probabilities with phase 1: {phase_1[0]}, {phase_1[1]}")
print("Purity after coordinate dephasing:", purity)
show_plot([
    {"type": "bar", "x": ["Outcome 0", "Outcome 1"], "y": list(map(float, coordinate)), "name": "Coordinate basis, either state"},
    {"type": "bar", "x": ["Outcome 0", "Outcome 1"], "y": list(map(float, phase_i)), "name": "Hadamard basis, phase i"},
    {"type": "bar", "x": ["Outcome 0", "Outcome 1"], "y": list(map(float, phase_1)), "name": "Hadamard basis, phase 1"},
], {"title": {"text": "Relative phase changes interference"}, "barmode": "group",
    "yaxis": {"title": {"text": "Probability"}, "range": [0, 1]}},
    description="Both states have coordinate probabilities 9/25 and 16/25. After a Hadamard transformation, the phase-i state has probabilities one half and one half; the real state has probabilities 49/50 and 1/50. Printed fractions are exact; bar heights use floating-point conversion.")

Download original code Jump to results

Expected output for the published preset

Coordinate probabilities: 9/25, 16/25
Hadamard probabilities with phase i: 1/2, 1/2
Hadamard probabilities with phase 1: 49/50, 1/50
Purity after coordinate dephasing: 337/625

This is the original example's output. Your edits may change it.

Compare a centered symbol with its continuum limit

Plot sin(h k)/h beside k, then compare a fixed three-momentum modal error with the quadratic envelope. Floating-point samples illustrate the source theorem.

Physics collection, hand calculations and proof sources

Plotting, data and saving guide

Python code: Compare a centered symbol with its continuum limit

import csv
import io
from math import sin, sqrt
from komorebi_browser import show_plot, export_file

momentum = (1, 2, -1)
spacings = [0.5, 0.25, 0.125, 0.0625]
if any(h == 0 for h in spacings):
    raise ValueError("Use nonzero spacings; the bounded global operator has a separate zero-spacing convention.")
ks = [-4+j/20 for j in range(161)]
traces = [{"x": ks, "y": ks, "name": "Continuum k", "mode": "lines", "line": {"dash": "dash"}}]
for h in spacings[:2]:
    traces.append({"x": ks, "y": [sin(h*k)/h for k in ks], "name": f"Centered, h={h}", "mode": "lines"})
show_plot(traces, {"title": {"text": "Centered spatial symbol"},
    "xaxis": {"title": {"text": "Momentum coordinate k"}},
    "yaxis": {"title": {"text": "Symbol"}}},
    description="The continuum symbol is the line k. Centered symbols sin(h k)/h approach that line at each fixed k as the nonzero spacing tends to zero. This plot uses a fixed momentum window.")

moment = sqrt(sum(k**6 for k in momentum))
rows = [(h, sqrt(sum((sin(h*k)/h-k)**2 for k in momentum)), h*h*moment/6) for h in spacings]
show_plot([
    {"x": spacings, "y": [row[1] for row in rows], "name": "Modal symbol error", "mode": "lines+markers"},
    {"x": spacings, "y": [row[2] for row in rows], "name": "h squared times sqrt(66) / 6", "mode": "lines+markers", "line": {"dash": "dash"}},
], {"title": {"text": "Quadratic error at fixed momentum (1, 2, -1)"},
    "xaxis": {"title": {"text": "Nonzero spacing h"}, "type": "log"},
    "yaxis": {"title": {"text": "Error or envelope"}, "type": "log"}},
    description="Four fixed-momentum symbol errors lie below the h-squared envelope. This is a finite floating-point illustration, with values available as CSV. It does not test arbitrary infinite Fourier series or a changing finite lattice.")
stream = io.StringIO(newline="")
writer = csv.writer(stream, lineterminator="\n")
writer.writerow(["h", "modal_symbol_error", "quadratic_envelope"])
writer.writerows(rows)
export_file("centered-modal-errors.csv", stream.getvalue())
print("Fixed momentum:", momentum)
print("Spacings:", ", ".join(map(str, spacings)))
print("Exported 4 modal error comparisons.")
print("These floating-point samples illustrate the bound; the Lean source supplies the general theorem.")

Download original code Jump to results

Expected output for the published preset

Fixed momentum: (1, 2, -1)
Spacings: 0.5, 0.25, 0.125, 0.0625
Exported 4 modal error comparisons.
These floating-point samples illustrate the bound; the Lean source supplies the general theorem.

This is the original example's output. Your edits may change it.

Explore coupled contraction functions

Compute exact rational coefficients for two coupled series, plot their degree-23 Taylor polynomials, and display the source majorant on the unit disk.

Function definitions, reading volumes and proof sources

Plotting, data and saving guide

Python code: Explore coupled contraction functions

from fractions import Fraction as Q
from komorebi_browser import show_plot, export_file

# Change these rational scales, retaining 0 < scale < 1.
q, r, a, b = Q(1, 3), Q(2, 3), Q(1, 2), Q(3, 4)
count = 12
if not all(isinstance(s, Q) and Q(0) < s < Q(1) for s in (q, r, a, b)):
    raise ValueError("Use four rational contractions strictly between zero and one.")
if type(count) is not int or not 2 <= count <= 24:
    raise ValueError("Use an integer count between 2 and 24.")

u, v = [Q(1)], [Q(1)]
for n in range(1, count):
    # Only coefficients with index less than n occur in either sum.
    u.append(sum(q**(2*i+1)*r**(2*(n-1-i)+1)*u[i]*v[n-1-i]
                 for i in range(n))/Q(2*n+1))
    v.append(sum(a**(2*i+1)*b**(2*(n-1-i)+1)*u[i]*v[n-1-i]
                 for i in range(n))/Q(2*n+1))

radius = Q(1)
rho = radius**2/2
tail = radius*rho**count/(1-rho)
xs = [j/80 for j in range(-80, 81)]
def polynomial(coefficients, x):
    return sum(float(c)*x**(2*n+1) for n,c in enumerate(coefficients))

show_plot([
    {"x": xs, "y": [polynomial(u,x) for x in xs], "name": "U Taylor polynomial", "mode": "lines"},
    {"x": xs, "y": [polynomial(v,x) for x in xs], "name": "V Taylor polynomial", "mode": "lines", "line": {"dash": "dash"}},
], {"title": {"text": f"Coupled functions: {count} odd coefficients"},
    "xaxis": {"title": {"text": "Real x in [-1, 1]"}},
    "yaxis": {"title": {"text": "Taylor polynomial value"}}},
    description="Two coupled odd Taylor polynomials share initial slope one and separate as x grows. Plotted values are floating-point evaluations. The source geometric majorant bounds the omitted series on the entire complex unit disk; it does not bound plotting roundoff.")

csv = "index,degree,u,v\n"+"".join(
    f"{n},{2*n+1},{u[n]},{v[n]}\n" for n in range(count))
export_file("coupled-special-function-coefficients.csv", csv)
print("Scales (q, r, a, b):", ", ".join(map(str, (q,r,a,b))))
print(f"Coefficients retained per component: {count} (through degree {2*count-1})")
print(f"u_1 = {u[1]}; v_1 = {v[1]}")
print("Uniform omitted-tail envelope on |z| <= 1:", tail)
print("Exported exact rational coefficients for both components.")

Download original code Jump to results

Expected output for the published preset

Scales (q, r, a, b): 1/3, 2/3, 1/2, 3/4
Coefficients retained per component: 12 (through degree 23)
u_1 = 2/27; v_1 = 1/8
Uniform omitted-tail envelope on |z| <= 1: 1/2048
Exported exact rational coefficients for both components.

This is the original example's output. Your edits may change it.

Reciprocal sequences and factorial growth

Use Komorebi Math to compare exact reciprocal coefficients with (Nn)!, then inspect the coefficients after factorial normalization. Start with N = 4 and r = 1.

Definitions, exact values and how to read this plot · Komorebi Math sequence API

Plotting, data and saving guide

Python code: Reciprocal sequences and factorial growth

from fractions import Fraction
from math import factorial, log10
from komorebi_math.sequences import reciprocal_coefficients
from komorebi_browser import show_plot, export_file

# D_N(t)^(-r) = sum A(n) t^(N*n) / (N*n)!
# Change these integer parameters and run again.
N, r, count = 4, 1, 16
if not (type(N) is int and 2 <= N <= 8 and type(r) is int and 1 <= r <= 3
        and type(count) is int and 2 <= count <= 16):
    raise ValueError("Use N=2..8, r=1..3, and count=2..16 for this experiment.")
a = reciprocal_coefficients(N, count, power=r)
ns = list(range(count))
scale = [factorial(N*n) for n in ns]
normalized = [Fraction(a[n], scale[n]) for n in ns]
if any(value <= 0 for value in a):
    raise ValueError("This logarithmic view requires positive coefficients.")

show_plot([
    {"x": ns, "y": [log10(value) for value in a], "mode": "lines+markers",
     "name": "Sequence A(n)", "line": {"color": "#0067a5"}, "marker": {"symbol": "circle"},
     "hovertemplate": "n = %{x}<br>log10 A(n) = %{y:.3f}<extra>Sequence</extra>"},
    {"x": ns, "y": [log10(value) for value in scale], "mode": "lines+markers",
     "name": "Factorial (Nn)!", "line": {"color": "#b54b00", "dash": "dash"}, "marker": {"symbol": "diamond"},
     "hovertemplate": "n = %{x}<br>log10 (Nn)! = %{y:.3f}<extra>Factorial</extra>"}],
    {"title": {"text": f"Sequence and factorial growth (N={N}, r={r})"},
     "xaxis": {"title": {"text": "Index n"}, "dtick": 2},
     "yaxis": {"title": {"text": "Size, in powers of 10"}}},
    description="Blue circles show A(n). Orange diamonds show (Nn)!. A height of 20 means 10 to the power 20. Each step in n adds N to the degree. This finite comparison does not establish an asymptotic equivalence.")
show_plot([{"x": ns,
    "y": [log10(v.numerator)-log10(v.denominator) for v in normalized],
    "mode": "lines+markers", "name": "Normalized coefficients",
    "hovertemplate": "n = %{x}<br>log10 normalized value = %{y:.3f}<extra></extra>"}],
    {"title": {"text": f"After division by (Nn)!: N={N}, r={r}"},
     "xaxis": {"title": {"text": "Index n"}, "dtick": 2},
     "yaxis": {"title": {"text": "Normalized size (log10)"}}},
    description="Each value is A(n) divided by (Nn)!. A height of -3 means 0.001. A fall of one unit means a value ten times smaller. Lines connect discrete samples. Exact fractions are in the CSV below.")
csv = "N,r,n,degree,A,factorial,normalized_fraction\n"
csv += "".join(f"{N},{r},{n},{N*n},{a[n]},{scale[n]},{normalized[n]}\n" for n in ns)
export_file("reciprocal-growth-exact.csv", csv)
print(f"Reciprocal family: N={N}, r={r}")
print(f"Computed n=0 through {count-1} with exact integers.")
print("A(0..4):", a[:5])
print("Exported exact coefficients and rational normalizations.")

Download original code Jump to results

Expected output for the published preset

Reciprocal family: N=4, r=1
Computed n=0 through 15 with exact integers.
A(0..4): (1, 1, 69, 33661, 60376809)
Exported exact coefficients and rational normalizations.

This is the original example's output. Your edits may change it.

Compare reciprocal families in 2D and 3D

Start with a labelled 2D comparison of N = 2 through 8. A separate 3D view follows. Both show the same factorial-normalized values, with exact fractions available as CSV.

Definitions, exact values and how to read this plot · Komorebi Math sequence API

Plotting, data and saving guide

Python code: Compare reciprocal families in 2D and 3D

from fractions import Fraction
from math import factorial, log10
from komorebi_math.sequences import reciprocal_coefficients
from komorebi_browser import show_plot, export_file

r, count = 1, 16
if not (type(r) is int and 1 <= r <= 3 and type(count) is int and 2 <= count <= 16):
    raise ValueError("Use r=1..3 and count=2..16 for this experiment.")
ns = list(range(count))
traces = []
flat_traces = []
colors = ["#0067a5", "#b54b00", "#007d60", "#963f87", "#6b58a3", "#89532d", "#353d46"]
symbols = ["circle", "diamond", "square", "triangle-up", "cross", "x", "triangle-down"]
csv = "N,r,n,degree,A,normalized_fraction\n"
for N in range(2, 9):
    a = reciprocal_coefficients(N, count, power=r)
    fractions = [Fraction(a[n], factorial(N*n)) for n in ns]
    if any(v <= 0 for v in fractions):
        raise ValueError("This logarithmic view requires positive coefficients.")
    heights = [log10(v.numerator)-log10(v.denominator) for v in fractions]
    flat_traces.append({"mode": "lines+markers+text", "name": f"N={N}", "cliponaxis": False,
                       "x": ns, "y": heights, "text": [""]*(count-1)+[f"N={N}"],
                       "textposition": "middle right", "textfont": {"size": 15, "color": colors[N-2]},
                       "line": {"color": colors[N-2], "dash": "solid" if N % 2 == 0 else "dash"},
                       "marker": {"symbol": symbols[N-2], "size": 8},
                       "hovertemplate": "n = %{x}<br>log10 normalized value = %{y:.3f}<extra>"+f"N={N}"+"</extra>"})
    traces.append({"type": "scatter3d", "mode": "lines+markers", "name": f"N={N}",
                   "x": ns, "y": [N]*count, "z": heights,
                   "line": {"color": colors[N-2]}, "marker": {"size": 5},
                   "hovertemplate": "n = %{x}<br>N = %{y}<br>log10 normalized value = %{z:.3f}<extra></extra>"})
    csv += "".join(f"{N},{r},{n},{N*n},{a[n]},{fractions[n]}\n" for n in ns)
show_plot(flat_traces,
    {"title": {"text": f"Compare the seven reciprocal families (r={r})"},
     "xaxis": {"title": {"text": "Index n"}, "dtick": 2, "range": [-0.3, count+0.8]},
     "yaxis": {"title": {"text": "Normalized size (log10)"}}},
    description="Read each labelled line from left to right. Its height is log10 of A(n)/(Nn)!. A height of -10 means 10 to the power -10. Each step down is a smaller normalized coefficient. Use the checkboxes to compare fewer families. Equal n at different N means different degrees Nn.")
show_plot(traces,
    {"title": {"text": "The same families in 3D"},
     "scene": {"xaxis": {"title": {"text": "n"}},
               "yaxis": {"title": {"text": "N"}, "dtick": 1},
               "zaxis": {"title": {"text": "log10 value"}}}},
    description="Axes: n is the sequence index, N is the integer spacing, and height is log10 of A(n)/(Nn)!. This is the same data as the 2D chart above. Lines connect samples within a family. There is no interpolation between different N values.")
export_file("reciprocal-landscape-exact.csv", csv)
print(f"Reciprocal landscape: N=2..8, r={r}, n=0..{count-1}")
print("Exact coefficient samples:", 7*count)
print("Secant anchor A_2(0..5):", reciprocal_coefficients(2, 6))
print("Exported exact coefficients. Plot heights are approximate logarithms.")

Download original code Jump to results

Expected output for the published preset

Reciprocal landscape: N=2..8, r=1, n=0..15
Exact coefficient samples: 112
Secant anchor A_2(0..5): (1, 1, 5, 61, 1385, 50521)
Exported exact coefficients. Plot heights are approximate logarithms.

This is the original example's output. Your edits may change it.

Factorial weights in the sequence atlas

Compare a Stirling row with its factorial-weighted row using ordinary counts. Then inspect a 2D map of contributions, with a separate 3D view below it.

Definitions, exact values and how to read this plot · Komorebi Math sequence API

Plotting, data and saving guide

Python code: Factorial weights in the sequence atlas

from math import factorial, log10
from komorebi_math.sequences import fubini_sequence
from komorebi_browser import show_plot, export_file

last, row = 18, 5
if not (type(last) is int and 0 <= last <= 18 and type(row) is int and 0 <= row <= last):
    raise ValueError("Use last=0..18 and row=0..last.")
S = [[0]*(last+1) for _ in range(last+1)]
S[0][0] = 1
for n in range(1, last+1):
    for k in range(1, n+1):
        S[n][k] = k*S[n-1][k] + S[n-1][k-1]
weighted = [[factorial(k)*S[n][k] for k in range(n+1)] for n in range(last+1)]
if tuple(map(sum, weighted)) != fubini_sequence().first(last+1):
    raise ArithmeticError("The Stirling sums disagree with the independent library recurrence.")
ks = list(range(row+1))
show_plot([
    {"type": "bar", "x": ks, "y": S[row][:row+1],
     "name": "Unordered S(n,k)", "marker": {"color": "#0067a5"},
     "hovertemplate": "k = %{x}<br>Count = %{y}<extra>Unordered blocks</extra>"},
    {"type": "bar", "x": ks, "y": weighted[row],
     "name": "Ordered k! S(n,k)", "marker": {"color": "#b54b00", "pattern": {"shape": "/"}},
     "hovertemplate": "k = %{x}<br>Count = %{y}<extra>Ordered blocks</extra>"}],
    {"title": {"text": f"What factorial weighting changes (n={row})"}, "barmode": "group",
     "xaxis": {"title": {"text": "Number of blocks k"}, "dtick": 1},
     "yaxis": {"title": {"text": "Count"}, "rangemode": "tozero"}},
    description=f"Blue bars count unordered partitions. Striped orange bars count ordered partitions. These are ordinary counts, not logarithms. For this row the totals are {sum(S[row])} and {sum(weighted[row])}. Exact values are in the CSV below.")
show_plot([{"type": "heatmap", "x": list(range(last+1)), "y": list(range(last+1)),
    "z": [[log10(1+weighted[n][k]) if k <= n else None for n in range(last+1)] for k in range(last+1)],
    "colorscale": "Cividis", "zmin": 0, "hoverongaps": False,
    "colorbar": {"orientation": "h", "y": 1.12, "yanchor": "bottom", "len": 0.95, "thickness": 16, "nticks": 4, "title": {"text": "log10 (1 + count)", "side": "top"}},
    "hovertemplate": "n = %{x}<br>k = %{y}<br>log10 (1 + count) = %{z:.3f}<extra></extra>"}],
    {"title": {"text": "Where the factorial-weighted contributions sit"},
     "xaxis": {"title": {"text": "Set size n"}, "dtick": 3},
     "yaxis": {"title": {"text": "Block count k"}, "dtick": 3}, "margin": {"t": 120}},
    description="Each square is one integer pair (n, k). Read a column to inspect a row of Stirling contributions. Brighter squares mean larger k! S(n,k), using log10(1 + count). The white triangle has k greater than n and is outside the domain. The data table gives the plotted values.")
points = [(n, k, weighted[n][k]) for n in range(last+1) for k in range(n+1) if weighted[n][k]]
show_plot([{"type": "scatter3d", "mode": "markers", "name": "Nonzero contributions",
    "x": [n for n,k,v in points], "y": [k for n,k,v in points],
    "z": [log10(1+v) for n,k,v in points],
    "hovertemplate": "n = %{x}<br>k = %{y}<br>log10 (1 + count) = %{z:.3f}<extra></extra>",
    "marker": {"size": 5, "color": [log10(1+v) for n,k,v in points], "colorscale": "Cividis", "cmin": 0}}],
    {"title": {"text": "The contributions in 3D"},
     "scene": {"xaxis": {"title": {"text": "n"}},
               "yaxis": {"title": {"text": "k"}},
               "zaxis": {"title": {"text": "Log size"}}}},
    description="Axes: n is set size, k is block count, and height is log10(1 + k! S(n,k)). This shows the nonzero entries from the 2D map above. Each exact row sum is a Fubini number. The CSV also includes zero contributions.")
csv = "n,k,stirling,k_factorial,weighted_contribution\n"
csv += "".join(f"{n},{k},{S[n][k]},{factorial(k)},{weighted[n][k]}\n" for n in range(last+1) for k in range(n+1))
export_file("factorial-stirling-exact.csv", csv)
print(f"Stirling row n={row}:", S[row][:row+1])
print("Factorial-weighted row:", weighted[row])
print("Bell row sum:", sum(S[row]))
print("Fubini row sum:", sum(weighted[row]))
print(f"All {last+1} weighted row sums match Komorebi Math.")
print(f"Exported exact contributions through n={last}.")

Download original code Jump to results

Expected output for the published preset

Stirling row n=5: [0, 1, 15, 25, 10, 1]
Factorial-weighted row: [0, 1, 30, 150, 240, 120]
Bell row sum: 52
Fubini row sum: 541
All 19 weighted row sums match Komorebi Math.
Exported exact contributions through n=18.

This is the original example's output. Your edits may change it.

Reconstruct an operator

Hand calculation, expected output and source connections

Python code: Reconstruct an operator

# Edit this example, then press Run. Reset restores the published version.

def require(condition, message):
    if not condition:
        raise AssertionError(message)


def multiply(a, b):
    return tuple(tuple(sum(x*y for x, y in zip(row, column))
                       for column in zip(*b)) for row in a)


def apply(a, vector):
    return tuple(sum(x*y for x, y in zip(row, vector)) for row in a)


def add_matrices(matrices):
    return tuple(tuple(sum(a[i][j] for a in matrices)
                       for j in range(len(matrices[0][0])))
                 for i in range(len(matrices[0])))


def add_vectors(vectors):
    return tuple(map(sum, zip(*vectors)))


def packets():
    x = (2, 3)
    p = (((1, 0), (0, 0)), ((0, 0), (0, 1)))
    identity, zero = ((1, 0), (0, 1)), ((0, 0), (0, 0))
    t = ((1, 2), (3, 4))
    require(add_matrices(p) == identity, 'Packets must sum to the identity')
    for j in range(2):
        for i in range(2):
            require(multiply(p[j], p[i]) == (p[i] if i == j else zero),
                    'Packet multiplication identity failed')
    # Rows are target packets and columns are source packets.
    blocks = tuple(multiply(multiply(p[j], t), p[i])
                   for j in range(2) for i in range(2))
    require(add_matrices(blocks) == t, 'Block reconstruction failed')
    direct = apply(t, x)
    rebuilt = add_vectors(tuple(apply(b, x) for b in blocks))
    missing = add_vectors(tuple(apply(b, x) for b in blocks[:-1]))
    require(direct == rebuilt == (8, 18), 'Unexpected reconstructed result')
    require(missing == (8, 6) and missing != direct, 'Missing-block control failed')
    return '\n'.join([
        f'Input: {x}',
        f'Packet parts: {tuple(apply(q, x) for q in p)}',
        f'Block contributions: {tuple(apply(b, x) for b in blocks)}',
        f'Direct result: {direct}',
        f'Reconstructed result: {rebuilt}',
        f'Without the final block: {missing}',
        'PASS: packets',
    ])


print(packets())

Download original code Jump to results

Expected output for the published preset

Input: (2, 3)
Packet parts: ((2, 0), (0, 3))
Block contributions: ((2, 0), (6, 0), (0, 6), (0, 12))
Direct result: (8, 18)
Reconstructed result: (8, 18)
Without the final block: (8, 6)
PASS: packets

This is the original example's output. Your edits may change it.

Test recovery from a summary

Hand calculation, expected output and source connections

Python code: Test recovery from a summary

# Edit this example, then press Run. Reset restores the published version.

def require(condition, message):
    if not condition:
        raise AssertionError(message)


def multiply(a, b):
    return tuple(tuple(sum(x*y for x, y in zip(row, column))
                       for column in zip(*b)) for row in a)


def apply(a, vector):
    return tuple(sum(x*y for x, y in zip(row, vector)) for row in a)


def recovery():
    r, f, h = ((1, 1),), ((1, 0),), ((2, 2),)
    u, v = (1, 0), (0, 1)
    summary = apply(r, u)[0]
    answers = (apply(f, u)[0], apply(f, v)[0])
    w = tuple(a-b for a, b in zip(u, v))
    rw, fw = apply(r, w)[0], apply(f, w)[0]
    require(summary == apply(r, v)[0] == 1, 'Collision is missing')
    require(answers == (1, 0) and rw == 0 and fw == 1, 'Witness failed')
    # The matrix identity proves the compatible linear rule for every vector.
    require(multiply(((2,),), r) == h, 'Compatible observation identity failed')
    return '\n'.join([
        f'Inputs: {u} and {v}', f'Same summary: {summary}',
        f'Requested first coordinates: {answers}', f'Kernel witness: {w}',
        f'R(w): {rw}', f'F(w): {fw}',
        f'Compatible observation coefficients: {h[0]}',
        'PASS: recovery',
    ])


print(recovery())

Download original code Jump to results

Expected output for the published preset

Inputs: (1, 0) and (0, 1)
Same summary: 1
Requested first coordinates: (1, 0)
Kernel witness: (1, -1)
R(w): 0
F(w): 1
Compatible observation coefficients: (2, 2)
PASS: recovery

This is the original example's output. Your edits may change it.

Use Komorebi Math

This uses the published Komorebi Math library for packet reconstruction and exact rational coordinate changes. These two operations are tested here. The sequence research presets separately test reciprocal coefficients and Fubini row sums in their documented finite ranges. Optional backends and other operations remain outside that scope.

Installation and expected output · Komorebi Math guide

Python code: Use Komorebi Math

"""Run two finite examples and print their expected results.

Run with the interpreter into which Komorebi Math was installed.
"""
from fractions import Fraction

import numpy as np

from komorebi_math.stable import ExactCoordinateTransform, PacketSystem


def main():
    packets = PacketSystem(
        [np.diag([1.0, 0.0]), np.diag([0.0, 1.0])],
        names=("left", "right"),
    )
    packets.certificate().require()
    vector = np.array([2.0, 3.0])
    reconstructed = packets.analyze(vector).reconstruct()
    np.testing.assert_array_equal(reconstructed, vector)

    transform = ExactCoordinateTransform(
        "A", "B", ((1, Fraction(1, 2)), (0, 1)),
        "EXAMPLE-SHEAR", "exact rational shear",
    )
    exact_vector = (Fraction(2), Fraction(3))
    mapped = transform.apply(exact_vector)
    restored = transform.inverse().apply(mapped)
    assert mapped == (Fraction(7, 2), Fraction(3))
    assert restored == exact_vector
    transform.certificate().require()

    print(f"Numerical reconstruction: {reconstructed.real.tolist()}")
    print("Exact coordinate change: (" + ", ".join(map(str, mapped)) + ")")
    print("Exact inverse: (" + ", ".join(map(str, restored)) + ")")
    print("PASS: first examples")


if __name__ == "__main__":
    main()

Download original code Jump to results

Expected output for the published preset

Numerical reconstruction: [2.0, 3.0]
Exact coordinate change: (7/2, 3)
Exact inverse: (2, 3)
PASS: first examples

This is the original example's output. Your edits may change it.

Plot a signal in 2D

Two sine waves and their sum. Zoom or inspect individual samples. This is a plotting tutorial, not a claim about a paper.

Plotting, data and saving guide

Python code: Plot a signal in 2D

import numpy as np
from komorebi_browser import show_plot

x = np.linspace(0, 2*np.pi, 201)
a, b = np.sin(x), 0.5*np.sin(3*x)
show_plot([
    {"x": x, "y": a, "name": "sin(x)", "mode": "lines"},
    {"x": x, "y": b, "name": "0.5 sin(3x)", "mode": "lines"},
    {"x": x, "y": a+b, "name": "Sum", "mode": "lines"},
], {"title": {"text": "Two waves and their sum"},
    "xaxis": {"title": {"text": "x (radians)"}},
    "yaxis": {"title": {"text": "Amplitude"}}},
    description="Two periodic sine waves and their pointwise sum on 0 to 2 pi.")
print("Plotted 201 samples of two waves and their sum.")

Download original code Jump to results

Expected output for the published preset

Plotted 201 samples of two waves and their sum.

This is the original example's output. Your edits may change it.

Explore a 3D surface

Rotate the saddle surface z = x squared minus y squared. Keyboard view buttons and a data table provide other ways to inspect it.

Plotting, data and saving guide

Python code: Explore a 3D surface

import numpy as np
from komorebi_browser import show_plot

x = np.linspace(-2, 2, 41)
y = np.linspace(-2, 2, 41)
X, Y = np.meshgrid(x, y)
Z = X**2 - Y**2
show_plot([{"type": "surface", "x": x, "y": y, "z": Z,
            "colorscale": "Viridis", "name": "Saddle"}],
          {"title": {"text": "Saddle surface: z = x² − y²"},
           "scene": {"xaxis": {"title": {"text": "x"}},
                     "yaxis": {"title": {"text": "y"}},
                     "zaxis": {"title": {"text": "z"}}}},
          description="A saddle rises along the x direction and falls along the y direction. The origin has height zero.")
print("Surface grid: 41 x 41")
print("Center height:", Z[20, 20])

Download original code Jump to results

Expected output for the published preset

Surface grid: 41 x 41
Center height: 0.0

This is the original example's output. Your edits may change it.

Explore a 3D curve

A sampled helix with labelled axes, rotation, zoom, and downloadable coordinates.

Plotting, data and saving guide

Python code: Explore a 3D curve

import numpy as np
from komorebi_browser import show_plot

t = np.linspace(0, 4*np.pi, 201)
show_plot([{"type": "scatter3d", "mode": "lines", "name": "Helix",
            "x": np.cos(t), "y": np.sin(t), "z": t/(2*np.pi),
            "line": {"width": 6, "color": "#18563d"}}],
          {"title": {"text": "Two turns of a helix"},
           "scene": {"xaxis": {"title": {"text": "cos(t)"}},
                     "yaxis": {"title": {"text": "sin(t)"}},
                     "zaxis": {"title": {"text": "t / (2π)"}}}},
          description="A helix makes two turns around the vertical axis while rising from height zero to two.")
print("Helix samples:", len(t))

Download original code Jump to results

Expected output for the published preset

Helix samples: 201

This is the original example's output. Your edits may change it.

Make a Matplotlib figure

Use ordinary Matplotlib commands to produce a PNG. This preset also exports the plotted numbers as CSV.

Plotting, data and saving guide

Python code: Make a Matplotlib figure

import numpy as np
import matplotlib.pyplot as plt
from komorebi_browser import show_matplotlib, export_file

x = np.linspace(-2, 2, 81)
y = x**2
fig, ax = plt.subplots(figsize=(7, 4))
ax.plot(x, y, color="#18563d", label="y = x²")
ax.set(xlabel="x", ylabel="y", title="A parabola")
ax.grid(True, alpha=0.3)
ax.legend()
show_matplotlib(fig, description="A parabola with its minimum at the origin. Values rise to four at x = minus two and two.")
export_file("parabola.csv", "x,y\n" + "".join(f"{a},{b}\n" for a,b in zip(x,y)))
print("Created a Matplotlib figure and parabola.csv.")

Download original code Jump to results

Expected output for the published preset

Created a Matplotlib figure and parabola.csv.

This is the original example's output. Your edits may change it.

Calculate with SymPy

Differentiate, integrate and factor a polynomial using exact symbolic expressions.

Plotting, data and saving guide

Python code: Calculate with SymPy

import sympy as sp

x = sp.symbols("x")
f = x**3 - 3*x + 2
print("Polynomial:", f)
print("Derivative:", sp.diff(f, x))
print("Integral on [0, 1]:", sp.integrate(f, (x, 0, 1)))
print("Factorization:", sp.factor(f))
assert sp.expand(sp.factor(f)) == f

Download original code Jump to results

Expected output for the published preset

Polynomial: x**3 - 3*x + 2
Derivative: 3*x**2 - 3
Integral on [0, 1]: 3/4
Factorization: (x - 1)**2*(x + 2)

This is the original example's output. Your edits may change it.

Calculate with SciPy

Numerically integrate x squared on [0, 1] and compare with the known value one third. The printed value is rounded.

Plotting, data and saving guide

Python code: Calculate with SciPy

from scipy.integrate import quad

value, estimated_error = quad(lambda x: x*x, 0, 1)
print(f"Integral of x squared on [0, 1]: {value:.6f}")
print("Within 1e-12 of one third:", abs(value - 1/3) < 1e-12)
assert abs(value - 1/3) < 1e-12

Download original code Jump to results

Expected output for the published preset

Integral of x squared on [0, 1]: 0.333333
Within 1e-12 of one third: True

This is the original example's output. Your edits may change it.

Plot CSV or JSON data

Upload a CSV with x,y columns or a JSON array of objects with x and y fields. With no upload, this uses the supplied sample. When several files are loaded, the first filename in alphabetical order is used.

Plotting, data and saving guide

Python code: Plot CSV or JSON data

import csv
import io
import json
from komorebi_browser import show_plot, export_file

if uploaded_files:
    name = sorted(uploaded_files)[0]
    text = uploaded_files[name]
    rows = json.loads(text) if name.lower().endswith(".json") else list(csv.DictReader(io.StringIO(text)))
    print("Using:", name)
else:
    rows = [{"x": 0, "y": 1}, {"x": 1, "y": 3}, {"x": 2, "y": 5}, {"x": 3, "y": 7}]
    print("Using sample data.")
x, y = [float(r["x"]) for r in rows], [float(r["y"]) for r in rows]
show_plot([{"x": x, "y": y, "mode": "lines+markers", "name": "Data"}],
          {"title": {"text": "Your x,y data"},
           "xaxis": {"title": {"text": "x"}}, "yaxis": {"title": {"text": "y"}}},
          description=f"A plot of {len(rows)} supplied x,y pairs. Inspect the data table for the numbers.")
export_file("processed-data.json", json.dumps([{"x": a, "y": b} for a,b in zip(x,y)], indent=2))
print(f"Plotted {len(rows)} rows.")

Download original code Jump to results

Expected output for the published preset

Using sample data.
Plotted 4 rows.

This is the original example's output. Your edits may change it.

Output

Choose another preset

Run an example to see its output here.

Errors

None.

Plotting, data and saving guide

Matplotlib figures appear as downloadable PNGs. Use plt.show() or show_matplotlib(fig, description="..."). Interactive plots use from komorebi_browser import show_plot and Plotly-style trace dictionaries. Supported traces are scatter, bar, heatmap, surface, and scatter3d. The playground supplies this helper. It is separate from the Komorebi Math package.

Use show_plot(data, layout, description="...") to label a figure and its axes. Interactive plots have series checkboxes, an Enlarge plot button, zoom controls, image and data downloads, and a table of the first 100 samples. 3D views also have keyboard buttons for front, top, and default views. The sequence family and factorial weights presets start with 2D views of the same data. If WebGL is unavailable, use those views, the table or the data downloads.

NumPy, Matplotlib, SymPy and SciPy load when selected presets or direct imports need them. Optional Komorebi backends remain outside the tested browser scope. Each run has a two minute limit, up to 50,000 samples per interactive figure, a 2 MB limit per figure or export, and an 8 MB combined figure and export limit.

Use export_file("result.csv", text) for CSV, JSON, or text downloads. Saved drafts remain in this browser until you delete them. Restore draft is explicit. Download edited code saves the current editor as a .py file. The run report records the executed code, output, package versions, source revision, and input-file checksums. It omits uploaded file contents. Downloaded plotting scripts can be reopened in this playground. The browser helper source documents the display functions.

Runtime, library revision, and source records

Pyodide 314.0.7, Python 3.14.2, NumPy 2.4.6. Matplotlib, SymPy, and SciPy are available on demand. Interactive plotting uses Plotly.js 4.1.1. These files are served by this site.

Example checksums and pinned library file list · Runtime sources and checksums · Runtime licenses · Plotly license · Pinned library source ZIP with license

Python playground

Separate equal histograms with an arithmetic projector

Recover a state after partial dephasing

Watch probability move between packets

See quantum phase change a measurement

Compare a centered symbol with its continuum limit

Explore coupled contraction functions

Reciprocal sequences and factorial growth

Compare reciprocal families in 2D and 3D

Factorial weights in the sequence atlas

Reconstruct an operator

Refine a signal

Test recovery from a summary

Use Komorebi Math

Plot a signal in 2D

Explore a 3D surface

Explore a 3D curve

Make a Matplotlib figure

Calculate with SymPy

Calculate with SciPy

Plot CSV or JSON data

Output

Errors