Určite ste videli známy experiment 2 štrbín: https://hrubos.tech/blogy/content/images/20260823220155-Snímka obrazovky 2026-08-23 o 20.50.11.png ; z videa: https://www.youtube.com/watch?v=oskRmMRvguM

Je známy tým, že 1 častica vytvára 2 interferencie. Predstavme si však takýto myšlienkový pokus:

Visia 3 kyvadlá na konci gulička, vytvárajú trojuholník. Do špica alebo vrcholu trojuholníka vrazí väčšia gulička, povedzme že je to elektrón alebo fotón. Chceme vidieť interferencie a konkrétne v bode tu, obrázok:

Video simulačky: https://hrubos.tech/simulacie/kyvadla_trojuholnik_vlny.mp4

https://hrubos.tech/blogy/content/images/20260823220527-2strbiny_na_vode.jpg

Počas nukleárneho útoku nám simulácia ukazuje pre našu obranu, že niekde aj vzniká nulová energia. Ak by sme vhodne zmanipulovali protiútok lejzrom alebo elektronovým delom, dokázali by sme povedzme pomocou AI presunúť nuly na okraje, kde sú maximá. A toto je kľúč k zastaveniu jadrovej reakcie pomocou experimentu 2 štrbín.

Na to nám zostáva ešte použiť kvantový CPU. Prečo? Máme tu tento problém obchodného cestujúceho pre milardy atómov:

Za pomoc so simuláciou podľa mojich príkazov ďakujem GPT AI aj perplexity AI:

using Pkg
Pkg.add("GLMakie")

using GLMakie
GLMakie.activate!()

# ============================================================
# TROJUHOLNÍK KYVADIEL + NÁRAZ + VLNY NA VODE
#
# Veľká vstupná guľa:
#   - trafí hornú ("špicovú") guľu trojuholníka
#
# Prenos impulzu:
#   - dve spodné guľe sa vychýlia symetricky von
#
# Výstup:
#   - vľavo 3D pohľad
#   - vpravo heatmapa výšky hladiny
#   - MP4: kyvadla_trojuholnik_vlny.mp4
# ============================================================

# ------------------------------------------------------------
# VIDEO
# ------------------------------------------------------------

const OUTPUT_FILE = "kyvadla_trojuholnik_vlny.mp4"
const FPS = 60
const NFRAMES = 1500

# Každý video-frame spraví viac fyzikálnych krokov,
# aby boli vlny a kyvadlá plynulejšie.
const SUBSTEPS = 2

# ------------------------------------------------------------
# NÁDRŽ A VLNY
# ------------------------------------------------------------

const W = 8.0
const H = 8.0

const NX = 180
const NY = 180

const dx = W / (NX - 1)
const dy = H / (NY - 1)

# Rýchlosť šírenia zjednodušenej hladinovej vlny
const c = 2.5

# Bezpečný krok explicitnej 2D vlnovej schémy
const dt = 0.42 * min(dx, dy) / c

# Hladina vody je z = 0
const WATER_Z = 0.0

# ------------------------------------------------------------
# FYZIKA KYVADIEL
# ------------------------------------------------------------

const g = 9.81
const pivot_z = 3.15

# Dve spodné výstupné gule
const L_LEFT = 2.95
const L_RIGHT = 2.95

# Horná guľa v špici trojuholníka
const L_TIP = 2.70

# Veľké prichádzajúce kyvadlo
const L_BIG = 3.10

lengths = [L_LEFT, L_RIGHT, L_TIP, L_BIG]

# Indexy
const LEFT  = 1
const RIGHT = 2
const TIP   = 3
const BIG   = 4

# ------------------------------------------------------------
# GEOMETRIA ROVNOSTRANNÉHO TROJUHOLNÍKA
# ------------------------------------------------------------

const SIDE = 2.15
const TRI_H = sqrt(3.0) * SIDE / 2.0

# Závesy malých kyvadiel:
#
#             TIP
#              ●
#
#       LEFT         RIGHT
#        ●             ●
#
pivot_xy = [
    [-SIDE / 2.0, 0.0],       # LEFT
    [ SIDE / 2.0, 0.0],       # RIGHT
    [0.0, TRI_H],             # TIP
    [0.0, TRI_H + 1.15]       # BIG: za špicou, vyššie v osi Y
]

# ------------------------------------------------------------
# SMERY POHYBU V XY ROVINE
# ------------------------------------------------------------

# Malé spodné gule sa po náraze rozletia smerom von.
#
# LEFT:  doľava a dolu
# RIGHT: doprava a dolu
#
# TIP sa hýbe v smere útoku veľkej gule.
# BIG sa pohybuje v osi Y smerom k špici.
directions = [
    Point2f(-sqrt(3.0) / 2.0, -0.5),  # LEFT von
    Point2f( sqrt(3.0) / 2.0, -0.5),  # RIGHT von
    Point2f(0.0, 1.0),                # TIP
    Point2f(0.0, -1.0)                # BIG smerom k TIP
]

# ------------------------------------------------------------
# UHLY A UHLOVÉ RÝCHLOSTI
# ------------------------------------------------------------

# Spodné gule začínajú vo zvislej polohe.
# Špicová guľa má malý náklon smerom k prichádzajúcej veľkej guli.
# Veľká guľa začína výrazne vychýlená.
theta = [0.0, 0.0, 0.08, -0.92]
omega = [0.0, 0.0, 0.0, 0.0]

# Tlmenie kývania
const PENDULUM_DAMPING = 0.018

# Polomery len pre detekciu kolízie a vizualizáciu
radii = [0.22, 0.22, 0.23, 0.36]

# ------------------------------------------------------------
# VODNÁ MRIEŽKA
# ------------------------------------------------------------

xs = range(-W / 2.0, W / 2.0, length = NX)
ys = range(-H / 2.0, H / 2.0, length = NY)

X = [x for y in ys, x in xs]
Y = [y for y in ys, x in xs]

eta = zeros(Float64, NY, NX)
eta_prev = zeros(Float64, NY, NX)
eta_next = zeros(Float64, NY, NX)

# Jeden Observable používajú surface! aj heatmap!
eta_obs = Observable(copy(eta))

# ------------------------------------------------------------
# POMOCNÉ FUNKCIE
# ------------------------------------------------------------

function bob_position(i, theta)
    x0, y0 = pivot_xy[i]
    ux, uy = directions[i]

    horizontal = lengths[i] * sin(theta[i])

    x = x0 + horizontal * ux
    y = y0 + horizontal * uy
    z = pivot_z - lengths[i] * cos(theta[i])

    return Point3f(x, y, z)
end

function bob_velocity(i, theta, omega)
    ux, uy = directions[i]

    horizontal_speed = lengths[i] * cos(theta[i]) * omega[i]
    vertical_speed = lengths[i] * sin(theta[i]) * omega[i]

    return Point3f(
        horizontal_speed * ux,
        horizontal_speed * uy,
        vertical_speed
    )
end

function distance3(p, q)
    return sqrt(
        (p[1] - q[1])^2 +
        (p[2] - q[2])^2 +
        (p[3] - q[3])^2
    )
end

# ------------------------------------------------------------
# VLNOVÁ ROVNICA
# ------------------------------------------------------------

function wave_step!(eta_next, eta, eta_prev)
    coeff_x = (c * dt / dx)^2
    coeff_y = (c * dt / dy)^2

    @inbounds for j in 2:NY-1, i in 2:NX-1
        d2x = eta[j, i + 1] - 2.0 * eta[j, i] + eta[j, i - 1]
        d2y = eta[j + 1, i] - 2.0 * eta[j, i] + eta[j - 1, i]

        eta_next[j, i] =
            2.0 * eta[j, i] -
            eta_prev[j, i] +
            coeff_x * d2x +
            coeff_y * d2y
    end

    # Pevné reflexné steny nádrže
    eta_next[1, :] .= eta_next[2, :]
    eta_next[end, :] .= eta_next[end - 1, :]
    eta_next[:, 1] .= eta_next[:, 2]
    eta_next[:, end] .= eta_next[:, end - 1]

    # Jemné tlmenie, aby vlnenie postupne zanikalo
    eta_next .*= 0.9988

    return nothing
end

# ------------------------------------------------------------
# LOKÁLNY IMPULZ NA HLADINE
# ------------------------------------------------------------

function create_splash!(eta, x, y, strength)
    ix = clamp(round(Int, (x + W / 2.0) / dx) + 1, 2, NX - 1)
    iy = clamp(round(Int, (y + H / 2.0) / dy) + 1, 2, NY - 1)

    radius = 0.16
    cells = 9

    @inbounds for j in max(2, iy - cells):min(NY - 1, iy + cells)
        for i in max(2, ix - cells):min(NX - 1, ix + cells)
            r2 = (xs[i] - x)^2 + (ys[j] - y)^2
            eta[j, i] += strength * exp(-r2 / (2.0 * radius^2))
        end
    end

    return nothing
end

# ------------------------------------------------------------
# FIGÚRA
# ------------------------------------------------------------

fig = Figure(
    size = (1600, 850),
    backgroundcolor = RGBf(0.015, 0.018, 0.030)
)

Label(
    fig[0, :],
    "Náraz veľkého kyvadla → dve krajné kyvadlá → interferencia vĺn",
    color = :white,
    fontsize = 24,
    font = :bold,
    padding = (0, 0, 12, 6)
)

# ------------------------------------------------------------
# 3D POHĽAD
# ------------------------------------------------------------

ax3 = Axis3(
    fig[1, 1],
    aspect = :data,
    perspectiveness = 0.55,
    elevation = 0.28,
    azimuth = -0.75,
    backgroundcolor = RGBf(0.01, 0.015, 0.025),
    xlabel = "X",
    ylabel = "Y",
    zlabel = "Z",
    xlabelcolor = :white,
    ylabelcolor = :white,
    zlabelcolor = :white
)

xlims!(ax3, -W / 2.0, W / 2.0)
ylims!(ax3, -H / 2.0, H / 2.0)
zlims!(ax3, -0.40, 3.7)

surface!(
    ax3,
    X,
    Y,
    eta_obs,
    colormap = :deep,
    colorrange = (-0.42, 0.42),
    shading = NoShading
)

# Steny štvorcovej nádrže
tank_corners = [
    (-W / 2.0, -H / 2.0),
    ( W / 2.0, -H / 2.0),
    ( W / 2.0,  H / 2.0),
    (-W / 2.0,  H / 2.0),
    (-W / 2.0, -H / 2.0)
]

for k in 1:4
    x1, y1 = tank_corners[k]
    x2, y2 = tank_corners[k + 1]

    lines!(
        ax3,
        [x1, x2],
        [y1, y2],
        [0.0, 0.0],
        color = (:white, 0.85),
        linewidth = 3
    )

    lines!(
        ax3,
        [x1, x1],
        [y1, y1],
        [0.0, -0.28],
        color = (:white, 0.50),
        linewidth = 2
    )
end

# Tyče kyvadiel
rods = [
    Observable(Point3f[
        Point3f(pivot_xy[i][1], pivot_xy[i][2], pivot_z),
        bob_position(i, theta)
    ])
    for i in 1:4
]

for i in 1:4
    lines!(
        ax3,
        rods[i],
        linewidth = i == BIG ? 6 : 4,
        color = i == BIG ? :gold : :white
    )
end

# Gule
balls3d = Observable([bob_position(i, theta) for i in 1:4])

scatter!(
    ax3,
    balls3d,
    markersize = [24, 24, 26, 42],
    color = [:deepskyblue, :deepskyblue, :orange, :crimson]
)

# Závesné body
for i in 1:4
    scatter!(
        ax3,
        [Point3f(pivot_xy[i][1], pivot_xy[i][2], pivot_z)],
        markersize = i == BIG ? 13 : 10,
        color = :white
    )
end

# ------------------------------------------------------------
# 2D HEATMAPA
# ------------------------------------------------------------

ax2 = Axis(
    fig[1, 2],
    aspect = DataAspect(),
    backgroundcolor = RGBf(0.01, 0.015, 0.025),
    xlabel = "X",
    ylabel = "Y",
    title = "Výška hladiny η(x, y, t)",
    titlecolor = :white,
    xlabelcolor = :white,
    ylabelcolor = :white
)

xlims!(ax2, -W / 2.0, W / 2.0)
ylims!(ax2, -H / 2.0, H / 2.0)

heatmap!(
    ax2,
    xs,
    ys,
    eta_obs,
    colormap = :turbo,
    colorrange = (-0.42, 0.42)
)

lines!(
    ax2,
    [-W / 2.0, W / 2.0, W / 2.0, -W / 2.0, -W / 2.0],
    [-H / 2.0, -H / 2.0, H / 2.0, H / 2.0, -H / 2.0],
    color = :white,
    linewidth = 3
)

# Projekcia gúľ na XY rovinu
balls2d = Observable([
    Point2f(bob_position(i, theta)[1], bob_position(i, theta)[2])
    for i in 1:4
])

scatter!(
    ax2,
    balls2d,
    markersize = [14, 14, 16, 24],
    color = [:deepskyblue, :deepskyblue, :orange, :crimson],
    strokecolor = :white,
    strokewidth = 1
)

Colorbar(
    fig[1, 3],
    limits = (-0.42, 0.42),
    colormap = :turbo,
    label = "výška hladiny η",
    labelcolor = :white,
    ticklabelcolor = :white,
    tickcolor = :white
)

# ------------------------------------------------------------
# SIMULÁCIA A VIDEO
# ------------------------------------------------------------

# Náraz sa vykoná iba raz.
collision_done = false

# Aby jeden dotyk vody nevytváral impulz v každom kroku.
in_water = falses(4)

simulation_time = 0.0

record(fig, OUTPUT_FILE, 1:NFRAMES; framerate = FPS) do frame

    for substep in 1:SUBSTEPS

        # ----------------------------------------------------
        # 1. Pohyb kyvadiel
        # ----------------------------------------------------

        for i in 1:4
            alpha = -(g / lengths[i]) * sin(theta[i])
            alpha -= PENDULUM_DAMPING * omega[i]

            omega[i] += alpha * dt
            theta[i] += omega[i] * dt
        end

        # ----------------------------------------------------
        # 2. Náraz veľkej gule do špicovej gule
        # ----------------------------------------------------

        p_big = bob_position(BIG, theta)
        p_tip = bob_position(TIP, theta)

        hit_distance = 0.72 * (radii[BIG] + radii[TIP])

        if !collision_done && distance3(p_big, p_tip) < hit_distance

            global collision_done = true

            # Zachová sa časť pohybu veľkého kyvadla,
            # ale väčšina impulzu sa pošle do sústavy.
            incoming_speed = max(abs(omega[BIG]), 0.45)

            # Veľká guľa po kontakte stráca energiu.
            omega[BIG] *= -0.20

            # Špicová guľa dostane krátky pohyb v smere nárazu.
            omega[TIP] = 0.55 * incoming_speed

            # Dve krajné gule sa vychýlia symetricky VON.
            #
            # LEFT má smer pohybu definovaný doľava-dolu,
            # RIGHT doprava-dolu. Rovnaké kladné omega preto
            # znamená symetrické "roztvorenie".
            omega[LEFT] = 1.85 * incoming_speed
            omega[RIGHT] = 1.85 * incoming_speed

            # Jemný centrálny impulz do vody pre vizuálny dôsledok nárazu
            create_splash!(eta, p_tip[1], p_tip[2], -0.07 * incoming_speed)
        end

        # ----------------------------------------------------
        # 3. Dotyk gúľ s vodou
        # ----------------------------------------------------

        for i in 1:4
            p = bob_position(i, theta)
            v = bob_velocity(i, theta, omega)

            # Kontakt nastane, keď spodná časť gule prejde hladinou.
            touches_water = (p[3] - radii[i]) < WATER_Z

            # Impulz iba pri vstupe smerom dole.
            if touches_water && !in_water[i] && v[3] < 0.0
                impact = 0.05 + 0.16 * min(abs(v[3]), 2.5)

                # Vtlačenie gule tvorí najprv lokálnu jamku.
                create_splash!(eta, p[1], p[2], -impact)
            end

            in_water[i] = touches_water
        end

        # ----------------------------------------------------
        # 4. Vývoj hladiny
        # ----------------------------------------------------

        wave_step!(eta_next, eta, eta_prev)

        eta_prev .= eta
        eta .= eta_next

        global simulation_time += dt
    end

    # --------------------------------------------------------
    # 5. Aktualizácia Makie objektov pre snímku videa
    # --------------------------------------------------------

    eta_obs[] = copy(eta)

    for i in 1:4
        rods[i][] = Point3f[
            Point3f(pivot_xy[i][1], pivot_xy[i][2], pivot_z),
            bob_position(i, theta)
        ]
    end

    balls3d[] = [bob_position(i, theta) for i in 1:4]

    balls2d[] = [
        Point2f(
            bob_position(i, theta)[1],
            bob_position(i, theta)[2]
        )
        for i in 1:4
    ]
end

display(fig)
println("Hotovo. Video bolo uložené do súboru: ", OUTPUT_FILE)

---