kernel-experience-tools 0.1.0__tar.gz

kernel_experience_tools-0.1.0/LICENSE

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

kernel_experience_tools-0.1.0/MANIFEST.in

@@ -0,0 +1,5 @@
+include README.md
+include LICENSE
+include requirements.txt
+include pyproject.toml
+recursive-include src *.py

kernel_experience_tools-0.1.0/PKG-INFO

@@ -0,0 +1,262 @@
+Metadata-Version: 2.4
+Name: kernel-experience-tools
+Version: 0.1.0
+Summary: Library for projecting memory kernels to experience functions
+Home-page: https://github.com/BRUTALLOLOL/kernel-experience-tools
+Author: Artem Vozmishchev
+Author-email: Artem Vozmishchev <your.email@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/BRUTALLOLOL/kernel-experience-tools
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy>=1.6.0
+Requires-Dist: matplotlib>=3.3.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Kernel-Experience Tools 🧠 → ⏳
+
+**A Python library that turns memory kernels into experience functions.**
+
+---
+
+## 📌 What is it?
+
+Every memory kernel K(t) hides a story.
+
+This library finds it.
+
+Given the Volterra relaxation equation
+
+x(t) = x₀ - ∫₀ᵗ K(t-τ) x(τ) dτ
+
+we compute the unique experience function n(t) such that
+
+x(t) = x₀ · λⁿ⁽ᵗ⁾
+
+One kernel. One curve. One number.
+
+---
+
+## 🚀 Quick start
+
+```python
+from kernel_experience import Kernel, project_kernel_to_n
+
+# Pick a kernel
+K = Kernel.tempered_power_law(alpha=0.6, beta=0.3)
+
+# Get its experience function
+t, x, n = project_kernel_to_n(K, t_max=10)
+
+print(f"Memory score: {n[-1]:.2f}")
+# Memory score: 3.44
+```
+
+---
+
+## 📦 Installation
+
+```bash
+pip install kernel-experience-tools
+```
+
+---
+
+## 📘 API Reference
+
+### Kernel
+
+Container for your memory kernel.
+
+**Parameters**
+
+- `func`: callable — Kernel function K(t)
+- `name`: str, optional — Kernel name (default: "CustomKernel")
+- `params`: dict, optional — Kernel parameters
+
+**Factory methods**
+
+```python
+# Exponential: γ·e^{-γt}
+K = Kernel.exponential(gamma=1.0)
+
+# Power law: γ·t^{α-1}/Γ(α)
+K = Kernel.power_law(alpha=0.7, gamma=1.0)
+
+# Mittag-Leffler: t^{α-1}E_{α,α}(-t^α)
+K = Kernel.mittag_leffler(alpha=0.7)
+
+# Tempered power law: γ·t^{α-1}e^{-βt}/Γ(α)
+K = Kernel.tempered_power_law(alpha=0.6, beta=0.3, gamma=1.0)
+```
+
+**Custom kernel**
+
+```python
+def my_kernel(t):
+    return np.exp(-t) * np.cos(t)
+
+K = Kernel(my_kernel, name="Oscillatory", params={"freq": 1.0})
+```
+
+---
+
+### project_kernel_to_n
+
+Main projection: K(t) → n(t).
+
+**Parameters**
+
+| Parameter | Type | Default | Description |
+|----------|------|---------|-------------|
+| `kernel` | `Kernel` | — | Memory kernel |
+| `lambda_param` | `float` | 0.8 | Base λ in (0,1) |
+| `t_max` | `float` | 10.0 | Maximum time |
+| `n_points` | `int` | 1000 | Number of time points |
+| `x0` | `float` | 1.0 | Initial condition |
+| `return_complex` | `bool` | False | Return complex n(t) for oscillatory kernels |
+
+**Returns**
+
+| Return | Type | Description |
+|--------|------|-------------|
+| `t` | `ndarray` | Time grid |
+| `x` | `ndarray` | Solution x(t) |
+| `n` | `ndarray` | Experience function n(t) |
+
+**Examples**
+
+```python
+# Basic usage
+t, x, n = project_kernel_to_n(K, t_max=20, n_points=2000)
+
+# Custom lambda
+t, x, n = project_kernel_to_n(K, lambda_param=0.5)
+
+# Oscillatory kernel — get complex n(t)
+K_osc = Kernel(lambda t: np.exp(-0.1*t)*np.sin(t), name="Oscillatory")
+t, x, n_complex = project_kernel_to_n(K_osc, return_complex=True)
+
+# Extract real and imaginary parts
+n_real = n_complex.real
+n_imag = n_complex.imag
+```
+
+---
+
+### solve_volterra
+
+Numerical solver for Volterra integral equation.
+
+**Parameters**
+
+| Parameter | Type | Default | Description |
+|----------|------|---------|-------------|
+| `kernel` | `Kernel` | — | Memory kernel |
+| `t_max` | `float` | 10.0 | Maximum time |
+| `n_points` | `int` | 1000 | Number of time points |
+| `x0` | `float` | 1.0 | Initial condition |
+
+**Returns**
+
+| Return | Type | Description |
+|--------|------|-------------|
+| `t` | `ndarray` | Time grid |
+| `x` | `ndarray` | Solution x(t) |
+
+**Example**
+
+```python
+t, x = solve_volterra(K, t_max=5, n_points=500)
+```
+
+---
+
+### compute_accuracy
+
+Compare original and reconstructed solutions.
+
+**Parameters**
+
+| Parameter | Type | Description |
+|----------|------|-------------|
+| `original_x` | `ndarray` | Original solution x(t) |
+| `reconstructed_x` | `ndarray` | Reconstructed solution x₀·λⁿ⁽ᵗ⁾ |
+
+**Returns**
+
+| Return | Type | Description |
+|--------|------|-------------|
+| `dict` | `dict` | Accuracy metrics |
+
+**Metrics**
+
+- `mean_error`: float — Mean relative error
+- `max_error`: float — Maximum relative error
+- `accuracy`: float — 1 - mean_error
+- `rmse`: float — Root mean square error
+
+**Example**
+
+```python
+# Get solution and n(t)
+t, x, n = project_kernel_to_n(K)
+
+# Reconstruct from n(t)
+x_rec = 1.0 * (0.8 ** n)
+
+# Check accuracy
+metrics = compute_accuracy(x, x_rec)
+print(f"Accuracy: {metrics['accuracy']:.2%}")
+print(f"Mean error: {metrics['mean_error']:.2e}")
+# Accuracy: 100.00%
+# Mean error: 1.23e-12
+```
+
+---
+
+## 🧠 What problem does it solve?
+
+Traditional relaxation models assume exponential decay.
+
+Real systems — glasses, polymers, biological tissues — show memory effects. Power laws. Stretched exponentials. Oscillations.
+
+This library gives you one language for all of them:
+
+K(t) → n(t)
+
+Once you have n(t), the relaxation curve is simply x₀ · λⁿ⁽ᵗ⁾.
+
+No fractional calculus. No special functions. No black boxes.
+
+Just your kernel. One function call. One curve.
+
+---
+
+## 📄 Citation
+
+```bibtex
+@software{vozmishchev2026kernel,
+  author = {Vozmishchev, Artem},
+  title = {Kernel-Experience Tools: Projecting Memory Kernels to Experience Functions},
+  year = {2026},
+  doi = {10.5281/zenodo.18239294},
+  url = {https://zenodo.org/records/18239294}
+}
+```
+
+---
+
+## 📜 License
+
+MIT License
+
+---
+
+**Now go find what your kernel remembers.**
+

kernel_experience_tools-0.1.0/README.md

@@ -0,0 +1,242 @@
+# Kernel-Experience Tools 🧠 → ⏳
+
+**A Python library that turns memory kernels into experience functions.**
+
+---
+
+## 📌 What is it?
+
+Every memory kernel K(t) hides a story.
+
+This library finds it.
+
+Given the Volterra relaxation equation
+
+x(t) = x₀ - ∫₀ᵗ K(t-τ) x(τ) dτ
+
+we compute the unique experience function n(t) such that
+
+x(t) = x₀ · λⁿ⁽ᵗ⁾
+
+One kernel. One curve. One number.
+
+---
+
+## 🚀 Quick start
+
+```python
+from kernel_experience import Kernel, project_kernel_to_n
+
+# Pick a kernel
+K = Kernel.tempered_power_law(alpha=0.6, beta=0.3)
+
+# Get its experience function
+t, x, n = project_kernel_to_n(K, t_max=10)
+
+print(f"Memory score: {n[-1]:.2f}")
+# Memory score: 3.44
+```
+
+---
+
+## 📦 Installation
+
+```bash
+pip install kernel-experience-tools
+```
+
+---
+
+## 📘 API Reference
+
+### Kernel
+
+Container for your memory kernel.
+
+**Parameters**
+
+- `func`: callable — Kernel function K(t)
+- `name`: str, optional — Kernel name (default: "CustomKernel")
+- `params`: dict, optional — Kernel parameters
+
+**Factory methods**
+
+```python
+# Exponential: γ·e^{-γt}
+K = Kernel.exponential(gamma=1.0)
+
+# Power law: γ·t^{α-1}/Γ(α)
+K = Kernel.power_law(alpha=0.7, gamma=1.0)
+
+# Mittag-Leffler: t^{α-1}E_{α,α}(-t^α)
+K = Kernel.mittag_leffler(alpha=0.7)
+
+# Tempered power law: γ·t^{α-1}e^{-βt}/Γ(α)
+K = Kernel.tempered_power_law(alpha=0.6, beta=0.3, gamma=1.0)
+```
+
+**Custom kernel**
+
+```python
+def my_kernel(t):
+    return np.exp(-t) * np.cos(t)
+
+K = Kernel(my_kernel, name="Oscillatory", params={"freq": 1.0})
+```
+
+---
+
+### project_kernel_to_n
+
+Main projection: K(t) → n(t).
+
+**Parameters**
+
+| Parameter | Type | Default | Description |
+|----------|------|---------|-------------|
+| `kernel` | `Kernel` | — | Memory kernel |
+| `lambda_param` | `float` | 0.8 | Base λ in (0,1) |
+| `t_max` | `float` | 10.0 | Maximum time |
+| `n_points` | `int` | 1000 | Number of time points |
+| `x0` | `float` | 1.0 | Initial condition |
+| `return_complex` | `bool` | False | Return complex n(t) for oscillatory kernels |
+
+**Returns**
+
+| Return | Type | Description |
+|--------|------|-------------|
+| `t` | `ndarray` | Time grid |
+| `x` | `ndarray` | Solution x(t) |
+| `n` | `ndarray` | Experience function n(t) |
+
+**Examples**
+
+```python
+# Basic usage
+t, x, n = project_kernel_to_n(K, t_max=20, n_points=2000)
+
+# Custom lambda
+t, x, n = project_kernel_to_n(K, lambda_param=0.5)
+
+# Oscillatory kernel — get complex n(t)
+K_osc = Kernel(lambda t: np.exp(-0.1*t)*np.sin(t), name="Oscillatory")
+t, x, n_complex = project_kernel_to_n(K_osc, return_complex=True)
+
+# Extract real and imaginary parts
+n_real = n_complex.real
+n_imag = n_complex.imag
+```
+
+---
+
+### solve_volterra
+
+Numerical solver for Volterra integral equation.
+
+**Parameters**
+
+| Parameter | Type | Default | Description |
+|----------|------|---------|-------------|
+| `kernel` | `Kernel` | — | Memory kernel |
+| `t_max` | `float` | 10.0 | Maximum time |
+| `n_points` | `int` | 1000 | Number of time points |
+| `x0` | `float` | 1.0 | Initial condition |
+
+**Returns**
+
+| Return | Type | Description |
+|--------|------|-------------|
+| `t` | `ndarray` | Time grid |
+| `x` | `ndarray` | Solution x(t) |
+
+**Example**
+
+```python
+t, x = solve_volterra(K, t_max=5, n_points=500)
+```
+
+---
+
+### compute_accuracy
+
+Compare original and reconstructed solutions.
+
+**Parameters**
+
+| Parameter | Type | Description |
+|----------|------|-------------|
+| `original_x` | `ndarray` | Original solution x(t) |
+| `reconstructed_x` | `ndarray` | Reconstructed solution x₀·λⁿ⁽ᵗ⁾ |
+
+**Returns**
+
+| Return | Type | Description |
+|--------|------|-------------|
+| `dict` | `dict` | Accuracy metrics |
+
+**Metrics**
+
+- `mean_error`: float — Mean relative error
+- `max_error`: float — Maximum relative error
+- `accuracy`: float — 1 - mean_error
+- `rmse`: float — Root mean square error
+
+**Example**
+
+```python
+# Get solution and n(t)
+t, x, n = project_kernel_to_n(K)
+
+# Reconstruct from n(t)
+x_rec = 1.0 * (0.8 ** n)
+
+# Check accuracy
+metrics = compute_accuracy(x, x_rec)
+print(f"Accuracy: {metrics['accuracy']:.2%}")
+print(f"Mean error: {metrics['mean_error']:.2e}")
+# Accuracy: 100.00%
+# Mean error: 1.23e-12
+```
+
+---
+
+## 🧠 What problem does it solve?
+
+Traditional relaxation models assume exponential decay.
+
+Real systems — glasses, polymers, biological tissues — show memory effects. Power laws. Stretched exponentials. Oscillations.
+
+This library gives you one language for all of them:
+
+K(t) → n(t)
+
+Once you have n(t), the relaxation curve is simply x₀ · λⁿ⁽ᵗ⁾.
+
+No fractional calculus. No special functions. No black boxes.
+
+Just your kernel. One function call. One curve.
+
+---
+
+## 📄 Citation
+
+```bibtex
+@software{vozmishchev2026kernel,
+  author = {Vozmishchev, Artem},
+  title = {Kernel-Experience Tools: Projecting Memory Kernels to Experience Functions},
+  year = {2026},
+  doi = {10.5281/zenodo.18239294},
+  url = {https://zenodo.org/records/18239294}
+}
+```
+
+---
+
+## 📜 License
+
+MIT License
+
+---
+
+**Now go find what your kernel remembers.**
+

kernel_experience_tools-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "kernel-experience-tools"
+version = "0.1.0"
+authors = [
+    {name = "Artem Vozmishchev", email = "your.email@example.com"}
+]
+description = "Library for projecting memory kernels to experience functions"
+readme = "README.md"
+requires-python = ">=3.7"
+license = {text = "MIT"}
+
+dependencies = [
+    "numpy",
+    "scipy>=1.6.0",
+    "matplotlib>=3.3.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/BRUTALLOLOL/kernel-experience-tools"

kernel_experience_tools-0.1.0/requirements.txt

@@ -0,0 +1,3 @@
+numpy
+scipy>=1.6.0
+matplotlib>=3.3.0

kernel_experience_tools-0.1.0/setup.cfg

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

kernel_experience_tools-0.1.0/setup.py

@@ -0,0 +1,50 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="kernel-experience-tools",
+    version="0.1.0",
+    author="Artem Vozmishchev",
+    author_email="xbrutallololx@gmail.com",
+    description="Library for projecting memory kernels to experience functions",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/BRUTALLOLOL/kernel-experience-tools",
+    
+    # Package structure
+    package_dir={"": "src"},
+    packages=find_packages(where="src"),
+    
+    # Python compatibility
+    python_requires=">=3.7",
+    
+    # Dependencies - pip will handle version compatibility
+    install_requires=[
+        "numpy",
+        "scipy>=1.6.0",
+        "matplotlib>=3.3.0",
+    ],
+    
+    # PyPI metadata
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Intended Audience :: Science/Research",
+        "Topic :: Scientific/Engineering :: Mathematics",
+        "Topic :: Scientific/Engineering :: Physics",
+    ],
+    
+    # Build options
+    include_package_data=True,
+    zip_safe=False,
+)

kernel_experience_tools-0.1.0/src/kernel_experience/__init__.py

@@ -0,0 +1,27 @@
+"""
+Kernel-Experience Tools: A library for projecting memory kernels to experience functions.
+"""
+
+# Use try-except for compatibility
+try:
+    # Absolute imports (preferred)
+    from kernel_experience.kernel import Kernel
+    from kernel_experience.projection import project_kernel_to_n, project_to_envelope_n, compute_accuracy
+    from kernel_experience.solvers import solve_volterra
+except ImportError:
+    # Relative imports as fallback
+    from .kernel import Kernel
+    from .projection import project_kernel_to_n, project_to_envelope_n, compute_accuracy
+    from .solvers import solve_volterra
+
+__version__ = "0.1.0"
+__author__ = "Artem Vozmishchev"
+__email__ = "xbrutallololx@gmail.com"
+
+__all__ = [
+    "Kernel",
+    "project_kernel_to_n",
+    "project_to_envelope_n",
+    "compute_accuracy",
+    "solve_volterra"
+]

kernel_experience_tools-0.1.0/src/kernel_experience/kernel.py

@@ -0,0 +1,86 @@
+"""
+Kernel class for memory kernels K(t).
+"""
+
+import numpy as np
+from typing import Callable, Union, List
+from dataclasses import dataclass
+
+
+@dataclass
+class Kernel:
+    """
+    Memory kernel representation.
+
+    Parameters
+    ----------
+    func : callable
+        Function K(t) that returns kernel value at time t.
+    name : str, optional
+        Human-readable name of the kernel.
+    params : dict, optional
+        Dictionary of kernel parameters.
+    """
+    func: Callable[[float], float]
+    name: str = "CustomKernel"
+    params: dict = None
+
+    def __post_init__(self):
+        if self.params is None:
+            self.params = {}
+
+    def __call__(self, t: Union[float, np.ndarray]) -> Union[float, np.ndarray]:
+        """Evaluate kernel at time t."""
+        return self.func(t)
+
+    def __repr__(self):
+        return f"Kernel(name='{self.name}', params={self.params})"
+
+    # Factory methods for common kernels
+    @classmethod
+    def exponential(cls, gamma: float = 1.0):
+        """Exponential kernel: K(t) = γ * e^{-γt}"""
+
+        def func(t):
+            return gamma * np.exp(-gamma * np.maximum(t, 0))
+
+        return cls(func=func, name="Exponential", params={"gamma": gamma})
+
+    @classmethod
+    def power_law(cls, alpha: float = 0.5, gamma: float = 1.0):
+        """Power-law kernel: K(t) = γ * t^(α-1) / Γ(α)"""
+        from scipy.special import gamma as gamma_func
+        prefactor = gamma / gamma_func(alpha)
+
+        def func(t):
+            t_safe = np.where(t > 0, t, 1e-12)  # Избегаем деления на ноль
+            return prefactor * np.power(t_safe, alpha - 1)
+
+        return cls(func=func, name="PowerLaw",
+                   params={"alpha": alpha, "gamma": gamma})
+
+    @classmethod
+    def mittag_leffler(cls, alpha: float = 0.7, beta: float = 1.0):
+        """Mittag-Leffler kernel: K(t) = t^(α-1) * E_{α,α}(-t^α)"""
+        from scipy.special import gamma
+
+        def func(t):
+            # Simplified version - in practice use ml() from scipy
+            t_alpha = np.power(t, alpha)
+            return np.power(t, alpha - 1) * np.exp(-t_alpha) / gamma(alpha)
+
+        return cls(func=func, name="MittagLeffler",
+                   params={"alpha": alpha, "beta": beta})
+
+    @classmethod
+    def tempered_power_law(cls, alpha: float = 0.6, beta: float = 0.3, gamma: float = 1.0):
+        """Tempered power-law: K(t) = γ * t^(α-1) * e^{-βt} / Γ(α)"""
+        from scipy.special import gamma as gamma_func
+        prefactor = gamma / gamma_func(alpha)
+
+        def func(t):
+            t_safe = np.where(t > 0, t, 1e-12)
+            return prefactor * np.power(t_safe, alpha - 1) * np.exp(-beta * t_safe)
+
+        return cls(func=func, name="TemperedPowerLaw",
+                   params={"alpha": alpha, "beta": beta, "gamma": gamma})

kernel_experience_tools-0.1.0/src/kernel_experience/projection.py

@@ -0,0 +1,107 @@
+"""
+Projection algorithms: K(t) → n(t).
+"""
+
+import numpy as np
+from typing import Tuple, Union
+from .kernel import Kernel
+from .solvers import solve_volterra
+
+
+def project_kernel_to_n(kernel: Kernel,
+                        lambda_param: float = 0.8,
+                        t_max: float = 10.0,
+                        n_points: int = 1000,
+                        x0: float = 1.0,
+                        return_complex: bool = False) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Main projection: K(t) → n(t).
+
+    Parameters
+    ----------
+    kernel : Kernel
+        Memory kernel.
+    lambda_param : float
+        Parameter λ in (0, 1).
+    t_max : float
+        Maximum time.
+    n_points : int
+        Number of time points.
+    x0 : float
+        Initial condition.
+    return_complex : bool
+        If True, return complex n(t) for oscillatory kernels.
+
+    Returns
+    -------
+    t : np.ndarray
+        Time grid.
+    x : np.ndarray
+        Solution x(t).
+    n : np.ndarray
+        Experience function n(t) (real or complex).
+    """
+    # 1. Solve Volterra equation
+    t, x = solve_volterra(kernel, t_max, n_points, x0)
+
+    # 2. Compute n(t) = log_λ(x(t)/x0)
+    ratio = x / x0
+
+    if return_complex:
+        # Complex logarithm for oscillatory solutions
+        n_real = np.log(np.abs(ratio)) / np.log(lambda_param)
+        n_imag = np.angle(ratio) / np.log(lambda_param)
+        n = n_real + 1j * n_imag
+    else:
+        # Real logarithm (enforce positivity)
+        ratio = np.maximum(ratio, 1e-12)  # Avoid log(0)
+        n = np.log(ratio) / np.log(lambda_param)
+
+    return t, x, n
+
+
+def project_to_envelope_n(kernel: Kernel,
+                          lambda_param: float = 0.8,
+                          t_max: float = 10.0,
+                          n_points: int = 1000,
+                          x0: float = 1.0) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Project to monotonic envelope of n(t).
+
+    Uses Hilbert transform to extract envelope of oscillatory solutions.
+    """
+    from scipy.signal import hilbert
+
+    t, x, n_complex = project_kernel_to_n(
+        kernel, lambda_param, t_max, n_points, x0, return_complex=True
+    )
+
+    # Extract envelope via Hilbert transform
+    analytic_signal = hilbert(x.real)
+    envelope = np.abs(analytic_signal)
+
+    # Compute envelope n(t)
+    ratio_env = envelope / x0
+    ratio_env = np.maximum(ratio_env, 1e-12)
+    n_env = np.log(ratio_env) / np.log(lambda_param)
+
+    # Ensure monotonic decrease (accumulated minimum)
+    n_env_mono = np.minimum.accumulate(n_env)
+
+    return t, envelope, n_env_mono
+
+
+def compute_accuracy(original_x: np.ndarray,
+                     reconstructed_x: np.ndarray) -> dict:
+    """
+    Compute accuracy metrics between original and reconstructed solutions.
+    """
+    mask = original_x != 0
+    rel_error = np.abs(original_x[mask] - reconstructed_x[mask]) / np.abs(original_x[mask])
+
+    return {
+        'mean_error': float(np.mean(rel_error)),
+        'max_error': float(np.max(rel_error)),
+        'accuracy': float(1 - np.mean(rel_error)),
+        'rmse': float(np.sqrt(np.mean((original_x - reconstructed_x) ** 2)))
+    }

kernel_experience_tools-0.1.0/src/kernel_experience/solvers.py

@@ -0,0 +1,76 @@
+"""
+Numerical solvers for Volterra integral equations.
+"""
+
+import numpy as np
+from typing import Callable, Tuple
+from .kernel import Kernel
+
+
+def solve_volterra(kernel: Kernel,
+                   t_max: float = 10.0,
+                   n_points: int = 1000,
+                   x0: float = 1.0,
+                   method: str = 'trapezoidal') -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Solve x(t) = x0 - ∫₀ᵗ K(t-τ) x(τ) dτ.
+
+    Parameters
+    ----------
+    kernel : Kernel
+        Memory kernel K(t).
+    t_max : float
+        Maximum time.
+    n_points : int
+        Number of time points.
+    x0 : float
+        Initial condition.
+    method : str
+        Integration method ('trapezoidal' or 'simpson').
+
+    Returns
+    -------
+    t : np.ndarray
+        Time grid.
+    x : np.ndarray
+        Solution x(t).
+    """
+    t = np.linspace(0, t_max, n_points)
+    dt = t[1] - t[0]
+    x = np.zeros(n_points)
+    x[0] = x0
+
+    # Precompute kernel values for efficiency
+    K_vals = np.zeros((n_points, n_points))
+    for i in range(n_points):
+        for j in range(i + 1):
+            K_vals[i, j] = kernel(t[i] - t[j])
+
+    # Solve using specified method
+    if method == 'trapezoidal':
+        for i in range(1, n_points):
+            integral = 0
+            for j in range(i):
+                weight = 0.5 if (j == 0 or j == i - 1) else 1.0
+                integral += weight * K_vals[i, j] * x[j] * dt
+
+            x[i] = x0 - integral
+
+    elif method == 'simpson':
+        for i in range(1, n_points):
+            if i % 2 == 0:  # Simpson requires even number of intervals
+                integral = K_vals[i, 0] * x[0] + K_vals[i, i] * x[i - 1]
+                for j in range(1, i):
+                    weight = 4.0 if j % 2 == 1 else 2.0
+                    integral += weight * K_vals[i, j] * x[j]
+                integral *= dt / 3.0
+                x[i] = x0 - integral
+            else:
+                # Fall back to trapezoidal for odd intervals
+                integral = 0
+                for j in range(i):
+                    weight = 0.5 if (j == 0 or j == i - 1) else 1.0
+                    integral += weight * K_vals[i, j] * x[j] * dt
+                x[i] = x0 - integral
+
+    return t, x

kernel_experience_tools-0.1.0/src/kernel_experience_tools.egg-info/PKG-INFO

@@ -0,0 +1,262 @@
+Metadata-Version: 2.4
+Name: kernel-experience-tools
+Version: 0.1.0
+Summary: Library for projecting memory kernels to experience functions
+Home-page: https://github.com/BRUTALLOLOL/kernel-experience-tools
+Author: Artem Vozmishchev
+Author-email: Artem Vozmishchev <your.email@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/BRUTALLOLOL/kernel-experience-tools
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy>=1.6.0
+Requires-Dist: matplotlib>=3.3.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Kernel-Experience Tools 🧠 → ⏳
+
+**A Python library that turns memory kernels into experience functions.**
+
+---
+
+## 📌 What is it?
+
+Every memory kernel K(t) hides a story.
+
+This library finds it.
+
+Given the Volterra relaxation equation
+
+x(t) = x₀ - ∫₀ᵗ K(t-τ) x(τ) dτ
+
+we compute the unique experience function n(t) such that
+
+x(t) = x₀ · λⁿ⁽ᵗ⁾
+
+One kernel. One curve. One number.
+
+---
+
+## 🚀 Quick start
+
+```python
+from kernel_experience import Kernel, project_kernel_to_n
+
+# Pick a kernel
+K = Kernel.tempered_power_law(alpha=0.6, beta=0.3)
+
+# Get its experience function
+t, x, n = project_kernel_to_n(K, t_max=10)
+
+print(f"Memory score: {n[-1]:.2f}")
+# Memory score: 3.44
+```
+
+---
+
+## 📦 Installation
+
+```bash
+pip install kernel-experience-tools
+```
+
+---
+
+## 📘 API Reference
+
+### Kernel
+
+Container for your memory kernel.
+
+**Parameters**
+
+- `func`: callable — Kernel function K(t)
+- `name`: str, optional — Kernel name (default: "CustomKernel")
+- `params`: dict, optional — Kernel parameters
+
+**Factory methods**
+
+```python
+# Exponential: γ·e^{-γt}
+K = Kernel.exponential(gamma=1.0)
+
+# Power law: γ·t^{α-1}/Γ(α)
+K = Kernel.power_law(alpha=0.7, gamma=1.0)
+
+# Mittag-Leffler: t^{α-1}E_{α,α}(-t^α)
+K = Kernel.mittag_leffler(alpha=0.7)
+
+# Tempered power law: γ·t^{α-1}e^{-βt}/Γ(α)
+K = Kernel.tempered_power_law(alpha=0.6, beta=0.3, gamma=1.0)
+```
+
+**Custom kernel**
+
+```python
+def my_kernel(t):
+    return np.exp(-t) * np.cos(t)
+
+K = Kernel(my_kernel, name="Oscillatory", params={"freq": 1.0})
+```
+
+---
+
+### project_kernel_to_n
+
+Main projection: K(t) → n(t).
+
+**Parameters**
+
+| Parameter | Type | Default | Description |
+|----------|------|---------|-------------|
+| `kernel` | `Kernel` | — | Memory kernel |
+| `lambda_param` | `float` | 0.8 | Base λ in (0,1) |
+| `t_max` | `float` | 10.0 | Maximum time |
+| `n_points` | `int` | 1000 | Number of time points |
+| `x0` | `float` | 1.0 | Initial condition |
+| `return_complex` | `bool` | False | Return complex n(t) for oscillatory kernels |
+
+**Returns**
+
+| Return | Type | Description |
+|--------|------|-------------|
+| `t` | `ndarray` | Time grid |
+| `x` | `ndarray` | Solution x(t) |
+| `n` | `ndarray` | Experience function n(t) |
+
+**Examples**
+
+```python
+# Basic usage
+t, x, n = project_kernel_to_n(K, t_max=20, n_points=2000)
+
+# Custom lambda
+t, x, n = project_kernel_to_n(K, lambda_param=0.5)
+
+# Oscillatory kernel — get complex n(t)
+K_osc = Kernel(lambda t: np.exp(-0.1*t)*np.sin(t), name="Oscillatory")
+t, x, n_complex = project_kernel_to_n(K_osc, return_complex=True)
+
+# Extract real and imaginary parts
+n_real = n_complex.real
+n_imag = n_complex.imag
+```
+
+---
+
+### solve_volterra
+
+Numerical solver for Volterra integral equation.
+
+**Parameters**
+
+| Parameter | Type | Default | Description |
+|----------|------|---------|-------------|
+| `kernel` | `Kernel` | — | Memory kernel |
+| `t_max` | `float` | 10.0 | Maximum time |
+| `n_points` | `int` | 1000 | Number of time points |
+| `x0` | `float` | 1.0 | Initial condition |
+
+**Returns**
+
+| Return | Type | Description |
+|--------|------|-------------|
+| `t` | `ndarray` | Time grid |
+| `x` | `ndarray` | Solution x(t) |
+
+**Example**
+
+```python
+t, x = solve_volterra(K, t_max=5, n_points=500)
+```
+
+---
+
+### compute_accuracy
+
+Compare original and reconstructed solutions.
+
+**Parameters**
+
+| Parameter | Type | Description |
+|----------|------|-------------|
+| `original_x` | `ndarray` | Original solution x(t) |
+| `reconstructed_x` | `ndarray` | Reconstructed solution x₀·λⁿ⁽ᵗ⁾ |
+
+**Returns**
+
+| Return | Type | Description |
+|--------|------|-------------|
+| `dict` | `dict` | Accuracy metrics |
+
+**Metrics**
+
+- `mean_error`: float — Mean relative error
+- `max_error`: float — Maximum relative error
+- `accuracy`: float — 1 - mean_error
+- `rmse`: float — Root mean square error
+
+**Example**
+
+```python
+# Get solution and n(t)
+t, x, n = project_kernel_to_n(K)
+
+# Reconstruct from n(t)
+x_rec = 1.0 * (0.8 ** n)
+
+# Check accuracy
+metrics = compute_accuracy(x, x_rec)
+print(f"Accuracy: {metrics['accuracy']:.2%}")
+print(f"Mean error: {metrics['mean_error']:.2e}")
+# Accuracy: 100.00%
+# Mean error: 1.23e-12
+```
+
+---
+
+## 🧠 What problem does it solve?
+
+Traditional relaxation models assume exponential decay.
+
+Real systems — glasses, polymers, biological tissues — show memory effects. Power laws. Stretched exponentials. Oscillations.
+
+This library gives you one language for all of them:
+
+K(t) → n(t)
+
+Once you have n(t), the relaxation curve is simply x₀ · λⁿ⁽ᵗ⁾.
+
+No fractional calculus. No special functions. No black boxes.
+
+Just your kernel. One function call. One curve.
+
+---
+
+## 📄 Citation
+
+```bibtex
+@software{vozmishchev2026kernel,
+  author = {Vozmishchev, Artem},
+  title = {Kernel-Experience Tools: Projecting Memory Kernels to Experience Functions},
+  year = {2026},
+  doi = {10.5281/zenodo.18239294},
+  url = {https://zenodo.org/records/18239294}
+}
+```
+
+---
+
+## 📜 License
+
+MIT License
+
+---
+
+**Now go find what your kernel remembers.**
+

kernel_experience_tools-0.1.0/src/kernel_experience_tools.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+requirements.txt
+setup.py
+src/kernel_experience/__init__.py
+src/kernel_experience/kernel.py
+src/kernel_experience/projection.py
+src/kernel_experience/solvers.py
+src/kernel_experience_tools.egg-info/PKG-INFO
+src/kernel_experience_tools.egg-info/SOURCES.txt
+src/kernel_experience_tools.egg-info/dependency_links.txt
+src/kernel_experience_tools.egg-info/not-zip-safe
+src/kernel_experience_tools.egg-info/requires.txt
+src/kernel_experience_tools.egg-info/top_level.txt

kernel_experience_tools-0.1.0/src/kernel_experience_tools.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

kernel_experience_tools-0.1.0/src/kernel_experience_tools.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

kernel_experience_tools-0.1.0/src/kernel_experience_tools.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy
+scipy>=1.6.0
+matplotlib>=3.3.0

kernel_experience_tools-0.1.0/src/kernel_experience_tools.egg-info/top_level.txt

@@ -0,0 +1 @@
+kernel_experience