wavefunction 0.0.1__tar.gz → 0.0.2__tar.gz

wavefunction-0.0.2/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: wavefunction
+Version: 0.0.2
+Summary: Quantum Wavefunction with Spectral Complexity measure
+Author-email: Juha Meskanen <juha@meskanen.com>
+Maintainer-email: Juha Meskanen <juha@meskanen.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/juhakm/wavefunction
+Project-URL: Bug Reports, https://github.com/juhakm/wavefunction
+Project-URL: Say Thanks!, https://github.com/juhakm/wavefunction
+Project-URL: Source, https://github.com/juhakm/wavefunction
+Keywords: quantum,quantum-field-theory,information-theory,wavefunction,spinor,emergent-physics,minimal-spectral-length,computational-physics
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Typing :: Typed
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<1.27,>=1.25
+Requires-Dist: scipy>=1.10
+Requires-Dist: numba>=0.59
+Requires-Dist: matplotlib
+Dynamic: license-file
+
+# Wavefunction
+
+Quantum Mechanical complex valued wavefunction with Spectral Complexity measure.
+
+## Install
+
+```bash
+pip install wavefunction
+```
+
+## Introduction
+
+Spectral Complexity measure for complex-valued wavefunctions.
+
+## Theory background (Meskanen 2026 — "The Wavefunction as Compression")
+
+The central hypothesis is that the quantum wavefunction is the universe's data-compression codec. Internal observers — themselves composed of compressed structures — perceive their constituent degrees of freedom as wave-like because they are observing *compressed information*. The codec that produces this compression is the Fourier / spectral decomposition.
+
+### Spectral Complexity $ C_s $
+
+A wavefunction $ \psi(x) $ can always be written as a superposition of spectral modes, each characterised by two attributes:
+
+- **frequency** $ \omega $ — the rate of oscillation, unbounded above zero
+- **phase** $ \phi $ — the offset of the oscillation, bounded in $[0, 2\pi)$
+
+The *spectral complexity* $ C_s(\psi) $ is the total continuous information cost needed to specify the set of modes that materially compose $ \psi $:
+
+$$
+C_s(\psi) = \sum_i \left[ \frac{\omega_i}{\Delta \omega} + \phi_{\text{cost}}(\phi_i) \right]
+$$
+
+#### Frequency cost (dominant term)
+
+$ \frac{\omega_i}{\Delta \omega} $ is the number of resolution steps $ \Delta \omega $ needed to locate frequency $ \omega_i $. It is unbounded, continuous, and grows linearly with frequency. This term *dominates* $ C_s $ and is the reason the measure exponentially suppresses high-frequency (rough, chaotic) states.
+
+The identification $ \Delta \omega = \hbar \ln 2 $ connects the minimum frequency resolution to Planck's constant (Meskanen 2026, §3.1).
+
+#### Phase cost (subdominant, bounded)
+
+Each phase $ \phi_i \in [0, 2\pi) $ requires a finite amount of information to specify. The cost is *global* over all modes: it measures how much information is needed to distinguish the phases from one another.
+
+With only two modes at phases 0 and $ \pi $, very little is needed; with many modes at crowded, uneven phases, somewhat more is required. In practice this term is bounded by $ \log_2(N_{\text{modes}}) $ and is a second-order correction.
+
+The current implementation uses a simple uniform fixed cost per non-reference mode as a tractable proxy; the reference mode (highest amplitude) is exempt because only *relative* phases are observable — a global phase shift leaves $ |\psi(x)|^2 $ unchanged.
+
+#### Amplitude and the fidelity engine
+
+Amplitude does not appear as a separate encoding cost. Instead it determines *which modes are included* in the description via a power-ranked fidelity engine: modes are added in descending power order until the accumulated power reaches a target fraction of the total. Modes below this threshold are simply absent from the description — they are not part of the codec output and contribute zero complexity cost.
+
+This correctly handles the case where many weak modes coexist with a few dominant ones: the dominant modes determine $ C_s $; the weak modes are free.
+
+#### Solomonoff suppression and the probability profile
+
+Under Solomonoff-like induction the prior probability of a configuration is $ P(\psi) \propto 2^{-C_s(\psi)} $. Because $ C_s $ is a *sum* over independent modes, the probability *factorises*:
+
+$$
+P(\psi) \propto \prod_i 2^{-\omega_i / \Delta \omega}
+$$
+
+Each mode is suppressed independently and exponentially by its frequency. The resulting probability profile is Boltzmann-like with inverse temperature $ \beta = \ln(2)/\Delta \omega $:
+
+$$
+P(\text{mode } i \text{ present}) \propto \exp(-\ln(2) \cdot \omega_i / \Delta \omega)
+$$
+
+Smooth, low-frequency, compressible states dominate the measure. Boltzmann brains, random fluctuations, and chaotic configurations are exponentially suppressed — not by fine-tuning, but because they require many high-frequency modes to describe.
+
+### The conjecture $ C_s \propto S_{\text{Euclidean}} $
+
+The central open conjecture (Meskanen 2026, §4) is that the minimum spectral complexity path through configuration space coincides with the minimum Euclidean action path of standard quantum gravity. If true, quantum gravity is Solomonoff induction over compressed descriptions of geometry, and $ \hbar $ is the minimum spectral resolution of a finite informational universe.

wavefunction-0.0.2/README.md

@@ -0,0 +1,70 @@
+# Wavefunction
+
+Quantum Mechanical complex valued wavefunction with Spectral Complexity measure.
+
+## Install
+
+```bash
+pip install wavefunction
+```
+
+## Introduction
+
+Spectral Complexity measure for complex-valued wavefunctions.
+
+## Theory background (Meskanen 2026 — "The Wavefunction as Compression")
+
+The central hypothesis is that the quantum wavefunction is the universe's data-compression codec. Internal observers — themselves composed of compressed structures — perceive their constituent degrees of freedom as wave-like because they are observing *compressed information*. The codec that produces this compression is the Fourier / spectral decomposition.
+
+### Spectral Complexity $ C_s $
+
+A wavefunction $ \psi(x) $ can always be written as a superposition of spectral modes, each characterised by two attributes:
+
+- **frequency** $ \omega $ — the rate of oscillation, unbounded above zero
+- **phase** $ \phi $ — the offset of the oscillation, bounded in $[0, 2\pi)$
+
+The *spectral complexity* $ C_s(\psi) $ is the total continuous information cost needed to specify the set of modes that materially compose $ \psi $:
+
+$$
+C_s(\psi) = \sum_i \left[ \frac{\omega_i}{\Delta \omega} + \phi_{\text{cost}}(\phi_i) \right]
+$$
+
+#### Frequency cost (dominant term)
+
+$ \frac{\omega_i}{\Delta \omega} $ is the number of resolution steps $ \Delta \omega $ needed to locate frequency $ \omega_i $. It is unbounded, continuous, and grows linearly with frequency. This term *dominates* $ C_s $ and is the reason the measure exponentially suppresses high-frequency (rough, chaotic) states.
+
+The identification $ \Delta \omega = \hbar \ln 2 $ connects the minimum frequency resolution to Planck's constant (Meskanen 2026, §3.1).
+
+#### Phase cost (subdominant, bounded)
+
+Each phase $ \phi_i \in [0, 2\pi) $ requires a finite amount of information to specify. The cost is *global* over all modes: it measures how much information is needed to distinguish the phases from one another.
+
+With only two modes at phases 0 and $ \pi $, very little is needed; with many modes at crowded, uneven phases, somewhat more is required. In practice this term is bounded by $ \log_2(N_{\text{modes}}) $ and is a second-order correction.
+
+The current implementation uses a simple uniform fixed cost per non-reference mode as a tractable proxy; the reference mode (highest amplitude) is exempt because only *relative* phases are observable — a global phase shift leaves $ |\psi(x)|^2 $ unchanged.
+
+#### Amplitude and the fidelity engine
+
+Amplitude does not appear as a separate encoding cost. Instead it determines *which modes are included* in the description via a power-ranked fidelity engine: modes are added in descending power order until the accumulated power reaches a target fraction of the total. Modes below this threshold are simply absent from the description — they are not part of the codec output and contribute zero complexity cost.
+
+This correctly handles the case where many weak modes coexist with a few dominant ones: the dominant modes determine $ C_s $; the weak modes are free.
+
+#### Solomonoff suppression and the probability profile
+
+Under Solomonoff-like induction the prior probability of a configuration is $ P(\psi) \propto 2^{-C_s(\psi)} $. Because $ C_s $ is a *sum* over independent modes, the probability *factorises*:
+
+$$
+P(\psi) \propto \prod_i 2^{-\omega_i / \Delta \omega}
+$$
+
+Each mode is suppressed independently and exponentially by its frequency. The resulting probability profile is Boltzmann-like with inverse temperature $ \beta = \ln(2)/\Delta \omega $:
+
+$$
+P(\text{mode } i \text{ present}) \propto \exp(-\ln(2) \cdot \omega_i / \Delta \omega)
+$$
+
+Smooth, low-frequency, compressible states dominate the measure. Boltzmann brains, random fluctuations, and chaotic configurations are exponentially suppressed — not by fine-tuning, but because they require many high-frequency modes to describe.
+
+### The conjecture $ C_s \propto S_{\text{Euclidean}} $
+
+The central open conjecture (Meskanen 2026, §4) is that the minimum spectral complexity path through configuration space coincides with the minimum Euclidean action path of standard quantum gravity. If true, quantum gravity is Solomonoff induction over compressed descriptions of geometry, and $ \hbar $ is the minimum spectral resolution of a finite informational universe.

{wavefunction-0.0.1 → wavefunction-0.0.2}/pyproject.toml

@@ -8,7 +8,7 @@ packages = ["wavefunction"]
 
 [project]
 name = "wavefunction"
-version = "0.0.1"
+version = "0.0.2"
 description = "Quantum Wavefunction with Spectral Complexity measure"
 readme = {file = "README.md", content-type = "text/markdown"}
 requires-python = ">=3.9"

wavefunction-0.0.2/tests/test_wavefunction.py

@@ -0,0 +1,199 @@
+import pytest
+import numpy as np
+from wavefunction import SpectralMode, Wavefunction
+
+# ---------------------------------------------------------------------------
+# Tests for SpectralMode
+# ---------------------------------------------------------------------------
+
+def test_spectral_mode_initialization():
+    """Ensure SpectralMode properties match specifications (e.g., phase wrapping)."""
+    # Amplitude should always be non-negative
+    m1 = SpectralMode(frequency=2.5, amplitude=-1.2, phase=0.0)
+    assert m1.amplitude == 1.2
+    
+    # Phase should wrap cleanly within [0, 2pi)
+    m2 = SpectralMode(frequency=-1.0, amplitude=0.5, phase=2.5 * np.pi)
+    assert pytest.approx(m2.phase) == 0.5 * np.pi
+
+    m3 = SpectralMode(frequency=0.0, amplitude=1.0, phase=-0.5 * np.pi)
+    assert pytest.approx(m3.phase) == 1.5 * np.pi
+
+
+# ---------------------------------------------------------------------------
+# Tests for Wavefunction Construction & Attributes
+# ---------------------------------------------------------------------------
+
+def test_wavefunction_normalization():
+    """Verify that Wavefunction automatically normalizes input data."""
+    raw_psi = np.array([3.0 + 4j, 0.0, 0.0, 0.0])
+    wf = Wavefunction(raw_psi, dx=1.0)
+    
+    # The L2 discrete norm should equal 1.0
+    assert pytest.approx(np.sum(np.abs(wf.psi) ** 2)) == 1.0
+    # Born rule array sanity check
+    assert pytest.approx(np.sum(wf.probability_density)) == 1.0
+
+def test_wavefunction_zero_norm_raises_error():
+    """An all-zero array cannot be normalized and should raise an exception."""
+    zero_psi = np.zeros(16)
+    with pytest.raises(ValueError, match="Cannot normalise a zero wavefunction"):
+        Wavefunction(zero_psi)
+
+def test_grid_derived_properties():
+    """Check coordinates, sizes, and natural default values."""
+    N = 8
+    dx = 0.5
+    raw_psi = np.ones(N)
+    wf = Wavefunction(raw_psi, dx=dx)
+    
+    assert wf.N == N
+    assert np.allclose(wf.x, np.array([0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5]))
+    
+    expected_delta_omega = 2.0 * np.pi / (N * dx)
+    assert pytest.approx(wf.delta_omega) == expected_delta_omega
+    assert pytest.approx(wf.hbar_identified) == expected_delta_omega / np.log(2.0)
+
+
+# ---------------------------------------------------------------------------
+# Tests for Fidelity Engine & Modes
+# ---------------------------------------------------------------------------
+
+def test_fidelity_engine_greedy_accumulation():
+    """Verify that the fidelity engine slices off low power noise bins."""
+    N = 128
+    dx = 0.1
+    delta_omega = 2.0 * np.pi / (N * dx)  # ~0.49087
+    
+    # Choose exact grid frequencies (e.g., bin 4 and bin 20) to eliminate leakage
+    k1 = 4 * delta_omega
+    k2 = 20 * delta_omega
+    
+    wf = Wavefunction.plane_wave_superposition(
+        N=N, amplitudes=[1.0, 0.01], wavenumbers=[k1, k2], dx=dx,
+        fidelity_target=0.999  # Excludes the tiny second mode
+    )
+    
+    modes = wf.retained_modes()
+    # High-power mode carries >99.9% of total variance, so weak mode is ignored
+    assert len(modes) == 1 
+    
+    # Relax target to capture both clean bins
+    wf_inclusive = Wavefunction.plane_wave_superposition(
+        N=N, amplitudes=[1.0, 0.01], wavenumbers=[k1, k2], dx=dx,
+        fidelity_target=1.0
+    )
+    assert len(wf_inclusive.retained_modes()) == 2
+
+
+# ---------------------------------------------------------------------------
+# Tests for Spectral Complexity Mechanics
+# ---------------------------------------------------------------------------
+
+def test_global_phase_invariance():
+    """Global phase factor shifts should not affect complexity or reference flags."""
+    wf_base = Wavefunction.gaussian_packet(N=64, k0=2.0)
+    wf_shifted = wf_base * np.exp(1j * 1.234) # arbitrary global phase rotation
+    
+    assert pytest.approx(wf_base.spectral_complexity()) == wf_shifted.spectral_complexity()
+    assert pytest.approx(wf_base.solomonoff_weight()) == wf_shifted.solomonoff_weight()
+
+def test_complexity_hierarchy():
+    """Chaotic configurations must present vastly larger complexity profiles."""
+    N = 128
+    dx = 0.1
+    # Simple low-frequency pure state vs random noise
+    smooth_wf = Wavefunction.plane_wave_superposition(N=N, amplitudes=[1.0], wavenumbers=[0.0], dx=dx)
+    chaotic_wf = Wavefunction.random_state(N=N, dx=dx, seed=123)
+    
+    assert smooth_wf.spectral_complexity() < chaotic_wf.spectral_complexity()
+    assert smooth_wf.solomonoff_weight() > chaotic_wf.solomonoff_weight()
+
+def test_reference_mode_exempt_from_phase_cost():
+    """Verify the reference mode yields 0 phase cost; others pay phase_resolution."""
+    N = 64
+    dx = 0.1
+    delta_omega = 2.0 * np.pi / (N * dx)  # ~0.98175
+    
+    # Choose exact grid frequencies (bin 0 and bin 5) to eliminate leakage
+    k1 = 0.0
+    k2 = 5 * delta_omega
+    
+    wf = Wavefunction.plane_wave_superposition(
+        N=N, amplitudes=[1.0, 1.0], wavenumbers=[k1, k2], dx=dx,
+        fidelity_target=1.0, phase_resolution=1.5
+    )
+    
+    modes = wf.retained_modes()
+    # Without leakage, we get exactly the 2 discrete modes we generated
+    assert len(modes) == 2
+    
+    # 0.0 frequency mode is our reference (lowest |w| fallback for tie-breaker)
+    # total cost = (0.0 / d_omega + 0.0) + (|k2| / d_omega + 1.5)
+    expected_freq_cost = abs(k2) / wf.delta_omega  # matches exactly 5.0
+    expected_phase_cost = 1.5
+    assert pytest.approx(wf.spectral_complexity()) == expected_freq_cost + expected_phase_cost
+
+
+# ---------------------------------------------------------------------------
+# Tests for Mathematical Invariants & Derived Metrics
+# ---------------------------------------------------------------------------
+
+def test_solomonoff_bounds_and_profiles():
+    """Validate limits for weights and dictionary profiles mapping."""
+    wf = Wavefunction.gaussian_packet(N=64)
+    weight = wf.solomonoff_weight()
+    
+    # Probability bounds
+    assert 0.0 < weight <= 1.0
+    
+    suppressions = wf.mode_suppression_factors()
+    retained_freqs = [m.frequency for m in wf.retained_modes()]
+    
+    assert set(suppressions.keys()) == set(retained_freqs)
+    for freq, factor in suppressions.items():
+        assert 0.0 < factor <= 1.0
+
+
+# ---------------------------------------------------------------------------
+# Tests for Linear Algebra Operators
+# ---------------------------------------------------------------------------
+
+def test_arithmetic_and_inner_product():
+    """Validate vector space rules and basic inner products."""
+    N = 32
+    dx = 0.2
+    wf1 = Wavefunction.plane_wave_superposition(N=N, amplitudes=[1.0], wavenumbers=[1.0], dx=dx)
+    wf2 = Wavefunction.plane_wave_superposition(N=N, amplitudes=[1.0], wavenumbers=[2.0], dx=dx)
+    
+    # Mismatched grid checks
+    wf_bad = Wavefunction.plane_wave_superposition(N=N+10, dx=dx)
+    with pytest.raises(ValueError, match="Grid size mismatch"):
+        _ = wf1 + wf_bad
+
+    # Test superposition scaling operation paths
+    wf_sum = wf1 + wf2
+    assert isinstance(wf_sum, Wavefunction)
+    assert pytest.approx(np.sum(np.abs(wf_sum.psi) ** 2)) == 1.0
+    
+    # Check scaling mechanics
+    wf_scaled = wf1 * 3.0
+    assert pytest.approx(np.sum(np.abs(wf_scaled.psi) ** 2)) == 1.0
+    
+    wf_rscaled = 3.0 * wf1
+    assert np.allclose(wf_scaled.psi, wf_rscaled.psi)
+
+    # Unitary normalization validation checks via self-inner-product
+    # <psi|psi> * dx for a normalized state will return exactly 1.0 * dx * (1/dx sum logic)
+    # wait, inner_product explicitly includes * self.dx multiplication at the end
+    # since sum(|psi|^2) == 1, inner_product(wf, wf) is exactly 1.0 * dx.
+    assert pytest.approx(wf1.inner_product(wf1)) == 1.0 * dx
+
+
+def test_repr():
+    """Verify string debugging readout formats correctly without breaking."""
+    wf = Wavefunction.gaussian_packet(N=32)
+    rep = repr(wf)
+    assert "Wavefunction" in rep
+    assert "C_s=" in rep
+    assert "modes=" in rep

wavefunction-0.0.2/wavefunction/__init__.py

@@ -0,0 +1,8 @@
+from .wavefunction import Wavefunction
+from .wavefunction import SpectralMode
+
+
+__all__ = [
+    "Wavefunction",
+    "SpectralMode",
+]

{wavefunction-0.0.1 → wavefunction-0.0.2}/wavefunction/wavefunction.py

@@ -614,62 +614,3 @@ class Wavefunction:
             f"ℏ_id={self.hbar_identified:.3e})"
         )
 
-
-# ---------------------------------------------------------------------------
-# Demo
-# ---------------------------------------------------------------------------
-
-if __name__ == "__main__":
-    print(__doc__)
-    print("=" * 65)
-    print("Demo")
-    print("=" * 65)
-
-    # 1. Gaussian packet — few dominant modes, low C_s
-    gp = Wavefunction.gaussian_packet(N=256, x0=12.8, sigma=2.0, k0=2.0, dx=0.1)
-    print("\n[1] Gaussian wave packet")
-    gp.spectral_complexity(verbose=True)
-    print(gp)
-
-    # 2. Two-component superposition — moderate C_s
-    sp = Wavefunction.plane_wave_superposition(
-        N=256, amplitudes=[0.6, 0.8],
-        wavenumbers=[1.0, 5.0], phases=[0.0, np.pi / 4], dx=0.1)
-    print("\n[2] Two-component superposition")
-    sp.spectral_complexity(verbose=True)
-    print(sp)
-
-    # 3. Random state — all modes active, high C_s
-    rnd = Wavefunction.random_state(N=256, seed=0, dx=0.1)
-    print("\n[3] Random (high-entropy) state")
-    print(f"  C_s = {rnd.spectral_complexity():.2f}  (verbose suppressed)")
-    print(rnd)
-
-    # 4. Solomonoff weights — exponential ordering
-    print("\nSolomonoff weights  2^{{-C_s}}:")
-    for label, wf in [("Gaussian", gp), ("Superposition", sp), ("Random", rnd)]:
-        print(f"  {label:>16s}:  {wf.solomonoff_weight():.4e}")
-
-    # 5. Interference economy
-    gp2 = Wavefunction.gaussian_packet(N=256, x0=20.0, sigma=2.0, k0=2.0, dx=0.1)
-    combined = gp + gp2
-    print(f"\n[5] Interference economy:")
-    print(f"  C_s(ψ₁)       = {gp.spectral_complexity():.2f}")
-    print(f"  C_s(ψ₂)       = {gp2.spectral_complexity():.2f}")
-    print(f"  C_s(ψ₁ + ψ₂)  = {combined.spectral_complexity():.2f}")
-    print("  Superposition is cheaper than two independent descriptions.")
-
-    # 6. Fidelity engine: weak modes don't inflate C_s
-    x = np.arange(64)
-    psi_clean = sum(np.exp(1j * 2*np.pi*k*x/64) for k in [2, 7, 13])
-    rng = np.random.default_rng(0)
-    psi_noisy = psi_clean + 0.01 * sum(
-        np.exp(1j * (2*np.pi*k*x/64 + rng.uniform(0, 2*np.pi)))
-        for k in range(20, 50))
-    wf_clean = Wavefunction(psi_clean, dx=0.1)
-    wf_noisy = Wavefunction(psi_noisy, dx=0.1)
-    print(f"\n[6] Fidelity engine — weak modes ignored:")
-    print(f"  C_s(clean, 3 modes)          = {wf_clean.spectral_complexity():.3f}")
-    print(f"  C_s(+ 30 weak noise modes)   = {wf_noisy.spectral_complexity():.3f}")
-    print(f"  Modes retained (clean/noisy) = "
-          f"{len(wf_clean.retained_modes())} / {len(wf_noisy.retained_modes())}")

wavefunction-0.0.2/wavefunction.egg-info/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: wavefunction
+Version: 0.0.2
+Summary: Quantum Wavefunction with Spectral Complexity measure
+Author-email: Juha Meskanen <juha@meskanen.com>
+Maintainer-email: Juha Meskanen <juha@meskanen.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/juhakm/wavefunction
+Project-URL: Bug Reports, https://github.com/juhakm/wavefunction
+Project-URL: Say Thanks!, https://github.com/juhakm/wavefunction
+Project-URL: Source, https://github.com/juhakm/wavefunction
+Keywords: quantum,quantum-field-theory,information-theory,wavefunction,spinor,emergent-physics,minimal-spectral-length,computational-physics
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Typing :: Typed
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<1.27,>=1.25
+Requires-Dist: scipy>=1.10
+Requires-Dist: numba>=0.59
+Requires-Dist: matplotlib
+Dynamic: license-file
+
+# Wavefunction
+
+Quantum Mechanical complex valued wavefunction with Spectral Complexity measure.
+
+## Install
+
+```bash
+pip install wavefunction
+```
+
+## Introduction
+
+Spectral Complexity measure for complex-valued wavefunctions.
+
+## Theory background (Meskanen 2026 — "The Wavefunction as Compression")
+
+The central hypothesis is that the quantum wavefunction is the universe's data-compression codec. Internal observers — themselves composed of compressed structures — perceive their constituent degrees of freedom as wave-like because they are observing *compressed information*. The codec that produces this compression is the Fourier / spectral decomposition.
+
+### Spectral Complexity $ C_s $
+
+A wavefunction $ \psi(x) $ can always be written as a superposition of spectral modes, each characterised by two attributes:
+
+- **frequency** $ \omega $ — the rate of oscillation, unbounded above zero
+- **phase** $ \phi $ — the offset of the oscillation, bounded in $[0, 2\pi)$
+
+The *spectral complexity* $ C_s(\psi) $ is the total continuous information cost needed to specify the set of modes that materially compose $ \psi $:
+
+$$
+C_s(\psi) = \sum_i \left[ \frac{\omega_i}{\Delta \omega} + \phi_{\text{cost}}(\phi_i) \right]
+$$
+
+#### Frequency cost (dominant term)
+
+$ \frac{\omega_i}{\Delta \omega} $ is the number of resolution steps $ \Delta \omega $ needed to locate frequency $ \omega_i $. It is unbounded, continuous, and grows linearly with frequency. This term *dominates* $ C_s $ and is the reason the measure exponentially suppresses high-frequency (rough, chaotic) states.
+
+The identification $ \Delta \omega = \hbar \ln 2 $ connects the minimum frequency resolution to Planck's constant (Meskanen 2026, §3.1).
+
+#### Phase cost (subdominant, bounded)
+
+Each phase $ \phi_i \in [0, 2\pi) $ requires a finite amount of information to specify. The cost is *global* over all modes: it measures how much information is needed to distinguish the phases from one another.
+
+With only two modes at phases 0 and $ \pi $, very little is needed; with many modes at crowded, uneven phases, somewhat more is required. In practice this term is bounded by $ \log_2(N_{\text{modes}}) $ and is a second-order correction.
+
+The current implementation uses a simple uniform fixed cost per non-reference mode as a tractable proxy; the reference mode (highest amplitude) is exempt because only *relative* phases are observable — a global phase shift leaves $ |\psi(x)|^2 $ unchanged.
+
+#### Amplitude and the fidelity engine
+
+Amplitude does not appear as a separate encoding cost. Instead it determines *which modes are included* in the description via a power-ranked fidelity engine: modes are added in descending power order until the accumulated power reaches a target fraction of the total. Modes below this threshold are simply absent from the description — they are not part of the codec output and contribute zero complexity cost.
+
+This correctly handles the case where many weak modes coexist with a few dominant ones: the dominant modes determine $ C_s $; the weak modes are free.
+
+#### Solomonoff suppression and the probability profile
+
+Under Solomonoff-like induction the prior probability of a configuration is $ P(\psi) \propto 2^{-C_s(\psi)} $. Because $ C_s $ is a *sum* over independent modes, the probability *factorises*:
+
+$$
+P(\psi) \propto \prod_i 2^{-\omega_i / \Delta \omega}
+$$
+
+Each mode is suppressed independently and exponentially by its frequency. The resulting probability profile is Boltzmann-like with inverse temperature $ \beta = \ln(2)/\Delta \omega $:
+
+$$
+P(\text{mode } i \text{ present}) \propto \exp(-\ln(2) \cdot \omega_i / \Delta \omega)
+$$
+
+Smooth, low-frequency, compressible states dominate the measure. Boltzmann brains, random fluctuations, and chaotic configurations are exponentially suppressed — not by fine-tuning, but because they require many high-frequency modes to describe.
+
+### The conjecture $ C_s \propto S_{\text{Euclidean}} $
+
+The central open conjecture (Meskanen 2026, §4) is that the minimum spectral complexity path through configuration space coincides with the minimum Euclidean action path of standard quantum gravity. If true, quantum gravity is Solomonoff induction over compressed descriptions of geometry, and $ \hbar $ is the minimum spectral resolution of a finite informational universe.

{wavefunction-0.0.1 → wavefunction-0.0.2}/wavefunction.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 LICENSE
 README.md
 pyproject.toml
+tests/test_wavefunction.py
 wavefunction/__init__.py
 wavefunction/py.typed
 wavefunction/wavefunction.py

wavefunction-0.0.1/PKG-INFO

@@ -1,47 +0,0 @@
-Metadata-Version: 2.4
-Name: wavefunction
-Version: 0.0.1
-Summary: Quantum Wavefunction with Spectral Complexity measure
-Author-email: Juha Meskanen <juha@meskanen.com>
-Maintainer-email: Juha Meskanen <juha@meskanen.com>
-License-Expression: MIT
-Project-URL: Homepage, https://github.com/juhakm/wavefunction
-Project-URL: Bug Reports, https://github.com/juhakm/wavefunction
-Project-URL: Say Thanks!, https://github.com/juhakm/wavefunction
-Project-URL: Source, https://github.com/juhakm/wavefunction
-Keywords: quantum,quantum-field-theory,information-theory,wavefunction,spinor,emergent-physics,minimal-spectral-length,computational-physics
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Science/Research
-Classifier: Intended Audience :: Education
-Classifier: Topic :: Scientific/Engineering
-Classifier: Topic :: Scientific/Engineering :: Physics
-Classifier: Topic :: Scientific/Engineering :: Mathematics
-Classifier: Topic :: Scientific/Engineering :: Information Analysis
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Typing :: Typed
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: numpy<1.27,>=1.25
-Requires-Dist: scipy>=1.10
-Requires-Dist: numba>=0.59
-Requires-Dist: matplotlib
-Dynamic: license-file
-
-# Wavefunction
-
-Quantum Mechanical complex valued wavefunction with Spectral Complexity measure.
-
-## Install
-
-```
-pip install wavefunction
-```
-
-[https://pypi.org/project/wavefunction/](https://pypi.org/project/wavefunction/)
-

wavefunction-0.0.1/README.md

@@ -1,12 +0,0 @@
-# Wavefunction
-
-Quantum Mechanical complex valued wavefunction with Spectral Complexity measure.
-
-## Install
-
-```
-pip install wavefunction
-```
-
-[https://pypi.org/project/wavefunction/](https://pypi.org/project/wavefunction/)
-

wavefunction-0.0.1/wavefunction/__init__.py

@@ -1,6 +0,0 @@
-from .wavefunction import Wavefunction
-
-
-__all__ = [
-    "Wavefunction"
-]

wavefunction-0.0.1/wavefunction.egg-info/PKG-INFO

@@ -1,47 +0,0 @@
-Metadata-Version: 2.4
-Name: wavefunction
-Version: 0.0.1
-Summary: Quantum Wavefunction with Spectral Complexity measure
-Author-email: Juha Meskanen <juha@meskanen.com>
-Maintainer-email: Juha Meskanen <juha@meskanen.com>
-License-Expression: MIT
-Project-URL: Homepage, https://github.com/juhakm/wavefunction
-Project-URL: Bug Reports, https://github.com/juhakm/wavefunction
-Project-URL: Say Thanks!, https://github.com/juhakm/wavefunction
-Project-URL: Source, https://github.com/juhakm/wavefunction
-Keywords: quantum,quantum-field-theory,information-theory,wavefunction,spinor,emergent-physics,minimal-spectral-length,computational-physics
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Science/Research
-Classifier: Intended Audience :: Education
-Classifier: Topic :: Scientific/Engineering
-Classifier: Topic :: Scientific/Engineering :: Physics
-Classifier: Topic :: Scientific/Engineering :: Mathematics
-Classifier: Topic :: Scientific/Engineering :: Information Analysis
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Typing :: Typed
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: numpy<1.27,>=1.25
-Requires-Dist: scipy>=1.10
-Requires-Dist: numba>=0.59
-Requires-Dist: matplotlib
-Dynamic: license-file
-
-# Wavefunction
-
-Quantum Mechanical complex valued wavefunction with Spectral Complexity measure.
-
-## Install
-
-```
-pip install wavefunction
-```
-
-[https://pypi.org/project/wavefunction/](https://pypi.org/project/wavefunction/)
-