zerozero 0.3.0__py3-none-any.whl

v/0.py

@@ -0,0 +1,26 @@
+"""
+v  —  0
+Diego Rincón
+
+The ground state is zero.
+Potential zero. Score one. Verified true.
+
+The set: all zeros on the critical line.
+Limit: n → ∞. P = 0. S = 1. RH.
+"""
+
+from v import zero, system
+
+T = [
+    14.134725, 21.022040, 25.010858, 30.424876, 32.935062,
+    37.586178, 40.918720, 43.327073, 48.005151, 49.773832,
+]
+
+# the set
+Z = {zero(t) for t in T}
+s = system(list(Z))
+
+print(s.show())
+print()
+print("verified:", s.verify()['verified'])
+print("limit:    n → ∞, P = 0, S = 1")

v/H.py

@@ -0,0 +1,62 @@
+"""
+v  —  operator
+Diego Rincón
+
+H @ ψ = λ · ψ
+
+H  =  multiplication by t   (Hilbert-Pólya)
+ψ  =  wave function          ξ(½ + it)
+λ  =  eigenvalue             t  (real ↔ ground state)
+
+Ground state:  λ ∈ ℝ  ↔  ε = 0  ↔  Fix(τ)
+Wind state:    λ ∈ ℂ  ↔  ε ≠ 0  ↔  off-axis
+"""
+
+import numpy as np
+from v import zero, system
+
+
+class operator:
+    def __init__(self, sys):
+        self.sys = sys
+
+    def H(self):
+        """Diagonal operator: eigenvalue of each zero."""
+        return np.diag([z.rho.imag - 1j * z.eps for z in self.sys.zeros])
+
+    def eigenvalues(self):
+        return np.linalg.eigvals(self.H())
+
+    def is_real(self, tol=1e-10):
+        return all(abs(v.imag) < tol for v in self.eigenvalues())
+
+    def state(self):
+        evs = self.eigenvalues()
+        return {
+            'eigenvalues': evs[:4],
+            'all_real':    self.is_real(),
+            'wind_cost':   sum(abs(v.imag) for v in evs),
+        }
+
+
+if __name__ == '__main__':
+    known = [14.134725, 21.022040, 25.010858]
+
+    print("ground state:")
+    s0 = system([zero(t) for t in known])
+    op0 = operator(s0)
+    st0 = op0.state()
+    print(f"  all real: {st0['all_real']}   wind cost: {st0['wind_cost']:.4f}")
+
+    print()
+    print("wind state:")
+    s1 = system([zero(t) for t in known] + [zero(14.134725, eps=0.25)])
+    op1 = operator(s1)
+    st1 = op1.state()
+    print(f"  all real: {st1['all_real']}   wind cost: {st1['wind_cost']:.4f}")
+
+    print()
+    print("change to ground:")
+    for lam in [0.0, 0.5, 1.0]:
+        d = operator(s1.change(lam))
+        print(f"  λ={lam}  all_real={d.is_real()}  wind_cost={d.state()['wind_cost']:.4f}")

v/__init__.py

@@ -0,0 +1,10 @@
+from .v import zero, plant, grow, system
+
+__version__ = '0.3.0'
+__all__ = ['zero', 'plant', 'grow', 'system']
+
+try:
+    from . import laserbrain
+    __all__ += ['laserbrain']
+except ImportError:
+    pass

v/laserbrain.py

@@ -0,0 +1,51 @@
+"""
+v  —  laserbrain
+Diego Rincón
+
+Gated Laplace diffusion on zero heights.
+
+K[i,j] = exp(-k · |t_i − t_j|)   row-normalised
+M       = (1−g)·I + g·K
+out     = x + sigmoid(gate) · (K @ x − x)
+
+Defaults from sensi trained weights: k=0.874, gate=−0.728
+"""
+
+import numpy as np
+
+
+def kernel(heights, k=0.874):
+    """Build K from actual zero heights (not indices)."""
+    t = np.array(heights, dtype=np.float64)
+    K = np.exp(-k * np.abs(t[:, None] - t[None, :]))
+    K /= K.sum(axis=1, keepdims=True)
+    return K
+
+
+def M(heights, k=0.874, gate=-0.728):
+    g = 1.0 / (1.0 + np.exp(-gate))   # sigmoid
+    return (1 - g) * np.eye(len(heights)) + g * kernel(heights, k)
+
+
+def apply(sys, k=0.874, gate=-0.728):
+    """
+    Apply laserbrain diffusion to a system.
+
+    Uses actual zero heights as distance metric.
+    Returns eigenvalues of M and the smoothed heights.
+    """
+    heights = sorted(set(round(abs(z.t), 8) for z in sys.zeros if z.t > 0))
+    n = len(heights)
+    if n == 0:
+        return {'eigenvalues': [], 'smoothed': [], 'heights': []}
+
+    mat = M(heights, k, gate)
+    h   = np.array(heights)
+    smoothed = (mat @ h).tolist()
+    evs = np.sort(np.linalg.eigvals(mat).real)[::-1].tolist()
+
+    return {
+        'heights':     heights,
+        'smoothed':    smoothed,
+        'eigenvalues': evs,
+    }

v/run.py

@@ -0,0 +1,33 @@
+"""
+v  —  build
+Diego Rincón
+
+Run everything.
+"""
+
+from v import plant, zero, grow, system
+from tao import follow
+
+T = [
+    14.134725, 21.022040, 25.010858, 30.424876, 32.935062,
+    37.586178, 40.918720, 43.327073, 48.005151, 49.773832,
+]
+
+print("v\n")
+
+# grow
+print("grow:")
+for s in grow(T):
+    n = s.size
+    print(f"  {n:>2}  {'█' * n}  {float(s):.4f}")
+
+# disturb
+print("\ndisturb:")
+s = system([plant(t) for t in T])
+s2 = system(s.zeros + [zero(T[0], eps=0.25)])
+print(f"  before  {s.state()}")
+print(f"  after   {s2.state()}")
+
+# return
+print("\nreturn:")
+follow(s2)

v/tao.py

@@ -0,0 +1,35 @@
+"""
+v  —  tao
+Diego Rincón
+
+The ground state is the tao.
+Wind is the cost of leaving it.
+Return is the path.
+
+λ ∈ [0, 1]  —  wind to ground.
+The tao does not move. Everything else returns to it.
+"""
+
+from v import zero, system
+
+
+def path(s, steps=10):
+    """The return path from wind to ground."""
+    return [s.change(lam) for lam in [i / steps for i in range(steps + 1)]]
+
+
+def follow(s):
+    """Follow the tao. Print the return."""
+    print("tao\n")
+    for d in path(s):
+        bar = "█" * int(float(d) * 20)
+        print(f"  {float(d):.4f}  {bar}")
+    print()
+    print(f"  ground: {s.ground().is_ground()}")
+
+
+if __name__ == '__main__':
+    from v import zero, system
+    known = [14.134725, 21.022040, 25.010858]
+    s = system([zero(t) for t in known] + [zero(14.134725, eps=0.25)])
+    follow(s)

v/v.py

@@ -0,0 +1,175 @@
+"""
+v
+Diego Rincón
+
+A language of zeros.
+
+Grammar G = { id, σ, τ, στ }  ≅  ℤ/2 × ℤ/2
+
+  σ : ρ ↦ ρ̄           conjugation
+  τ : ρ ↦ 1 − ρ̄       functional equation
+
+Conservation:  Re(ρ) + Re(τ(ρ)) = 1
+Fixed point:   Fix(τ) = { Re(ρ) = ½ }
+Wave:          ψ(t) = ξ(½ + it)
+Operator:      H @ ψ = t · ψ
+"""
+
+class zero:
+    def __init__(self, t, eps=0.0):
+        self.t   = t          # imaginary part  (time)
+        self.eps = eps        # departure from ½ (space)
+
+    @property
+    def rho(self):
+        return complex(0.5 + self.eps, self.t)
+
+    def σ(self):   return zero( -self.t,  self.eps)
+    def τ(self):   return zero(  self.t, -self.eps)
+    def στ(self):  return zero( -self.t, -self.eps)
+
+    def orbit(self):
+        return {'id': self, 'σ': self.σ(), 'τ': self.τ(), 'στ': self.στ()}
+
+    def conservation(self):
+        return (0.5 + self.eps) + (0.5 - self.eps)   # always 1
+
+    def cost(self):
+        return abs(self.eps)
+
+    def is_ground(self):
+        return self.eps == 0.0
+
+    def show(self):
+        e = f"{self.eps:+.4f}" if self.eps != 0 else ""
+        return f"ρ = ½{e} + {self.t:.6f}i"
+
+    def __repr__(self):
+        sign = '+' if self.t >= 0 else '-'
+        return f"½ + {self.eps:+.4f} {sign} {abs(self.t):.6f}i"
+
+
+def plant(t):
+    """Plant a zero at height t. Rooted at ½. Ground by default."""
+    return zero(t, eps=0.0)
+
+
+def grow(T):
+    """Grow a system from a list of heights. One by one."""
+    s = system([])
+    for t in T:
+        s = system(s.zeros + [plant(t)])
+        yield s
+
+
+class system:
+    def __init__(self, zeros):
+        # enforce grammar: every zero enters with its full orbit
+        self.zeros = []
+        for z in zeros:
+            self._add_orbit(z)
+
+    def _add_orbit(self, z):
+        for g, member in z.orbit().items():
+            key = (round(member.t, 8), round(member.eps, 8))
+            if not any((round(x.t,8), round(x.eps,8)) == key for x in self.zeros):
+                self.zeros.append(member)
+
+    @property
+    def size(self):
+        """Number of planted zeros — unique positive heights."""
+        return len(set(round(z.t, 8) for z in self.zeros if z.t > 0))
+
+    def potential(self):
+        """Total latent potential — sum of costs across full grammar orbits."""
+        return sum(z.cost() for z in self.zeros)
+
+    def is_ground(self):
+        return self.potential() == 0.0
+
+    def is_wind(self):
+        return not self.is_ground()
+
+    def wind(self):
+        """Wind state: the displaced zeros and their cost."""
+        displaced = [z for z in self.zeros if not z.is_ground()]
+        return {'zeros': displaced, 'cost': sum(z.cost() for z in displaced)}
+
+    def time(self):
+        """Current height — max t in the zero set."""
+        return max(abs(z.t) for z in self.zeros) if self.zeros else 0.0
+
+    def state(self):
+        return {
+            'size':      self.size,
+            'zeros':     len(self.zeros),
+            'time':      self.time(),
+            'potential': self.potential(),
+            'score':     self.score(),
+            'ground':    self.is_ground(),
+        }
+
+    def score(self):
+        """Score: 1.0 at ground state, 0.2 after one imagined zero."""
+        return 1.0 / (1.0 + 4.0 * self.potential())
+
+    def verify(self):
+        """Verify every zero is in Fix(τ). Truth requires verification."""
+        results = {z.show(): z.is_ground() for z in self.zeros}
+        verified = all(results.values())
+        return {'verified': verified, 'zeros': results}
+
+    def ground(self):
+        """Return to ground state."""
+        return self.change(1.0)
+
+    def connect(self, other):
+        """Ground connector — join two systems, return to ground."""
+        return system(self.zeros + other.zeros).ground()
+
+    def change(self, lam):
+        """Float lam ∈ [0,1]. 0 = current state. 1 = ground state."""
+        lam = max(0.0, min(1.0, lam))
+        deformed = [zero(z.t, z.eps * (1.0 - lam)) for z in self.zeros]
+        return system.__new_from_raw(deformed)
+
+    @classmethod
+    def __new_from_raw(cls, zeros):
+        s = cls.__new__(cls)
+        s.zeros = zeros
+        return s
+
+    def show(self):
+        lines = [f"v  |  {len(self.zeros)} zeros  |  P={self.potential():.4f}  |  S={self.score():.4f}"]
+        for z in self.zeros:
+            lines.append(f"  {z.show()}  {'← ground' if z.is_ground() else f'cost {z.cost():.4f}'}")
+        return "\n".join(lines)
+
+    def __float__(self):
+        return self.score()
+
+    def __repr__(self):
+        return f"{self.score():.4f}"
+
+
+if __name__ == '__main__':
+    known = [14.134725, 21.022040, 25.010858]
+
+    print("v\n")
+    for t in known:
+        z = zero(t)
+        print(f"  {z}   ground: {z.is_ground()}   conservation: {z.conservation()}")
+
+    print()
+    z_imag = zero(14.134725, eps=0.25)
+    print(f"  imagined: {z_imag}   cost: {z_imag.cost()}")
+    print(f"  τ-image:  {z_imag.τ()}")
+    print(f"  sum:      {z_imag.conservation()}")
+
+    print()
+    print("system latent potential:")
+    s_ground = system([zero(t) for t in known])
+    s_imag   = system([zero(t) for t in known] + [z_imag])
+    print(f"  {s_ground}")
+    print(f"  {s_imag}")
+    print(f"  ground state: {s_ground.is_ground()}")

zerozero-0.3.0.dist-info/METADATA

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: zerozero
+Version: 0.3.0
+Summary: language of zeros
+Author: Diego Rincón
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Provides-Extra: laserbrain
+Requires-Dist: numpy; extra == "laserbrain"
+
+# v
+
+language of zeros.
+
+```python
+import v
+
+s = v.system([v.plant(14.134725)])
+s.state()    # {'zeros': 2, 'potential': 0.0, 'score': 1.0, 'ground': True}
+s.verify()   # {'verified': True, ...}
+```
+
+grammar G = ℤ/2 × ℤ/2. conservation law `Re(ρ) + Re(τ(ρ)) = 1`. ground/wind state. RH in code.
+
+— Diego Rincón

zerozero-0.3.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+v/0.py,sha256=qzK9hg4tuO5ya839pCw58CU5p6Pg2rDM-HaIZOsTwcM,501
+v/H.py,sha256=EmeZbgJNF8z-fQRGquhKmcjLXnTzrN81SBAx2Ea9fhs,1682
+v/__init__.py,sha256=-MI_Ik206WUoOeg3imP0NvmcGryAwNbGjycVKm1YDBE,204
+v/laserbrain.py,sha256=ku-6LkDqdCTuOT4_6uzeVL_LtPBGU8FP4IVI1QjqIW0,1333
+v/run.py,sha256=fKMqNuKRk4OG6r4TPIKHwVmCMPXbsl0B-FxPNjbmlts,582
+v/tao.py,sha256=J0C3m6QnjWEuoerUHeDjHsgBYjFIkmtGlJHwxfL2H6Q,820
+v/v.py,sha256=U8mwjA5vHRevFV4VjUwI0jAi0wad9zFx29UPt8TmMqA,5283
+zerozero-0.3.0.dist-info/METADATA,sha256=w_wtdfA80wdaSEfOXXRqwKebUuU8w2x6WZfBVFeyZl8,558
+zerozero-0.3.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+zerozero-0.3.0.dist-info/top_level.txt,sha256=czJOGrHbcu6etP3xyQpYbWfgCrWDMNHL_qJuzQp3-k0,2
+zerozero-0.3.0.dist-info/RECORD,,

zerozero-0.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

zerozero-0.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+v