revisionlab 0.1.0__py3-none-any.whl

revisionlab/__init__.py

@@ -0,0 +1,19 @@
+"""Delayed evidence and residual-memory experiments, native to PyTorch."""
+
+from .diagnostics import aggregate_alignment, credit_alignment
+from .memory import ResidualMemory, SparseResidualMemory, delta_write
+from .protocols import BudgetReport, ForecastTicket, MemoryProtocol, ReleasedEvidence
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "BudgetReport",
+    "ForecastTicket",
+    "MemoryProtocol",
+    "ReleasedEvidence",
+    "ResidualMemory",
+    "SparseResidualMemory",
+    "aggregate_alignment",
+    "credit_alignment",
+    "delta_write",
+]

revisionlab/baselines.py

@@ -0,0 +1,148 @@
+"""Existing recursive least squares and explicit negative-control baselines."""
+
+import math
+from dataclasses import replace
+
+import numpy as np
+import torch
+from numpy.typing import NDArray
+from torch import Tensor, nn
+
+from .memory import ResidualMemory
+from .protocols import ReleasedEvidence
+
+
+def _key(values: Tensor, key: Tensor | NDArray[np.float64]) -> Tensor:
+    if isinstance(key, Tensor):
+        if key.dtype != values.dtype or key.device != values.device:
+            raise ValueError("Tensor keys must match memory dtype and device")
+        result = key
+    else:
+        result = torch.as_tensor(np.array(key, copy=True), dtype=values.dtype, device=values.device)
+    if result.shape != values.shape or not bool(torch.isfinite(result).all()):
+        raise ValueError("Key must be a finite vector matching memory width")
+    return result
+
+
+class RLS_Corrector(nn.Module):  # type: ignore[misc]
+    """FP64-default RLS residual corrector, reproducing the v13 baseline.
+
+    Initial covariance is 100 I. Forgetting lambda is in (0,1]; observed
+    residuals are clipped to [-12,12]. Low-level writes do not deduplicate:
+    use DelayedReplay for owner-bound, exactly-once evidence handling.
+    """
+
+    def __init__(self, slots: int, forget: float = 0.999, *, dtype: torch.dtype = torch.float64):
+        super().__init__()
+        if isinstance(slots, bool) or not isinstance(slots, int) or slots < 1:
+            raise ValueError("slots must be a positive integer")
+        if not math.isfinite(forget) or not 0 < forget <= 1:
+            raise ValueError("forget must be finite and in (0,1]")
+        if dtype not in (torch.float32, torch.float64):
+            raise ValueError("dtype must be float32 or float64")
+        self.register_buffer("forgetting_factor", torch.tensor(forget, dtype=dtype))
+        self.register_buffer("values", torch.zeros(slots, dtype=dtype))
+        self.register_buffer("P", 100 * torch.eye(slots, dtype=dtype))
+        self.register_buffer("writes", torch.zeros((), dtype=torch.int64))
+        self.register_buffer("last_label_hour", torch.full((), -1, dtype=torch.int64))
+
+    def read(self, key: Tensor | NDArray[np.float64]) -> Tensor:
+        result = torch.dot(self.values, _key(self.values, key))
+        if not bool(torch.isfinite(result)):
+            raise FloatingPointError("RLS read is non-finite")
+        return result
+
+    @property
+    def forget(self) -> float:
+        return float(self.forgetting_factor)
+
+    @torch.no_grad()  # type: ignore[untyped-decorator]
+    def write(self, evidence: ReleasedEvidence) -> None:
+        if evidence.ticket.address_version != 0:
+            raise ValueError("Only address version 0 is supported")
+        if int(self.writes) >= torch.iinfo(torch.int64).max:
+            raise OverflowError("RLS write counter exhausted; write not committed")
+        key = _key(self.values, evidence.ticket.read_key)
+        residual = evidence.target - evidence.ticket.base_prediction
+        if not math.isfinite(residual):
+            raise ValueError("Residual must be finite")
+        target = max(-12.0, min(12.0, residual))
+        px = self.P @ key
+        denominator = self.forget + torch.dot(key, px)
+        if not bool(torch.isfinite(denominator)) or float(denominator) <= 0:
+            raise FloatingPointError("RLS denominator is not finite and positive")
+        gain = px / denominator
+        values = self.values + gain * (target - self.read(key))
+        covariance = (self.P - torch.outer(gain, px)) / self.forget
+        covariance = (covariance + covariance.T) * 0.5
+        if not bool(torch.isfinite(values).all() and torch.isfinite(covariance).all()):
+            raise FloatingPointError("RLS candidate state is non-finite; write not committed")
+        self.values.copy_(values)
+        self.P.copy_(covariance)
+        self.writes.add_(1)
+        self.last_label_hour.fill_(evidence.ticket.available_hour)
+
+    def config(self) -> dict[str, object]:
+        return {
+            "slots": self.values.numel(),
+            "forget": self.forget,
+            "dtype": str(self.values.dtype).removeprefix("torch."),
+        }
+
+    def snapshot(self) -> dict[str, object]:
+        return {
+            "values": self.values.detach().clone(),
+            "P": self.P.detach().clone(),
+            "writes": int(self.writes),
+            "last_label_hour": None if int(self.writes) == 0 else int(self.last_label_hour),
+            "forget": self.forget,
+        }
+
+
+class NoWrite(ResidualMemory):
+    """Zero-correction control: accept mature evidence but never modify state."""
+
+    def __init__(self, slots: int, *, dtype: torch.dtype = torch.float64):
+        super().__init__(slots, 1.0, dtype=dtype)
+
+    def read(self, key: Tensor | NDArray[np.float64]) -> Tensor:
+        _key(self.values, key)
+        return torch.zeros((), dtype=self.values.dtype, device=self.values.device)
+
+    def write(self, evidence: ReleasedEvidence) -> None:
+        if evidence.ticket.address_version != 0:
+            raise ValueError("Only address version 0 is supported")
+        _key(self.values, evidence.ticket.read_key)
+        if not math.isfinite(evidence.target - evidence.ticket.base_prediction):
+            raise ValueError("Residual must be finite")
+
+    def config(self) -> dict[str, object]:
+        return {
+            "slots": self.values.numel(),
+            "dtype": str(self.values.dtype).removeprefix("torch."),
+        }
+
+
+class ShuffledWrite(ResidualMemory):
+    """Negative control: permute write addresses, keep read addresses unchanged."""
+
+    def __init__(
+        self, slots: int, rate: float = 0.05, *, seed: int = 0, dtype: torch.dtype = torch.float64
+    ):
+        if slots < 2:
+            raise ValueError("Shuffled-write requires at least two slots")
+        super().__init__(slots, rate, dtype=dtype)
+        self.seed = seed
+        generator = torch.Generator().manual_seed(seed)
+        permutation = torch.randperm(slots, generator=generator)
+        if torch.equal(permutation, torch.arange(slots)):
+            permutation = permutation.roll(1)
+        self.register_buffer("permutation", permutation)
+
+    def write(self, evidence: ReleasedEvidence) -> None:
+        key = _key(self.values, evidence.ticket.read_key)
+        shuffled = key[self.permutation].detach().cpu().numpy()
+        super().write(replace(evidence, ticket=replace(evidence.ticket, read_key=shuffled)))
+
+    def config(self) -> dict[str, object]:
+        return {**super().config(), "seed": self.seed}

revisionlab/diagnostics.py

@@ -0,0 +1,42 @@
+"""Single-trial cosine and pooled rho; zero-norm alignment is undefined."""
+
+from typing import Any
+
+import numpy as np
+import torch
+from numpy.typing import NDArray
+
+
+def _array(value: Any) -> NDArray[np.float64]:
+    if isinstance(value, torch.Tensor):
+        value = value.detach().to(device="cpu", dtype=torch.float64).numpy()
+    return np.asarray(value, dtype=np.float64)
+
+
+def _alignment(first: Any, second: Any, *, flatten: bool) -> float | None:
+    a, b = _array(first), _array(second)
+    if flatten:
+        a, b = a.ravel(), b.ravel()
+    if a.shape != b.shape or not (np.isfinite(a).all() and np.isfinite(b).all()):
+        raise ValueError("Finite matched vectors required")
+    if a.size == 0:
+        return None
+    scale_a, scale_b = float(np.max(np.abs(a))), float(np.max(np.abs(b)))
+    if scale_a == 0 or scale_b == 0:
+        return None
+    # Independent global scaling leaves pooled rho unchanged, avoids over/underflow.
+    a, b = a / scale_a, b / scale_b
+    denominator = np.sqrt(np.sum(a * a)) * np.sqrt(np.sum(b * b))
+    return float(np.clip(np.sum(a * b) / denominator, -1, 1))
+
+
+def credit_alignment(update: Any, negative_gradient: Any) -> dict[str, bool | float | None]:
+    """Cosine of an actual update with a reference negative gradient."""
+    cosine = _alignment(update, negative_gradient, flatten=True)
+    return {"defined": cosine is not None, "cosine": cosine}
+
+
+def aggregate_alignment(updates: Any, negative_gradients: Any) -> dict[str, bool | float | None]:
+    """sum dot / sqrt(sum squared norms), not an average of trial cosines."""
+    rho = _alignment(updates, negative_gradients, flatten=False)
+    return {"defined": rho is not None, "rho": rho}

revisionlab/memory.py

@@ -0,0 +1,195 @@
+"""Normalized delta/LMS updates; evidence ownership belongs to the replay runner."""
+
+import math
+from numbers import Integral
+from typing import Any
+
+import numpy as np
+import torch
+from numpy.typing import NDArray
+from torch import Tensor, nn
+
+from .protocols import ReleasedEvidence, _key
+
+
+def _size_rate(slots: int, rate: float) -> None:
+    if isinstance(slots, bool) or not isinstance(slots, Integral) or slots < 1:
+        raise ValueError("slots must be a positive integer")
+    if isinstance(rate, bool) or not math.isfinite(rate) or not 0 < rate <= 1:
+        raise ValueError("rate must be finite and in (0, 1]")
+
+
+def delta_write(values: Tensor, key: Tensor, target: Tensor, rate: float) -> Tensor:
+    """Pure differentiable update: [...,slots,channels], [...,slots], [...,channels].
+
+    All tensors must share dtype/device and exactly matching leading dimensions.
+    Finite inputs and representable intermediate squared key norms are required;
+    stateful backends validate norms and proposals before committing. This
+    function neither clips residuals nor mutates inputs.
+    """
+    if values.ndim < 2 or key.ndim != values.ndim - 1 or target.ndim != values.ndim - 1:
+        raise ValueError(
+            "Expected values [...,slots,channels], key [...,slots], target [...,channels]"
+        )
+    if (
+        values.shape[-2] < 1
+        or values.shape[-1] < 1
+        or key.shape != values.shape[:-1]
+        or target.shape != (*values.shape[:-2], values.shape[-1])
+    ):
+        raise ValueError("Delta update shape mismatch")
+    if not values.is_floating_point() or values.dtype != key.dtype or values.dtype != target.dtype:
+        raise ValueError("Delta update requires one shared floating dtype")
+    if values.device != key.device or values.device != target.device:
+        raise ValueError("Delta update requires one shared device")
+    if isinstance(rate, bool) or not math.isfinite(rate) or not 0 < rate <= 1:
+        raise ValueError("rate must be finite and in (0, 1]")
+    prediction = torch.einsum("...n,...nd->...d", key, values)
+    floor = max(1e-12, torch.finfo(values.dtype).tiny)
+    denominator = key.square().sum(-1, keepdim=True).clamp_min(floor)
+    return values + (rate / denominator).unsqueeze(-1) * key.unsqueeze(-1) * (
+        target - prediction
+    ).unsqueeze(-2)
+
+
+class SparseResidualMemory:
+    """Backward-compatible NumPy scalar backend; one instance per horizon."""
+
+    def __init__(
+        self, slots: int, rate: float, permutation: NDArray[np.int64] | None = None
+    ) -> None:
+        _size_rate(slots, rate)
+        self.values: NDArray[np.float64] = np.zeros(slots, dtype=np.float64)
+        self.rate = float(rate)
+        self.writes = 0
+        self.last_label_hour: int | None = None
+        self.permutation: NDArray[np.int64] | None = None
+        if permutation is not None:
+            candidate = np.asarray(permutation)
+            if (
+                candidate.shape != (slots,)
+                or not np.issubdtype(candidate.dtype, np.integer)
+                or not np.array_equal(np.sort(candidate), np.arange(slots))
+            ):
+                raise ValueError("Permutation must be an integral bijection")
+            self.permutation = np.frombuffer(candidate.astype(np.int64).tobytes(), dtype=np.int64)
+
+    def read(self, key: Any) -> float:
+        result = float(np.dot(self.values, _key(key, self.values.size)))
+        if not math.isfinite(result):
+            raise FloatingPointError("Memory read is not finite")
+        return result
+
+    def write(self, evidence: ReleasedEvidence) -> None:
+        if evidence.ticket.address_version != 0:
+            raise ValueError("Unsupported address_version")
+        key = _key(evidence.ticket.read_key, self.values.size)
+        if self.permutation is not None:
+            key = key[self.permutation]
+        with np.errstate(over="ignore", invalid="ignore"):
+            squared_norm = float(key @ key)
+        if not math.isfinite(squared_norm):
+            raise FloatingPointError("Key squared norm is not finite")
+        residual = float(np.clip(evidence.target - evidence.ticket.base_prediction, -12, 12))
+        with np.errstate(over="ignore", invalid="ignore", divide="ignore"):
+            proposal = self.values + self.rate * key * (residual - np.dot(self.values, key)) / max(
+                squared_norm, 1e-12
+            )
+        if not np.isfinite(proposal).all():
+            raise FloatingPointError("Memory proposal is not finite")
+        self.values[:] = proposal
+        self.writes += 1
+        self.last_label_hour = evidence.ticket.available_hour
+
+    def snapshot(self) -> dict[str, Any]:
+        return {
+            "values": self.values.copy(),
+            "writes": self.writes,
+            "rate": self.rate,
+            "last_label_hour": self.last_label_hour,
+        }
+
+
+class ResidualMemory(nn.Module):  # type: ignore[misc]
+    """Native Torch scalar state; one instance per horizon, default FP64.
+
+    Tensor keys require an exact dtype/device match. NumPy ticket keys are
+    explicitly copied into this backend's configured dtype/device. Stateful
+    writes use clipped target-minus-base residuals and have no autograd graph.
+    """
+
+    def __init__(
+        self,
+        slots: int,
+        rate: float,
+        *,
+        dtype: torch.dtype = torch.float64,
+        device: torch.device | str | None = None,
+    ) -> None:
+        super().__init__()
+        _size_rate(slots, rate)
+        if not dtype.is_floating_point:
+            raise ValueError("Memory requires a floating dtype")
+        self.register_buffer("values", torch.zeros(slots, dtype=dtype, device=device))
+        self.register_buffer("learning_rate", torch.tensor(rate, dtype=dtype, device=device))
+        self.register_buffer("writes", torch.zeros((), dtype=torch.int64, device=device))
+        self.register_buffer(
+            "last_label_hour", torch.full((), -1, dtype=torch.int64, device=device)
+        )
+
+    @property
+    def rate(self) -> float:
+        return float(self.learning_rate.item())
+
+    def _read_key(self, key: Any) -> Tensor:
+        if isinstance(key, Tensor):
+            if key.dtype != self.values.dtype or key.device != self.values.device:
+                raise ValueError("Tensor key dtype/device must match memory")
+            result = key
+        else:
+            result = torch.tensor(_key(key), dtype=self.values.dtype, device=self.values.device)
+        if result.shape != self.values.shape or not torch.isfinite(result).all():
+            raise ValueError("A finite key with matching address width is required")
+        return result
+
+    def read(self, key: Any) -> Tensor:
+        result = torch.dot(self.values, self._read_key(key))
+        if not torch.isfinite(result):
+            raise FloatingPointError("Memory read is not finite")
+        return result
+
+    def write(self, evidence: ReleasedEvidence) -> None:
+        if evidence.ticket.address_version != 0:
+            raise ValueError("Unsupported address_version")
+        hour = evidence.ticket.available_hour
+        limits = torch.iinfo(torch.int64)
+        if not limits.min <= hour <= limits.max or int(self.writes.item()) >= limits.max:
+            raise ValueError("Evidence hour/write count exceeds native metadata range")
+        key = self._read_key(evidence.ticket.read_key)
+        if not torch.isfinite(key.square().sum()):
+            raise FloatingPointError("Key squared norm is not finite")
+        residual = max(-12.0, min(12.0, evidence.target - evidence.ticket.base_prediction))
+        target = self.values.new_tensor([residual])
+        with torch.no_grad():
+            proposal = delta_write(self.values[:, None], key, target, self.rate).squeeze(-1)
+            if not torch.isfinite(proposal).all():
+                raise FloatingPointError("Memory proposal is not finite")
+            self.values.copy_(proposal)
+            self.writes.add_(1)
+            self.last_label_hour.fill_(hour)
+
+    def snapshot(self) -> dict[str, Any]:
+        hour = int(self.last_label_hour.item())
+        return {
+            "values": self.values.detach().clone(),
+            "writes": int(self.writes.item()),
+            "rate": self.rate,
+            "last_label_hour": None if int(self.writes.item()) == 0 else hour,
+        }
+
+    def config(self) -> dict[str, Any]:
+        return {
+            "slots": self.values.numel(),
+            "rate": self.rate,
+            "dtype": str(self.values.dtype).removeprefix("torch."),
+        }

revisionlab/protocols.py

@@ -0,0 +1,123 @@
+"""Immutable issued forecasts and causally released evidence."""
+
+from dataclasses import dataclass, field
+from numbers import Integral
+from typing import Any, Protocol, runtime_checkable
+from uuid import uuid4
+
+import numpy as np
+import torch
+from numpy.typing import NDArray
+
+
+def _tick(value: int, name: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, Integral):
+        raise ValueError(f"{name} must be an integral tick")
+    if not -(2**63) <= value < 2**63:
+        raise ValueError(f"{name} must fit the signed int64 tick range")
+    return int(value)
+
+
+def _scalar(value: float, name: str) -> float:
+    if isinstance(value, bool):
+        raise ValueError(f"{name} must be a finite scalar")
+    if isinstance(value, torch.Tensor):
+        value = value.detach().cpu().numpy()
+    array = np.asarray(value)
+    if array.ndim != 0:
+        raise ValueError(f"{name} must be a finite scalar")
+    try:
+        result = float(array)
+    except (TypeError, ValueError) as error:
+        raise ValueError(f"{name} must be a finite scalar") from error
+    if not np.isfinite(result):
+        raise ValueError(f"{name} must be a finite scalar")
+    return result
+
+
+def _key(value: Any, slots: int | None = None) -> NDArray[np.float64]:
+    if isinstance(value, torch.Tensor):
+        value = value.detach().to(device="cpu", dtype=torch.float64).numpy()
+    result = np.asarray(value, dtype=np.float64)
+    if result.ndim != 1 or result.size == 0 or not np.isfinite(result).all():
+        raise ValueError("A finite nonempty one-dimensional key is required")
+    if slots is not None and result.size != slots:
+        raise ValueError("Address width mismatch")
+    return result
+
+
+@dataclass(frozen=True)
+class ForecastTicket:
+    issue_hour: int
+    horizon: int
+    base_prediction: float
+    read_key: NDArray[np.float64]
+    prediction: float | None = None
+    ticket_id: str = field(default_factory=lambda: str(uuid4()))
+    address_version: int = 0
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "issue_hour", _tick(self.issue_hour, "issue_hour"))
+        horizon = _tick(self.horizon, "horizon")
+        if horizon < 1:
+            raise ValueError("Horizon must be positive")
+        object.__setattr__(self, "horizon", horizon)
+        _tick(self.issue_hour + horizon, "available_hour")
+        object.__setattr__(
+            self, "base_prediction", _scalar(self.base_prediction, "base_prediction")
+        )
+        if self.prediction is not None:
+            object.__setattr__(self, "prediction", _scalar(self.prediction, "prediction"))
+        version = _tick(self.address_version, "address_version")
+        if version < 0:
+            raise ValueError("address_version must be nonnegative")
+        object.__setattr__(self, "address_version", version)
+        if not isinstance(self.ticket_id, str) or not self.ticket_id:
+            raise ValueError("ticket_id must be a nonempty string")
+        # Immutable bytes backing prevents callers from re-enabling NumPy writes.
+        object.__setattr__(self, "read_key", _key(self.read_key).tobytes())
+
+    def __getattribute__(self, name: str) -> Any:
+        value = object.__getattribute__(self, name)
+        if name == "read_key" and isinstance(value, bytes):
+            # Return a fresh view: NumPy shape/dtype metadata remains mutable even
+            # when its data backing is immutable. Never expose our stored object.
+            return np.frombuffer(value, dtype=np.float64)
+        return value
+
+    @property
+    def available_hour(self) -> int:
+        return self.issue_hour + self.horizon
+
+
+@dataclass(frozen=True)
+class ReleasedEvidence:
+    ticket: ForecastTicket
+    target: float
+    now_hour: int
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.ticket, ForecastTicket):
+            raise ValueError("Evidence requires a ForecastTicket")
+        now = _tick(self.now_hour, "now_hour")
+        if now < self.ticket.available_hour:
+            raise ValueError("Outcome has not matured")
+        object.__setattr__(self, "now_hour", now)
+        object.__setattr__(self, "target", _scalar(self.target, "target"))
+
+
+@dataclass(frozen=True)
+class BudgetReport:
+    value_bytes: int
+    metadata_bytes: int
+    pending_bytes: int
+    seconds: float
+
+
+@runtime_checkable
+class MemoryProtocol(Protocol):
+    def read(self, key: Any) -> Any: ...
+
+    def write(self, evidence: ReleasedEvidence) -> None: ...
+
+    def snapshot(self) -> dict[str, Any]: ...

revisionlab/replay.py

@@ -0,0 +1,204 @@
+"""Owner-bound delayed evidence replay; pending state contains no future labels."""
+
+import math
+import sys
+import uuid
+from numbers import Integral
+from typing import Any
+
+import numpy as np
+import torch
+from numpy.typing import NDArray
+
+from .protocols import ForecastTicket, ReleasedEvidence
+
+
+class ReplayLedger:
+    """One horizon and address version per ledger, with retained audit IDs.
+
+    Settled IDs are retained without a bound to guarantee lifetime exactly-once
+    release through checkpoints. There is no automatic retention limit: callers
+    must rotate ledgers explicitly if accepting a shorter deduplication window.
+    ``budget`` exposes growing audit payload plus Python container overhead.
+    """
+
+    def __init__(self, horizon: int, *, owner_id: str | None = None):
+        if isinstance(horizon, bool) or not isinstance(horizon, Integral) or horizon < 1:
+            raise ValueError("horizon must be a positive integer")
+        self.horizon: int = int(horizon)
+        self.owner_id: str = str(uuid.uuid4()) if owner_id is None else owner_id
+        if not isinstance(self.owner_id, str) or not self.owner_id or ":" in self.owner_id:
+            raise ValueError("owner_id must be a nonempty string without colon")
+        self.pending: dict[str, ForecastTicket] = {}
+        self.settled_ids: set[str] = set()
+        self.clock: int | None = None
+        self.squared_error: float = 0.0
+        self.base_squared_error: float = 0.0
+        self.releases: int = 0
+
+    def _time(self, hour: int) -> None:
+        if isinstance(hour, bool) or not isinstance(hour, Integral):
+            raise ValueError("Event time must be an integer hour")
+        if not -(2**63) <= hour < 2**63:
+            raise ValueError("Event time must fit int64")
+        if self.clock is not None and hour < self.clock:
+            raise ValueError("Event time must be monotonic; release before issuing at that tick")
+
+    def issue(self, ticket: ForecastTicket) -> None:
+        self._time(ticket.issue_hour)
+        if ticket.horizon != self.horizon or ticket.address_version != 0:
+            raise ValueError("Ticket horizon or address version does not match ledger")
+        if not ticket.ticket_id.startswith(self.owner_id + ":"):
+            raise ValueError("Foreign ticket owner")
+        if ticket.ticket_id in self.pending or ticket.ticket_id in self.settled_ids:
+            raise ValueError("Ticket ID has already been issued")
+        if ticket.prediction is None or not math.isfinite(ticket.prediction):
+            raise ValueError("Ledger requires the actual finite issued prediction")
+        self.pending[ticket.ticket_id] = ticket
+        self.clock = ticket.issue_hour
+
+    def validate_release(self, ticket_id: str, target: float, now_hour: int) -> ReleasedEvidence:
+        self._time(now_hour)
+        if ticket_id in self.settled_ids:
+            raise ValueError("Ticket has already been released")
+        if ticket_id not in self.pending:
+            raise ValueError("Unknown or foreign ticket ID")
+        ticket = self.pending[ticket_id]
+        if ticket.address_version != 0 or ticket.horizon != self.horizon:
+            raise ValueError("Stored ticket horizon or address version does not match ledger")
+        evidence = ReleasedEvidence(ticket, target, now_hour)
+        assert ticket.prediction is not None
+        try:
+            squared_error = (ticket.prediction - evidence.target) ** 2
+            base_error = (ticket.base_prediction - evidence.target) ** 2
+        except OverflowError as error:
+            raise ValueError("Squared error must be finite") from error
+        if not math.isfinite(
+            squared_error + self.squared_error + base_error + self.base_squared_error
+        ):
+            raise ValueError("Squared error must be finite")
+        return evidence
+
+    def _settle(self, evidence: ReleasedEvidence) -> float:
+        ticket = evidence.ticket
+        canonical = self.validate_release(ticket.ticket_id, evidence.target, evidence.now_hour)
+        if canonical.ticket is not ticket:
+            raise ValueError("Release must use the canonical pending ticket")
+        assert ticket.prediction is not None
+        loss = (ticket.prediction - evidence.target) ** 2
+        self.squared_error += loss
+        self.base_squared_error += (ticket.base_prediction - evidence.target) ** 2
+        self.releases += 1
+        del self.pending[ticket.ticket_id]
+        self.settled_ids.add(ticket.ticket_id)
+        self.clock = evidence.now_hour
+        return loss
+
+    @property
+    def mse(self) -> float | None:
+        return self.squared_error / self.releases if self.releases else None
+
+    @property
+    def base_mse(self) -> float | None:
+        return self.base_squared_error / self.releases if self.releases else None
+
+    def budget(self) -> dict[str, int]:
+        return {
+            "pending_tickets": len(self.pending),
+            "settled_ids": len(self.settled_ids),
+            "pending_key_bytes": sum(ticket.read_key.nbytes for ticket in self.pending.values()),
+            "audit_id_payload_bytes": sum(len(value.encode()) for value in self.settled_ids),
+            "audit_python_bytes": sys.getsizeof(self.settled_ids)
+            + sum(sys.getsizeof(value) for value in self.settled_ids),
+        }
+
+    def state(self) -> dict[str, Any]:
+        return {
+            "horizon": self.horizon,
+            "owner_id": self.owner_id,
+            "clock": self.clock,
+            "squared_error": self.squared_error,
+            "base_squared_error": self.base_squared_error,
+            "releases": self.releases,
+            "settled_ids": sorted(self.settled_ids),
+            "pending": [
+                {
+                    "issue_hour": ticket.issue_hour,
+                    "horizon": ticket.horizon,
+                    "base_prediction": ticket.base_prediction,
+                    "read_key": torch.tensor(np.array(ticket.read_key, copy=True)),
+                    "prediction": ticket.prediction,
+                    "ticket_id": ticket.ticket_id,
+                    "address_version": ticket.address_version,
+                }
+                for ticket in self.pending.values()
+            ],
+        }
+
+    @classmethod
+    def from_state(cls, state: dict[str, Any]) -> "ReplayLedger":
+        ledger = cls(state["horizon"], owner_id=state["owner_id"])
+        settled = state["settled_ids"]
+        if len(set(settled)) != len(settled) or any(
+            not isinstance(value, str) or not value.startswith(ledger.owner_id + ":")
+            for value in settled
+        ):
+            raise ValueError("Invalid settled ticket IDs")
+        ledger.settled_ids = set(settled)
+        for data in sorted(state["pending"], key=lambda item: item["issue_hour"]):
+            ledger.issue(ForecastTicket(**data))
+        clock = state["clock"]
+        if clock is not None:
+            ledger._time(clock)
+        elif ledger.pending or ledger.settled_ids:
+            raise ValueError("Nonempty ledger requires a clock")
+        ledger.clock = clock
+        count = state["releases"]
+        if isinstance(count, bool) or not isinstance(count, int) or count != len(settled):
+            raise ValueError("Release count must match settled audit IDs")
+        ledger.releases = count
+        for name in ("squared_error", "base_squared_error"):
+            value = state[name]
+            if not isinstance(value, (int, float)) or not math.isfinite(value) or value < 0:
+                raise ValueError("Invalid accumulated error")
+            setattr(ledger, name, float(value))
+        return ledger
+
+
+class DelayedReplay:
+    """Sequential single-process replay: revise only after an issued outcome matures.
+
+    Calls must be serialized by the caller; this class is not thread-safe.
+    """
+
+    def __init__(self, memory: Any, horizon: int, *, correction_clip: float = 3.0):
+        if not math.isfinite(correction_clip) or correction_clip <= 0:
+            raise ValueError("correction_clip must be finite and positive")
+        self.memory = memory
+        self.ledger = ReplayLedger(horizon)
+        self.correction_clip = float(correction_clip)
+
+    def issue(
+        self, issue_hour: int, base_prediction: float, read_key: NDArray[np.float64] | torch.Tensor
+    ) -> ForecastTicket:
+        self.ledger._time(issue_hour)
+        correction = float(self.memory.read(read_key))
+        if not math.isfinite(correction):
+            raise ValueError("Memory correction must be finite")
+        correction = max(-self.correction_clip, min(self.correction_clip, correction))
+        ticket = ForecastTicket(
+            issue_hour,
+            self.ledger.horizon,
+            base_prediction,
+            read_key,
+            prediction=base_prediction + correction,
+            ticket_id=self.ledger.owner_id + ":" + str(uuid.uuid4()),
+            address_version=0,
+        )
+        self.ledger.issue(ticket)
+        return ticket
+
+    def release(self, ticket_id: str, target: float, now_hour: int) -> float:
+        evidence = self.ledger.validate_release(ticket_id, target, now_hour)
+        self.memory.write(evidence)
+        return self.ledger._settle(evidence)

revisionlab/serialization.py

@@ -0,0 +1,113 @@
+"""Atomic, weights-only checkpoints with explicit model and ledger validation."""
+
+import os
+import tempfile
+from pathlib import Path
+from typing import Any
+
+import torch
+from torch import nn
+
+from .baselines import NoWrite, RLS_Corrector, ShuffledWrite
+from .memory import ResidualMemory
+from .replay import DelayedReplay, ReplayLedger
+
+
+def save_checkpoint(path: str | Path, runner: DelayedReplay) -> None:
+    if type(runner.memory) not in (ResidualMemory, RLS_Corrector, NoWrite, ShuffledWrite):
+        raise ValueError("Checkpoint supports native RevisionLab models only")
+    if runner.memory.values.dtype not in (torch.float32, torch.float64):
+        raise ValueError("Checkpoint dtype must be float32 or float64")
+    if isinstance(runner.memory, ResidualMemory) and not 0 < runner.memory.rate <= 1:
+        raise ValueError("Checkpoint learning rate must be in (0,1]")
+    if isinstance(runner.memory, RLS_Corrector) and not 0 < runner.memory.forget <= 1:
+        raise ValueError("Checkpoint forgetting factor must be in (0,1]")
+    for name, value in runner.memory.state_dict().items():
+        if value.is_floating_point() and value.dtype != runner.memory.values.dtype:
+            raise ValueError(f"Checkpoint tensor dtype mismatch: {name}")
+        if not bool(torch.isfinite(value).all()):
+            raise ValueError(f"Checkpoint tensor is non-finite: {name}")
+    payload = {
+        "format_version": 1,
+        "model_type": type(runner.memory).__name__,
+        "model_config": runner.memory.config(),
+        "model_state": {
+            name: value.detach().cpu().clone() for name, value in runner.memory.state_dict().items()
+        },
+        "ledger": runner.ledger.state(),
+        "correction_clip": runner.correction_clip,
+    }
+    destination = Path(path)
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    descriptor, temporary = tempfile.mkstemp(
+        prefix=destination.name + ".", suffix=".tmp", dir=destination.parent
+    )
+    try:
+        with os.fdopen(descriptor, "wb") as stream:
+            torch.save(payload, stream)
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.replace(temporary, destination)
+    finally:
+        if os.path.exists(temporary):
+            os.unlink(temporary)
+
+
+def load_checkpoint(path: str | Path) -> DelayedReplay:
+    payload: dict[str, Any] = torch.load(path, map_location="cpu", weights_only=True)
+    if not isinstance(payload, dict) or payload.get("format_version") != 1:
+        raise ValueError("Unsupported checkpoint format")
+    factories: dict[str, type[nn.Module]] = {
+        "ResidualMemory": ResidualMemory,
+        "RLS_Corrector": RLS_Corrector,
+        "NoWrite": NoWrite,
+        "ShuffledWrite": ShuffledWrite,
+    }
+    model_type = payload.get("model_type")
+    if model_type not in factories:
+        raise ValueError("Unknown checkpoint model type")
+    config = dict(payload["model_config"])
+    dtype_name = config.pop("dtype", None)
+    if dtype_name not in ("float32", "float64"):
+        raise ValueError("Checkpoint dtype must be float32 or float64")
+    dtype = torch.float32 if dtype_name == "float32" else torch.float64
+    memory = factories[model_type](**config, dtype=dtype)
+    expected = memory.state_dict()
+    saved = payload["model_state"]
+    if not isinstance(saved, dict) or set(saved) != set(expected):
+        raise ValueError("Checkpoint model state keys mismatch")
+    for name, value in saved.items():
+        if not isinstance(value, torch.Tensor):
+            raise ValueError("Checkpoint state must contain tensors")
+        if value.shape != expected[name].shape or value.dtype != expected[name].dtype:
+            raise ValueError(f"Checkpoint tensor shape/dtype mismatch: {name}")
+        if not bool(torch.isfinite(value).all()):
+            raise ValueError(f"Checkpoint tensor is non-finite: {name}")
+    if int(saved["writes"]) < 0:
+        raise ValueError("Checkpoint write counter cannot be negative")
+    if isinstance(memory, ResidualMemory):
+        if not 0 < float(saved["learning_rate"]) <= 1:
+            raise ValueError("Checkpoint learning rate must be in (0,1]")
+        if not torch.equal(saved["learning_rate"], expected["learning_rate"]):
+            raise ValueError("Checkpoint learning rate and config mismatch")
+    if isinstance(memory, RLS_Corrector):
+        if not 0 < float(saved["forgetting_factor"]) <= 1:
+            raise ValueError("Checkpoint forgetting factor must be in (0,1]")
+        if not torch.equal(saved["forgetting_factor"], expected["forgetting_factor"]):
+            raise ValueError("Checkpoint forgetting factor and config mismatch")
+    if isinstance(memory, NoWrite) and (bool(saved["values"].any()) or int(saved["writes"]) != 0):
+        raise ValueError("No-write checkpoint must preserve zero state")
+    if isinstance(memory, ShuffledWrite):
+        permutation = saved["permutation"]
+        if not torch.equal(permutation.sort().values, torch.arange(memory.values.numel())):
+            raise ValueError("Checkpoint write permutation must be bijective")
+        if not torch.equal(permutation, expected["permutation"]):
+            raise ValueError("Checkpoint write permutation and seed config mismatch")
+    memory.load_state_dict(saved, strict=True)
+    ledger = ReplayLedger.from_state(payload["ledger"])
+    for ticket in ledger.pending.values():
+        if ticket.read_key.size != memory.values.numel():
+            raise ValueError("Pending ticket address width does not match checkpoint model")
+    runner = DelayedReplay(memory, ledger.horizon, correction_clip=payload["correction_clip"])
+    runner.ledger = ledger
+    return runner

revisionlab/smoke.py

@@ -0,0 +1,97 @@
+"""A synthetic delayed-residual smoke check, not forecasting validation."""
+
+import argparse
+import json
+from collections import deque
+
+import numpy as np
+import torch
+
+from .baselines import NoWrite, RLS_Corrector, ShuffledWrite
+from .memory import ResidualMemory
+from .replay import DelayedReplay
+
+
+def synthetic_check(steps: int = 128, seed: int = 0, horizon: int = 3) -> dict[str, object]:
+    if isinstance(steps, bool) or not isinstance(steps, int) or steps < 1:
+        raise ValueError("steps must be a positive integer")
+    if isinstance(horizon, bool) or not isinstance(horizon, int) or horizon < 1:
+        raise ValueError("horizon must be a positive integer")
+    generator = np.random.default_rng(seed)
+    slots = 8
+    addresses = generator.integers(slots, size=steps)
+    noise = generator.normal(0, 0.03, size=steps)
+    residuals = np.linspace(-2, 2, slots)[addresses] + noise
+    methods: dict[str, ResidualMemory | RLS_Corrector] = {
+        "residual": ResidualMemory(slots, 0.5),
+        "rls": RLS_Corrector(slots, 0.999),
+        "no-write": NoWrite(slots),
+        "shuffled-write": ShuffledWrite(slots, 0.5, seed=seed),
+    }
+    results: dict[str, object] = {}
+    for name, memory in methods.items():
+        runner = DelayedReplay(memory, horizon)
+        pending: deque[tuple[int, str, int]] = deque()
+        for now in range(steps):
+            # This evaluator queue owns targets; runner pending state contains
+            # only issued tickets and never a not-yet-mature target.
+            while pending and pending[0][0] <= now:
+                _, ticket_id, index = pending.popleft()
+                runner.release(ticket_id, float(residuals[index]), now)
+            key = np.zeros(slots)
+            key[addresses[now]] = 1
+            ticket = runner.issue(now, 0.0, key)
+            pending.append((ticket.available_hour, ticket.ticket_id, now))
+        while pending:
+            available, ticket_id, index = pending.popleft()
+            runner.release(ticket_id, float(residuals[index]), available)
+        corrected_mse = runner.ledger.mse
+        base_mse = runner.ledger.base_mse
+        assert corrected_mse is not None and base_mse is not None
+        results[name] = {
+            "base_mse": base_mse,
+            "corrected_mse": corrected_mse,
+            "mse_improvement": base_mse - corrected_mse,
+            "releases": runner.ledger.releases,
+            "model_tensor_bytes": sum(
+                value.numel() * value.element_size() for value in memory.state_dict().values()
+            ),
+            "ledger": runner.ledger.budget(),
+        }
+    return {
+        "scope": "synthetic stationary address-residual smoke; not real-world forecasting evidence",
+        "steps": steps,
+        "seed": seed,
+        "horizon": horizon,
+        "dtype": str(torch.float64),
+        "methods": results,
+    }
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(prog="revisionlab-check")
+    parser.add_argument("--steps", type=int, default=128)
+    parser.add_argument("--seed", type=int, default=0)
+    parser.add_argument("--horizon", type=int, default=3)
+    parser.add_argument(
+        "--json", action="store_true", help="print machine-readable synthetic results"
+    )
+    args = parser.parse_args(argv)
+    try:
+        report = synthetic_check(args.steps, args.seed, args.horizon)
+    except (ValueError, OverflowError) as error:
+        parser.error(str(error))
+    if args.json:
+        print(json.dumps(report, indent=2, allow_nan=False))
+    else:
+        print(report["scope"])
+        methods = report["methods"]
+        assert isinstance(methods, dict)
+        for name, row in methods.items():
+            print(
+                f"{name}: base MSE={row['base_mse']:.6f}; corrected MSE={row['corrected_mse']:.6f}"
+            )
+
+
+if __name__ == "__main__":
+    main()

revisionlab-0.1.0.dist-info/METADATA

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: revisionlab
+Version: 0.1.0
+Summary: PyTorch-native delayed-feedback memory contracts, controls, and diagnostics
+Project-URL: Repository, https://github.com/cjw0076/revisionlab
+Project-URL: Issues, https://github.com/cjw0076/revisionlab/issues
+Author: cjw0076
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.24
+Requires-Dist: torch>=2.2
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: hatch>=1.13; extra == 'dev'
+Requires-Dist: mypy>=1.11; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Requires-Dist: twine>=5; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# RevisionLab
+
+**PyTorch-native delayed-feedback memory contracts, controls, and diagnostics.**
+
+RevisionLab records a prediction when it is issued, waits for its outcome to mature, and applies a residual-state update to the memory that owned the prediction. It provides a small substrate for testing delayed correction: immutable tickets, explicit memory interfaces, replay, negative controls, and resumable state.
+
+v0.1 focuses on fixed-capacity residual memory and RLS correction. It does not implement Cosmos v14 state splitting or the v10 learned-refinement toy. It makes no claim to support every neural architecture. [archcredit](https://github.com/cjw0076/archcredit) remains a separate architecture/credit benchmark library; RevisionLab does not depend on it.
+
+## Install and check
+
+From a checkout with Python 3.10 or newer:
+
+```powershell
+python -m pip install -e ".[dev]"
+revisionlab-check
+```
+
+The check runs a small synthetic delayed-feedback example. It does not download weather data or replay the historical experiment.
+
+## Minimal API
+
+```python
+import numpy as np
+from revisionlab import ResidualMemory
+from revisionlab.replay import DelayedReplay
+
+runner = DelayedReplay(ResidualMemory(2, rate=0.1), horizon=2)
+ticket = runner.issue(0, 1.0, np.array([1.0, 0.0]))
+error = runner.release(ticket.ticket_id, target=2.0, now_hour=2)
+assert ticket.prediction == 1.0
+assert error == 1.0
+assert runner.memory.read(np.array([1.0, 0.0])) == 0.1
+```
+
+See [examples/delayed_forecast.py](examples/delayed_forecast.py) for a complete replay example. `revisionlab.serialization.save_checkpoint(path, runner)` and `load_checkpoint(path)` preserve delayed-feedback runners using the four native built-in correctors. Custom correctors and the NumPy reference are not supported by these checkpoint helpers in v0.1.
+
+## Contracts
+
+| Boundary | Purpose |
+| --- | --- |
+| Prediction ticket | Keeps prediction-time key, baseline, actual forecast, maturity, and owner identity. |
+| Released evidence | Rejects targets that have not matured and invalid timestamp/target fields. |
+| Memory `read`/`write`/`snapshot` | Reads a correction, applies valid delayed evidence, and copies state. |
+| `DelayedReplay` | Owns tickets, evaluates the issued forecast, and settles feedback exactly once. |
+| Checkpoint | Preserves memory, replay owner, pending tickets, and settled identities for resume. |
+| Local alignment | Compares a correction update with a local residual-loss reference direction. |
+
+The NumPy reference and PyTorch-native implementations use fixed-capacity state. Negative controls are explicitly named; shuffled writes corrupt write addressing rather than demonstrating a new learning rule. A no-write control must preserve zero correction and perform no learning.
+
+`ResidualMemory(slots, rate)` is the native normalized-delta corrector. `revisionlab.baselines` provides `RLS_Corrector(slots, forget)`, `NoWrite(slots)`, and `ShuffledWrite(slots, rate, seed=...)`. See [the method manifest](docs/methods.md) for equations and clipping. Low-level memory `write` applies each valid call; **exactly-once settlement is a `DelayedReplay` guarantee**, not a guarantee of direct memory writes. Tickets retain prediction-time keys and forecasts, and the runner rejects duplicate/foreign settlement.
+
+Memory values have fixed capacity. Replay retains settled ticket identities for lifetime deduplication, so its total audit ledger grows with settled forecasts; report that overhead alongside pending tickets. Do not call the entire runner constant-memory.
+
+## What the evidence means
+
+Recovered v13 artifacts report the following historical mean joint MSE:
+
+| Historical policy | Mean joint MSE |
+| --- | ---: |
+| Frozen baseline | 2.122014 |
+| Native live residual | 2.092176 |
+| Live RLS | 2.070044 |
+
+These are prior-run receipts for one site and the first half of 2026, across five weight seeds. The residual method improved on the frozen baseline in that recorded setting, while RLS had the lower mean MSE. This release has not rerun the full weather experiment, established superiority over RLS, or demonstrated generalization to other climates. See [provenance](docs/provenance.md) and [historical evidence](docs/evidence/README.md).
+
+The original shuffled-write policy used a fixed cyclic permutation. The release's seeded `ShuffledWrite` control is a distinct policy and does not reproduce that historical control automatically.
+
+Local residual alignment `rho` is not full-model BPTT alignment. The delta primitive is differentiable, but that alone does not prove correct global credit assignment or causal memory capacity. Zero-norm directions have undefined alignment.
+
+## Development and contribution
+
+```powershell
+python -m ruff check .
+python -m ruff format --check .
+python -m mypy src/revisionlab
+python -m pytest
+python -m build
+python -m twine check dist/*
+```
+
+[CONTRIBUTING.md](CONTRIBUTING.md) explains the five-minute corrector recipe. CI covers Python 3.10/3.11/3.12, lint/format, types, tests, `aot_eager` compile/serialization/gradcheck, and wheel installation outside the checkout. A CI definition is not a claim that hosted jobs have already passed; current receipts belong in [STATE.md](STATE.md).
+
+See [release steps](docs/releasing.md) for TestPyPI/PyPI handoff and [the source audit](docs/source-audit.md) for adversarial regression requirements. No PyPI upload automation is configured. Licensed under [MIT](LICENSE); participation follows the [Code of Conduct](CODE_OF_CONDUCT.md).
+
+Local v0.1.0 validation: **95 tests passed, 1 CUDA hardware skip**; lint/format, strict package types, and separate reviews passed. See [verification evidence](docs/verification.md) and [release notes](docs/release-notes-v0.1.0.md). Hosted and publication receipts are recorded separately.

revisionlab-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+revisionlab/__init__.py,sha256=xNZ9bEB_rQF3vo0GSrduvxVV8urFLeqwbvxmRDSLmUA,541
+revisionlab/baselines.py,sha256=5EnkAK-02lK9MIx_YKpRjkJuUkkC_h19Zxo3Z41oxB8,6520
+revisionlab/diagnostics.py,sha256=y-QRr7Ij9FRX7TMLX60v7dGdKOU9JMg-3baAIqIEVZ8,1700
+revisionlab/memory.py,sha256=ZB5uiBZDHPqEm_7pQiMDiKVOmpTM2vHLo-v05R9fJ0c,8525
+revisionlab/protocols.py,sha256=WPOP35TayQhQqzRKryOkK15HznEhNT9e5ostM-ibq40,4499
+revisionlab/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+revisionlab/replay.py,sha256=4U81SS9wXjm7_FO3WnrZS6Hz_9FApSjCSl99-MFGQ4w,9189
+revisionlab/serialization.py,sha256=uhVuba79w4iVo2ba_KkhfNJ2m2YIdpFj-Nkhwfr4SII,5669
+revisionlab/smoke.py,sha256=AuVvLpxNx3Ws5GmjcQgwgSQgFKz-ErdPLihRE3PbfDA,3880
+revisionlab-0.1.0.dist-info/METADATA,sha256=TdzLTJV05x0O3YSts1skmKSOqWy0pm47AmYMUP2T3ts,6686
+revisionlab-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+revisionlab-0.1.0.dist-info/entry_points.txt,sha256=CGYpMf6zgpP7cD7sNiZaxnxopitGZhp2vm_9xNDMkbo,61
+revisionlab-0.1.0.dist-info/licenses/LICENSE,sha256=lWs6EroFZQ8AWVa1DyaiRcWRTLdYilkP8VJ1C8cPnJg,1093
+revisionlab-0.1.0.dist-info/RECORD,,

revisionlab-0.1.0.dist-info/WHEEL

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

revisionlab-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+revisionlab-check = revisionlab.smoke:main

revisionlab-0.1.0.dist-info/licenses/LICENSE

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