pasm2 2.0.0a9__py3-none-any.whl

pasm2/__init__.py

@@ -0,0 +1,55 @@
+"""PASM v2.0 —— 通用 AI 认知底座（独立演进包，与 pasm/ 平行，互不侵入）。
+
+定位
+----
+PASM v2.0：从「仿生认知引擎」走向「通用 AI 认知底座」。
+情感为核，逻辑为骨，语言为口，安全为界。给 AI 应用认知器官，而不是给 AI 应用指令。
+
+与 pasm/（0.7.x 现役引擎）的关系
+--------------------------------
+· 本包是**独立文件包**：不 import pasm/，pasm/ 也不 import 本包；
+  桌面端（PASM Studio）、PyPI 发行、现有发版链路均不受影响。
+· 唯一的显式关联是 `pasm2/engine_api.py`——它是 `pasm/engine_api.py`
+  的**同源镜像**（阶段 0 冻结基线，api 1.1），由
+  `tools/sync_engine_api_mirror.py --lite pasm2/engine_api.py --note pasm2`
+  同步并做漂移检测。
+· 两条版本轴各自独立：
+    · pasm/ 引擎轴   → pasm.__version__（0.7.x，现役，不因 v2.0 改动）
+    · pasm2/ 底座轴  → pasm2.__version__（2.0.0a0，从阶段 0 起步）
+    · 桌面产品轴     → desktop/appinfo.py 的 APP_VERSION（完全不沾）
+
+阶段 0（基线冻结）交付物
+------------------------
+    · engine_api.py   契约冻结镜像（api 1.1）
+    · config.py       消融开关框架 —— 所有 v2.0 新模块默认全关
+    · safety.py       层 -2 安全层入口：价值锚点（不可修改）+ 骨架
+    · evalkit/        成长日记 Schema（GrowthTrace）
+    · modules/        十九层架构规划注册表（只登记、不实现）
+    · tests/          tests/test_pasm2_baseline.py 回归基线
+    · 校验            tools/verify_pasm2_baseline.py
+
+开发纪律（源自 v2.0 方案）
+--------------------------
+契约先行 · 开关驱动 · 消融优先 · 异步写盘 · 可复现 · 回放验证；
+先安全后象量，先象量后符号，先验证后回写，先系统 1 后系统 2；
+每加一层必须有开关、有指标、有收益；守住 CPU 毫秒级、可解释、契约稳定三条底线。
+"""
+
+__version__ = "2.0.0a9"
+__author__ = "arronZheng (小志)"
+__stage__ = "9-final-brainwide"  # 阶段 9：小脑/DMN/显著网/自传体（收官）（应用开发者门面）
+__api_version__ = "1.1"           # 冻结的引擎接口契约版本（与 engine_api 镜像一致）
+
+from . import engine_api  # noqa: E402,F401  契约冻结镜像（零依赖，随包即用）
+from . import safety      # noqa: E402,F401  层 -2 安全层入口（价值锚点常开）
+
+
+def version_info() -> dict:
+    """版本自述（基线报告与桌面看板用）。"""
+    return {
+        "package": "pasm2",
+        "version": __version__,
+        "stage": __stage__,
+        "api_version": __api_version__,
+        "sibling_engine": "pasm 0.7.x（独立，互不依赖）",
+    }

pasm2/capabilities.py

@@ -0,0 +1,136 @@
+# -*- coding: utf-8 -*-
+"""pasm2 能力申报面（api 2.0-surface）——v2.0 九阶段收官（2026-09-29）。
+
+定位与纪律
+----------
+``pasm2/engine_api.py`` 是主仓 ``pasm/engine_api.py``（api 1.1）的**冻结镜像**，
+由 ``tools/sync_engine_api_mirror.py`` 做漂移检测——pasm2 不得单方面改动它。
+
+本模块是 pasm2 **自有**的能力申报层（surface，非契约镜像）：
+    · 应用层可据此探测"当前配置下引擎开了哪些能力"（诚实申报，不编造）；
+    · surface 版本随阶段推进（a9 = 九阶段全实装）；
+    · 冻结镜像 api 1.1 与本 surface 并存，互不干扰（单向隔离铁律不破）。
+
+用法
+----
+    from pasm2.capabilities import capabilities, SURFACE_VERSION
+    caps = capabilities(PASM2Config())            # 全关 → enabled 为空（诚实）
+    caps = capabilities(PASM2Config(use_cerebellum=True))
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+__all__ = ["SURFACE_VERSION", "STAGES", "STAGE_FLAGS", "capabilities",
+           "capability_diff", "selftest"]
+
+SURFACE_VERSION = "2.0-surface.a9"
+
+# 九阶段总览（与 MODULE_PLAN 对齐；status 以 MODULE_PLAN 为准，此处只做展示）
+STAGES: List[Dict[str, str]] = [
+    {"stage": "0", "title": "基线冻结（契约镜像 + 安全层 + 成长记录）"},
+    {"stage": "1", "title": "仿脑件（边界守卫/实体自组织/丘脑/四通道/工作记忆/ACC）"},
+    {"stage": "2", "title": "符号化梯度 + 符号注册 + 三角校验 + 失衡监测"},
+    {"stage": "3", "title": "记忆图关联 + 岛叶内感受 + 反事实推理"},
+    {"stage": "4", "title": "SLH 单向桥（符号↔外部映射 + 四路路由）"},
+    {"stage": "5", "title": "CognitiveKit SDK（三档门面）"},
+    {"stage": "6", "title": "数学脑 v2（mathlab）+ 路由动态分值 + 记忆图增量"},
+    {"stage": "7", "title": "双系统门控 + 量子叠加决策"},
+    {"stage": "8", "title": "CognitiveAssembler（声明式流水线装配）"},
+    {"stage": "9", "title": "小脑时序 + 显著性网络 + DMN + 自传体记忆"},
+]
+
+# 开关 → 所属阶段（selftest 校验每个键都是 PASM2Config 真实字段，fail-fast）
+STAGE_FLAGS: Dict[str, str] = {
+    # 阶段 1（注：安全层/价值锚定是内核一部分，不设开关，故不在此申报）
+    "use_entity_attractor": "1",
+    "use_thalamus": "1", "use_brainstem": "1",
+    "dopamine_channel": "1", "serotonin_channel": "1",
+    "norepinephrine_channel": "1", "acetylcholine_channel": "1",
+    "use_prospective_memory": "1",
+    "use_acc": "1", "use_emotional_memory": "1",
+    # 阶段 2
+    "use_predictive_context": "2", "use_symbolization": "2",
+    "use_triangulation": "2", "use_imbalance_monitor": "2",
+    # 阶段 3
+    "use_pattern_separation": "3", "use_system_consolidation": "3",
+    "use_reconsolidation": "3", "use_memory_graph": "3",
+    "use_insula": "3", "use_counterfactual": "3",
+    # 阶段 4
+    "use_symbol_mapping": "4", "use_four_way_routing": "4",
+    # 阶段 6
+    "use_quantization": "6", "use_dynamic_routing_score": "6",
+    # 阶段 7
+    "use_dual_system": "7", "use_quantum": "7",
+    # 阶段 9
+    "use_cerebellum": "9", "use_dmn": "9",
+    "use_salience_network": "9", "use_autobiographical": "9",
+}
+
+
+def capabilities(config: Any) -> Dict[str, Any]:
+    """给定配置，诚实申报开启的能力面（按阶段分组）。
+
+    返回：
+        {
+          "surface": SURFACE_VERSION,
+          "engine_stage": config 所在 pasm2.__stage__,
+          "enabled":   {"1": [flags...], "2": [...]},   # 只含开启项
+          "disabled":  n（关闭的受管开关数）,
+          "total_managed": n（受管开关总数）,
+        }
+    """
+    import dataclasses
+    fields = {f.name for f in dataclasses.fields(config)}
+    enabled: Dict[str, List[str]] = {}
+    disabled = 0
+    for flag, stage in STAGE_FLAGS.items():
+        if flag not in fields:
+            continue                      # 非受管/历史字段：跳过不申报
+        if getattr(config, flag):
+            enabled.setdefault(stage, []).append(flag)
+        else:
+            disabled += 1
+    import pasm2 as _p2
+    return {"surface": SURFACE_VERSION,
+            "engine_stage": getattr(_p2, "__stage__", "unknown"),
+            "enabled": dict(sorted(enabled.items())),
+            "disabled": disabled,
+            "total_managed": len([f for f in STAGE_FLAGS
+                                  if f in fields])}
+
+
+def capability_diff(base: Any, other: Any) -> Dict[str, List[str]]:
+    """对比两配置的能力差集（other 相对 base 新增开启的开关）。"""
+    cb, co = capabilities(base), capabilities(other)
+    fb = {f for v in cb["enabled"].values() for f in v}
+    fo = {f for v in co["enabled"].values() for f in v}
+    return {"added": sorted(fo - fb), "removed": sorted(fb - fo)}
+
+
+def selftest() -> str:
+    import dataclasses
+    import pasm2.config as p2config
+
+    fields = {f.name for f in dataclasses.fields(p2config.PASM2Config)}
+    bad = [f for f in STAGE_FLAGS if f not in fields]
+    assert not bad, "STAGE_FLAGS 含不存在的字段: %s" % bad
+
+    # 全关基线 → enabled 为空（诚实申报）
+    caps0 = capabilities(p2config.PASM2Config())
+    assert caps0["enabled"] == {} and caps0["disabled"] == caps0["total_managed"]
+    # 全开 → 覆盖阶段 1-9（5/8 是 SDK 层无开关，不在此申报）
+    cfg = p2config.PASM2Config(**{f: True for f in STAGE_FLAGS})
+    caps1 = capabilities(cfg)
+    assert set(caps1["enabled"]) == {"1", "2", "3", "4", "6", "7", "9"}, caps1
+    assert caps1["disabled"] == 0
+    # diff
+    d = capability_diff(p2config.PASM2Config(), cfg)
+    assert len(d["added"]) == len(STAGE_FLAGS) and d["removed"] == []
+    return ("capabilities selftest OK: %s / %d managed flags / stages %s"
+            % (SURFACE_VERSION, caps1["total_managed"],
+               sorted(caps1["enabled"])))
+
+
+if __name__ == "__main__":
+    print(selftest())

pasm2/cognitive/__init__.py

@@ -0,0 +1,9 @@
+"""pasm2.cognitive —— 阶段 6：认知体的高层数值/分析能力层。
+
+mathlab（数学脑 v2）是本包首个成员：与主仓 pasm/cognitive/mathlab.py 同源
+命名、pasm2 内自持实现（单向隔离铁律）。量化统计（quantize_vector /
+transition_matrix）是记忆图 δ 项与四路路由动态分值的离散统计底座。
+"""
+from . import mathlab
+
+__all__ = ["mathlab"]

pasm2/cognitive/mathlab.py

@@ -0,0 +1,318 @@
+"""pasm2.cognitive.mathlab —— 阶段 6：离散与线性分析（数学脑 v2）。
+
+定位：给 v2.0 认知体装上「会算」的脑子——纯 numpy，无重依赖，CPU 毫秒级。
+与主仓 `pasm/cognitive/mathlab.py`（v0.27.0 落地）**API 同源命名**，pasm2 内
+自持实现（pasm/ 单向隔离铁律：不 import pasm，也不被 pasm import）。
+
+能力清单（对齐 docs/roadmap_multimodal_quantum_math.md Phase A）：
+    线性   矩阵运算、行列式/秩、线性方程组求解（Gauss 消元）
+    线性   最小二乘线性回归（斜率/截距/R²/残差）、多元回归
+    统计   均值/方差/分位数/相关系数矩阵、离群点检测（IQR/z-score）
+    离散   图分析：拓扑排序（环检测）、最短路（Dijkstra）、连通分量
+    离散   排列组合、马尔可夫链稳态
+    量化   向量/序列离散化 + 转移矩阵统计（认知管线接入点：记忆图 δ 项
+           与四路路由分值的统计底座）
+
+诚实性纪律：输入退化（空序列/奇异矩阵/不连通图）如实申报，不编造数值。
+"""
+from __future__ import annotations
+
+import math
+from itertools import combinations
+from typing import Any, Dict, List, Optional, Sequence, Tuple
+
+import numpy as np
+
+__all__ = [
+    "fit_linear", "fit_multi_linear", "describe", "corr_matrix",
+    "solve_linear_system", "matrix_facts",
+    "topo_sort", "has_cycle", "dijkstra", "connected_components",
+    "markov_steady", "choose",
+    "quantize_vector", "quantize_series", "transition_matrix",
+]
+
+
+def _f(x: Any) -> float:
+    return float(x)
+
+
+# ================= 线性 =================
+def fit_linear(x: Sequence[float], y: Sequence[float]) -> dict:
+    """最小二乘一元线性回归：slope/intercept/r2/rmse/n（不足 2 点诚实报错）。"""
+    if len(x) != len(y) or len(x) < 2:
+        return {"ok": False, "reason": "need len(x)==len(y)>=2"}
+    xs = np.asarray(x, dtype=np.float64)
+    ys = np.asarray(y, dtype=np.float64)
+    if float(np.std(xs)) < 1e-12:
+        return {"ok": False, "reason": "x is constant"}
+    slope, intercept = np.polyfit(xs, ys, 1)
+    pred = slope * xs + intercept
+    resid = ys - pred
+    ss_res = float(np.sum(resid ** 2))
+    ss_tot = float(np.sum((ys - ys.mean()) ** 2))
+    r2 = 1.0 - ss_res / ss_tot if ss_tot > 1e-12 else 1.0
+    return {"ok": True, "slope": round(float(slope), 6),
+            "intercept": round(float(intercept), 6), "r2": round(r2, 6),
+            "rmse": round(math.sqrt(ss_res / len(xs)), 6), "n": len(xs)}
+
+
+def fit_multi_linear(X: Sequence[Sequence[float]], y: Sequence[float],
+                     ridge: float = 0.0) -> dict:
+    """多元最小二乘（可加 ridge 正则）；奇异/欠定时诚实申报。"""
+    A = np.asarray(X, dtype=np.float64)
+    t = np.asarray(y, dtype=np.float64)
+    if A.ndim != 2 or A.shape[0] != t.size or A.shape[0] == 0:
+        return {"ok": False, "reason": "shape mismatch"}
+    M = np.hstack([A, np.ones((A.shape[0], 1))])
+    G = M.T @ M + ridge * np.eye(M.shape[1])
+    try:
+        w = np.linalg.solve(G, M.T @ t)
+    except np.linalg.LinAlgError:
+        return {"ok": False, "reason": "singular"}
+    pred = M @ w
+    resid = t - pred
+    ss_res = float(np.sum(resid ** 2))
+    ss_tot = float(np.sum((t - t.mean()) ** 2))
+    r2 = 1.0 - ss_res / ss_tot if ss_tot > 1e-12 else 1.0
+    return {"ok": True, "coef": [round(float(v), 6) for v in w[:-1]],
+            "intercept": round(float(w[-1]), 6), "r2": round(r2, 6),
+            "rmse": round(math.sqrt(ss_res / len(t)), 6)}
+
+
+def describe(series: Sequence[float], name: str = "") -> dict:
+    """描述统计：n/mean/std/min/q25/median/q75/max/IQR 离群点。"""
+    a = np.asarray(series, dtype=np.float64)
+    if a.size == 0:
+        return {"ok": False, "reason": "empty series", "name": name}
+    q1, med, q3 = (float(np.percentile(a, p)) for p in (25, 50, 75))
+    iqr = q3 - q1
+    lo, hi = q1 - 1.5 * iqr, q3 + 1.5 * iqr
+    outliers = [round(float(v), 6) for v in a[(a < lo) | (a > hi)]]
+    return {"ok": True, "name": name, "n": int(a.size),
+            "mean": round(float(a.mean()), 6),
+            "std": round(float(a.std()), 6),
+            "min": round(float(a.min()), 6), "q25": round(q1, 6),
+            "median": round(med, 6), "q75": round(q3, 6),
+            "max": round(float(a.max()), 6), "iqr": round(iqr, 6),
+            "outliers_iqr": outliers}
+
+
+def corr_matrix(rows: Sequence[Sequence[float]],
+                cols: Optional[List[str]] = None) -> dict:
+    """相关系数矩阵（列数 < 2 或常数列诚实申报）。"""
+    A = np.asarray(rows, dtype=np.float64)
+    if A.ndim != 2 or A.shape[0] < 2 or A.shape[1] < 2:
+        return {"ok": False, "reason": "need >=2 rows and >=2 cols"}
+    with np.errstate(divide="ignore", invalid="ignore"):
+        C = np.corrcoef(A, rowvar=False)
+    C = np.where(np.isfinite(C), C, 0.0)       # 常数列相关系数无定义 → 0 并申报
+    degenerate = [j for j in range(A.shape[1])
+                  if float(np.std(A[:, j])) < 1e-12]
+    names = cols or ["c%d" % j for j in range(A.shape[1])]
+    return {"ok": True, "cols": names,
+            "matrix": [[round(float(v), 6) for v in row] for row in C],
+            "degenerate_cols": degenerate}
+
+
+def solve_linear_system(A: Sequence[Sequence[float]],
+                        b: Sequence[float]) -> dict:
+    """Gauss 消元解 Ax=b（奇异时诚实申报，不凑数）。"""
+    M = np.asarray(A, dtype=np.float64)
+    v = np.asarray(b, dtype=np.float64)
+    if M.ndim != 2 or M.shape[0] != v.size:
+        return {"ok": False, "reason": "shape mismatch"}
+    try:
+        x = np.linalg.solve(M, v)
+    except np.linalg.LinAlgError as e:
+        return {"ok": False, "reason": "singular: %s" % e}
+    return {"ok": True,
+            "solution": [round(float(val), 6) for val in x]}
+
+
+def matrix_facts(A: Sequence[Sequence[float]]) -> dict:
+    """行列式/秩/迹/条件数。"""
+    M = np.asarray(A, dtype=np.float64)
+    if M.ndim != 2 or M.size == 0:
+        return {"ok": False, "reason": "need 2-D matrix"}
+    return {"ok": True, "shape": list(M.shape),
+            "det": round(float(np.linalg.det(M)), 6) if M.shape[0] == M.shape[1] else None,
+            "rank": int(np.linalg.matrix_rank(M)),
+            "trace": round(float(np.trace(M)), 6),
+            "cond": (round(float(np.linalg.cond(M)), 6)
+                     if M.shape[0] == M.shape[1] else None)}
+
+
+# ================= 离散（图） =================
+def topo_sort(n: int, edges: Sequence[Tuple[int, int]]) -> dict:
+    """Kahn 拓扑排序；有环返回 ok=False + 环上节点（流程依赖校验用）。"""
+    adj: List[List[int]] = [[] for _ in range(n)]
+    indeg = [0] * n
+    for u, v in edges:
+        if not (0 <= u < n and 0 <= v < n):
+            return {"ok": False, "reason": "node out of range"}
+        adj[u].append(v)
+        indeg[v] += 1
+    queue = [i for i in range(n) if indeg[i] == 0]
+    order: List[int] = []
+    while queue:
+        u = queue.pop(0)
+        order.append(u)
+        for v in adj[u]:
+            indeg[v] -= 1
+            if indeg[v] == 0:
+                queue.append(v)
+    if len(order) != n:
+        cyclic = sorted(i for i in range(n) if indeg[i] > 0)
+        return {"ok": False, "reason": "cycle", "cyclic_nodes": cyclic}
+    return {"ok": True, "order": order}
+
+
+def has_cycle(n: int, edges: Sequence[Tuple[int, int]]) -> bool:
+    return not topo_sort(n, edges)["ok"]
+
+
+def dijkstra(graph: Dict[int, List[Tuple[int, float]]],
+             src: int) -> Dict[int, float]:
+    """最短路（不可达节点不出现在结果里）。"""
+    import heapq
+    dist: Dict[int, float] = {src: 0.0}
+    heap = [(0.0, src)]
+    seen = set()
+    while heap:
+        d, u = heapq.heappop(heap)
+        if u in seen:
+            continue
+        seen.add(u)
+        for v, w in graph.get(u, ()):
+            nd = d + float(w)
+            if nd < dist.get(v, math.inf):
+                dist[v] = nd
+                heapq.heappush(heap, (nd, v))
+    return {k: round(v, 6) for k, v in dist.items() if k != src}
+
+
+def connected_components(n: int, edges: Sequence[Tuple[int, int]]) -> dict:
+    """无向连通分量（并查集）。"""
+    parent = list(range(n))
+
+    def find(x: int) -> int:
+        while parent[x] != x:
+            parent[x] = parent[parent[x]]
+            x = parent[x]
+        return x
+
+    for u, v in edges:
+        ru, rv = find(u), find(v)
+        if ru != rv:
+            parent[ru] = rv
+    groups: Dict[int, List[int]] = {}
+    for i in range(n):
+        groups.setdefault(find(i), []).append(i)
+    comps = sorted((sorted(g) for g in groups.values()), key=len, reverse=True)
+    return {"ok": True, "n_components": len(comps),
+            "components": comps, "largest": comps[0] if comps else []}
+
+
+# ================= 离散（组合 / 马尔可夫） =================
+def choose(n: int, k: int) -> int:
+    if k < 0 or k > n:
+        return 0
+    return math.comb(n, k)
+
+
+def markov_steady(P: Sequence[Sequence[float]],
+                  iters: int = 2000) -> dict:
+    """行随机矩阵幂法求稳态分布；非行随机诚实申报。"""
+    M = np.asarray(P, dtype=np.float64)
+    if M.ndim != 2 or M.shape[0] != M.shape[1] or M.shape[0] == 0:
+        return {"ok": False, "reason": "need square matrix"}
+    row_sums = M.sum(axis=1)
+    if not np.allclose(row_sums, 1.0, atol=1e-6):
+        return {"ok": False, "reason": "not row-stochastic",
+                "row_sums": [round(float(s), 6) for s in row_sums]}
+    pi = np.full(M.shape[0], 1.0 / M.shape[0])
+    for _ in range(iters):
+        pi = pi @ M
+    return {"ok": True,
+            "steady": [round(float(v), 6) for v in pi]}
+
+
+# ================= 量化（认知管线接入点） =================
+def quantize_vector(z: Sequence[float], levels: int = 4,
+                    lo: Optional[float] = None,
+                    hi: Optional[float] = None) -> List[int]:
+    """连续向量 → 均匀离散码（0..levels-1）。
+
+    lo/hi 缺省用向量自身 min/max（自适应）；lo==hi（常向量）→ 全 0 码，
+    如实退化不报错。记忆图统计相关项（δ 项）与路由分值的离散统计底座。
+    """
+    a = np.asarray(z, dtype=np.float64)
+    if a.size == 0 or levels < 1:
+        return []
+    lo_v = float(a.min()) if lo is None else float(lo)
+    hi_v = float(a.max()) if hi is None else float(hi)
+    if hi_v - lo_v < 1e-12:
+        return [0] * a.size
+    idx = np.clip(((a - lo_v) / (hi_v - lo_v) * levels).astype(int),
+                  0, levels - 1)
+    return [int(v) for v in idx]
+
+
+def quantize_series(series: Sequence[float], levels: int = 4) -> List[int]:
+    """标量序列量化（等价于 quantize_vector 的一维情形）。"""
+    return quantize_vector(series, levels=levels)
+
+
+def transition_matrix(codes: Sequence[int], n_states: Optional[int] = None,
+                      alpha: float = 0.0) -> dict:
+    """离散码序列 → 转移计数/概率矩阵（可选 Laplace 平滑 alpha）。
+
+    返回 {ok, n_states, counts, probs, n_transitions}；probs 行归一
+    （平滑后），可与 markov_steady 串联求稳态分布。
+    """
+    c = list(codes)
+    if len(c) < 2:
+        return {"ok": False, "reason": "need >=2 codes"}
+    n = n_states if n_states is not None else (max(c) + 1)
+    if min(c) < 0 or max(c) >= n:
+        return {"ok": False, "reason": "code out of range"}
+    counts = np.full((n, n), float(alpha))
+    for a, b in zip(c[:-1], c[1:]):
+        counts[a][b] += 1.0
+    row_sums = counts.sum(axis=1, keepdims=True)
+    probs = np.divide(counts, np.maximum(row_sums, 1e-12))
+    return {"ok": True, "n_states": int(n), "n_transitions": len(c) - 1,
+            "counts": counts.astype(int).tolist(),
+            "probs": [[round(float(v), 6) for v in row] for row in probs]}
+
+
+# ================= 自检 =================
+def selftest() -> str:
+    rng = np.random.RandomState(0)
+    xs = list(range(20))
+    ys = [2.0 * x + 1.0 + rng.randn() * 0.1 for x in xs]
+    fl = fit_linear(xs, ys)
+    assert fl["ok"] and abs(fl["slope"] - 2.0) < 0.05 and fl["r2"] > 0.99
+    sol = solve_linear_system([[2, 1], [1, 3]], [5, 10])
+    assert sol["ok"] and abs(sol["solution"][0] - 1.0) < 1e-6
+    assert solve_linear_system([[1, 2], [2, 4]], [1, 2])["ok"] is False
+    ts = topo_sort(3, [(0, 1), (1, 2)])
+    assert ts["ok"] and ts["order"] == [0, 1, 2]
+    assert has_cycle(2, [(0, 1), (1, 0)]) is True
+    d = dijkstra({0: [(1, 1.0), (2, 4.0)], 1: [(2, 1.0)]}, 0)
+    assert d[2] == 2.0
+    cc = connected_components(4, [(0, 1), (2, 3)])
+    assert cc["n_components"] == 2
+    ms = markov_steady([[0.5, 0.5], [0.5, 0.5]])
+    assert ms["ok"] and abs(ms["steady"][0] - 0.5) < 1e-3
+    assert markov_steady([[0.5, 0.4], [0.5, 0.6]])["ok"] is False
+    ds = describe([1, 2, 3, 4, 100])
+    assert ds["ok"] and 100 in ds["outliers_iqr"]
+    q = quantize_vector([0.0, 0.24, 0.26, 1.0], levels=4)
+    assert q == [0, 0, 1, 3]
+    tm = transition_matrix([0, 1, 0, 1, 1])
+    assert tm["ok"] and tm["n_transitions"] == 4
+    ms2 = markov_steady(tm["probs"])
+    assert ms2["ok"]
+    return ("mathlab selftest OK: linear/stats/graph/markov/quantize "
+            "all honest")