Native IFS Holography

An overview of holography performed not with light and lenses, but with a fractal-time generator — and the path from it toward a holographic computer.

---

1. What This Is

The Krestianstvo Wavefront Evaluator (KWE) performs holography natively, inside a simulated medium whose propagation law is an Iterated Function System (IFS) fractal clock, not the wave equation of classical optics. There is no laser, no lens, no photographic plate. There is a complex field ψ on a grid, evolved by a reversible operator built from the IFS ring kernel, and the holographic properties — encoding, reconstruction, redundancy — emerge from that operator.

The central object is the holographic eye: a live observer that receives a propagated wavefront, optionally transforms it in the hologram domain, and reconstructs a percept. The reconstruction is a soliton — a self-sustaining eigenstate of the IFS medium — rather than a passive image.

[Image placeholder — 5-stage holographic eye pipeline: object plane → hologram domain → transform → reconstruction → soliton percept]

---

2. Classical Holography in One Paragraph

A classical hologram records the interference of an object wave O with a reference wave R onto a square-law (intensity-only) medium:

I = |O + R|²  =  |O|² + |R|² + O·R* + O*·R

The cross-term O·R* carries the object’s full phase, which the intensity recording would otherwise lose. Reconstruction re-illuminates the plate with R; diffraction re-emits O. The defining property is distributed redundancy: because free-space propagation sends every object point to every location on the plate, any fragment of the plate reconstructs the whole scene (at reduced resolution).

Two ingredients make this work:

1. A reference wave to encode phase into intensity
2. Globally-spreading propagation (Fresnel/Fourier) so information is delocalized

---

3. Native IFS Holography — How KWE Differs

KWE keeps the idea of holography (encode a wavefront, reconstruct it) but replaces both ingredients with native, fractal-medium machinery.

3.1 The Propagator Is the IFS Fractal Laplacian, Not Free Space

The field evolves by a symplectic Störmer–Verlet leapfrog of a Schrödinger-type equation i∂ₜψ = −Lψ, where L is an IFS ring operator: a sum over rings of radius r_d with weights w_d:

L = Σ_d w_d ( R_d − n_d·I )

R_d sums the field around a discrete ring of radius r_d. The ring radii come from the IFS fractal clock (the “Fresnel IFS” depth schedule). Key properties, all verified:

• Reversible. The leapfrog is palindromic (kick–drift–kick), so F⁻ᵀ Fᵀ = I to machine precision. Forward T steps then backward T steps returns the input exactly.
• Symplectic / norm-preserving. It rotates phase space; it does not dissipate. This is why backward propagation reconstructs rather than smears.
• Diffusive, not instantaneous. Unlike Fresnel/Fourier (which fill the aperture in one step), the IFS ring operator spreads the field gradually and locally — energy creeps outward over many steps. This single fact drives the central result.

3.2 No Reference Wave Is Needed — the Field Is Complex

Classical holography needs a reference beam only because detectors measure intensity and lose phase. KWE carries the full complex field ψ (real + imaginary) end to end. Nothing is ever collapsed to |ψ|² during the pipeline. Therefore:

• No reference wave, no |·|² recording, no DC term, no twin image
• No Gerchberg–Saxton, no phase-shifting
• Reconstruction is simply running the reversible operator backward

This was confirmed with a single point source: point → Fᵀ → swPsi (hologram) → F⁻ᵀ → exact point, 100% energy back at the source pixel — no iteration, no phase recovery.

3.3 Depth Is Duration, Not Euclidean Distance

In classical optics, depth z is a spatial coordinate baked into wavefront curvature. In the IFS medium there is no z axis. Depth is encoded as the number of IFS steps a point propagates — depth is duration of fractal-clock evolution. Near points evolve fewer steps (tight, high-frequency fringes); far points evolve more (spread, low-frequency). Reconstruction depth-scans by watching where each point refocuses along the backward sweep.

The third dimension is the clock.

Comparison Table

	Classical holography	Native IFS holography (KWE)
Medium	Physical light + plate	Complex field ψ on a grid
Propagator	Fresnel / Fourier (wave eq.)	IFS fractal Laplacian (leapfrog)
Reference wave	Required	None (full complex field kept)
Recording	|O+R|² intensity (lossy)	Complex ψ (lossless)
Phase recovery	Needs GS / phase-shifting	Not needed (phase never lost)
Reconstruction	Re-illuminate with R, diffract	Run operator backward F⁻ᵀ (exact)
Spread	Global, instantaneous	Diffusive, depth-gated
Depth encoding	Euclidean z (curvature)	Duration = # of IFS steps
Twin image	Present (must separate)	None

---

4. The Holographic Eye and [H] — Computing in the Hologram Domain

The eye is the live pipeline (IFSEye in holography.js, driven by eye.js):

ψ_obj  ──Fᵀ──►  ψ_holo  ──[H]──►  ψ_holo'  ──F⁻ᵀ──►  ψ_evidence  ──relax──►  ψ_percept
object         hologram        transform        reconstruction        soliton
plane           domain          (optional)        (exact inverse)       percept

Five stages, each a panel in the UI:

1. ψ_obj — the source wavefront (geometry as points/edges, or a received field)
2. ψ_holo = Fᵀ(ψ_obj) — the spread hologram-domain field. The maximally-mixed representation.
3. [H] — the hologram-domain transform slot. Because the field is maximally spread here, a local edit in H-space is a distributed edit in object-space — the holographic property that makes this the natural place to compute. Implemented modes: identity, low/high-pass aperture, phase conjugate, left-occlusion, random-block zero/noise.
4. ψ_evidence = F⁻ᵀ(ψ_holo’) — the reconstruction (exact inverse when [H]=identity)
5. ψ_percept — the evidence relaxed onto a soliton eigenstate of the IFS medium via feedback injection. Perception is not a copy of the measurement; it is the stable attractor nearest the evidence.

The eye supports save/load of the hologram-domain field (.kwe): the file stores ψ_holo' (post-[H]), and loading re-runs the backward leg to reconstruct, then settles a fresh soliton from noise toward the loaded evidence — so a recalled memory is perceived as the medium’s canonical eigenstate, not a verbatim echo.

[Image placeholder — holographic eye demo: 5 panels showing ψ_obj, ψ_holo, ψ_holo’ (with aperture mask), ψ_evidence, ψ_percept]

---

5. Results — Establishing True Holography

The decisive question: does the IFS medium exhibit distributed redundancy — the cut-in-half property — or is it merely a reversible blur (a photo)?

The test: occlude a fraction r of the hologram-domain field ([H] mask), reconstruct, and score the reconstruction by correlation with the object. Linear falloff (score ≈ 1−r) = photographic (local); graceful/concave falloff = holographic (global).

5.1 Exact Reconstruction (Foundation)

A single point source reconstructs exactly — point → Fᵀ → F⁻ᵀ → point, 100% energy at the origin pixel, ~2.8 × 10⁻⁶ error after 100 GPU (Float32) steps. No GS, no phase-shifting. This proves the pipeline is a faithful, reversible encoder/decoder.

5.2 The Occlusion-Redundancy Curve — Holography Is Depth-Gated

Measured reconstruction score vs. occluded fraction r, at shallow (T=100) and deep (T=350) propagation:

  r       T=100     T=350      photo line (1−r)
 0.00     1.000     1.000      1.00
 0.25     0.981     0.952      0.75
 0.40     0.872     0.917      0.60     ← curves diverge past r≈0.4
 0.50     0.707     0.857      0.50
 0.75     0.234     0.559      0.25     ← T=350 more than 2× T=100
 0.90     0.000     0.258      0.10     ← decisive: same object, only T differs

• T=100 tracks the photo line and collapses to 0.000 at r=0.9 — convex, photographic. Shallow propagation leaves the spread local.
• T=350 stays far above the photo line and never collapses (0.258 at r=0.9) — concave, graceful degradation. Deep propagation makes the spread global: every point’s energy reaches the whole grid, so any fragment carries the whole object.

This is the cut-the-hologram-in-half property, reproduced in a fractal medium, and quantified: the holographic regime switches on with propagation depth T.

5.3 Interpretation

The IFS ring operator is diffusive (slow, local) where Fresnel/Fourier is instantaneous and global. Holographic redundancy requires global spread, which the diffusive operator only reaches at deep T. The transition from local→global spread is the transition from photographic→holographic behaviour. KWE is genuinely holographic; the control parameter is the fractal-clock duration.

---

6. IFS as a Fractal-Time Generator

The IFS clock is not a detail of the propagator — it is the substrate. Consequences:

• Depth = duration. 3D structure is encoded in how long a wavefront evolves, not in a spatial coordinate. The clock is literally the depth axis.
• Reversibility = time symmetry. Reconstruction is running the clock backward. The hologram is a time-reversal operation, not a spatial diffraction trick.
• The medium has its own eigenstates (solitons). Perception, memory, and reconstruction are all expressed as relaxation onto these eigenstates — the clock’s stable orbits.

Calling IFS a fractal-time generator is precise: it generates the temporal scaffold on which wavefronts live, spread, and refocus. Holography here is what that scaffold does to a complex field.

---

7. The Path: Holographic Computer → Cyberphysical Engine

The [H] slot is the doorway from holographic imaging to holographic computing. Because operations in the hologram domain are distributed in object space, [H] is a place to compute on whole wavefronts at once:

1. Holographic memory (associative). Superpose multiple objects’ hologram fields into one; recall the nearest with a partial cue via soliton relaxation. The Hopfield-IFS associative memory already works in this engine; the depth-gated global spread is the substrate that makes content-addressable recall robust to partial input.

2. Holographic transforms as computation. Filters, phase masks, conjugation, and learned kernels placed in [H] perform wavefront-wide operations — a single pass that touches every object point. This is the kernel of a holographic computer: compute by transforming spread wavefronts, not by addressing individual cells.

3. Multiplexing. Multiple snaps at different angles (carrier-tagged) or different objects (associative) stored in one field — parallax, multi-view, and memory in a single complex medium.

4. Cyberphysical engine. KWE already runs the field as a live, multiplayer, reactive world (IFS fractal clock + Croquet synchronization + Renkon reactive model). The eye is a continuous observer of an evolving field — a living perceptual loop. Coupling this loop to external sensors/actuators turns the holographic medium into a cyberphysical engine: a shared, synchronized, reversible wavefront substrate that perceives, remembers, and computes — clocked by fractal time.

IFS fractal-time generator
        │  (defines a reversible, depth-gated wavefront medium)
        ▼
Native IFS holography           ← exact reconstruction + true (depth-gated) redundancy [PROVEN]
        │  (add the [H] transform slot)
        ▼
Holographic computer            ← associative memory, wavefront-wide transforms [IN PROGRESS]
        │  (couple to a live, synced, reactive world + I/O)
        ▼
Cyberphysical engine            ← perceiving/remembering/computing shared medium [VISION]

---

8. Status Summary

Capability	Status
Reversible IFS propagator (leapfrog, symplectic)	✅ verified to machine precision
Exact reconstruction (no GS / phase-shift)	✅ point source, 100% energy
True holographic redundancy (cut-in-half)	✅ proven, depth-gated (T≈350)
Holographic eye (5-stage live pipeline)	✅ working, with soliton percept
[H] hologram-domain transform slot	✅ several modes (filter/occlude/conjugate)
Save / load hologram field (.kwe)	✅ stores ψ_holo', reconstructs on load
Per-point depth encoding (3D from duration)	◻ designed, not in eye yet
Associative multi-object memory	◻ Hopfield-IFS works; multiplex into eye pending
Holographic computing via [H]	◻ slot live; computational transforms pending
Cyberphysical I/O coupling	◻ vision

---

Source files: hologram_world.js (IFS clock + world program), holography.js (IFSEye, IFSHologram), ifs-gpu.js (GPU leapfrog + [H] shaders), apps/eye.js (live eye demo). Constants: GRID, DT=0.12, T_RECORD=100, N_DEPTH_TIERS=4, IFS_DEPTH=8.