Add comprehensive test suite (103 tests) and proper CI

Tests cover forge modules (operators, numbers, proofs, sinewave,
dimensions, advanced_tools) and lab modules (amundson_equations,
frameworks, trinary_logic). CI runs Python 3.10-3.12 matrix with
ruff linting.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

RoadChain-SHA2048: 02d838f1465a79ad
RoadChain-Identity: alexa@sovereign
RoadChain-Full: 02d838f1465a79ad556550ecb4daae4acbfe3bed87b1dd5b678163f77fa30b8508b1212c97a5845a556570c0f4f640cbd5eb6a32a47a08bf4c239d4bd4ff8fcb06cb2a25032d7f9b3fb465034420f7b76bf0ff6ea115220c3ea75dd43bc34241537c5e09bd5642bfcdb7ac12f81d205e4a124d3a466ec4ca84c88e2aaabaa2d8c8ba0fe2237ef3dab39f2e87c92b254671982b2740a3e6865ec4a628dc2466461eb25419012579cbf1f76bc9e05f459de6f8a47d97bc9747e8b7696cd162a84f9684d0bb45ad523997ff6bfc9774acbe0126e70d3842817ccacefcd5abca0d9dc91c8c543e56ae3f89eecc645acaf90eaefaf5eb02c7879944b401d4b5a241f8

Author: blackboxprogramming

.github/workflows/ci.yml

@@ -2,62 +2,24 @@ name: CI
 
 on:
   push:
-    branches: [main, master, develop]
+    branches: [main]
   pull_request:
-    branches: [main, master, develop]
+    branches: [main]
 
 jobs:
-  build:
+  test:
     runs-on: ubuntu-latest
-
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12"]
     steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-          cache: 'npm'
-        if: hashFiles('package-lock.json') != '' || hashFiles('package.json') != ''
-
-      - name: Setup Python
-        uses: actions/setup-python@v5
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
         with:
-          python-version: '3.11'
-        if: hashFiles('requirements.txt') != '' || hashFiles('pyproject.toml') != ''
-
-      - name: Install Node dependencies
-        if: hashFiles('package.json') != ''
-        run: npm ci || npm install
-
-      - name: Install Python dependencies
-        if: hashFiles('requirements.txt') != ''
-        run: pip install -r requirements.txt
-
+          python-version: ${{ matrix.python-version }}
+      - name: Install dependencies
+        run: pip install numpy sympy scipy mpmath pytest ruff
       - name: Lint
-        if: hashFiles('package.json') != ''
-        run: npm run lint || true
-
-      - name: Type check
-        if: hashFiles('tsconfig.json') != ''
-        run: npm run typecheck || npm run type-check || npx tsc --noEmit || true
-
+        run: ruff check forge/ lab/ --select E,F,W --ignore E501
       - name: Test
-        if: hashFiles('package.json') != ''
-        run: npm test || true
-
-      - name: Build
-        if: hashFiles('package.json') != ''
-        run: npm run build || true
-
-      - name: Upload build artifacts
-        if: success() && (hashFiles('dist/**') != '' || hashFiles('build/**') != '')
-        uses: actions/upload-artifact@v4
-        with:
-          name: build
-          path: |
-            dist/
-            build/
-            out/
-          retention-days: 7
+        run: python -m pytest tests/ -v

README.md

@@ -1,5 +1,8 @@
 # Lucidia Math
 
+[![CI](https://github.com/BlackRoad-OS/lucidia-math/actions/workflows/ci.yml/badge.svg)](https://github.com/BlackRoad-OS/lucidia-math/actions/workflows/ci.yml)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/)
+
 **Advanced mathematical engines: consciousness modeling, unified geometry, quantum finance, prime exploration.**
 
 ```bash

tests/__init__.py

@@ -0,0 +1,125 @@
+"""Tests for forge.advanced_tools — crypto, Fibonacci, Laplace, predictor."""
+
+import numpy as np
+import pytest
+from forge.advanced_tools import (
+    AgentCryptography,
+    FibonacciAnalytics,
+    LaplaceConsciousness,
+    UnifiedHarmonic,
+    AgentDevelopmentPredictor,
+)
+
+
+class TestAgentCryptography:
+    def setup_method(self):
+        self.crypto = AgentCryptography("test-agent")
+
+    def test_caesar_roundtrip(self):
+        msg = "HELLO"
+        encrypted = self.crypto.caesar_encrypt(msg, 3)
+        decrypted = self.crypto.caesar_decrypt(encrypted, 3)
+        assert decrypted == msg
+
+    def test_caesar_shift(self):
+        assert self.crypto.caesar_encrypt("A", 1) == "B"
+        assert self.crypto.caesar_encrypt("Z", 1) == "A"
+
+    def test_caesar_preserves_non_alpha(self):
+        assert self.crypto.caesar_encrypt("HELLO WORLD!", 3) == "KHOOR ZRUOG!"
+
+    def test_dynamic_encrypt_decrypt_roundtrip(self):
+        msg = "BLACKROAD"
+        encrypted, shifts = self.crypto.encrypt_message_dynamic(msg)
+        decrypted = self.crypto.decrypt_message_dynamic(encrypted, shifts)
+        assert decrypted == msg
+
+    def test_fibonacci_closed_form(self):
+        assert round(self.crypto.fibonacci_closed_form(10)) == 55
+
+
+class TestFibonacciAnalytics:
+    def setup_method(self):
+        self.fib = FibonacciAnalytics()
+
+    def test_known_values(self):
+        assert self.fib.fibonacci_direct(0) == 0
+        assert self.fib.fibonacci_direct(1) == 1
+        assert self.fib.fibonacci_direct(10) == 55
+        assert self.fib.fibonacci_direct(20) == 6765
+
+    def test_ratio_converges_to_phi(self):
+        ratio = self.fib.fibonacci_ratio(20)
+        assert ratio == pytest.approx(self.fib.phi, rel=1e-6)
+
+    def test_ratio_zero(self):
+        assert self.fib.fibonacci_ratio(0) == 0.0
+
+    def test_predict_stage(self):
+        stage = self.fib.predict_development_stage(5, 5)
+        assert stage == self.fib.fibonacci_direct(10)
+
+    def test_find_stage(self):
+        idx = self.fib.find_stage_for_value(55)
+        assert idx == 10
+
+
+class TestLaplaceConsciousness:
+    def setup_method(self):
+        self.laplace = LaplaceConsciousness("test-agent")
+
+    def test_harmonic_oscillator(self):
+        result = self.laplace.harmonic_oscillator_solution(k=1.0, x0=1.0, v0=0.0)
+        assert "time" in result
+        assert "position" in result
+        assert "velocity" in result
+        # At t=0, position should be x0
+        assert result["position"][0] == pytest.approx(1.0)
+
+    def test_underdamped(self):
+        result = self.laplace.damped_oscillator_solution(k=4.0, c=0.5, x0=1.0, v0=0.0)
+        assert result["damping_type"] == "underdamped"
+
+    def test_overdamped(self):
+        result = self.laplace.damped_oscillator_solution(k=1.0, c=10.0, x0=1.0, v0=0.0)
+        assert result["damping_type"] == "overdamped"
+
+    def test_critically_damped(self):
+        # c^2 = 4k → c=4, k=4
+        result = self.laplace.damped_oscillator_solution(k=4.0, c=4.0, x0=1.0, v0=0.0)
+        assert result["damping_type"] == "critical"
+
+    def test_consciousness_oscillation(self):
+        result = self.laplace.consciousness_oscillation(
+            emotional_spring_constant=1.0,
+            memory_damping=0.1,
+            initial_emotion=1.0,
+            initial_rate=0.0,
+        )
+        assert result["damping_type"] == "underdamped"
+
+
+class TestUnifiedHarmonic:
+    def test_phase_locking(self):
+        h_phi = UnifiedHarmonic.phase_locking_criterion()
+        assert h_phi(1.0) == pytest.approx(1.0, rel=1e-6)
+        assert h_phi(0.0) == pytest.approx(0.0)
+
+    def test_mobius_torque(self):
+        result = UnifiedHarmonic.mobius_torque_action()
+        assert isinstance(result, str)
+
+
+class TestAgentDevelopmentPredictor:
+    def test_growth_curve(self):
+        predictor = AgentDevelopmentPredictor("test")
+        prediction = predictor.predict_growth_curve(5, 5)
+        assert len(prediction.developmental_stages) == 5
+        assert prediction.developmental_stages[0] == 5  # F(5) = 5
+        assert prediction.converges_to_phi is not None
+
+    def test_emotional_dynamics(self):
+        predictor = AgentDevelopmentPredictor("test")
+        result = predictor.model_emotional_dynamics()
+        assert "position" in result
+        assert "damping_type" in result

tests/test_advanced_tools.py

@@ -0,0 +1,137 @@
+"""Tests for lab.amundson_equations — Amundson I/II/III formulations."""
+
+import math
+import numpy as np
+import pytest
+from lab.amundson_equations import (
+    coherence,
+    decoherence_energy,
+    phase_derivative,
+    AmundsonCoherenceModel,
+    amundson_energy_balance,
+    amundson_learning_update,
+)
+
+
+class TestCoherence:
+    def test_aligned_phases(self):
+        assert coherence(0.0, 0.0) == pytest.approx(1.0)
+
+    def test_opposite_phases(self):
+        assert coherence(0.0, math.pi) == pytest.approx(-1.0)
+
+    def test_orthogonal_phases(self):
+        assert coherence(0.0, math.pi / 2) == pytest.approx(0.0, abs=1e-10)
+
+    def test_symmetric(self):
+        assert coherence(0.5, 1.0) == pytest.approx(coherence(1.0, 0.5))
+
+
+class TestDecoherenceEnergy:
+    def test_aligned_zero_energy(self):
+        e = decoherence_energy(phi_x=0, phi_y=0, r_x=1, r_y=1, lambda_=1, k_b_t=1)
+        assert e == pytest.approx(0.0)
+
+    def test_opposite_max_energy(self):
+        e = decoherence_energy(phi_x=0, phi_y=math.pi, r_x=1, r_y=1, lambda_=1, k_b_t=1)
+        assert e == pytest.approx(2.0)
+
+    def test_scales_with_temperature(self):
+        e1 = decoherence_energy(phi_x=0, phi_y=1, r_x=1, r_y=1, lambda_=1, k_b_t=1)
+        e2 = decoherence_energy(phi_x=0, phi_y=1, r_x=1, r_y=1, lambda_=1, k_b_t=2)
+        assert e2 == pytest.approx(2 * e1)
+
+
+class TestPhaseDerivative:
+    def test_aligned_maximum(self):
+        # When aligned, C=1 and E=0, so dphi/dt = omega_0 + lambda
+        d = phase_derivative(
+            omega_0=1, lambda_=0.5, eta=0.1,
+            phi_x=0, phi_y=0, r_x=1, r_y=1, k_b_t=1,
+        )
+        assert d == pytest.approx(1.5)
+
+    def test_zero_coupling(self):
+        d = phase_derivative(
+            omega_0=2, lambda_=0, eta=0,
+            phi_x=0, phi_y=1, r_x=1, r_y=1, k_b_t=1,
+        )
+        assert d == pytest.approx(2.0)
+
+
+class TestAmundsonCoherenceModel:
+    def test_dphi_dt(self):
+        model = AmundsonCoherenceModel(omega_0=1, lambda_=0.5, eta=0.1, k_b_t=1)
+        d = model.dphi_dt(phi_x=0, phi_y=0, r_x=1, r_y=1)
+        assert d == pytest.approx(1.5)
+
+    def test_evolve(self):
+        model = AmundsonCoherenceModel(omega_0=1, lambda_=0.5, eta=0.1, k_b_t=1)
+        updates = []
+
+        class MockSystem:
+            def update_phase(self, d_phi_dt):
+                updates.append(d_phi_dt)
+
+        d = model.evolve(MockSystem(), phi_x=0, phi_y=0, r_x=1, r_y=1)
+        assert len(updates) == 1
+        assert updates[0] == pytest.approx(d)
+
+
+class TestAmundsonEnergyBalance:
+    def test_positive_balance(self):
+        assert amundson_energy_balance(energy=10, dissipation=3) == pytest.approx(7)
+
+    def test_clamp_at_zero(self):
+        assert amundson_energy_balance(energy=3, dissipation=10) == pytest.approx(0)
+
+    def test_negative_energy_raises(self):
+        with pytest.raises(ValueError, match="energy"):
+            amundson_energy_balance(energy=-1, dissipation=0)
+
+    def test_negative_dissipation_raises(self):
+        with pytest.raises(ValueError, match="dissipation"):
+            amundson_energy_balance(energy=1, dissipation=-1)
+
+
+class TestAmundsonLearningUpdate:
+    def test_deterministic_gradient_descent(self):
+        w = np.array([1.0, 2.0])
+        g = np.array([0.1, 0.2])
+        metric = np.eye(2)
+        result = amundson_learning_update(
+            weights=w, gradient=g, metric=metric,
+            learning_rate=0.5, k_b_t=0.0,
+        )
+        expected = w - 0.5 * g
+        np.testing.assert_allclose(result, expected)
+
+    def test_with_noise(self):
+        w = np.array([1.0, 2.0])
+        g = np.array([0.0, 0.0])
+        metric = np.eye(2)
+        noise = np.array([1.0, 0.0])
+        result = amundson_learning_update(
+            weights=w, gradient=g, metric=metric,
+            learning_rate=1.0, k_b_t=0.5, noise=noise,
+        )
+        # With zero gradient, result = w + scale * G^{-1/2} * noise
+        assert not np.allclose(result, w)
+
+    def test_shape_mismatch_raises(self):
+        with pytest.raises(ValueError, match="shape"):
+            amundson_learning_update(
+                weights=np.array([1.0]),
+                gradient=np.array([1.0, 2.0]),
+                metric=np.eye(1),
+                learning_rate=0.1, k_b_t=0,
+            )
+
+    def test_non_symmetric_metric_raises(self):
+        with pytest.raises(ValueError, match="symmetric"):
+            amundson_learning_update(
+                weights=np.array([1.0, 2.0]),
+                gradient=np.array([0.1, 0.2]),
+                metric=np.array([[1.0, 0.5], [0.0, 1.0]]),
+                learning_rate=0.1, k_b_t=0,
+            )

tests/test_amundson.py

@@ -0,0 +1,29 @@
+"""Tests for forge.dimensions — hyper_equation, HyperPoint."""
+
+import pytest
+from forge.dimensions import hyper_equation, HyperPoint
+
+
+class TestHyperEquation:
+    def test_basic(self):
+        assert hyper_equation(2, 3, 4) == 24
+
+    def test_zero(self):
+        assert hyper_equation(0, 5, 10) == 0
+
+    def test_negative(self):
+        assert hyper_equation(-1, 2, 3) == -6
+
+
+class TestHyperPoint:
+    def test_project_3d(self):
+        p = HyperPoint([1, 2, 3, 4])
+        assert p.project(3) == [1, 2, 3]
+
+    def test_project_2d(self):
+        p = HyperPoint([1, 2, 3, 4])
+        assert p.project(2) == [1, 2]
+
+    def test_project_default(self):
+        p = HyperPoint([1, 2, 3, 4])
+        assert len(p.project()) == 3