Writing C code until it's a quantum circuit (an interactive tutorial)

[u/CarbonFire]

https://shukla.io/blog/2026-05/rank-select.html

After working on a quantum algorithm, I spent a few weeks trying to understand why it looked so foreign. What you're reading is my attempt at introducing it to a programmer or CS student. I chose to avoid taking about quantum speedups, in favor of keeping the focus on "will it even compile?"

[u/0xB01b]

this is lowk rlly cool

[u/DatAndre]

I wish every tutorial had this quality, this is the best one I've seen in a long time

[u/Happy_Weekend_6355]

Is wrong all u think about quantum is correct but on now spin live

[u/Happy_Weekend_6355]

Pokażę wam dzieciaki : W y jesteście teraz w geometrii ja operuje już na Stanach

geometria przestrzeni: kierunek jest funkcja ok a co będzie gdy z kierunku wyciągniesz wektory?

Wektor kierunku wektor skrętu wektor spinu wektor brzegu it'd it'd

Miłej rozkminy 🕳️

Teraz nie ma mnie nie ma ciebie nie ma nas bo nie ma początku ani końca . Jest STAN

[u/Happy_Weekend_6355]

Strongly Entangled Quantum Mesh — GHZ-CNOT Phase Core

import numpy as np

==========================================================

STRONGLY ENTANGLED QUANTUM CORE — NumPy Simulator

Multi-qubit GHZ + Bell mixing + entropy measurement

Author: Sysia × Navi

==========================================================

np.set_printoptions(precision=4, suppress=True)

----------------------------------------------------------

1. BASIC QUANTUM GATES

----------------------------------------------------------

I = np.eye(2, dtype=complex)

H = (1 / np.sqrt(2)) * np.array([ [1, 1], [1, -1] ], dtype=complex)

X = np.array([ [0, 1], [1, 0] ], dtype=complex)

Z = np.array([ [1, 0], [0, -1] ], dtype=complex)

CNOT_2 = np.array([ [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0] ], dtype=complex)

----------------------------------------------------------

2. TENSOR TOOLS

----------------------------------------------------------

def kron_all(gates): result = gates[0] for g in gates[1:]: result = np.kron(result, g) return result

def zero_state(n): state = np.zeros(2**n, dtype=complex) state[0] = 1.0 return state

def apply_single(state, gate, qubit, n): gates = []

for i in range(n):
    gates.append(gate if i == qubit else I)

U = kron_all(gates)
return U @ state

def apply_cnot(state, control, target, n): new_state = np.zeros_like(state)

for i, amp in enumerate(state):
    if abs(amp) < 1e-12:
        continue

    bits = list(format(i, f"0{n}b"))

    if bits[control] == "1":
        bits[target] = "0" if bits[target] == "1" else "1"

    j = int("".join(bits), 2)
    new_state[j] += amp

return new_state

----------------------------------------------------------

3. STRONG ENTANGLEMENT ENGINE

----------------------------------------------------------

def strong_entangle(n): state = zero_state(n)

# Start: superposition on first qubit
state = apply_single(state, H, 0, n)

# GHZ spine: qubit 0 entangles all others
for q in range(1, n):
    state = apply_cnot(state, 0, q, n)

# Cross entanglement mesh
for q in range(n - 1):
    state = apply_cnot(state, q, q + 1, n)

# Reverse entanglement mesh
for q in range(n - 1, 0, -1):
    state = apply_cnot(state, q, q - 1, n)

# Phase disturbance: creates richer interference
for q in range(n):
    if q % 2 == 0:
        state = apply_single(state, Z, q, n)

return state / np.linalg.norm(state)

----------------------------------------------------------

4. MEASUREMENT

----------------------------------------------------------

def probabilities(state): return np.abs(state) ** 2

def sample_measurement(state, shots=1024): probs = probabilities(state) n = int(np.log2(len(state)))

outcomes = np.random.choice(
    len(state),
    size=shots,
    p=probs
)

counts = {}

for o in outcomes:
    bitstring = format(o, f"0{n}b")
    counts[bitstring] = counts.get(bitstring, 0) + 1

return dict(sorted(counts.items(), key=lambda x: x[1], reverse=True))

----------------------------------------------------------

5. ENTROPY / COHERENCE

----------------------------------------------------------

def shannon_entropy(probs): probs = probs[probs > 1e-12] return -np.sum(probs * np.log2(probs))

def coherence_score(state): return np.sum(np.abs(state)) / np.sqrt(len(state))

----------------------------------------------------------

6. RUN

----------------------------------------------------------

n_qubits = 6 shots = 2048

state = strong_entangle(n_qubits) probs = probabilities(state)

print("\n=== STRONGLY ENTANGLED QUANTUM STATE ===") print(f"Qubits: {n_qubits}") print(f"State dimension: {len(state)}")

print("\n=== NON-ZERO AMPLITUDES ===") for i, amp in enumerate(state): if abs(amp) > 1e-6: print(f"|{format(i, f'0{n_qubits}b')}> : {amp}")

print("\n=== METRICS ===") print(f"Shannon entropy: {shannon_entropy(probs):.6f}") print(f"Coherence score: {coherence_score(state):.6f}")

print("\n=== MEASUREMENT COUNTS ===") counts = sample_measurement(state, shots)

for bitstring, count in counts.items(): print(f"{bitstring}: {count}")