tqce 1.0.0__tar.gz

tqce-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TQCE Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tqce-1.0.0/PKG-INFO

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: tqce
+Version: 1.0.0
+Summary: Temporal Quantum Causal Engine — A computational paradigm based on causal loop mechanics
+Author: utachicodes
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/utachicodes/tqce
+Project-URL: Repository, https://github.com/utachicodes/tqce
+Project-URL: Documentation, https://github.com/utachicodes/tqce/blob/main/docs/api.md
+Keywords: causal-inference,temporal-computing,optimization,tensor-networks
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: networkx>=3.0
+Requires-Dist: scipy>=1.10
+Requires-Dist: matplotlib>=3.7
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Dynamic: license-file
+
+# TQCE — Temporal Quantum Causal Engine
+
+**A novel computational paradigm based on causal loop mechanics.**
+
+Paradox resolution in closed timelike curves is computationally equivalent to optimization under self-referential constraint systems. TQCE exploits this equivalence to build a new class of algorithms that solve problems standard approaches cannot handle — circular dependencies, self-referential optimization, and causal reasoning with feedback loops.
+
+## Installation
+
+```bash
+git clone <repo-url>
+cd tqce
+pip install -e ".[dev]"
+```
+
+Requirements: Python 3.11+, numpy, networkx, scipy, matplotlib.
+
+## Quick Start
+
+```python
+import numpy as np
+from tqce import CausalNode, TQCEOrchestrator
+from tqce.viz import plot_convergence, plot_ctn_graph
+
+np.random.seed(42)
+
+# Build a causal loop: A -> B -> C with retrocausal C -> A
+engine = TQCEOrchestrator("My Problem")
+net = engine.build_network()
+
+net.add_node(CausalNode("A", time_coordinate=0.0, state_dim=4))
+net.add_node(CausalNode("B", time_coordinate=1.0, state_dim=4))
+net.add_node(CausalNode("C", time_coordinate=2.0, state_dim=4))
+
+net.add_causal_edge("A", "B", weight=0.8)
+net.add_causal_edge("B", "C", weight=0.6)
+net.add_retrocausal_edge("C", "A", weight=0.4)  # backward in time
+
+# Solve for a self-consistent timeline
+results = engine.solve(verbose=True)
+
+# Visualize
+plot_ctn_graph(net)
+plot_convergence(results["fixed_point"]["iteration_history"])
+```
+
+## Five Core Components
+
+### 1. Causal Tensor Networks (CTN)
+
+Standard tensor networks are directed acyclic graphs. CTNs extend this by adding retrocausal edges — connections pointing backward in time — creating Closed Causal Loops (CCLs). The network state is computed not by forward propagation but by fixed-point iteration: repeatedly updating all nodes until the global state converges to a self-consistent solution. This is the computational analog of finding a valid timeline in a system with closed timelike curves.
+
+**Class:** `CausalTensorNetwork`
+
+### 2. Paradox Pressure Gradient Descent (PPGD)
+
+PPGD is a gradient-based optimizer where the loss function is causal inconsistency itself. The "paradox pressure" at each node measures how far its current state is from what its causal parents demand. By treating this pressure as a differentiable loss surface, PPGD descends toward self-consistent basins using momentum and adaptive learning rates scaled by local paradox pressure.
+
+**Class:** `ParadoxPressureGradientDescent`
+
+### 3. Temporal Eigenstate Collapse (TEC)
+
+Multiple candidate timelines are superposed as a "temporal wavefunction" with complex amplitudes. Causal interference between timelines amplifies consistent resolutions (constructive interference) and cancels paradoxical ones (destructive interference). After several rounds of interference, the system collapses to the timeline with the highest probability — the most self-consistent solution.
+
+**Class:** `TemporalWavefunction`
+
+### 4. Chrono-Entropic Regularization (CER)
+
+Inspired by the second law of thermodynamics: entropy must be non-decreasing, even in causal loops. CER penalizes states where a past node has higher approximate entropy than its future retrocausal parents. This prevents information from growing unboundedly as it circulates through the loop, acting as a principled regularizer derived from physical constraints.
+
+**Class:** `ChronoEntropicRegularizer`
+
+### 5. Bootstrap Amplification (BA)
+
+In a bootstrap paradox, information exists with no origin. BA exploits this computationally: a weak signal is injected into a causal loop where it influences itself at each pass. With the right resonance conditions (spectral radius of the loop kernel below 1), the signal amplifies to a stable fixed point that is larger than the input. Chrono-entropic damping prevents unbounded growth.
+
+**Class:** `BootstrapAmplifier`
+
+## Visualization
+
+TQCE includes a dark-themed visualization module:
+
+| Function | Description |
+|----------|-------------|
+| `plot_convergence()` | Fixed-point inconsistency over iterations, with optional PPGD loss overlay |
+| `plot_paradox_pressure_landscape()` | Bar chart of paradox pressure per node |
+| `plot_ctn_graph()` | Network graph with blue causal and red retrocausal edges |
+| `plot_tec_probabilities()` | Timeline probability distribution after interference |
+| `plot_amplification_trace()` | Amplification factor over loop iterations |
+| `animate_convergence()` | Animated convergence showing per-node traces |
+
+All functions are importable from `tqce.viz`.
+
+## Examples
+
+Three demo scripts are provided in `examples/`:
+
+- **`circular_constraints.py`** — Solve a circular dependency problem (A depends on C, B on A, C on B) using the full TQCE pipeline.
+- **`signal_amplification.py`** — Recover a weak signal buried below the noise floor using Bootstrap Amplification.
+- **`anomaly_detection.py`** — Detect time series anomalies by measuring paradox pressure when data points are inserted into causal loops.
+
+Run any example:
+```bash
+python examples/circular_constraints.py
+```
+
+See [docs/examples.md](docs/examples.md) for detailed walkthroughs.
+
+## Architecture
+
+```
+tqce/
+├── network/          # CausalNode, CausalTensorNetwork
+├── optimization/     # ChronoEntropicRegularizer, ParadoxPressureGradientDescent
+├── quantum/          # TemporalWavefunction
+├── amplification/    # BootstrapAmplifier
+├── engine/           # TQCEOrchestrator
+└── viz/              # Plotting and animation
+```
+
+## References
+
+- Deutsch, D. (1991). *Quantum mechanics near closed timelike lines.* Physical Review D, 44(10), 3197.
+- Novikov, I. D. (1989). *An analysis of the operation of a time machine.* Soviet Physics JETP, 68(3), 439.
+- Lloyd, S., Maccone, L., Garcia-Patron, R., Giovannetti, V., & Shikano, Y. (2011). *Quantum mechanics of time travel through post-selected teleportation.* Physical Review D, 84(2), 025007.
+
+## License
+
+MIT License. See [LICENSE](LICENSE) for details.

tqce-1.0.0/README.md

@@ -0,0 +1,128 @@
+# TQCE — Temporal Quantum Causal Engine
+
+**A novel computational paradigm based on causal loop mechanics.**
+
+Paradox resolution in closed timelike curves is computationally equivalent to optimization under self-referential constraint systems. TQCE exploits this equivalence to build a new class of algorithms that solve problems standard approaches cannot handle — circular dependencies, self-referential optimization, and causal reasoning with feedback loops.
+
+## Installation
+
+```bash
+git clone <repo-url>
+cd tqce
+pip install -e ".[dev]"
+```
+
+Requirements: Python 3.11+, numpy, networkx, scipy, matplotlib.
+
+## Quick Start
+
+```python
+import numpy as np
+from tqce import CausalNode, TQCEOrchestrator
+from tqce.viz import plot_convergence, plot_ctn_graph
+
+np.random.seed(42)
+
+# Build a causal loop: A -> B -> C with retrocausal C -> A
+engine = TQCEOrchestrator("My Problem")
+net = engine.build_network()
+
+net.add_node(CausalNode("A", time_coordinate=0.0, state_dim=4))
+net.add_node(CausalNode("B", time_coordinate=1.0, state_dim=4))
+net.add_node(CausalNode("C", time_coordinate=2.0, state_dim=4))
+
+net.add_causal_edge("A", "B", weight=0.8)
+net.add_causal_edge("B", "C", weight=0.6)
+net.add_retrocausal_edge("C", "A", weight=0.4)  # backward in time
+
+# Solve for a self-consistent timeline
+results = engine.solve(verbose=True)
+
+# Visualize
+plot_ctn_graph(net)
+plot_convergence(results["fixed_point"]["iteration_history"])
+```
+
+## Five Core Components
+
+### 1. Causal Tensor Networks (CTN)
+
+Standard tensor networks are directed acyclic graphs. CTNs extend this by adding retrocausal edges — connections pointing backward in time — creating Closed Causal Loops (CCLs). The network state is computed not by forward propagation but by fixed-point iteration: repeatedly updating all nodes until the global state converges to a self-consistent solution. This is the computational analog of finding a valid timeline in a system with closed timelike curves.
+
+**Class:** `CausalTensorNetwork`
+
+### 2. Paradox Pressure Gradient Descent (PPGD)
+
+PPGD is a gradient-based optimizer where the loss function is causal inconsistency itself. The "paradox pressure" at each node measures how far its current state is from what its causal parents demand. By treating this pressure as a differentiable loss surface, PPGD descends toward self-consistent basins using momentum and adaptive learning rates scaled by local paradox pressure.
+
+**Class:** `ParadoxPressureGradientDescent`
+
+### 3. Temporal Eigenstate Collapse (TEC)
+
+Multiple candidate timelines are superposed as a "temporal wavefunction" with complex amplitudes. Causal interference between timelines amplifies consistent resolutions (constructive interference) and cancels paradoxical ones (destructive interference). After several rounds of interference, the system collapses to the timeline with the highest probability — the most self-consistent solution.
+
+**Class:** `TemporalWavefunction`
+
+### 4. Chrono-Entropic Regularization (CER)
+
+Inspired by the second law of thermodynamics: entropy must be non-decreasing, even in causal loops. CER penalizes states where a past node has higher approximate entropy than its future retrocausal parents. This prevents information from growing unboundedly as it circulates through the loop, acting as a principled regularizer derived from physical constraints.
+
+**Class:** `ChronoEntropicRegularizer`
+
+### 5. Bootstrap Amplification (BA)
+
+In a bootstrap paradox, information exists with no origin. BA exploits this computationally: a weak signal is injected into a causal loop where it influences itself at each pass. With the right resonance conditions (spectral radius of the loop kernel below 1), the signal amplifies to a stable fixed point that is larger than the input. Chrono-entropic damping prevents unbounded growth.
+
+**Class:** `BootstrapAmplifier`
+
+## Visualization
+
+TQCE includes a dark-themed visualization module:
+
+| Function | Description |
+|----------|-------------|
+| `plot_convergence()` | Fixed-point inconsistency over iterations, with optional PPGD loss overlay |
+| `plot_paradox_pressure_landscape()` | Bar chart of paradox pressure per node |
+| `plot_ctn_graph()` | Network graph with blue causal and red retrocausal edges |
+| `plot_tec_probabilities()` | Timeline probability distribution after interference |
+| `plot_amplification_trace()` | Amplification factor over loop iterations |
+| `animate_convergence()` | Animated convergence showing per-node traces |
+
+All functions are importable from `tqce.viz`.
+
+## Examples
+
+Three demo scripts are provided in `examples/`:
+
+- **`circular_constraints.py`** — Solve a circular dependency problem (A depends on C, B on A, C on B) using the full TQCE pipeline.
+- **`signal_amplification.py`** — Recover a weak signal buried below the noise floor using Bootstrap Amplification.
+- **`anomaly_detection.py`** — Detect time series anomalies by measuring paradox pressure when data points are inserted into causal loops.
+
+Run any example:
+```bash
+python examples/circular_constraints.py
+```
+
+See [docs/examples.md](docs/examples.md) for detailed walkthroughs.
+
+## Architecture
+
+```
+tqce/
+├── network/          # CausalNode, CausalTensorNetwork
+├── optimization/     # ChronoEntropicRegularizer, ParadoxPressureGradientDescent
+├── quantum/          # TemporalWavefunction
+├── amplification/    # BootstrapAmplifier
+├── engine/           # TQCEOrchestrator
+└── viz/              # Plotting and animation
+```
+
+## References
+
+- Deutsch, D. (1991). *Quantum mechanics near closed timelike lines.* Physical Review D, 44(10), 3197.
+- Novikov, I. D. (1989). *An analysis of the operation of a time machine.* Soviet Physics JETP, 68(3), 439.
+- Lloyd, S., Maccone, L., Garcia-Patron, R., Giovannetti, V., & Shikano, Y. (2011). *Quantum mechanics of time travel through post-selected teleportation.* Physical Review D, 84(2), 025007.
+
+## License
+
+MIT License. See [LICENSE](LICENSE) for details.

tqce-1.0.0/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tqce"
+version = "1.0.0"
+description = "Temporal Quantum Causal Engine — A computational paradigm based on causal loop mechanics"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.11"
+authors = [
+    {name = "utachicodes"}
+]
+keywords = ["causal-inference", "temporal-computing", "optimization", "tensor-networks"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Scientific/Engineering :: Physics",
+]
+dependencies = [
+    "numpy>=1.24",
+    "networkx>=3.0",
+    "scipy>=1.10",
+    "matplotlib>=3.7",
+]
+
+[project.urls]
+Homepage = "https://github.com/utachicodes/tqce"
+Repository = "https://github.com/utachicodes/tqce"
+Documentation = "https://github.com/utachicodes/tqce/blob/main/docs/api.md"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-v --tb=short"
+
+[tool.setuptools.packages.find]
+include = ["tqce*"]

tqce-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tqce-1.0.0/tests/test_amplification.py

@@ -0,0 +1,59 @@
+"""Tests for Bootstrap Amplification."""
+
+import numpy as np
+import pytest
+
+from tqce.amplification.amplifier import BootstrapAmplifier
+
+
+class TestBootstrapAmplifier:
+    def test_amplify_returns_correct_shape(self):
+        amp = BootstrapAmplifier(signal_dim=8)
+        signal = np.random.randn(8) * 0.01
+        result, stats = amp.amplify(signal)
+        assert result.shape == (8,)
+
+    def test_amplification_factor_positive(self):
+        amp = BootstrapAmplifier(signal_dim=4, amplification_target=5.0)
+        signal = np.random.randn(4) * 0.1
+        _, stats = amp.amplify(signal)
+        assert stats["amplification_factor"] > 0
+
+    def test_amplification_near_target(self):
+        np.random.seed(42)
+        target = 10.0
+        amp = BootstrapAmplifier(
+            signal_dim=4, amplification_target=target, stability_coefficient=0.9
+        )
+        signal = np.ones(4) * 0.1
+        result, stats = amp.amplify(signal, max_iterations=500)
+        assert stats["amplification_factor"] > 1.0
+
+    def test_convergence(self):
+        np.random.seed(42)
+        amp = BootstrapAmplifier(signal_dim=4, amplification_target=5.0)
+        signal = np.ones(4) * 0.1
+        _, stats = amp.amplify(signal, max_iterations=500)
+        assert stats["converged"] or stats["iterations"] == 500
+
+    def test_stats_keys(self):
+        amp = BootstrapAmplifier(signal_dim=4)
+        _, stats = amp.amplify(np.ones(4) * 0.1)
+        expected = {
+            "amplification_factor", "iterations", "converged",
+            "amplification_history"
+        }
+        assert set(stats.keys()) == expected
+
+    def test_zero_signal_no_crash(self):
+        amp = BootstrapAmplifier(signal_dim=4)
+        result, stats = amp.amplify(np.zeros(4))
+        assert np.all(np.isfinite(result))
+
+    def test_learn_resonance(self):
+        np.random.seed(42)
+        amp = BootstrapAmplifier(signal_dim=4, amplification_target=5.0)
+        signals = np.random.randn(5, 4) * 0.1
+        amp.learn_resonance(signals, n_epochs=3)
+        eigvals = np.linalg.eigvals(amp.loop_kernel)
+        assert np.max(np.abs(eigvals)) <= amp.stability_coefficient + 0.01

tqce-1.0.0/tests/test_engine.py

@@ -0,0 +1,61 @@
+"""Tests for the TQCE Orchestrator."""
+
+import numpy as np
+import pytest
+
+from tqce.network.node import CausalNode
+from tqce.engine.orchestrator import TQCEOrchestrator
+
+
+class TestTQCEOrchestrator:
+    def _build_problem(self) -> TQCEOrchestrator:
+        np.random.seed(42)
+        engine = TQCEOrchestrator("Test Problem")
+        net = engine.build_network()
+        net.add_node(CausalNode("A", time_coordinate=0.0, state_dim=4))
+        net.add_node(CausalNode("B", time_coordinate=1.0, state_dim=4))
+        net.add_node(CausalNode("C", time_coordinate=2.0, state_dim=4))
+        net.add_causal_edge("A", "B", weight=0.8)
+        net.add_causal_edge("B", "C", weight=0.6)
+        net.add_retrocausal_edge("C", "A", weight=0.4)
+        return engine
+
+    def test_build_network_returns_ctn(self):
+        engine = TQCEOrchestrator()
+        net = engine.build_network()
+        from tqce.network.ctn import CausalTensorNetwork
+        assert isinstance(net, CausalTensorNetwork)
+
+    def test_solve_returns_result(self):
+        engine = self._build_problem()
+        result = engine.solve(n_candidate_timelines=5, verbose=False)
+        assert "fixed_point" in result
+        assert "summary" in result
+
+    def test_solve_with_tec(self):
+        engine = self._build_problem()
+        result = engine.solve(
+            use_tec=True, n_candidate_timelines=5, verbose=False
+        )
+        assert "tec" in result
+
+    def test_solve_with_ppgd(self):
+        engine = self._build_problem()
+        result = engine.solve(use_ppgd=True, verbose=False)
+        assert "ppgd" in result
+
+    def test_solve_without_tec_or_ppgd(self):
+        engine = self._build_problem()
+        result = engine.solve(use_tec=False, use_ppgd=False, verbose=False)
+        assert "tec" not in result
+        assert "ppgd" not in result
+
+    def test_summary_has_expected_keys(self):
+        engine = self._build_problem()
+        result = engine.solve(verbose=False)
+        summary = result["summary"]
+        assert summary["problem"] == "Test Problem"
+        assert summary["n_nodes"] == 3
+        assert summary["n_causal_edges"] == 2
+        assert summary["n_retrocausal_edges"] == 1
+        assert summary["has_closed_causal_loops"] is True

tqce-1.0.0/tests/test_network.py

@@ -0,0 +1,167 @@
+"""Tests for Causal Tensor Network components."""
+
+import numpy as np
+import pytest
+
+from tqce.network.node import CausalNode
+from tqce.network.ctn import CausalTensorNetwork
+
+
+class TestCausalNode:
+    def test_create_node_with_defaults(self):
+        node = CausalNode("A", time_coordinate=0.0, state_dim=4)
+        assert node.node_id == "A"
+        assert node.time_coordinate == 0.0
+        assert node.state_dim == 4
+        assert node.state.shape == (4,)
+        assert node.paradox_pressure == 0.0
+
+    def test_create_node_with_explicit_state(self):
+        state = np.array([1.0, 2.0, 3.0])
+        node = CausalNode("B", time_coordinate=1.0, state_dim=3, state=state)
+        np.testing.assert_array_equal(node.state, state)
+
+    def test_default_state_is_small_random(self):
+        node = CausalNode("C", time_coordinate=0.0, state_dim=100)
+        assert np.abs(node.state).max() < 1.0
+
+    def test_causal_parents_default_empty(self):
+        node = CausalNode("D", time_coordinate=0.0, state_dim=4)
+        assert node.causal_parents == []
+        assert node.retrocausal_parents == []
+
+    def test_node_with_custom_functions(self):
+        fn = lambda x: x * 2
+        node = CausalNode("E", time_coordinate=0.0, state_dim=4,
+                          forward_fn=fn, retro_fn=fn)
+        assert node.forward_fn is not None
+        assert node.retro_fn is not None
+
+
+class TestCausalTensorNetwork:
+    def _make_simple_network(self) -> CausalTensorNetwork:
+        """A -> B -> C with retrocausal C -> A."""
+        net = CausalTensorNetwork()
+        net.add_node(CausalNode("A", time_coordinate=0.0, state_dim=4))
+        net.add_node(CausalNode("B", time_coordinate=1.0, state_dim=4))
+        net.add_node(CausalNode("C", time_coordinate=2.0, state_dim=4))
+        net.add_causal_edge("A", "B", weight=0.8)
+        net.add_causal_edge("B", "C", weight=0.6)
+        net.add_retrocausal_edge("C", "A", weight=0.4)
+        return net
+
+    def test_add_nodes(self):
+        net = CausalTensorNetwork()
+        node = CausalNode("A", time_coordinate=0.0, state_dim=4)
+        net.add_node(node)
+        assert "A" in net.nodes
+        assert "A" in net.graph
+
+    def test_causal_edge_enforces_temporal_order(self):
+        net = CausalTensorNetwork()
+        net.add_node(CausalNode("A", time_coordinate=1.0, state_dim=4))
+        net.add_node(CausalNode("B", time_coordinate=0.0, state_dim=4))
+        with pytest.raises(ValueError, match="violates causality"):
+            net.add_causal_edge("A", "B")
+
+    def test_retrocausal_edge_enforces_backward_time(self):
+        net = CausalTensorNetwork()
+        net.add_node(CausalNode("A", time_coordinate=0.0, state_dim=4))
+        net.add_node(CausalNode("B", time_coordinate=1.0, state_dim=4))
+        with pytest.raises(ValueError, match="must go from future to past"):
+            net.add_retrocausal_edge("A", "B")
+
+    def test_causal_edge_registers_parent(self):
+        net = CausalTensorNetwork()
+        net.add_node(CausalNode("A", time_coordinate=0.0, state_dim=4))
+        net.add_node(CausalNode("B", time_coordinate=1.0, state_dim=4))
+        net.add_causal_edge("A", "B", weight=0.7)
+        assert ("A", 0.7) in net.nodes["B"].causal_parents
+
+    def test_retrocausal_edge_registers_parent(self):
+        net = self._make_simple_network()
+        assert ("C", 0.4) in net.nodes["A"].retrocausal_parents
+
+    def test_compute_node_state_no_parents(self):
+        net = CausalTensorNetwork()
+        node = CausalNode("X", time_coordinate=0.0, state_dim=4)
+        net.add_node(node)
+        result = net.compute_node_state("X")
+        np.testing.assert_array_equal(result, node.state)
+
+    def test_compute_node_state_with_parents(self):
+        net = CausalTensorNetwork()
+        a = CausalNode("A", time_coordinate=0.0, state_dim=4)
+        b = CausalNode("B", time_coordinate=1.0, state_dim=4)
+        a.state = np.ones(4)
+        net.add_node(a)
+        net.add_node(b)
+        net.add_causal_edge("A", "B", weight=1.0)
+        result = net.compute_node_state("B")
+        expected = np.tanh(np.ones(4))
+        np.testing.assert_allclose(result, expected, atol=1e-6)
+
+    def test_compute_node_state_deterministic(self):
+        """compute_node_state must produce the same result on repeated calls."""
+        net = self._make_simple_network()
+        r1 = net.compute_node_state("A")
+        r2 = net.compute_node_state("A")
+        np.testing.assert_array_equal(r1, r2)
+
+    def test_mixed_dimension_projection(self):
+        """Nodes with different state_dim should work via stored projections."""
+        net = CausalTensorNetwork()
+        net.add_node(CausalNode("A", time_coordinate=0.0, state_dim=3))
+        net.add_node(CausalNode("B", time_coordinate=1.0, state_dim=5))
+        net.add_causal_edge("A", "B", weight=1.0)
+        result = net.compute_node_state("B")
+        assert result.shape == (5,)
+
+
+class TestFixedPointSolver:
+    def test_simple_chain_converges(self):
+        """A -> B -> C (no loops) converges immediately."""
+        net = CausalTensorNetwork()
+        net.add_node(CausalNode("A", time_coordinate=0.0, state_dim=3))
+        net.add_node(CausalNode("B", time_coordinate=1.0, state_dim=3))
+        net.add_node(CausalNode("C", time_coordinate=2.0, state_dim=3))
+        net.add_causal_edge("A", "B")
+        net.add_causal_edge("B", "C")
+        result = net.run_temporal_fixed_point(verbose=False)
+        assert result["converged"]
+
+    def test_loop_converges(self):
+        """A -> B -> C -> A (retro) should find a self-consistent fixed point."""
+        np.random.seed(42)
+        net = CausalTensorNetwork()
+        net.add_node(CausalNode("A", time_coordinate=0.0, state_dim=4))
+        net.add_node(CausalNode("B", time_coordinate=1.0, state_dim=4))
+        net.add_node(CausalNode("C", time_coordinate=2.0, state_dim=4))
+        net.add_causal_edge("A", "B", weight=0.8)
+        net.add_causal_edge("B", "C", weight=0.6)
+        net.add_retrocausal_edge("C", "A", weight=0.4)
+        result = net.run_temporal_fixed_point(verbose=False)
+        assert result["converged"]
+        assert result["final_inconsistency"] < 1e-7
+
+    def test_iteration_history_decreasing(self):
+        """Inconsistency should generally decrease over iterations."""
+        np.random.seed(42)
+        net = CausalTensorNetwork()
+        net.add_node(CausalNode("A", time_coordinate=0.0, state_dim=4))
+        net.add_node(CausalNode("B", time_coordinate=1.0, state_dim=4))
+        net.add_retrocausal_edge("B", "A", weight=0.5)
+        net.add_causal_edge("A", "B", weight=0.5)
+        result = net.run_temporal_fixed_point(verbose=False)
+        history = result["iteration_history"]
+        assert history[-1] < history[0]
+
+    def test_result_keys(self):
+        net = CausalTensorNetwork()
+        net.add_node(CausalNode("A", time_coordinate=0.0, state_dim=2))
+        result = net.run_temporal_fixed_point(max_iterations=5, verbose=False)
+        expected_keys = {
+            "converged", "iterations", "final_inconsistency",
+            "node_states", "paradox_pressures", "iteration_history"
+        }
+        assert set(result.keys()) == expected_keys