Spiral-Time Memory

A Falsifiable Framework for Non-Markovian Temporal Structure in Quantum Mechanics

Overview

This repository explores a minimal theoretical framework where time itself carries intrinsic memory, encoded in a triadic structure Ψ(t) = (t, φ(t), χ(t)). The proposal offers:

• Dynamical alternative to the projection postulate - Measurement emerges from memory stabilization
• Explicit falsification criteria - Process-tensor tomography with CP-divisibility tests
• Experimental discrimination - Three operational criteria distinguish intrinsic temporal memory from environmental decoherence
• Reduction to standard QM - Markovian limit recovered when χ → 0

This repository is intended as a research and validation framework, not a production physics engine.

Status: Theoretical framework with outlined experimental tests. No empirical confirmation yet.

Orientation: This repository assumes familiarity with non-Markovian quantum dynamics and process tensor methods. The README serves as a research overview and documents the core claims and falsification logic; formal derivations and proofs are provided in THEORY.md and paper/spiral_time.md.

---

Core Idea

Standard quantum mechanics treats time as a memoryless parameter. This work asks: What if temporal dynamics are fundamentally non-Markovian?

The Framework

Standard QM: Time is an external parameter

ẋ(t) = F(x(t))                    # Present determines future

Spiral-Time: Time is a dynamical state with memory

Ψ(t) = t + iφ(t) + jχ(t)         # Triadic structure
ẋ(t) = F(x(t), ∫K(t-τ)x(τ)dτ)    # History matters
         └─ memory kernel

Extended Hilbert Space:

H_ext = H_sys ⊗ H_mem             # Memory sector encodes temporal history

Full evolution on H_ext is unitary; traced dynamics on H_sys is non-Markovian.

---

Key Features

Measurement Without Collapse

Problem: Projection postulate is ad hoc, not derivable from unitary evolution

Solution: Measurement = dynamical stabilization of temporal memory

χ(t⁺) = χ(t⁻) + Δχ_meas           # Memory sector stabilizes

Competing modes lose coherence relative to stabilized memory → effective "collapse" in coarse-grained descriptions while remaining continuous in (|ψ⟩, χ) space.

Born Rule Emergence

Standard approach: |⟨n|ψ⟩|² is axiomatic

Spiral-Time proposal: Emerges from time-integrated stability

P_n = lim_{T→0} (1/T) ∫_{t₀}^{t₀+T} |ψ_n(t)|² dt → |ψ_n(t₀)|²

Compatible with Gleason's theorem via temporal coarse-graining measure.

Experimental Discrimination from Environmental Decoherence

Critical question: How to distinguish from known environmental non-Markovianity?

Three Operational Criteria:

Criterion	Environmental	Spiral-Time
1. Memory Kernel	State-dependent, coupled to bath	State-independent: K(t-τ) only
2. CP-Divisibility	Violated due to info backflow	Violated structurally in isolated systems
3. Process Tensor	Finite-rank (finite bath)	No finite-rank representation

Operational test: Must satisfy ALL THREE criteria to claim Spiral-Time memory vs environmental effects.

Sensitivity: Predicted deviations O(εχ) ∼ 10⁻³–10⁻², within reach of current trapped-ion and superconducting platforms (resolution ~10⁻³).

---

Falsification Criteria

Primary Test: Process Tensor Tomography

Null Hypothesis (Markovian dynamics):

ℰ_{t:0} = ℰ_{t:s} ∘ ℰ_{s:0}  with ℰ_{t:s} CP for all t ≥ s ≥ 0

(Evolution factorizes into completely positive maps)

Spiral-Time Prediction: Even after controlling environment and reset protocols, reconstructed process tensors should exhibit:

• Statistically significant deviations from CP-divisible fits
• Outcome probabilities depending on intervention history
• Persistent non-Markovianity under controlled "reset" operations
• State-independent memory kernel K(t-τ)

Experimental Protocols

Protocol A: Reset Test

• Platform: NV centers, trapped ions, superconducting qubits
• Test: Repeated measure–reset cycles with varied history sequences
• Expected: Residual history dependence beyond systematics (state-independent)
• Falsification: No history dependence → theory fails

Protocol B: Process Tensor Tomography

• Method: Reconstruct process over ≥3 time steps with intermediate operations
• Test: Does best-fit model require non-factorizing correlations?
• Critical: Test with multiple initial states → verify state-independence
• Falsification: All processes CP-divisible → theory fails

Protocol C: Leggett-Garg Under Interventions

• Test: Multi-time correlations with/without engineered memory suppression
• Expected: Violations persist under maximal isolation
• Falsification: Violations disappear with environment → environmental origin

Formal Falsification Statement

The Spiral-Time memory hypothesis is falsified if:

Under controlled intervention and reset protocols, process-tensor reconstruction yields CP-divisible (Markovian) descriptions for all tested multi-time settings within experimental uncertainty, OR if observed non-Markovianity can be reproduced by finite environmental baths (fails discrimination criteria), AND no state-independent history-dependent deviations remain beyond systematics.

---

Repository Structure

spiral-time-memory/
├── CITATION.cff               # Citation metadata for academic referencing
├── .flake8                    # Linting is advisory and tuned for research-grade scientific code
├── README.md                  # Project overview, scope, and navigation entry point
├── THEORY.md                  # Formal axioms, assumptions, protocols, falsification criteria
├── IMPLEMENTATIONS.md         # Rationale for non-unique implementations and equivalence classes
├── QUICKSTART.md              # 5-minute setup and minimal working example
├── requirements.txt           # Pinned runtime and analysis dependencies
├── setup.py                   # Package installation configuration
├── pytest.ini                 # Test configuration and coverage settings
├── Makefile                   # Common development commands
│
├── .github/
│   └── workflows/
│       └── ci.yml             # Automated testing pipeline (Linux/macOS/Windows)
│
├── paper/                     # Paper manuscript
│   └── spiral_time.md         # Complete paper in Markdown format
│                              
│
├── theory/                    # Mathematical foundations
│   ├── __init__.py
│   ├── operators.py           # Extended Hilbert space: H_ext = H_sys ⊗ H_mem
│   │                          # Triadic operators, von Neumann evolution, memory tracing
│   └── dynamics.py            # Non-Markovian evolution with explicit memory kernels
│                              # Memory kernel implementations (exponential, power-law, Gaussian)
│
├── analysis/                  # Falsification and experimental discrimination tools
│   ├── __init__.py
│   │
│   ├── cp_divisibility.py     # CORE: Process tensor CP-divisibility tests
│   │                          # Quantum channel representation (Choi matrices, Kraus operators)
│   │                          # CP-divisibility detection (null hypothesis: Markovian)
│   │                          # Process tensor reconstruction (Protocol B)
│   │                          # Primary falsification criterion
│   │
│   ├── state_independence.py  # CRITERION 1: State-independent memory (Section 10.1)
│   │                          # Tests if K(t-τ) depends only on time separation
│   │                          # Statistical analysis across initial states (CV, ANOVA)
│   │                          # Distinguishes Spiral-Time from environmental effects
│   │                          # Verdict: State-independent → Spiral-Time
│   │                          #           State-dependent → Environmental
│   │
│   ├── process_tensor_rank.py  # CRITERION 3: Finite-rank obstruction (Section 10.3)
│   │                           # Singular value decomposition of process tensors
│   │                           # Rank scaling analysis (growth vs saturation)
│   │                           # Tests for unbounded temporal correlations
│   │                           # Verdict: Finite rank → Environmental (d_bath limit)
│   │                           #           Unbounded → Spiral-Time (continuous χ(t))
│   │
│   ├── non_markovianity.py     # MEASURES: Comprehensive non-Markovianity quantification
│   │                           # BLP measure (Breuer-Laine-Piilo): Information backflow
│   │                           # RHP measure (Rivas-Huelga-Plenio): CP-divisibility violations
│   │                           # Fisher information: Parameter estimation perspective
│   │                           # Consensus framework across multiple measures
│   │                           # Detects non-Markovianity but doesn't distinguish origin
│   │                           # (must combine with Criteria 1-3 for discrimination)
│   │
│   └── environmental_models.py # BASELINES: Environmental decoherence for comparison
│                               # Finite-dimensional bath models (rank ≤ d_bath)
│                               # State-dependent decoherence kernels
│                               # Collision models (sequential interactions)
│                               # ComparisonFramework: Side-by-side Spiral-Time vs Environmental
│                               # Demonstrates all three discrimination criteria
│                             
│
├── simulations/                # Illustrative comparisons (pedagogical)
│   ├── __init__.py
│   ├── markov_comparison.py    # Markovian vs memory dynamics visualization
│   └── resonance_statistics.py  # Born rule emergence exploration (Eq. 7)
│
├── experiments/                # Experimental protocol implementations
│   ├── __init__.py
│   │
│   ├── reset_tests/            # Protocol A: Reset test for history dependence
│   │   ├── __init__.py
│   │   ├── protocol_a.py       # Reset-based memory persistence tests
│   │   └── README.md           # Protocol A experimental details
│   │
│   ├── process_tensor/         # Protocol B: Multi-time tomography
│   │   ├── __init__.py
│   │   ├── protocol_b.py       # Process tensor reconstruction protocol
│   │   └── README.md           # Protocol B experimental details
│   │
│   └── leggett_garg/           # Protocol C: Controlled interventions
│       ├── __init__.py
│       ├── protocol_c.py       # Leggett–Garg inequality under memory suppression
│       └── README.md           # Protocol C experimental details
│
├── tests/                      # Comprehensive unit and integration tests
│   ├── __init__.py
│   ├── conftest.py             # Pytest fixtures and configuration
│   ├── test_operators.py       # Tests for theory/operators.py
│   ├── test_dynamics.py        # Tests for theory/dynamics.py
│   ├── test_cp_divisibility.py      # Tests for analysis/cp_divisibility.py
│   ├── test_state_independence.py   # Tests for state-independence criterion
│   ├── test_process_tensor_rank.py     # Tests for rank analysis
│   ├── test_non_markovianity.py        # Tests for non-Markovianity measures
│   ├── test_environmental_models.py    # Tests for environmental baselines
│   └── test_protocols.py               # Tests for experimental protocols A-C
│
└── examples/                           # Interactive tutorials and demonstrations
    ├── spiral_time_intro.ipynb         # Core concepts and first demonstrations
    ├── non_markovian_walkthrough.ipynb # Deep dive into memory effects
    ├── cp_divisibility_tutorial.ipynb  # Falsification criterion explained
    ├── discrimination_workflow.ipynb   # Complete Section 10 three-criteria test
    └── protocol_examples.ipynb         # How to implement Protocols A-C

---

Analysis Module Breakdown

The analysis/ directory now contains a complete suite for experimental discrimination:

File	Purpose	Section
cp_divisibility.py	Core CP-divisibility tests, quantum channels	9.2-9.3
state_independence.py	Test if memory is state-independent	10.1
process_tensor_rank.py	Test for finite vs unbounded rank	10.3
non_markovianity.py	BLP, RHP, Fisher measures	Background
environmental_models.py	Comparison with environmental effects	10

Three Discrimination Criteria (Section 10):

1. State-independence → state_independence.py
2. CP-violation in isolation → cp_divisibility.py
3. No finite-rank representation → process_tensor_rank.py

---

Key Organizational Principles

Theory (theory/): Mathematical foundations only

• Operators, dynamics, memory kernels
• No experimental protocols

Analysis (analysis/): Falsification and discrimination

• All tools for testing the theory
• Comparison with environmental effects
• Multiple non-Markovianity measures

Experiments (experiments/): Protocol implementations

• Concrete experimental procedures (A, B, C)
• Platform-specific adaptations
• Expected signatures and controls

Tests (tests/): Verification

• Unit tests for all modules
• Integration tests for workflows
• Reproducibility checks

Examples (examples/): Education and demonstration

• Interactive notebooks
• Complete workflows
• Visualization tools

Quick Start

Installation

# Clone repository
git clone https://github.com/dfeen87/spiral-time-memory.git
cd spiral-time-memory

# Install dependencies
pip install -r requirements.txt

# Or install as editable package with dev tools
pip install -e ".[dev,notebooks]"

# Verify installation
pytest tests/ -v

Run Your First Experiment

import numpy as np
from theory.dynamics import MemoryKernelConfig, NonMarkovianEvolver

# Define system with memory
def F(x):
    """Harmonic oscillator"""
    return np.array([x[1], -x[0]])

def g(mem_int):
    """Memory coupling"""
    return np.array([0, -0.1 * mem_int[1]])

# Configure memory kernel
config = MemoryKernelConfig(kernel_type="exponential", tau_mem=1.0)

# Evolve with memory
evolver = NonMarkovianEvolver(F, g, config, dt=0.01)
x0 = np.array([1.0, 0.0])
times, states = evolver.evolve(x0, (0, 10))

print(f"Memory effect: amplitude decays from {states[0,0]:.3f} to {states[-1,0]:.3f}")

Test Falsification Criterion

from analysis.cp_divisibility import ProcessTensorReconstructor, ProcessTensorConfig

# Configure process tensor test
config = ProcessTensorConfig(n_timesteps=5, hilbert_dim=2, dt=0.1)
reconstructor = ProcessTensorReconstructor(config)

# Generate test process
channels = reconstructor.generate_test_process(memory_strength=0.3)
times = [i * config.dt for i in range(config.n_timesteps)]

# Test hypothesis
results = reconstructor.test_memory_hypothesis(channels, times)
print(results['verdict'])
# Output: "NON-MARKOVIAN (consistent with memory)" or "MARKOVIAN (theory falsified)"

Run Experimental Protocol

# Protocol A: Reset test for history dependence
python experiments/reset_tests/protocol_a.py

# Or via make
make run-protocol-a

---

CI Notes

This repository prioritizes reproducibility and executable correctness. All tests, simulations, and notebooks are required to pass in CI.

Static linting and type checking are included as advisory signals only. Due to the exploratory and numerical nature of the research code, some patterns intentionally trade strict static typing for clarity and physical correctness.

---

Comparison with Standard QM

Aspect	Standard QM	Spiral-Time
Time	External parameter	Dynamical state Ψ = t + iφ + jχ
State Space	H_sys	H_ext = H_sys ⊗ H_mem
Dynamics	Markovian (state at t sufficient)	Non-Markovian (history dependence)
Measurement	Projection postulate (axiom)	Memory stabilization (dynamical)
Born Rule	Postulate	Temporal coarse-graining (proposal)
Collapse	Fundamental	Effective (continuous in extended space)
Nonlocality	Entanglement	Temporal coherence + memory

Reduction: χ → 0 with vanishing memory coupling → standard Markovian QM recovered

---

Scope and Limitations

What This Proposes

• Falsifiable extension of quantum mechanics with specific experimental signatures
• Dynamical mechanism for measurement without projection postulate
• Reduction to standard physics in appropriate limits
• Three-part operational test distinguishing from environmental effects

What This Does NOT Claim

• To replace quantum field theory (it's an embedding principle)
• That implementations here are unique or canonical (see IMPLEMENTATIONS.md)
• Complete derivation of GR or Standard Model masses (Eqs. 9-10 are effective relations)
• Empirical validation (experimental tests remain to be performed)

Critical Disclaimers

All code is illustrative, not definitive:

• Memory kernel forms (exponential, power-law, Gaussian) are non-unique choices
• Discretization schemes are implementation-dependent
• Parameter values are for demonstration
• See IMPLEMENTATIONS.md for detailed disclaimers

---

Documentation

• THEORY.md — Complete axioms, experimental protocols, falsification criteria
• IMPLEMENTATIONS.md — Why code choices are non-unique (READ THIS)
• QUICKSTART.md — 5-minute getting started guide
• examples/ — Interactive Jupyter notebooks

---

Citation

If you use this work, please cite:

@unpublished{kruger2026spiraltime,
  title  = {Spiral-Time with Memory as a Fundamental Principle:
            From Non-Markovian Dynamics to Measurement without Collapse},
  author = {Kr{\"u}ger, Marcel},
  year   = {2026},
  note   = {ResearchGate preprint, identifier: 10.13140/RG.2.2.27393.93280}
}

See CITATION.cff for structured citation metadata for this repository.

---

Contributing

Contributions are welcome, especially:

High Priority

• Experimental implementations of Protocols A-C on real hardware
• Alternative memory kernel formulations with theoretical justification
• CP-divisibility test refinements and validation
• State-independence test protocols (Section 10 criteria)

Medium Priority

• Additional example notebooks and tutorials
• Performance optimizations for process tensor tomography
• Extended Hilbert space visualization tools
• Cross-platform experimental adapters

Before Contributing

1. Read THEORY.md for theoretical background
2. Read IMPLEMENTATIONS.md for code philosophy
3. Run make check to verify code quality
4. Open an issue for discussion before major PRs

Code style: Run make format before committing (uses Black, isort)

---

Development

Common Commands

# Run all tests
make test

# Run tests with coverage
make test-cov

# Format code
make format

# Check code quality (format + lint + tests)
make check

# Run experimental protocol
make run-protocol-a

# Start Jupyter notebook
make notebook-server

# Clean build artifacts
make clean

Build & CI

The CI pipeline is intentionally minimal, deterministic, and transparent. It runs on GitHub Actions and uses only pinned Python dependencies from requirements.txt.

Triggers

• push and pull_request events targeting main or develop
• Weekly scheduled run (Sunday 00:00 UTC) to surface dependency drift
• Manual workflow_dispatch runs for reviewers

What CI runs

• Unit/integration tests with coverage on Python 3.9–3.12 (Ubuntu only)
• Lint + type checks: Black, isort, flake8, mypy
• Notebook execution: all notebooks in examples/*.ipynb are executed with nbconvert
• Reproducibility check: deterministic memory-kernel output with fixed seeds

Reproduce CI locally

python -m pip install --upgrade pip
pip install -r requirements.txt

# Tests
pytest tests/ -v --cov=theory --cov=analysis --cov=simulations --cov-report=term-missing

# Lint / type checks
black --check --diff theory/ analysis/ simulations/ experiments/ tests/
isort --check-only --diff theory/ analysis/ simulations/ experiments/ tests/
flake8 theory/ analysis/ simulations/ experiments/ tests/ --count --show-source --statistics
mypy theory/ analysis/ --ignore-missing-imports --no-strict-optional

# Notebook execution
for notebook in examples/*.ipynb; do
  jupyter nbconvert --to notebook --execute --inplace \
    --ExecutePreprocessor.timeout=600 "$notebook"
done

Common failure modes

• Notebook execution errors: usually indicate a missing dependency or a non-deterministic cell. Keep notebooks deterministic (fixed seeds, no hidden data downloads).
• Lint failures: formatting or import order deviations; run make format before committing.
• Test failures on specific Python versions: check for version-sensitive numerical tolerances or dependency pins.

See .github/workflows/ci.yml for the exact pipeline definition.

---

Experimental Status

Current State

• Theoretical framework complete
• Falsification criteria explicit
• Reference implementations provided
• Discrimination from environmental effects formalized
• Experimental validation pending

Platforms of Interest

• Trapped ions: High-fidelity multi-time measurements
• Superconducting qubits: Fast reset protocols
• NV centers: Long coherence for memory tests
• Photonic systems: Process tensor tomography

Expected Timeline

• Near term (6-12 months): Protocol A on existing platforms
• Medium term (1-2 years): Full process tensor tomography (Protocol B)
• Long term (2-5 years): Comprehensive discrimination tests

---

Frequently Asked Questions

Is this a new interpretation of quantum mechanics?

No. This is a structural hypothesis with falsifiable predictions. If process tensors remain CP-divisible under controlled interventions, the theory fails. It's not about interpretation—it's about measurable signatures.

How does this differ from environmental decoherence?

Three decisive criteria (Section 10 of paper):

1. Memory kernel is state-independent (not coupled to ρ(t))
2. CP-divisibility violated in isolated systems (no environment needed)
3. Process tensor has no finite-rank representation (unbounded temporal correlations)

Standard environmental effects fail at least one of these tests.

What if all experiments show Markovian dynamics?

Then the theory is falsified. This is the point—the framework makes testable predictions that could be wrong.

Are the code implementations canonical?

No. See IMPLEMENTATIONS.md. Memory kernel forms, discretization schemes, and numerical parameters are illustrative choices. Alternative implementations are equally valid.

Can this replace quantum field theory?

No. It's an embedding principle that reduces to standard QFT in the χ → 0 limit. Think of it as a framework that could contain QFT as a special case, not a replacement.

What about relativity?

Spacetime metric emerges as effective structure (Eq. 9: g_μν ∼ ∂_μΨ · ∂_νΨ). Full GR derivation not claimed—this is a consistency-level relation showing how metric could arise from triadic time-state variations.

---

Support and Community

• GitHub Issues: Bug reports, feature requests, theoretical questions
• Discussions: Community forum for extended conversations
• Email: [dfeen87@gmail.com] for collaboration inquiries

Getting Help

1. Check QUICKSTART.md for setup issues
2. Read THEORY.md for theoretical questions
3. See IMPLEMENTATIONS.md for code questions
4. Search existing GitHub Issues
5. Open new issue with minimal reproducible example

---

Acknowledgments

This work builds on foundations in:

• Non-Markovian quantum dynamics (Breuer-Laine-Piilo, Rivas-Huelga-Plenio)
• Process tensor formalism (Pollock et al.)
• Quantum foundations (Gleason, Zurek, Leggett)

---

License

MIT License - see LICENSE for details.

In brief: You can use, modify, and distribute this code freely, with attribution. No warranty is provided.

---

Version History

• v0.1.0 (January 2026): Initial public research release
  • Formal theoretical framework with explicit falsification criteria
  • Reference implementations for theory, analysis, and experimental protocols
  • Comprehensive unit test suite
  • Experimental Protocols A–C defined and documented
  • Operational criteria for discrimination from environmental effects

---

Final Notes

The Core Claim

If time carries intrinsic memory, then:

1. Measurement collapse may be replaced by dynamical memory stabilization
2. Born rule emerges from temporal coarse-graining
3. Multi-time quantum processes will exhibit state-independent, structurally non-CP-divisible signatures with no finite-rank representation

The Test

Perform process tensor tomography under controlled interventions:

• If all processes are CP-divisible → theory falsified
• If non-Markovianity is state-dependent → environmental origin
• If reproducible by finite bath → not Spiral-Time intrinsic memory
• If all three discrimination criteria pass → consistent with Spiral-Time

The Stakes

Either:

• Nature exhibits intrinsic temporal memory → measurement problem resolved dynamically
• Nature is fundamentally Markovian → back to projection postulate

---

Repository Version: 0.1.0
Paper Status: ResearchGate preprint (identifier: 10.13140/RG.2.2.27393.93280)

License: MIT
Last Updated: January 2026

Ready for collaboration, experimentation, and potential falsification.