| """Transparent five-axis tensor carrier and 32-coefficient mixed-jet algebra. |
| |
| This is a reference experiment, not an audio-compression breakthrough. WAV stores |
| compressed bytes as a PCM data payload; custom psri metadata makes decoding exact. |
| """ |
| from __future__ import annotations |
| import argparse |
| from dataclasses import dataclass |
| import hashlib |
| import itertools |
| import json |
| import math |
| from pathlib import Path |
| import platform |
| import struct |
| import time |
| import zlib |
| import numpy as np |
|
|
| DIM = 5 |
| SIZE = 1 << DIM |
|
|
| @dataclass |
| class Jet5: |
| c: np.ndarray |
|
|
| def __post_init__(self): |
| self.c = np.asarray(self.c, dtype=np.float64) |
| if self.c.shape != (SIZE,): |
| raise ValueError('Jet5 requires exactly 32 real coefficients') |
|
|
| @classmethod |
| def scalar(cls, x: float): |
| c = np.zeros(SIZE); c[0] = x |
| return cls(c) |
|
|
| @classmethod |
| def variable(cls, x: float, axis: int, speed: float = 1.0): |
| if axis not in range(DIM): |
| raise ValueError('axis must be 0,1,2,3,4') |
| z = cls.scalar(x); z.c[1 << axis] = speed |
| return z |
|
|
| def __add__(self, other): |
| if not isinstance(other, Jet5): other = Jet5.scalar(other) |
| return Jet5(self.c + other.c) |
| __radd__ = __add__ |
|
|
| def __neg__(self): return Jet5(-self.c) |
| def __sub__(self, other): return self + (-other if isinstance(other, Jet5) else -float(other)) |
|
|
| def __mul__(self, other): |
| if not isinstance(other, Jet5): return Jet5(self.c * float(other)) |
| out = np.zeros(SIZE) |
| for a in range(SIZE): |
| remaining = (SIZE - 1) ^ a |
| b = remaining |
| while True: |
| out[a | b] += self.c[a] * other.c[b] |
| if b == 0: break |
| b = (b - 1) & remaining |
| return Jet5(out) |
| __rmul__ = __mul__ |
|
|
| def exp(self): |
| n = self.c.copy(); n[0] = 0 |
| n = Jet5(n) |
| term = Jet5.scalar(1.0) |
| out = Jet5.scalar(1.0) |
| for k in range(1, DIM + 1): |
| term = term * n * (1.0 / k) |
| out = out + term |
| return out * math.exp(self.c[0]) |
|
|
| def inverse(self): |
| if self.c[0] == 0: raise ZeroDivisionError('Jet inverse needs nonzero scalar part') |
| q = self.c.copy(); q[0] = 0 |
| q = Jet5(-q / self.c[0]) |
| term = Jet5.scalar(1); out = Jet5.scalar(1) |
| for _ in range(1, DIM + 1): |
| term = term * q; out = out + term |
| return out * (1.0 / self.c[0]) |
|
|
|
|
| def _chunk(tag: bytes, body: bytes) -> bytes: |
| if len(tag) != 4: raise ValueError('RIFF chunk identifier must be four bytes') |
| return tag + struct.pack('<I', len(body)) + body + b'\x00' * (len(body) % 2) |
|
|
|
|
| def encode_wav(tensor: np.ndarray, path: Path, sample_rate: int = 48000, |
| axes=None, quantization=None) -> dict: |
| """Losslessly encode an integer tensor; any prior float quantization is separate.""" |
| tensor = np.asarray(tensor) |
| if tensor.ndim != 5 or tensor.dtype.kind != 'i' or tensor.dtype.itemsize != 2: |
| raise ValueError('codec domain is a five-dimensional signed-int16 tensor') |
| if not (1 <= sample_rate <= 1_000_000): raise ValueError('unsupported sample rate') |
| tensor = np.ascontiguousarray(tensor, dtype='<i2') |
| raw = tensor.tobytes(order='C') |
| comp = zlib.compress(raw, level=9) |
| metadata = { |
| 'format': 'phase-shift-carrier-v1', 'shape': list(tensor.shape), |
| 'dtype': '<i2', 'order': 'C', 'encoding': 'zlib', |
| 'raw_bytes': len(raw), 'compressed_bytes': len(comp), |
| 'raw_sha256': hashlib.sha256(raw).hexdigest(), |
| 'compressed_sha256': hashlib.sha256(comp).hexdigest(), |
| 'axes': axes or ['u','v','layer','scale','successor'], |
| 'interpretation': 'digital tensor indices; non-auditory data carrier', |
| 'quantization': quantization if quantization is not None else 'none within codec; input int16 is preserved exactly' |
| } |
| |
| |
| |
| pcm_bytes = comp + b'\x00' * (len(comp) % 2) |
| fmt = struct.pack('<HHIIHH', 1, 1, sample_rate, sample_rate * 2, 2, 16) |
| body = (b'WAVE' + _chunk(b'fmt ', fmt) |
| + _chunk(b'psri', json.dumps(metadata, sort_keys=True, separators=(',', ':')).encode()) |
| + _chunk(b'data', pcm_bytes)) |
| container = b'RIFF' + struct.pack('<I', len(body)) + body |
| path = Path(path); path.write_bytes(container) |
| return {**metadata, 'wav_bytes': len(container), 'sample_rate': sample_rate, |
| 'nominal_duration_seconds': len(pcm_bytes) / (2 * sample_rate)} |
|
|
|
|
| def read_chunks(path: Path) -> dict: |
| blob = Path(path).read_bytes() |
| if blob[:4] != b'RIFF' or blob[8:12] != b'WAVE': raise ValueError('not a RIFF WAVE file') |
| if len(blob) != 8 + struct.unpack('<I', blob[4:8])[0]: raise ValueError('RIFF size mismatch') |
| cursor = 12; chunks = {} |
| while cursor < len(blob): |
| if cursor + 8 > len(blob): raise ValueError('truncated chunk header') |
| tag = blob[cursor:cursor+4]; length = struct.unpack('<I', blob[cursor+4:cursor+8])[0] |
| start = cursor+8; stop = start+length |
| if stop > len(blob): raise ValueError('truncated chunk body') |
| if tag in chunks: raise ValueError('duplicate chunk identifier') |
| chunks[tag] = blob[start:stop] |
| cursor = stop + length % 2 |
| return chunks |
|
|
|
|
| def decode_wav(path: Path) -> tuple[np.ndarray, dict]: |
| chunks = read_chunks(path) |
| meta = json.loads(chunks[b'psri']) |
| if meta['format'] != 'phase-shift-carrier-v1' or meta['dtype'] != '<i2': |
| raise ValueError('unsupported tensor codec') |
| if len(meta['shape']) != 5 or any(type(n) is not int or n <= 0 for n in meta['shape']): |
| raise ValueError('invalid tensor shape') |
| if math.prod(meta['shape']) * 2 != meta['raw_bytes']: raise ValueError('shape length mismatch') |
| encoded = chunks[b'data'][:meta['compressed_bytes']] |
| if hashlib.sha256(encoded).hexdigest() != meta['compressed_sha256']: |
| raise ValueError('compressed payload checksum failed') |
| raw = zlib.decompress(encoded) |
| if len(raw) != meta['raw_bytes'] or hashlib.sha256(raw).hexdigest() != meta['raw_sha256']: |
| raise ValueError('decoded payload checksum failed') |
| return np.frombuffer(raw, dtype='<i2').reshape(meta['shape']).copy(), meta |
|
|
|
|
| def heat5(field: np.ndarray, time_value: float, rates: np.ndarray) -> np.ndarray: |
| """Periodic five-axis discrete heat semigroup, with anisotropic rates.""" |
| x = np.asarray(field, dtype=float); rates = np.asarray(rates, dtype=float) |
| if x.ndim != 5 or rates.shape != (5,) or np.any(rates < 0) or time_value < 0: |
| raise ValueError('heat5 needs 5D input, five nonnegative rates and nonnegative time') |
| eigenvalue = np.zeros(x.shape) |
| for axis, n in enumerate(x.shape): |
| shape = [1]*5; shape[axis] = n |
| eigenvalue += rates[axis] * (4*np.sin(np.pi*np.fft.fftfreq(n))**2).reshape(shape) |
| return np.fft.ifftn(np.fft.fftn(x) * np.exp(-time_value*eigenvalue)).real |
|
|
|
|
| def finite_mixed(function, x: np.ndarray, axes: list[int], h: float) -> float: |
| answer = 0.0 |
| for signs in itertools.product([-1,1], repeat=len(axes)): |
| q = x.copy() |
| for axis, sign in zip(axes, signs): q[axis] += sign*h |
| answer += np.prod(signs) * function(q) |
| return answer/(2*h)**len(axes) |
|
|
|
|
| def run_demo(directory: Path, seed: int = 640291) -> dict: |
| directory = Path(directory); directory.mkdir(parents=True, exist_ok=True) |
| rng = np.random.default_rng(seed) |
| x = np.array([0.2, -0.3, 0.4, 0.1, -0.2]) |
| a = np.array([0.4, -0.7, 0.8, 0.3, -0.5]) |
| speeds = np.array([1., .5, 2., .75, 1.25]) |
| variables = [Jet5.variable(x[i], i, speeds[i]) for i in range(5)] |
| expr = sum((a[i]*variables[i] for i in range(5)), Jet5.scalar(0)).exp() |
| product = Jet5.scalar(1) |
| for v in variables: product = product*v |
| expr = expr + product |
| expected = np.zeros(32) |
| for mask in range(32): |
| selected = [i for i in range(5) if mask & (1<<i)] |
| remaining = [i for i in range(5) if not mask & (1<<i)] |
| expected[mask] = ((math.exp(float(a@x)) * math.prod(a[i] for i in selected) |
| + math.prod(x[i] for i in remaining)) |
| * math.prod(speeds[i] for i in selected)) |
| algebra_error = float(np.max(np.abs(expr.c-expected))) |
| assert algebra_error < 1e-12 |
| comm_err=0.; assoc_err=0.; inv_err=0.; nilpotence_err=0. |
| for _ in range(50): |
| j,k,l = [Jet5(rng.normal(size=32)) for _ in range(3)] |
| comm_err=max(comm_err, float(np.max(np.abs((j*k).c-(k*j).c)))) |
| assoc_err=max(assoc_err, float(np.max(np.abs(((j*k)*l).c-(j*(k*l)).c)))) |
| j.c[0] = 2.0 |
| inv_err=max(inv_err,float(np.max(np.abs((j*j.inverse()).c-Jet5.scalar(1).c)))) |
| j.c[0] = 0 |
| power = Jet5.scalar(1) |
| for _ in range(6): power=power*j |
| nilpotence_err=max(nilpotence_err,float(np.max(np.abs(power.c)))) |
| assert max(comm_err,assoc_err,inv_err,nilpotence_err)<1e-10 |
| function=lambda q: math.exp(float(a@q))+float(np.prod(q)) |
| fd=[] |
| for axes in [[0],[0,1],list(range(5))]: |
| mask=sum(1<<i for i in axes) |
| true=expected[mask]/math.prod(speeds[i] for i in axes) |
| for h in [1e-1,1e-2,1e-3,1e-4]: |
| estimate=finite_mixed(function,x,axes,h) |
| fd.append({'order':len(axes),'step':h,'estimate':estimate,'analytic':true,'absolute_error':abs(estimate-true)}) |
| |
| |
| jet_delta=1/4096 |
| jet_integers=np.rint(expr.c/jet_delta).astype('<i2').reshape((2,2,2,2,2)) |
| assert np.max(np.abs(expr.c/jet_delta)) < 32767 |
| jet_metadata=encode_wav(jet_integers,directory/'jet_coefficients.wav', |
| axes=['epsilon_4','epsilon_3','epsilon_2','epsilon_1','epsilon_0'], |
| quantization={'kind':'round-to-nearest','step':jet_delta,'offset':0.0, |
| 'source':'32 real Jet5 coefficients','interpretation':'binary axis values select the five-generator subset mask'}) |
| jet_back,jet_back_metadata=decode_wav(directory/'jet_coefficients.wav') |
| jet_recovered=jet_back.ravel()*jet_back_metadata['quantization']['step'] |
| jet_carrier_error=float(np.max(np.abs(jet_recovered-expr.c))) |
| assert np.array_equal(jet_back,jet_integers) and jet_carrier_error <= jet_delta/2+1e-14 |
| jet_carrier={'path':'jet_coefficients.wav','shape':[2,2,2,2,2], |
| 'axis_order':['epsilon_4','epsilon_3','epsilon_2','epsilon_1','epsilon_0'], |
| 'quantization_step':jet_delta,'max_absolute_error':jet_carrier_error,'proved_bound':jet_delta/2, |
| 'exact_integer_roundtrip':True,'wav_bytes':jet_metadata['wav_bytes'], |
| 'raw_integer_bytes':jet_metadata['raw_bytes'],'raw_sha256':jet_metadata['raw_sha256'], |
| 'recovered_coefficients':jet_recovered.tolist()} |
| |
| shape=(12,10,8,6,4) |
| grid=np.indices(shape) |
| field=(np.sin(2*np.pi*grid[0]/shape[0])+.5*np.cos(2*np.pi*grid[1]/shape[1]) |
| +.25*np.sin(2*np.pi*(grid[2]/shape[2]+grid[3]/shape[3]))+.1*grid[4]) |
| structured=np.rint(32*field).astype('<i2') |
| random_tensor=rng.integers(-32768,32768,size=shape,dtype=np.int16) |
| codec_results=[] |
| for name, tensor in [('structured', structured),('uniform_random',random_tensor)]: |
| t0=time.perf_counter() |
| row=encode_wav(tensor,directory/(name+'.wav')) |
| decoded,metadata=decode_wav(directory/(name+'.wav')) |
| elapsed=time.perf_counter()-t0 |
| assert np.array_equal(tensor,decoded) |
| row.update(name=name, exact_roundtrip=True, max_integer_error=int(np.max(np.abs(tensor.astype(int)-decoded.astype(int)))), |
| compressed_over_raw=row['compressed_bytes']/row['raw_bytes'],wav_over_raw=row['wav_bytes']/row['raw_bytes'],elapsed_seconds=elapsed) |
| codec_results.append(row) |
| rate_rows=[] |
| baseline_chunks=None |
| for rate in [24000,48000,96000]: |
| path=directory/f'structured_{rate}Hz.wav' |
| row=encode_wav(structured,path,rate) |
| chunks=read_chunks(path) |
| if baseline_chunks is None: baseline_chunks=chunks |
| assert chunks[b'data']==baseline_chunks[b'data'] and chunks[b'psri']==baseline_chunks[b'psri'] |
| rate_rows.append({'sample_rate':rate,'wav_bytes':row['wav_bytes'],'nominal_duration_seconds':row['nominal_duration_seconds'], |
| 'identical_pcm_bytes':True,'identical_tensor_metadata':True,'raw_sha256':row['raw_sha256']}) |
| |
| delta=1/32 |
| quant=np.rint(field/delta)*delta |
| quant_error=float(np.max(np.abs(field-quant))) |
| assert quant_error<=delta/2+1e-14 |
| rates=np.array([.4,.8,1.2,1.6,2.]) |
| noise=rng.normal(size=shape) |
| mixed=field+.6*noise+.3*heat5(noise,1.2,rates) |
| heat_rows=[] |
| for t in [0,.1,.3,1,3,10]: |
| y=heat5(mixed,t,rates) |
| heat_rows.append({'time':t,'mean':float(y.mean()),'centered_l2_norm':float(np.linalg.norm(y-y.mean()))}) |
| semigroup_error=float(np.max(np.abs(heat5(heat5(mixed,.7,rates),1.3,rates)-heat5(mixed,2.,rates)))) |
| assert semigroup_error<1e-12 |
| assert all(heat_rows[i+1]['centered_l2_norm'] <= heat_rows[i]['centered_l2_norm']+1e-12 for i in range(len(heat_rows)-1)) |
| report={ |
| 'seed':seed,'environment':{'python':platform.python_version(),'numpy':np.__version__,'platform':platform.platform()}, |
| 'jet':{'function':'exp(sum(a_i*x_i)) + product(x_i)','a':a.tolist(),'x':x.tolist(),'axis_speeds':speeds.tolist(), |
| 'coefficients':expr.c.tolist(),'analytic_coefficients':expected.tolist(),'max_absolute_error':algebra_error, |
| 'random_algebra_trials':50,'commutativity_error':comm_err,'associativity_error':assoc_err,'inverse_error':inv_err,'nilpotence_order_6_error':nilpotence_err, |
| 'finite_difference_controls':fd}, |
| 'codec':codec_results,'jet_wav_carrier':jet_carrier,'sample_rate_control':rate_rows, |
| 'heat':{'axis_rates':rates.tolist(),'semigroup_max_error':semigroup_error,'progression':heat_rows}, |
| 'quantization':{'step':delta,'max_absolute_error':quant_error,'proved_bound':delta/2}, |
| 'interpretation':{'five_dimensions':'five digital tensor axes, not physical dimensions', |
| 'hypernumbers':'standard tensor product of five dual-number algebras, not a new number system', |
| 'compression':'zlib finds redundancy; WAV adds container overhead', |
| 'rsi_scope':'representation verification only; these tests do not demonstrate model intelligence gains'} |
| } |
| (directory/'metrics.json').write_text(json.dumps(report,indent=2)+'\n') |
| np.savez_compressed(directory/'reference_tensors.npz',structured=structured,random=random_tensor,continuous_field=field) |
| return report |
|
|
| if __name__=='__main__': |
| parser=argparse.ArgumentParser() |
| parser.add_argument('--out',type=Path,default=Path(__file__).resolve().parent/'results') |
| parser.add_argument('--seed',type=int,default=640291) |
| args=parser.parse_args() |
| result=run_demo(args.out,args.seed) |
| print(json.dumps({'jet_error':result['jet']['max_absolute_error'],'heat_semigroup_error':result['heat']['semigroup_max_error'], |
| 'codec':[{k:r[k] for k in ['name','raw_bytes','compressed_bytes','wav_bytes','wav_over_raw','exact_roundtrip']} for r in result['codec']], |
| 'quantization':result['quantization'],'jet_wav_carrier':result['jet_wav_carrier']},indent=2)) |
|
|
