medium-modulation 0.1.0__py3-none-any.whl

medium_modulation/__init__.py

@@ -0,0 +1,7 @@
+"""medium-modulation: Resonant medium between S∝A and S∝V."""
+
+__version__ = "0.1.0"
+
+from .core import coupling_factor, modulated_entropy, resonance_spectrum
+
+__all__ = ["coupling_factor", "modulated_entropy", "resonance_spectrum"]

medium_modulation/cli.py

@@ -0,0 +1,80 @@
+"""CLI mm – medium-modulation command-line interface."""
+
+import numpy as np
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from .core import coupling_factor, modulated_entropy, resonance_spectrum
+
+app = typer.Typer(
+    help="medium-modulation CLI – fractal entropy coupling between S∝A and S∝V"
+)
+console = Console()
+
+
+@app.command()
+def modulate(
+    depth: float = typer.Option(0.5, help="Modulation depth in [0, 1]"),
+    freq: float = typer.Option(1.0, help="Modulation frequency (rad/s)"),
+    steps: int = typer.Option(100, help="Number of time steps over [0, 10]"),
+    s_a: float = typer.Option(1.0, help="Action-governed entropy S_A"),
+    s_v: float = typer.Option(1.618, help="Volume-governed entropy S_V"),
+) -> None:
+    """Apply fractal modulation to the S_A/S_V entropy duality."""
+    t_range = np.linspace(0, 10, steps)
+    s_mod = [modulated_entropy(s_a, s_v, depth, freq, ti) for ti in t_range]
+    arr = np.array(s_mod)
+
+    table = Table(title="Modulation Results")
+    table.add_column("Metric", style="cyan")
+    table.add_column("Value", style="green")
+    table.add_row("Mean S_mod", f"{arr.mean():.6f}")
+    table.add_row("Min S_mod", f"{arr.min():.6f}")
+    table.add_row("Max S_mod", f"{arr.max():.6f}")
+    table.add_row("Std S_mod", f"{arr.std():.6f}")
+    table.add_row("depth", str(depth))
+    table.add_row("freq", str(freq))
+    table.add_row("steps", str(steps))
+
+    console.print(table)
+
+
+@app.command()
+def spectrum(
+    f_min: float = typer.Option(0.1, help="Minimum frequency"),
+    f_max: float = typer.Option(10.0, help="Maximum frequency"),
+    n: int = typer.Option(50, help="Number of frequency points"),
+    depth: float = typer.Option(0.5, help="Modulation depth in [0, 1]"),
+) -> None:
+    """Show the resonance spectrum over a frequency range."""
+    freqs = np.linspace(f_min, f_max, n)
+    spec = resonance_spectrum(freqs, depth)
+
+    table = Table(title="Resonance Spectrum")
+    table.add_column("Metric", style="cyan")
+    table.add_column("Value", style="green")
+    table.add_row("Peak amplitude", f"{spec.max():.6f}")
+    table.add_row("Min amplitude", f"{spec.min():.6f}")
+    table.add_row("Mean amplitude", f"{spec.mean():.6f}")
+    table.add_row("Peak frequency", f"{freqs[spec.argmax()]:.4f} rad/s")
+
+    console.print(table)
+
+
+@app.command()
+def couple(
+    a: float = typer.Option(1.0, help="Action amplitude A"),
+    v: float = typer.Option(1.618, help="Volume amplitude V"),
+    depth: float = typer.Option(0.5, help="Modulation depth in [0, 1]"),
+) -> None:
+    """Compute dynamic coupling strength between action and volume."""
+    kappa = coupling_factor(a, v, modulation_depth=depth)
+    console.print(
+        f"[bold cyan]Coupling factor k(A={a}, V={v}, depth={depth}):[/] "
+        f"[green]{kappa:.6f}[/]"
+    )
+
+
+if __name__ == "__main__":
+    app()

medium_modulation/core.py

@@ -0,0 +1,75 @@
+"""Fractal modulation operators and resonance coupling for medium-modulation."""
+
+import numpy as np
+import sympy as sp
+
+# Golden ratio – the natural coupling constant
+_PHI = 0.618033988749895
+
+t_sym, omega, phi_sym = sp.symbols("t omega phi", real=True, positive=True)
+depth_sym = sp.symbols("depth", positive=True)
+
+# Symbolic modulation operator M(t) = 1 + depth · sin(ωt + φ)
+M = 1 + depth_sym * sp.sin(omega * t_sym + phi_sym)
+
+
+def _duality_factor(S_A: float, S_V: float, alpha: float = _PHI) -> float:
+    """Weighted duality: α·S_A + (1-α)·S_V."""
+    return alpha * S_A + (1.0 - alpha) * S_V
+
+
+def modulated_entropy(
+    S_A: float,
+    S_V: float,
+    depth: float = 0.5,
+    freq: float = 1.0,
+    t: float = 0.0,
+) -> float:
+    """Fractal medium modulation: S_mod = α·(S_A·M) + (1-α)·S_V.
+
+    Parameters
+    ----------
+    S_A:   action-governed entropy
+    S_V:   volume-governed entropy
+    depth: modulation depth ∈ [0, 1]
+    freq:  modulation frequency (rad/s)
+    t:     time point
+
+    Returns
+    -------
+    Modulated composite entropy value.
+    """
+    modulation = 1.0 + depth * np.sin(freq * t)
+    return _duality_factor(S_A * modulation, S_V, alpha=_PHI)
+
+
+def resonance_spectrum(freqs: np.ndarray, depth: float = 0.5) -> np.ndarray:
+    """Resonance spectrum evaluated over a frequency array.
+
+    Parameters
+    ----------
+    freqs: 1-D array of frequencies
+    depth: modulation depth ∈ [0, 1]
+
+    Returns
+    -------
+    Array of resonance amplitudes.
+    """
+    freqs = np.asarray(freqs, dtype=float)
+    return 1.0 + depth * np.sin(2.0 * np.pi * freqs)
+
+
+def coupling_factor(A: float, V: float, modulation_depth: float = 0.5) -> float:
+    """Dynamic coupling strength between action and volume at t=0.
+
+    Parameters
+    ----------
+    A:                action amplitude
+    V:                volume amplitude
+    modulation_depth: depth of the modulation operator
+
+    Returns
+    -------
+    Scalar coupling strength.
+    """
+    return modulated_entropy(A, V, depth=modulation_depth, freq=1.0, t=0.0)

medium_modulation/entropy_table_bridge.py

@@ -0,0 +1,42 @@
+"""Bridge between medium-modulation and entropy-table domain registry."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import yaml
+
+
+class MediumModulationBridge:
+    """Stores modulation relations and exports them to domains.yaml format."""
+
+    DOMAIN = "medium-modulation"
+
+    def __init__(self) -> None:
+        self._relations: dict[str, float] = {}
+
+    def add_modulation(self, key: str, value: float) -> None:
+        """Register a named modulation value."""
+        self._relations[key] = float(value)
+
+    def export(self, filepath: Path | str = "domains.yaml") -> Path:
+        """Serialise relations to a YAML file and return the path."""
+        filepath = Path(filepath)
+        data: dict = {}
+
+        if filepath.exists():
+            with filepath.open() as fh:
+                data = yaml.safe_load(fh) or {}
+
+        data.setdefault("domains", {}).setdefault(self.DOMAIN, {}).update(
+            self._relations
+        )
+
+        with filepath.open("w") as fh:
+            yaml.safe_dump(data, fh, default_flow_style=False, allow_unicode=True)
+
+        return filepath
+
+    def relations(self) -> dict[str, float]:
+        """Return a copy of the currently registered relations."""
+        return dict(self._relations)

medium_modulation-0.1.0.dist-info/METADATA

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: medium-modulation
+Version: 0.1.0
+Summary: Resonant medium between S∝A and S∝V – fractal modulation operators, resonance spectra and tunable interference for controlled information propagation.
+Project-URL: Repository, https://github.com/GenesisAeon/medium-modulation
+Project-URL: Issues, https://github.com/GenesisAeon/medium-modulation/issues
+Author-email: GenesisAeon Team <team@genesisaeon.org>
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: entropy-governance>=0.1.0
+Requires-Dist: entropy-table>=1.0.1
+Requires-Dist: implosive-genesis>=0.4.0
+Requires-Dist: numpy>=2.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: sympy>=1.13.0
+Requires-Dist: typer>=0.15.0
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.9; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.5.0; extra == 'docs'
+Requires-Dist: mkdocs>=1.6.0; extra == 'docs'
+Description-Content-Type: text/markdown
+
+# medium-modulation
+
+**The resonant medium between action and expanse.**
+
+[![CI](https://github.com/GenesisAeon/medium-modulation/actions/workflows/ci.yml/badge.svg)](https://github.com/GenesisAeon/medium-modulation/actions/workflows/ci.yml)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue)](https://www.python.org)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
+
+medium-modulation serves as the dynamic coupling layer that modulates the fundamental duality of the GenesisAeon framework: action-governed entropy production (S ∝ A) versus volume-governed informational expansion (S ∝ V).
+
+Through fractal modulation operators, resonance spectra, and tunable interference fields, it turns raw tension into coherent emergence.
+
+---
+
+## Install
+
+```bash
+pip install medium-modulation
+```
+
+## Usage
+
+```bash
+mm modulate --depth 0.7 --freq 2.3
+mm spectrum
+```
+
+## API
+
+```python
+from medium_modulation.core import modulated_entropy, resonance_spectrum, coupling_factor
+import numpy as np
+
+# Fractal medium modulation
+S_mod = modulated_entropy(S_A=1.0, S_V=1.618, depth=0.5, freq=1.0, t=0.0)
+
+# Resonance spectrum over frequency range
+freqs = np.linspace(0.1, 10, 50)
+spec = resonance_spectrum(freqs, depth=0.5)
+
+# Dynamic coupling strength
+kappa = coupling_factor(A=1.0, V=1.618, modulation_depth=0.5)
+```
+
+## Architecture
+
+```
+medium-modulation/
+├── src/medium_modulation/
+│   ├── core.py                  # Modulation operator + fractal coupling
+│   ├── cli.py                   # CLI mm
+│   └── entropy_table_bridge.py  # entropy-table integration
+├── tests/
+│   ├── test_core.py
+│   └── test_cli.py
+└── domains.yaml                 # Domain configuration
+```
+
+## Integrations
+
+| Package | Role |
+|---------|------|
+| `entropy-governance` | Duality factor α·S_A + (1-α)·S_V |
+| `entropy-table` | Domain relation registry |
+| `implosive-genesis` | Fractal emergence substrate |
+
+**DOI** (after Zenodo release): 10.5281/zenodo.XXXXXXX
+**PyPI**: https://pypi.org/project/medium-modulation/
+
+---
+
+Built with [SymPy](https://www.sympy.org/) · [NumPy](https://numpy.org/) · [Typer](https://typer.tiangolo.com/) · [Rich](https://rich.readthedocs.io/)

medium_modulation-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+medium_modulation/__init__.py,sha256=p7yFwOlArb1OxR2HT70F_x_hIlfKzuDbtWGXcs7ChZY,244
+medium_modulation/cli.py,sha256=5QH7zP7G-R6im_ZhhK64QI4A0CmRcioDUINMbUKiDB8,2944
+medium_modulation/core.py,sha256=2jhaRe6ha4XCHwChzFJjm-4FLhL9Kz91zTpOP6llAeI,2137
+medium_modulation/entropy_table_bridge.py,sha256=ew6yXsQUQnL4EVcgRNZwgSAB44y8IA7HAuXQKSbM0AQ,1301
+medium_modulation-0.1.0.dist-info/METADATA,sha256=m2pjtlDN9uXIxJ7VsakegWziSKEpSj5om5E9J4fQ1Uo,3296
+medium_modulation-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+medium_modulation-0.1.0.dist-info/entry_points.txt,sha256=qu6E4pMJdLgXkgtEY9h_gZLEsW8qpxgFT2OwtT9XO_8,49
+medium_modulation-0.1.0.dist-info/licenses/LICENSE,sha256=wSqMUOfr3YalZyMoR93_W327v9D9Z0BeOg5-DFn4g1g,1090
+medium_modulation-0.1.0.dist-info/RECORD,,

medium_modulation-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

medium_modulation-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mm = medium_modulation.cli:app

medium_modulation-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 JohannRömer
+
+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.