Quantum Signal Characterisation API

Overview API Operational — v1.0.0

What This Does

The API accepts raw time-series data — voltage samples, IQ pairs, ADC readings — and returns a structural characterisation of what the signal is doing. It works on radio signals, sensor streams, financial data, or any continuous measurement.

How It Works

Your data is converted into quantum state-space trajectories. Adaptive thresholding identifies significant state transitions. Unsupervised anomaly gating filters noise. Spike-based coincidence scoring measures structural similarity. Multi-lag autocorrelation captures temporal patterns. Twelve mathematical phenomena detectors surface anomalous signatures.

The pipeline runs server-side. You receive only the characterisation — classification tags, temporal profile, anomaly level, and detected phenomena.

What Makes It Different

No training data: Fully unsupervised. Works on signals never seen before.
Not pattern matching: Characterises mathematical structure, not protocol signatures.
Universal input: Any time-series. RF, vibration, medical, financial, quantum hardware.
Structural output: Not just "anomaly detected" but what kind of anomaly.
Edge-ready: Designed for neuromorphic hardware at milliwatt power.

API Reference Authentication: X-API-Key header

Endpoints

Base URL: https://quantum-signal-api.sparsesupernova.workers.dev

POST Analyse time-series data

https://quantum-signal-api.sparsesupernova.workers.dev/api/characterise

GET Run on built-in demo signal

https://quantum-signal-api.sparsesupernova.workers.dev/api/demo

GET Service health check

https://quantum-signal-api.sparsesupernova.workers.dev/api/health

Request Format

Endpoint: POST /api/characterise

Headers:

X-API-Key: Your API key
Content-Type: application/json

Body schema:

                        
{
  "samples": [0.12, -0.34, 0.56, ...],
  "config": {
    "sample_rate": 44100
  }
}

Field reference

samples (required)

Flat list of numbers. Minimum 128, maximum 100,000 (validated in production; larger payloads may hit platform limits).
Format: voltage, amplitude, or magnitude.
Scale: API is scale-invariant. Send raw ADC (e.g. 0–4096) or normalized floats (−1.0 to 1.0). No pre-normalization required.
RF / Rydberg / SDR: Do not send interleaved I/Q. Send magnitude √(I²+Q²) per sample as the array.

config (optional)

Omit for 99% of use cases. The system auto-tunes thresholds and windowing.
Include only if you need to override sample_rate for temporal accuracy (defaults to 1 Hz if omitted; affects frequency labels, not classification).

Integration tips

Python: Set User-Agent (e.g. QuantumSignalClient/1.0) to avoid Cloudflare blocking default Python-urllib.
RF / Rydberg: Send magnitude √(I²+Q²); scale-invariant; omit config unless overriding sample rate.

Response Fields

Field	Description
`characterisation.classification`	Array of tags: STRUCTURED, ANTI_CORRELATED, MODULATED, etc.
`characterisation.temporal_profile`	CORRELATED, ANTI_CORRELATED, or NEUTRAL
`characterisation.anomaly_level`	HIGH, MODERATE, or LOW
`characterisation.confidence`	0.0 – 1.0 classification confidence
`phenomena_detected`	Array of triggered mathematical detectors with confidence
`metrics`	Raw/anomalous event counts, autocorrelation lags, burst ratio
`processing`	Threshold method, trajectory count, processing time

Example Response

                
{
  "success": true,
  "characterisation": {
    "classification": ["STRUCTURED", "ACTIVE", "MODULATED", "HIGH_ANOMALY"],
    "temporal_profile": "CORRELATED",
    "activity_level": "HIGH",
    "anomaly_level": "HIGH",
    "confidence": 0.82
  },
  "phenomena_detected": [
    { "detector": "information_backflow", "confidence": 0.71 },
    { "detector": "quantum_darwinism", "confidence": 0.58 },
    { "detector": "criticality", "confidence": 0.63 }
  ],
  "metrics": {
    "raw_events": 1728,
    "anomalous_events": 106,
    "gating_reduction": "93.9%",
    "autocorrelation_lag1": 0.089,
    "autocorrelation_lag2": -0.041,
    "autocorrelation_lag3": 0.032,
    "burst_ratio": 0.496
  },
  "processing": {
    "threshold": 0.3179,
    "threshold_method": "MAD",
    "processing_time_ms": 230
  }
}

Live Testing Demo key: demo-sparse-supernova-2026

Try It Now

Run the analysis on the built-in demo signal, or paste your own samples.

First request after idle may be 1–3s slower (cold start). Subsequent requests are fast.

Ready

Detectors 12 mathematical signatures

What We Detect

The pipeline tests for twelve mathematical phenomena in every signal. Each detector asks a specific structural question — not "is this a known protocol?" but "is this signal doing something mathematically unusual?"

Physical Phenomena

Quantum Zeno: Measurement frequency correlates with delayed transitions
Criticality: Self-organised criticality in event magnitude distribution
Information Backflow: Non-Markovian temporal correlations
Fractal Dimension: Chaotic structure in state-space trajectories
Topological Transitions: Phase changes in signal geometry
Penrose OR: Gravity-scale collapse events

Structural Signatures

Weak Values: Anomalous measurement outcomes outside expected bounds
Quantum Darwinism: Environmental redundancy and information copying
Retrocausality: Future events correlating with past states
Teleportation Shadow: Cross-channel correlations without direct coupling
Simulation Glitches: Quantisation artifacts and periodic patterns
Consciousness Correlation: Observer-dependent measurement bias

Integration

Quick Start

Copy-paste the snippet for your stack. No config needed — the system auto-tunes.

Python (recommended for data science / Rydberg)

                        
import requests
import numpy as np

# 1. Generate Data (Example: Gaussian Noise)
# Note: Noise often trends to ANTI_CORRELATED or low structure; may show STRUCTURED depending on gating/windowing.
data = np.random.normal(0, 1, 5000).tolist()

# Pro Tip: To see "STRUCTURED" detection, use a sine wave instead:
# t = np.linspace(0, 1, 5000)
# data = (np.sin(2 * np.pi * 50 * t)).tolist()

# 2. Request — no config needed; system auto-tunes
url = "https://quantum-signal-api.sparsesupernova.workers.dev/api/characterise"
headers = {
    "X-API-Key": "demo-sparse-supernova-2026",
    "Content-Type": "application/json",
    "User-Agent": "QuantumSignalClient/1.0",
}

print(f"Sending {len(data)} samples to Sparse Supernova...")
response = requests.post(url, headers=headers, json={"samples": data})

# 3. Results
if response.status_code == 200:
    result = response.json()
    print("Classification:", result["characterisation"]["classification"])
    print("Phenomena:", [p["detector"] for p in result["phenomena_detected"]])
else:
    print("Error:", response.text)

Expectations: Noise often trends to ANTI_CORRELATED or low structure (may show STRUCTURED depending on gating/windowing). Sine → STRUCTURED. The snippet prints Phenomena (e.g. Quantum Zeno, Criticality). RF/IQ: Send magnitude √(I²+Q²); set User-Agent to avoid Cloudflare blocks.

cURL (Linux / Mac / WSL)

Minimum 128 samples: The API rejects payloads with fewer than 128 samples (400 Bad Request). The first example below is for documentation; the second generates 150 samples so it works on first run.

# 1. Documentation example (visual — replace ... with 125+ more values or use #2) curl -X POST https://quantum-signal-api.sparsesupernova.workers.dev/api/characterise \ -H "X-API-Key: demo-sparse-supernova-2026" \ -H "Content-Type: application/json" \ -d '{"samples": [0.1, -0.3, 0.5, ...]}' # min 128 samples required # 2. Copy-paste to test (generates 150 samples, runs immediately) curl -X POST https://quantum-signal-api.sparsesupernova.workers.dev/api/characterise \ -H "X-API-Key: demo-sparse-supernova-2026" \ -H "Content-Type: application/json" \ -d "{\"samples\": [$(for i in {1..150}; do echo -n \"0.$RANDOM,\"; done | sed 's/,$//')]}"

JavaScript / Node

                        
// 1. Generate dummy data (min 128 samples required)
const samples = Array.from({ length: 200 }, () => Math.random() * 2 - 1);

// 2. Async wrapper — runs in Node 18+ or Browser
(async () => {
  try {
    const resp = await fetch(
      "https://quantum-signal-api.sparsesupernova.workers.dev/api/characterise",
      {
        method: "POST",
        headers: {
          "X-API-Key": "demo-sparse-supernova-2026",
          "Content-Type": "application/json",
        },
        body: JSON.stringify({ samples })
      }
    );

    if (!resp.ok) {
      throw new Error(`API Error: ${resp.status} ${await resp.text()}`);
    }

    const result = await resp.json();

    // 3. Signal Intelligence output
    console.log("Classification:", result.characterisation.classification);
    console.log("Phenomena:", result.phenomena_detected);

  } catch (error) {
    console.error("Failed:", error.message);
  }
})();

SDR / Rydberg

Speaks hardware language: magnitude √(I²+Q²), not raw JSON. Fits Unix pipelines (rtl_sdr, GNU Radio). Converting I/Q to magnitude before upload cuts bandwidth by 50%. Save the script below as iq_to_magnitude.py so the pipeline runs.

# INTEGRATION EXAMPLE: RTL-SDR → SPARSE SUPERNOVA # Pipe live radio → magnitude (JSON) → API rtl_sdr -f 462.5625e6 -s 2.4e6 -n 48000 - | \ python3 iq_to_magnitude.py | \ curl -X POST "https://quantum-signal-api.sparsesupernova.workers.dev/api/characterise" \ -H "X-API-Key: demo-sparse-supernova-2026" \ -H "Content-Type: application/json" \ -d @-

Save as iq_to_magnitude.py

# Read binary from stdin (rtl_sdr: uint8, 48k samples × 2 = 96,000 bytes) import sys, numpy as np, json raw = sys.stdin.buffer.read(96000) y = np.frombuffer(raw, dtype=np.uint8).astype(float) y = (y - 127.5) / 127.5 # Normalize to -1..1 i, q = y[0::2], y[1::2] magnitude = np.sqrt(i**2 + q**2) # √(I²+Q²) print(json.dumps({"samples": magnitude.tolist()}))