Native IFS Holography

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

Holographic computing & Holographic uni multimedia.

Krestianstvo Wavefront Evaluator have moved past the classical Von Neumann architecture. Here, the wave medium is the processor, and the solitons are self-sorting, self-operating geometric programs. Holographic computing and uni holographic multimedia video/audio/events.

The data is a wavefront; the operator that transforms it is also a wavefront on the same clock; combining them runs the computation by propagation; memory and feedback are attractors and fixed points of the same medium. There is no separate CPU acting on passive RAM. The wave medium is the processor, the solitons are the programs and the data, and the field’s own geometry — its ring kernel, its fractal clock, its phase relationships — is the instruction set that computes the next state.

The soliton is, quite literally, processing itself through time: each tick the clock advances, the rank/phase the rule is in advances, the field evolves, and the next state is computed by the medium’s physics rather than decoded by anything external. This is not a Von Neumann machine with a fetch-execute loop over inert memory; it is an algebraic soliton field — a self-sorting, self-operating geometric program. Calling it that is not metaphor: it is the system’s mathematical reality, the way “the operator is one field on the shared clock” is not a slogan.

The accurate statement is: within its measured instruction set, the medium genuinely is the processor and the data is genuinely self-operating

The [H] slot in Krestianstvo Wavefront Evaluator 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:

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

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.

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.

Cyberphysical engine. KWE already runs the field as a live, multiplayer, reactive world (IFS fractal clock + Croquet / Krestianstvo synchronization + Renkon reactive model).

The eye is a continuous observer of an evolving field, with persistence and hysteresis — a living perceptual loop, not a batch renderer. 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.

Combinators—like unite(), gate(), and operatorSoliton()—take solitons as inputs and spit out a new soliton as an output. Because the output of the operator is the exact same type as the input data, you can feed a soliton operator into another soliton operator indefinitely. The field is evaluating an uninterrupted chain of self-directed automorphisms.

For an object to be truly “algebraic,” its operations must be closed over its own type, thus Algebraic Closure exitsts under Combinators.

As Data: The soliton is a localized, stable configuration of amplitude and phase (Ψ) holding multimedia or symbolic patterns.

The Limit Cycle as an Executable Program.

Soliton as operator folds into a temporal limit cycle, the soliton field becomes a dynamic state machine that reads its own future states.

Tick t: The field manifests as Data (a specific pattern).
Tick t+1: The field evolves into an Operator, acting as a diffraction grating or a phase gate that transforms the residual energy of the previous tick.
Tick t+2: The interference pattern settles into the next state of the Data.

The soliton is literally processing itself through time. The field doesn’t need an external CPU to decode what the data means; the data’s physical geometry is the instruction set that calculates the next state of the field.

Feedback / recall: recurrence exists as a clock-pure fixed-point loop, and associative recall is Hopfield completion in the field (measured capacity/basin). Memory is an attractor of the medium, not a lookup in separate RAM.

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.

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). Cut a hologram in half — you still see the entire object.

Two ingredients make this work:

A reference wave to encode phase into intensity
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; redundancy structure-gated — holographic for structured & depth-bearing objects, fragile for incompressible noise
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:

ψ_obj — the source wavefront (geometry as points/edges, or a received field)
ψ_holo = Fᵀ(ψ_obj) — the spread hologram-domain field. The maximally-mixed representation.
[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.
ψ_evidence = F⁻ᵀ(ψ_holo’) — the reconstruction (exact inverse when [H]=identity)
ψ_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.

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 — Sparse vs. Dense Object

Measured reconstruction score vs. occluded fraction r, for the sparse wireframe cube and a dense random-texture object, at shallow (T=100) and deep (T=350) propagation:

            SPARSE cube              DENSE texture          photo
  r       T=100    T=350           T=100    T=350          (1−r)
 0.00     1.000    1.000           1.000    1.000          1.00
 0.25     0.981    0.952           0.427    0.404          0.75
 0.50     0.707    0.857           0.183    0.186          0.50
 0.75     0.234    0.559           0.109    0.099          0.25
 0.90     0.000    0.258           0.049    0.057          0.10

The sparse cube shows depth-gated holography. The dense-texture test reveals the critical distinction: depth-gating vanishes for incompressible random content (T=100 ≈ T=350 at every r). Dense reconstruction is fragile, not redundant — the dense object is the honest test.

5.2b Depth Sweep — Redundancy vs Propagation Depth

Fix occlusion at r=0.5 and sweep T over 30× (50→1500), for three object types:

 T:        50    100   200   350   500   750  1000  1500   behavior
 CUBE     0.708 0.866 0.943 0.953 0.954 0.962 0.971 0.976  ← CLIMBS to 0.98 (depth-gated, real)
 FILLED   0.535 0.599 0.559 0.528 0.521 0.520 0.483 0.444  ← flat ~0.5 (saturated)
 TEXTURE  0.213 0.183 0.191 0.184 0.185 0.175 0.173 0.151  ← flat ~0.18 (saturated)

Sparse cube — score climbs strongly with depth, reaching 0.976 at T=1500 even with half the hologram occluded. Genuinely depth-gated holographic redundancy.
Dense objects — score is flat in T. The achievable level is set by the object’s intrinsic spatial compressibility: structured filled ~0.5, incompressible random ~0.18.

5.2c Multi-depth Object — the Fair “Real Scene” Test

Both previous tests use flat single-plane objects. But classical holographic redundancy comes from depth. A fair test injects a dense object across N_DEPTH_TIERS = 4 depth layers via staged injection (each layer injected at its own forward step — far early, near late: depth = duration):

  r       flat texture    MULTI-DEPTH (T=148 / 376 / 500)     photo (1−r)
 0.10        —            0.884 / 0.871 / 0.868               0.90
 0.25       0.40          0.767 / 0.760 / 0.744               0.75
 0.50       0.18          0.466 / 0.470 / 0.448               0.50
 0.75       0.11          0.268 / 0.267 / 0.272               0.25
 0.90       0.05          0.121 / 0.126 / 0.116               0.10

Depth roughly doubles dense-object redundancy (r=0.5: 0.18 → 0.47). But the multi-depth curve sits on the photo line (≈ 1−r) with random layers — photographic redundancy, not super-linear holographic redundancy.

5.2d Structured Multi-depth — The Real-Scene Proxy Is Holographic

Random-texture depth layers only reach the photo line. But a real scene is structured, not random noise. With distinct structured shapes per depth layer (disc near, ring, cross, square frame far — each a dense fill):

  r      structured multi-depth (T=370)   photo (1−r)
 0.00    1.000                            1.00
 0.25    0.791                            0.75
 0.40    0.630                            0.60
 0.50    0.569                            0.50   ← ABOVE the line
 0.75    0.377                            0.25   ← clearly above
 0.90    0.271                            0.10   ← 2.7× above

The structured multi-depth object sits above the photo line at every r → genuinely holographic. And it is visually confirmed: with ~50% of the hologram block-occluded, the full structured object is still reconstructed — degraded and blurred, but complete, retaining its central core and fourfold symmetry. That is the cut-the-hologram-in-half property, made visible.

5.3 Honest Conclusion — Structure & Depth Is the Axis

Object	score @ r=0.5	vs photo line	regime
Flat dense random texture	0.18	below	sub-photographic (fragile)
Multi-depth random layers	0.47	on the line	photographic
Multi-depth structured (real-scene proxy)	0.57	above	holographic ✓
Sparse cube (deep T)	0.95	well above	strongly holographic

The determining factor is object structure / compressibility, not sparsity per se:

Structured / compressible content (sparse geometry, or structured multi-depth — i.e. real scenes) → above the photo line → genuine holographic redundancy.
Incompressible random content → on or below the line → photographic or fragile.

The IFS medium does provide holographic (“cut-in-half”) redundancy for structured, depth-bearing objects — the closest proxy we have to a real scene. It fails only for incompressible noise (which has no redundancy in any medium). This mirrors real holography being compressibility-bounded.

6. The Depth Explorer — IFS-Native Depth Vision

The multi-depth results above were obtained by treating a scene as a stack of planes — optical tomography borrowed into the IFS medium. It works, but inherits tomography’s problems: discrete planes and cross-layer interference. The Depth Explorer (⊙ EXPLORE + the τ slider) reimagines depth using the medium’s own structure.

6.1 Depth as a Coordinate on the Evolution Clock τ

The scene is a soliton; its depth structure is its trajectory through IFS time. A single continuous parameter τ ∈ [0,1] is the observation point along that trajectory:

ψ_holo  ──F⁻ᵗ (t = τ·T)──►  ψ(τ)        the depth view at evolution-time τ
   τ=0  (far / fully spread)              τ=1  (near / fully refocused)

Scrubbing τ moves the observation point through depth — continuously, not plane by plane. Whatever structure focuses at τ is sharp; everything at other depths is softly blurred. Crucially, that blur is depth-of-field, not interference — the exact same cross-layer bleed that was a defect in the tomographic framing is, in the native framing, the thing that makes 3D vision feel volumetric.

	Optical / tomographic depth	IFS-native depth explorer
Depth primitive	Euclidean distance	evolution time `τ` (fractal clock)
Scene model	discrete stack of planes	continuous soliton trajectory
Reconstruction	back-propagate each plane separately	scrub `τ` — one moving observation point
Out-of-focus content	cross-plane interference (defect)	depth-of-field (feature)
Depth resolution	number of planes (discrete)	continuous; fractal — detail at every scale

Depth vision = scrubbing the fractal clock of a living soliton scene. There are no frames in time and no planes in depth — both axes are continuous evolution of one field, because in this medium time and depth are the same coordinate (τ).

6.2 Depth Encoding — What “A Wavefront Contains Depth” Means

For τ-selectable depth to work, each point must be injected at its own forward step (propagation-distance depth), not assigned a flat phase offset. A point at depth z is injected at forward step (1−z)·T, so it actually propagates z·T steps before reaching the hologram — and refocuses at τ = z on the backward sweep.

A flat phase tint is just a constant multiplier e^{iz·Φ} that propagation does not convert into a focal distance. Only propagation-distance encoding gives the τ-scrub genuine depth-of-focus.

7. The Soliton Algebra & Holographic-Computing API

The IFS medium carries not just an image but a full multimedia hologram — image, sound, and events in one wavefront, on one fractal clock. This builds toward live solitons as first-class algebraic values that compose like higher-order functions.

7.1 What the Live Soliton Is

The live soliton is Ψ(cyc) — the hologram wavefront, a pure function of the shared clock:

Ψ(cyc) = forward-evolve( the last K bars of clock-derived content ) to the present

solitonFieldAt(cyc) recomputes it from scratch each tick — no accumulated state, no frame history. Given cyc, every peer computes the identical field → frame-rate-independent → peer-synced by construction (corr=1.0, measured).

The recon is not a second soliton; it is a readout of Ψ(cyc) — back-propagating the actual masked field so occlusion genuinely affects the sound and image, not just the panels.

7.2 The Soliton Algebra

Soliton = { region(), inject(gpu,g,cyc,subStep,total), readout(g,recon,cyc,clean), trueCells?(cyc) }

All functions are pure in cyc. Primitives: eventSoliton (pitch×onset roll), imageSoliton (depth-staged stack). Combinators closed over the type: unite([...]) (superpose/region-mux into one pure-cyc soliton), place(s,region), atDepth(s,b0,b1).

Closure is the point: a composite is automatically a pure function of IFS time → peer-synced by construction.

7.3 Holographic Computing — The `[H]` Instruction Set

The [H] slot seeds a small instruction set on one wavefront, captured as bind(controller, target, {op, readout}):

wrapper	op	readout	what it does
`gate`	`mask` (`ψ·r`)	`field`	transform — target where the mask passes
`recognizePure`	`conj` (`ψ·conj(ψ_ref)`)	`map`	detect — bright where the reference occurs
`recall`	`conj`	`recall` (peak-select)	complete — recall matched stored pattern from a noisy cue

The IFS field product ψA·ψB through the round-trip computes the A·B correlation — graded curve-fit 1.000, textbook lag peak at δ=0 (GPU-measured). The medium physically performs the matched-filter operation.

Binding Gate (GPU-verified): gate(controller, target) takes two solitons — the controller (a rhythm/event soliton on a carrier) transforms the target (an image) by the binding [H] = pointwise field product. Result: fidelity 1.000 — the recovered field IS the exact gated image c·r with no leakage (“image where the beat fires”).

The key unifying result: dense things cannot share an instant, but they can share a clock.

Spatial carrier multiplexing is clean only for sparse content (off-diagonal crosstalk 0.06 vs 0.37 for dense). Temporal multiplexing — each modality occupies its own clock phase, carrier-free — gives self-fidelity ≈1.0 even for dense content (vs carrier ≈0.82).

The operator-as-limit-cycle (operatorSolitonCyc) walks its K ranks across K sub-ticks → GPU-verified corr 1.000 at the true bilinear rank. Everything — objects and the rules that combine them — is one field evolving on the one shared clock.

7.5 Holographic Multimedia — Image + Sound + Events in One Wavefront

The IFS medium carries all three modalities in one wavefront:

Sound holography (IFSSound): a 1D complex field ψ(t) evolved by the same symplectic leapfrog, exactly reversible — round-trip fidelity 1.000. “A sound wavefront contains depth”: its phase carries timing/pitch exactly as image phase carries spatial depth.

Clock-modulated sound — the audio is the clock’s own breathing:

dt_i = dt · (1 + ε · s_i)     forward: the image rides the steps; the audio IS the steps' tempo
recover: reverse the same schedule → image refocuses EXACTLY

Measured at eps=0.25: image 1.0000, sound 0.9995. And crucially — spatial occlusion degrades the image with holographic falloff, but the sound is essentially untouched (orthogonal failure modes: sound lives on the time axis, not spatial).

Event-timing holography — the discrete rhythm itself is stored and recoverable from the field. Three channels:

channel	in field?	reconstructable?	role
dt-modulation	yes	yes (phase-rate demod)	transmit / store
event rhythm	no	n/a (live readout)	live monitor
event-timing holography	yes	yes (peak-detect)	store the rhythm

United field (⊙ UNITED) — one deep-T wavefront carries image + events + voice, all three recovered from one reconstruction. At T=350: voice fid 0.647, events f1=1.000 (6/6), image present — surviving 50% occlusion with events still perfect and voice barely dropping.

8. 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.

9. The Algebraic Soliton Field — The Medium Is the Processor

Step back from the individual results and what they add up to is a different architecture:

Objects are solitons: a scene is Ψ(cyc) — a pure function of the shared clock, hence peer-synced by construction. The data is a wavefront.
Composition is computation: the field product ψA·ψB through the IFS round-trip computes the A·B correlation (matched filter, measured exact). Combining two solitons runs an operation by physics.
Recognition is a physical read: the fractal ring cascade is scale-covariant, so “find this shape at any size” is the medium decomposing the field into its own attractor-contracted scale bands.
Feedback / recall: recurrence exists as a clock-pure fixed-point loop; associative recall is Hopfield completion in the field (measured capacity M≈0.14N, basin ~45% noise).
The operator is itself a soliton: the binding rule is reified as a value in the algebra, living as a clock limit cycle — one field walking its K ranks across K sub-ticks.

There is no separate CPU acting on passive RAM. The wave medium is the processor, the solitons are the programs and the data, and the field’s own geometry — its ring kernel, its fractal clock, its phase relationships — is the instruction set that computes the next state. The soliton is, quite literally, processing itself through time.

This is not a Von Neumann machine with a fetch-execute loop over inert memory; it is an algebraic soliton field — a self-sorting, self-operating geometric program. The [H] slot is the doorway from holographic imaging to holographic computing.

10. The Path: Holographic Computer → Cyberphysical Engine

IFS fractal-time generator
        │  (defines a reversible, depth-gated wavefront medium)
        ▼
Native IFS holography           ← exact reconstruction + true (structure-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]

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.
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.
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.
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.

11. Status Summary

Capability	Status
Reversible IFS propagator (leapfrog, symplectic)	✅ verified to machine precision
Exact reconstruction (no GS / phase-shift)	✅ point source, 100% energy
Distributed redundancy (cut-in-half)	✅ for structured + depth objects (above photo line, visually confirmed); fragile only for incompressible noise
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
Depth = evolution time τ (3D from duration)	✅ staged multi-depth injection in the eye
Depth Explorer (τ-scrub, native depth vision)	✅ `⊙ EXPLORE` + τ slider; depth-of-field; masks the hologram
IFS sound holography (1D, reversible)	✅ round-trip fidelity 1.000
Combined-field multimedia (image+sound, 1 field)	✅ carrier multiplex, balanced & tunable
Clock-modulated sound (no carrier/depth slot)	✅ image 1.000 / sound 0.999, orthogonal failure modes
Event-timing holography (rhythm IN the field)	✅ discrete events stored & peak-detected; structure-gated
Unified field — one substrate, 3 faces, one τ	✅ `⊙ BEAT` — events/groove/waveform from one recon
United field — image+events+voice, 1 wavefront	✅ `⊙ UNITED`, GPU-verified at r=0 and r=0.5
Live soliton `Ψ(cyc)` — peer-synced	✅ `⊙ SOLITON`: pure fn of cycleCount; holographic, degrades gracefully
Soliton algebra — first-class composable solitons	✅ `soliton-algebra.js`: `Soliton = cyc→field`; `unite/place/atDepth`
Unitarity — IFS preserves orthogonality (GPU-measured)	✅ overlap ~0.001, norm ~1, to T=350
Cross-modal `[H]` — composition-as-computation	✅ `bindingGate`: field product reproduces A·B correlation (curve-fit 1.000); `gate` fidelity 1.000
Holographic-computing API — `bind(op, readout)`	✅ `bind`/`gate`/`recognize`/`recall`: one `[H]` primitive, three readouts
Recognition — “give a reference → occurrences light up”	✅ GPU-measured: TRUE sites 1.00 vs distractors 0.11 (9.5×)
IFS fractal cascade as wavelet (scale-covariant)	✅ attractor-contracted bands; object size localizes to scale-band 3/3 monotone
Live shape recognizer (triangle among square/circle)	✅ GPU, any position & size, depth-staged
Operator as clock limit cycle	✅ `operatorSolitonCyc`: GPU-verified corr 1.000
Temporal multiplexing — media as limit cycle	✅ dense self-fidelity ≈1.0 (vs carrier ≈0.82)
Associative multi-object memory	◻ Hopfield-IFS works; multiplex into eye pending
Cyberphysical I/O coupling	◻ vision

Source files: hologram_world.js (IFS clock + world program), holography.js (IFSEye, IFSHologram, multimedia), ifs-gpu.js (GPU leapfrog + [H] shaders + operator-cycle shaders), soliton-algebra.js (first-class composable solitons; bind/gate/recognize/recall; operatorSolitonCyc), apps/eye.js (live eye demo). Constants: GRID, DT=0.12, T_RECORD=100, N_DEPTH_TIERS=4, IFS_DEPTH=8.