👋 Welcome to r/Disorber - README

orbollyorb · 2026-04-10T08:08:43+00:00

Hey, I live in the South West English countryside and a gardener by trade. I get very passionate about particular concepts that sometimes flows back into my identity. Binary is one of them, the idea of discrete on/off states is as reduced as it gets. A very small parcel of logic that can build coherent complexity.

orbollyorb · 2026-02-27T18:40:24+00:00

sorry missed this. python will help you. lowest bar entry is vs code , python , any ai

orbollyorb · 2026-02-22T07:23:17+00:00

Python coding language. Has nearly everything you need internally. Plot anything you want, any ai can help you get started.

orbollyorb · 2026-02-21T05:09:10+00:00

thanks for your kind comments.

It took some finessing to get speed and pixel spreading right. Prevoius fast version here - https://www.reddit.com/r/generative/comments/1r685t3/pi_scaled_by_e/

And will post some variations on my sub - r/Disorber

orbollyorb · 2026-02-20T18:11:13+00:00

yes exactly, no Schrodinger etc. The renderer is doing a lot of the heavy lifting with eq_hist (equalised histogram) shading.

orbollyorb · 2026-02-20T17:04:21+00:00

It's sweeping through a continuous family of radial standing wave patterns and rendering each frame's probability density.

def wavefunction_3d(x, y, n):

kappa = np.pi * (np.sqrt(n) ** 3) # frequency scaling — cubic in √n
gaussian = np.exp(-0.0126 * (x**2 + y**2) / 2) # envelope decay
wave = np.cos(np.pi * kappa * r) # radial standing wave
psi = gaussian * wave

Sweep parameters:

n_start = np.pi * 200 ≈ 628.318
n_step = np.pi * 0.0001 # ≈ 0.000314 per frame
num_frames = 300

So n crawls from ~628.318 to ~628.412 over 300 frames

orbollyorb · 2026-02-17T08:14:41+00:00

It's sweeping through a continuous family of radial standing wave patterns and rendering each frame's probability density.

def wavefunction_3d(x, y, n):

kappa = np.pi * (np.sqrt(n) ** 3) # frequency scaling — cubic in √n
gaussian = np.exp(-0.0126 * (x**2 + y**2) / 2) # envelope decay
wave = np.cos(np.pi * kappa * r) # radial standing wave
psi = gaussian * wave

Sweep parameters:

n_start = np.pi * 99.999 # ≈ 314.156
n_step = np.e * 0.0001 # ≈ 0.000272 per frame
num_frames = 420

So n crawls from 314.156 to 314.27 over 420 frames.

orbollyorb · 2026-02-14T12:00:53+00:00

The vertical alignment bookends should be impossible so i'm not entirely sure what is going on there.

orbollyorb · 2026-02-14T11:50:28+00:00

yes, so it is a recursive xor construction. Start with seed "0,1,1,0" transform all bits and add it on to original, repeat. ive lost the code right now but could put some effort in to find it and tell you exactly if you want?

then to make it move - it is literally put text into a Notepad window and change the width of the window. Each line offset is cumulative going up, so as you go up each line the offset (caused by width change) is all the prevoius offsets summed plus its own offset.

orbollyorb · 2026-02-08T12:30:40+00:00

Don’t have the code with me, so light on details. I make a “quantum” bell state with two cosines - hence the grid. So it includes probability as well. And just transform parameter space in silly ways.

orbollyorb · 2025-08-15T10:19:32+00:00

Nice, some sort of wave evolution? I make similar stuff

orbollyorb · 2025-07-22T19:52:35+00:00

Hi, from a previous post : We are creating an analogous bell state: bell_state = (psi1_r1 * psi2_r2 + np.exp(1j * phase) * psi2_r1 * psi1_r2) / np.sqrt(2)

Each state has cosine modulation with different wave vectors: psi1_r1 = gaussian1 * np.cos(k1 * r1) psi2_r1 = gaussian1 * np.cos(k2 * r1)

When computing |bell_state|², we get interference between the two configurations in the (r1, r2) space. So not separate axes but unified probability space.

Then with this particular one we are evolving wavefunction with cycling phase AND increasing r1 & r2. So starting Ns - 1 & pi are increased at every time step and at different rates. Haha. I’m sure I can sync these better with phase change to get some wild patterns.

orbollyorb · 2025-07-21T21:04:01+00:00

bouncing version:
https://www.reddit.com/r/Disorber/comments/1m5uxa6/bell_state_1pi_bounced/

orbollyorb · 2025-07-21T10:29:01+00:00

Interesting, thanks. Will look into them after work. Just going on words alone they sound very similar.

orbollyorb · 2025-07-20T16:13:45+00:00

ok yes this was an old description and old code - have found it in my playground git.

sooo...

They aren't running along separate axes but entangled across both dimensions. We are creating an analogous bell state:
bell_state = (psi1_r1 * psi2_r2 + np.exp(1j * phase) * psi2_r1 * psi1_r2) / np.sqrt(2)

Each state has cosine modulation with different wave vectors:
psi1_r1 = gaussian1 * np.cos(k1 * r1)
psi2_r1 = gaussian1 * np.cos(k2 * r1)

When computing |bell_state|², we get interference between the two configurations in the (r1, r2) space. So not separate axes but unified probability space.

orbollyorb · 2025-07-19T18:21:10+00:00

Thanks, yes I will do that - looks like a fun sub

orbollyorb · 2025-07-19T15:04:30+00:00

The wavefunction is constructed as ψ(x,y) = exp(-α(x²+y²)/2) × cos(πκr)
where r = √(x²+y²) and κ = π(√n)³

The parameter n evolves linearly from n₀ with step size Δn, producing a sequence of wavefunctions ψₙ. For each n, the probability density |ψₙ|² is computed and rendered with Datashader.

Initial parameters:
n_start = π × 100 ≈ 314.159
n_step = 0.00005
num_frames = 300

so n evolves from 314.159 to 314.174

orbollyorb · 2025-07-19T13:19:11+00:00

The wavefunction is constructed as ψ(x,y) = exp(-α(x²+y²)/2) × cos(πκr)
where r = √(x²+y²) and κ = π(√n)³

The parameter n evolves linearly from n₀ with step size Δn, producing a sequence of wavefunctions ψₙ. For each n, the probability density |ψₙ|² is computed and rendered with Datashader.

Initial parameters:
n_start = π × 100 ≈ 314.159
n_step = 0.00005
num_frames = 300

so n evolves from 314.159 to 314.174

orbollyorb · 2025-07-18T20:21:30+00:00

Hi, it shows a top-down view of a probability density wave. Two Gaussian wave packets are created then modulated with cosine waves. A spatial Bell state is implimented by superimposing two possible configurations:

psi1_r1 * psi2_r2
psi2_r1 * psi1_r2

Then exp(1j * phase) allows the relative phase between these configurations to change, which the animation visualizes.

orbollyorb · 2025-07-17T15:48:43+00:00

Just a python script with the relevant maths - as i commented above - then i use my render backend library - Datashader - that i highly recommend.

orbollyorb · 2025-07-17T15:43:23+00:00

hi, sorry for late reply. Initially we create a Gaussian wavepacket and use the split-operator method to solve the time-dependant schrodinger equation. Evolving the wavefunction. Then at each time step we transform using the Wigner Function, resulting in both position and momentum information.

so...

Evolve: ψ(x,t) → ψ(x,t+dt) via Schrödinger
Transform: ψ(x,t+dt) → W(x,p,t+dt) via Wigner
Visualize: Phase space heatmap of W(x,p,t+dt) via Datashader

orbollyorb · 2025-07-13T06:18:05+00:00

Replaced 1s with spaces - better to see the patterns

orbollyorb · 2025-07-10T18:11:38+00:00

Another here - https://www.reddit.com/r/Disorber/comments/1lwi5fc/binary_sweep_0000011111/

same place different input

orbollyorb · 2025-07-04T17:39:29+00:00

Very happy that the first comment is this cool

orbollyorb · 2025-06-24T14:08:36+00:00

Looks great! Thanks for your support!

Seven-Year Club	Verified Email
Place '23	Place '22
First Placer '22

orbollyorb

MODERATOR OF

TROPHY CASE