kappalogic 0.9.0__py3-none-any.whl

kappalogic/__init__.py

@@ -0,0 +1,59 @@
+from .core import (
+    sgn, reg, NOT, AND, OR, NAND, NOR, XOR, XNOR, AND_n, OR_n,
+    eq, neq, gt, lt, ge, le, DEFAULT_XI, DEFAULT_KERNEL,
+)
+from .funcs import intf, par, maxf, minf, clamp
+from .applications import (
+    kronecker_delta, levi_civita, dirac_delta_integral,
+    line_intersection_y, collatz_step, collatz_sequence,
+    choc_bar_source,
+)
+from .kernels import KERNELS, apply_kernel
+from .heat import xi_of_time, time_of_xi, heat_step_profile, heat_kernel_gaussian, gaussian_match
+from .quantum_well import (
+    box_heat_kernel, box_heat_kernel_eigen,
+    infinite_well_propagator, infinite_well_propagator_eigen,
+)
+from .search import soft_gt, soft_eq, soft_or, soft_and, anneal_solve, numeric_grad, l2_penalty
+from .field_theory import kink_profile, kink_eom_residual, kink_energy_exact, topological_charge
+from .stat_mech import box_partition_function, box_partition_function_exact, witten_index_toy
+from .info_theory import (
+    gaussian_variance, differential_entropy_gaussian,
+    fisher_information_gaussian, de_bruijn_check,
+)
+from .topology import morse_index, euler_characteristic
+from .spacetime import inside_lightcone, future_lightcone
+from .bridge import floor_smooth, sum_via_integral, gamma_via_riemann_sum
+from .electronic_structure import (
+    fermi_occupation, tight_binding_chain_energies,
+    find_chemical_potential, total_energy_smeared,
+    tight_binding_dos_continuum, continuum_filling, continuum_energy, continuum_find_mu,
+)
+from .theory import max_gradient_location, max_gradient_value, is_single_passing_at_zero, fusion_is_safe
+
+__all__ = [
+    "sgn", "reg", "NOT", "AND", "OR", "NAND", "NOR", "XOR", "XNOR", "AND_n", "OR_n",
+    "eq", "neq", "gt", "lt", "ge", "le", "DEFAULT_XI", "DEFAULT_KERNEL",
+    "intf", "par", "maxf", "minf", "clamp",
+    "kronecker_delta", "levi_civita", "dirac_delta_integral",
+    "line_intersection_y", "collatz_step", "collatz_sequence",
+    "choc_bar_source",
+    "KERNELS", "apply_kernel",
+    "xi_of_time", "time_of_xi", "heat_step_profile", "heat_kernel_gaussian", "gaussian_match",
+    "box_heat_kernel", "box_heat_kernel_eigen",
+    "infinite_well_propagator", "infinite_well_propagator_eigen",
+    "soft_gt", "soft_eq", "soft_or", "soft_and", "anneal_solve", "numeric_grad", "l2_penalty",
+    "kink_profile", "kink_eom_residual", "kink_energy_exact", "topological_charge",
+    "box_partition_function", "box_partition_function_exact", "witten_index_toy",
+    "gaussian_variance", "differential_entropy_gaussian",
+    "fisher_information_gaussian", "de_bruijn_check",
+    "morse_index", "euler_characteristic",
+    "inside_lightcone", "future_lightcone",
+    "floor_smooth", "sum_via_integral", "gamma_via_riemann_sum",
+    "fermi_occupation", "tight_binding_chain_energies",
+    "find_chemical_potential", "total_energy_smeared",
+    "tight_binding_dos_continuum", "continuum_filling", "continuum_energy", "continuum_find_mu",
+    "max_gradient_location", "max_gradient_value", "is_single_passing_at_zero", "fusion_is_safe",
+]
+
+__version__ = "0.9.0"

kappalogic/applications.py

@@ -0,0 +1,88 @@
+"""
+kappalogic.applications
+=========================
+応用19〜20の実例。
+
+注意 (実装時に見つかった原設計の誤り):
+    応用20のコラッツ漸化式
+        f(x+1) = (f(x)/2)*int(x/2) + (3f(x)+1)*int((x+1)/2)
+    は "ステップ番号 x" の偶奇で分岐しているが、コラッツ写像は
+    本来 "現在の値 f(x)" の偶奇で分岐すべきものなので、この式は
+    数値検証の結果、2ステップ目から真の数列と一致しないことを確認した
+    (例: n0=27 -> 真の値82 に対しこの式は13.5を返す)。
+    本実装では par(f(x)) (修正済みの奇偶判定) を使って
+        f(x+1) = (f(x)/2)*(1-par(f(x))) + (3f(x)+1)*par(f(x))
+    と書き換え、n0=27 (111ステップ、最大値9232) を含む多数の初期値で
+    真のコラッツ数列と完全一致することを確認済み。
+"""
+import numpy as np
+from .core import eq, gt, lt, AND
+from .funcs import par
+
+
+def kronecker_delta(i, j, xi=1e-3):
+    """delta_ij = (i=j)"""
+    return eq(i, j, xi)
+
+
+def levi_civita(i, j, k, xi=1e-3):
+    """epsilon_ijk = sgn((i-j)(j-k)(k-i))  ※重複指標では0になる"""
+    from .core import sgn
+    return sgn((i - j) * (j - k) * (k - i), xi)
+
+
+def dirac_delta_integral(f, a, xs, weights):
+    """
+    ∫ f(x) delta(x-a) dx = f(x)(x=a) の離散近似。
+    xs, weights: 数値積分用の分点と重み (例: 台形則の点と幅)
+    """
+    xs = np.asarray(xs, dtype=float)
+    fx = np.asarray([f(x) for x in xs])
+    return np.sum(fx * eq(xs, a) * weights)
+
+
+def line_intersection_y(a, b, c, d, x):
+    """
+    2直線 y=ax+b, y=cx+d の交点のy座標を
+    ((ax+b)=(cx+d)) という等式インジケータで表現した式の値。
+    (本来は交点のxを解いて代入するのが素直だが、
+     "式の中に方程式の解を埋め込む" という応用19の考え方の例として、
+     xを動かしたときに交点近傍だけ1になることを確認するデモ)
+    """
+    return eq(a * x + b, c * x + d)
+
+
+def collatz_step(fx, xi=1e-3):
+    """
+    修正済みコラッツ漸化式: f(x)の偶奇で分岐(元式のバグを修正)。
+    f(x+1) = (f(x)/2)(1-par(f(x))) + (3f(x)+1)(par(f(x)))
+    """
+    p = par(fx)
+    return (fx / 2) * (1 - p) + (3 * fx + 1) * p
+
+
+def collatz_sequence(n0, max_steps=1000):
+    """collatz_step を繰り返し適用して数列を生成 (n=1で停止)"""
+    seq = [float(n0)]
+    fx = float(n0)
+    for _ in range(max_steps):
+        if abs(fx - 1) < 1e-6:
+            break
+        fx = float(collatz_step(fx))
+        seq.append(fx)
+    return seq
+
+
+def choc_bar_source(x, y, z, a, b, c, rho, xi=1e-3):
+    """
+    密度rho, 幅a x 奥行b x 高さc の直方体(板チョコ)が作る
+    ポアソン方程式の右辺: 4*pi*rho * (箱の内部なら1、外なら0)
+    """
+    inside = AND(
+        AND(lt(x, a / 2, xi), lt(y, b / 2, xi), xi),
+        AND(lt(z, c / 2, xi),
+            AND(gt(x, -a / 2, xi), AND(gt(y, -b / 2, xi), gt(z, -c / 2, xi), xi), xi),
+            xi),
+        xi,
+    )
+    return 4 * np.pi * rho * inside

kappalogic/bridge.py

@@ -0,0 +1,42 @@
+"""
+kappalogic.bridge
+====================
+Σ(離散和)と∫(連続積分)の橋渡し。
+
+floor(x) = sum_{k=1}^{K} Theta(x-k) (x>0, K>=floor(x)で十分) という
+初等的な恒等式を、このライブラリのgt(符号保存版の大小比較)の総和として
+実装する。これにより
+    sum_{n=0}^{N} f(n) = integral_0^{N+1} f(floor(x)) dx
+という初等解析の恒等式を、gtゲートの総和で明示的に構成できる。
+
+n!とGamma関数(Γ(n+1)=∫_0^∞ t^n e^{-t} dt = n!、オイラー積分)の
+数値実験で、Σ(離散和)→∫(オイラー積分)→n!(階乗)の一致を検証済み
+(相対誤差~1e-11、中点則で十分な精度)。
+"""
+import numpy as np
+import math
+from .core import gt, DEFAULT_XI
+
+
+def floor_smooth(x, K=50, xi=DEFAULT_XI):
+    """floor(x) = sum_{k=1}^{K} gt(x,k) の近似(x>0, K>=想定される最大値+1)。"""
+    return sum(gt(x, k, xi) for k in range(1, K + 1))
+
+
+def sum_via_integral(f, N, xi=DEFAULT_XI, n_points=200000):
+    """
+    sum_{n=0}^{N} f(n) を integral_0^{N+1} f(floor_smooth(x)) dx として
+    数値積分で計算する(Σ->∫の橋渡しの実演)。fは整数引数を取る関数。
+    """
+    xs = np.linspace(0, N + 1, n_points)
+    fx = np.array([f(int(round(floor_smooth(x, K=N + 2, xi=xi)))) for x in xs])
+    return np.trapezoid(fx, xs)
+
+
+def gamma_via_riemann_sum(n, dt=0.01, t_max=200):
+    """
+    Gamma(n+1) = integral_0^inf t^n e^{-t} dt を中点則のリーマン和で近似する。
+    dt->0でn!(math.factorial(n))に収束することを確認済み(相対誤差~1e-11@dt=0.1)。
+    """
+    ts = np.arange(dt / 2, t_max, dt)
+    return np.sum(ts ** n * np.exp(-ts)) * dt

kappalogic/core.py

@@ -0,0 +1,118 @@
+"""
+kappalogic.core
+================
+tanh(x/xi) を土台にした「擬連続論理」の基本ゲート群。
+v0.2: kernel引数でtanh/erf/algebraicを切り替え可能に(kernels.py参照)。
+デフォルトはtanhのままなので、v0.1のコードはそのまま動く。
+
+注意 (実装時に見つかった原設計の誤り。詳細はdev_notes.md):
+    ユーザー原案の定義10・定義11
+        (A>B) := not(reg(A-B) - 1)
+        (A<B) := not(reg(A-B) + 1)
+    は reg() が sgn() を2乗するため符号情報を失っており、実際には
+    A>B でも A<B でも同じ値を返してしまうことを数値検証で確認した。
+    本実装では符号を保持する sgn() を使った
+        (A>B) := (sgn(A-B) + reg(A-B)) / 2
+        (A<B) := (reg(A-B) - sgn(A-B)) / 2
+    に置き換えて正しく動作することを確認済み。
+"""
+import numpy as np
+from .kernels import apply_kernel
+
+DEFAULT_XI = 1e-3
+DEFAULT_KERNEL = "tanh"
+
+
+def sgn(x, xi=DEFAULT_XI, kernel=DEFAULT_KERNEL):
+    """kappa(x/xi): x>0 -> +1, x=0 -> 0, x<0 -> -1 (符号を保持)"""
+    return apply_kernel(x, xi, kernel)
+
+
+def reg(x, xi=DEFAULT_XI, kernel=DEFAULT_KERNEL):
+    """sgn(x)^2: x!=0 -> 1, x=0 -> 0 (符号情報は失われる)"""
+    return sgn(x, xi, kernel) ** 2
+
+
+def NOT(x, xi=DEFAULT_XI, kernel=DEFAULT_KERNEL):
+    """1 - reg(x): x==0 -> 1, x!=0 -> 0"""
+    return 1 - reg(x, xi, kernel)
+
+
+def AND(a, b, xi=DEFAULT_XI, kernel=DEFAULT_KERNEL):
+    """a,b が共に非0のとき1、さもなければ0"""
+    return reg(a * b, xi, kernel)
+
+
+def OR(a, b, xi=DEFAULT_XI, kernel=DEFAULT_KERNEL):
+    """a,b が共に0のとき0、さもなければ1"""
+    return NOT(NOT(a, xi, kernel) * NOT(b, xi, kernel), xi, kernel)
+
+
+def NAND(a, b, xi=DEFAULT_XI, kernel=DEFAULT_KERNEL):
+    return NOT(AND(a, b, xi, kernel), xi, kernel)
+
+
+def NOR(a, b, xi=DEFAULT_XI, kernel=DEFAULT_KERNEL):
+    return NOT(OR(a, b, xi, kernel), xi, kernel)
+
+
+def XOR(a, b, xi=DEFAULT_XI, kernel=DEFAULT_KERNEL):
+    return OR(AND(a, NOT(b, xi, kernel), xi, kernel),
+              AND(NOT(a, xi, kernel), b, xi, kernel), xi, kernel)
+
+
+def XNOR(a, b, xi=DEFAULT_XI, kernel=DEFAULT_KERNEL):
+    return NOT(XOR(a, b, xi, kernel), xi, kernel)
+
+
+def AND_n(*vals, xi=DEFAULT_XI, kernel=DEFAULT_KERNEL):
+    """
+    n項ANDの融合版(カルノー図的簡約): AND(AND(a,b),c,...) と数学的に等価だが、
+    先に全部の積を取ってからreg()を1回だけ呼ぶので (1) 高速 (2) 境界付近の
+    値が混在していても他の値の大きさで判定を安定化できる、という利点がある
+    (詳細・ベンチマークはdev_notes.md)。
+    """
+    prod = 1.0
+    for v in vals:
+        prod = prod * v
+    return reg(prod, xi, kernel)
+
+
+def OR_n(*vals, xi=DEFAULT_XI, kernel=DEFAULT_KERNEL):
+    """n項ORの融合版: OR(OR(a,b),c,...) と数学的に等価。AND_nと同じ利点。"""
+    prod = 1.0
+    for v in vals:
+        prod = prod * NOT(v, xi, kernel)
+    return NOT(prod, xi, kernel)
+
+
+def eq(a, b, xi=DEFAULT_XI, kernel=DEFAULT_KERNEL):
+    """(A=B): A==B -> 1, else 0"""
+    return NOT(a - b, xi, kernel)
+
+
+def neq(a, b, xi=DEFAULT_XI, kernel=DEFAULT_KERNEL):
+    """(A≠B): A!=B -> 1, else 0"""
+    return reg(a - b, xi, kernel)
+
+
+def gt(a, b, xi=DEFAULT_XI, kernel=DEFAULT_KERNEL):
+    """(A>B): A>B -> 1, else 0  (符号を保持した修正版)"""
+    d = a - b
+    return (sgn(d, xi, kernel) + reg(d, xi, kernel)) / 2
+
+
+def lt(a, b, xi=DEFAULT_XI, kernel=DEFAULT_KERNEL):
+    """(A<B): A<B -> 1, else 0  (符号を保持した修正版)"""
+    d = a - b
+    return (reg(d, xi, kernel) - sgn(d, xi, kernel)) / 2
+
+
+def ge(a, b, xi=DEFAULT_XI, kernel=DEFAULT_KERNEL):
+    """(A≧B): A>=B -> 1, else 0"""
+    return OR(eq(a, b, xi, kernel), gt(a, b, xi, kernel), xi, kernel)
+
+
+def le(a, b, xi=DEFAULT_XI, kernel=DEFAULT_KERNEL):
+    """(A≦B): A<=B -> 1, else 0"""
+    return OR(eq(a, b, xi, kernel), lt(a, b, xi, kernel), xi, kernel)

kappalogic/electronic_structure.py

@@ -0,0 +1,93 @@
+"""
+kappalogic.electronic_structure
+===================================
+密度汎関数理論(DFT)への接続。
+
+発見: フェルミ・ディラック分布(有限温度の電子占有数)
+    f(eps) = 1/(1+exp((eps-mu)/kT))
+は代数的に 1/(1+e^{-y}) = (1+tanh(y/2))/2 という恒等式そのものなので、
+このライブラリの sgn(x,xi)=tanh(x/xi) を使って
+    occupation(eps,mu,xi=2*kT) = (1+sgn(mu-eps,xi))/2
+と書けば、フェルミ・ディラック分布と機械精度で完全に一致する
+(xi = 2*kT が正しい対応関係。検証済み)。
+
+これは、DFT計算コード(VASP, Quantum ESPRESSOなど)で金属を扱う際に
+使われる「電子スメアリング」という実務的な数値手法と、このライブラリの
+「hard(T=0のステップ関数)/soft(xi>0でなだらか)の二重性」が
+数学的に同一であることを意味する。1次元タイトバインディング鎖で、
+xi(スメアリング幅)を0に近づけると全電子エネルギーがT=0の厳密値に
+収束することを数値実験で確認した。
+
+【訂正】当初、有限鎖(N=200)での収束次数が教科書的なO(kT^2)
+(ゾンマーフェルト展開)より速く見える現象を確認したが、これは
+有限系サイズ(離散準位)+二分探索の精度限界による数値アーティファクト
+だった。連続体の状態密度(tight_binding_dos_continuum)で高精度に
+(scipy.integrate.quad + brentq)再計算したところ、xiを半分にする
+たびの誤差比が4.00で安定し、標準的なO(xi^2)であることを確認した
+(dev_notes.md参照)。
+"""
+import numpy as np
+from .core import sgn
+
+
+def fermi_occupation(eps, mu, kT):
+    """
+    フェルミ・ディラック占有数。sgn(x,xi=2*kT)を使って実装。
+    kT->0でハードなステップ関数(T=0の占有)に収束する。
+    """
+    xi = 2 * kT
+    return (1 + sgn(mu - eps, xi)) / 2
+
+
+def tight_binding_chain_energies(N, t_hop=1.0):
+    """1次元タイトバインディング鎖(周期境界条件)のエネルギー準位。eps_k=-2*t*cos(k)"""
+    j = np.arange(N)
+    k = 2 * np.pi * j / N
+    return -2 * t_hop * np.cos(k)
+
+
+def find_chemical_potential(eps, target_occupation, kT, lo=-10.0, hi=10.0, iters=60):
+    """占有数の合計がtarget_occupationになるようmuを二分探索で求める。"""
+    for _ in range(iters):
+        mid = (lo + hi) / 2
+        occ = np.sum(fermi_occupation(eps, mid, kT))
+        if occ < target_occupation:
+            lo = mid
+        else:
+            hi = mid
+    return (lo + hi) / 2
+
+
+def tight_binding_dos_continuum(eps, t_hop=1.0):
+    """1次元タイトバインディングの厳密な連続体状態密度: g(eps)=1/(pi*sqrt(4t^2-eps^2))"""
+    return 1.0 / (np.pi * np.sqrt(4 * t_hop ** 2 - eps ** 2 + 1e-300))
+
+
+def continuum_filling(mu, xi, t_hop=1.0):
+    """連続体極限でのフィリング(占有数の積分)。scipy.integrate.quadで高精度計算。"""
+    from scipy import integrate
+    f = lambda eps: tight_binding_dos_continuum(eps, t_hop) * fermi_occupation(eps, mu, xi / 2)
+    val, _ = integrate.quad(f, -2 * t_hop + 1e-9, 2 * t_hop - 1e-9, limit=200)
+    return val
+
+
+def continuum_energy(mu, xi, t_hop=1.0):
+    """連続体極限での全電子エネルギー(1電子あたり)。有限系サイズ効果を排除した検証用。"""
+    from scipy import integrate
+    f = lambda eps: eps * tight_binding_dos_continuum(eps, t_hop) * fermi_occupation(eps, mu, xi / 2)
+    val, _ = integrate.quad(f, -2 * t_hop + 1e-9, 2 * t_hop - 1e-9, limit=200)
+    return val
+
+
+def continuum_find_mu(target, xi, t_hop=1.0):
+    """連続体極限での化学ポテンシャルをbrentqで高精度に求める(有限系の二分探索精度限界を回避)。"""
+    from scipy import optimize
+    g = lambda mu: continuum_filling(mu, xi, t_hop) - target
+    return optimize.brentq(g, -2 * t_hop, 2 * t_hop, xtol=1e-12)
+
+
+def total_energy_smeared(eps, target_occupation, kT):
+    """スメアリング(有限kT)を使った全電子エネルギーの計算(有限鎖版、DFTでの標準的な手法)。"""
+    mu = find_chemical_potential(eps, target_occupation, kT)
+    occ = fermi_occupation(eps, mu, kT)
+    return np.sum(eps * occ)

kappalogic/field_theory.py

@@ -0,0 +1,67 @@
+"""
+kappalogic.field_theory
+==========================
+発見(2026-07): この理論の基本ブロック sgn(x)=tanh(x/xi) は、
+実は場の理論のφ^4理論(二重井戸型ポテンシャル)の静的古典解
+(キンク・ソリトン)そのものである。
+
+【命題1(運動方程式)】phi(x)=tanh(x/xi)は
+    phi'' = (2/xi^2)(phi^3-phi)
+を厳密に満たす。
+
+証明(sympyによる記号微分で確認済み、有限差分ではなく閉じた式):
+    phi'(x) = (1/xi)*sech^2(x/xi) = (1/xi)*(1-phi^2)   ... (*)
+    phi''(x) = d/dx[(1/xi)(1-phi^2)] = (-2*phi/xi)*phi'
+             = (-2*phi/xi)*(1/xi)(1-phi^2) = (2/xi^2)(phi^3-phi)
+sympy.diff(tanh(x/xi), x, 2) と (2/xi^2)(phi^3-phi) の差を
+simplify すると厳密に0になることを確認した。
+
+このEOMは、ポテンシャル V(phi)=(phi^2-1)^2/(2*xi^2) のオイラー・
+ラグランジュ方程式 phi''=dV/dphi と一致する(dV/dphiを計算して
+2*phi*(phi^2-1)/xi^2になることも確認済み)。
+
+【命題2(厳密なエネルギー)】このキンクの古典エネルギー(質量)は
+    E = integral_{-inf}^{inf} [ (1/2)*phi'(x)^2 + V(phi(x)) ] dx = 4/(3*xi)
+と閉じた式で求まる(sympy.integrate、無限区間の積分を厳密に実行)。
+幅xiに反比例する、というのは物理的に自然な結果(細いソリトンほど
+勾配エネルギーが大きい)。
+
+ソリトン数(トポロジカル電荷) Q = (phi(+inf)-phi(-inf))/2 = 1 は、
+sgn(±inf)=±1という漸近値からtanhの定義より自明に従う。
+"""
+import numpy as np
+from .core import sgn
+
+
+def kink_profile(x, xi=1.0):
+    """phi(x) = tanh(x/xi): phi^4理論の静的キンク解。V(phi)=(phi^2-1)^2/(2*xi^2)の古典解。"""
+    return sgn(x, xi)
+
+
+def kink_eom_residual(x, xi=1.0, h=1e-4):
+    """
+    運動方程式 phi'' - (2/xi^2)(phi^3-phi) = 0 の残差(数値検証用)。
+    厳密解ならほぼ0になるはず(命題1は既にsympyで閉じた式で証明済み、
+    これはその追加の数値的サニティチェック)。
+    """
+    phi = lambda xx: kink_profile(xx, xi)
+    phi_pp = (phi(x + h) - 2 * phi(x) + phi(x - h)) / h ** 2
+    rhs = (2 / xi ** 2) * (phi(x) ** 3 - phi(x))
+    return phi_pp - rhs
+
+
+def kink_energy_exact(xi=1.0):
+    """
+    キンクの厳密なエネルギー(質量) E = 4/(3*xi)。命題2参照
+    (sympyによる無限区間積分で導出済み、閉じた式)。
+    """
+    return 4.0 / (3.0 * xi)
+
+
+def topological_charge(xi=1.0, x_inf=1e4):
+    """
+    ソリトン数(トポロジカル電荷) Q = (phi(+inf)-phi(-inf))/2。
+    このキンクでは常に1(sgnの漸近値+1,-1の半差)。
+    """
+    return (kink_profile(x_inf, xi) - kink_profile(-x_inf, xi)) / 2
+

kappalogic/funcs.py

@@ -0,0 +1,38 @@
+"""
+kappalogic.funcs
+==================
+定義14〜18: int(x), par(x), max/min/clamp
+
+注意 (実装時に見つかった原設計の誤り。詳細はdev_notes.md):
+    ユーザー原案の定義15 par(x):=int(x)-2*int(x/2) は偶数で-1を返す
+    バグがあったため、int(x)-int(x/2) に修正済み。
+"""
+import numpy as np
+from .core import gt, lt, NOT, DEFAULT_XI, DEFAULT_KERNEL
+
+
+def intf(x):
+    """int(x): xが整数のとき1、さもなければ0"""
+    x = np.asarray(x, dtype=float)
+    return NOT(np.sin(np.pi * x))
+
+
+def par(x):
+    """par(x): xが奇数のとき1、さもなければ0 (0や偶数は0)"""
+    x = np.asarray(x, dtype=float)
+    return intf(x) - intf(x / 2)
+
+
+def maxf(a, b, xi=DEFAULT_XI, kernel=DEFAULT_KERNEL):
+    """max(A,B) = (A-B)(A>B) + B"""
+    return (a - b) * gt(a, b, xi, kernel) + b
+
+
+def minf(a, b, xi=DEFAULT_XI, kernel=DEFAULT_KERNEL):
+    """min(A,B) = (A-B)(A<B) + B"""
+    return (a - b) * lt(a, b, xi, kernel) + b
+
+
+def clamp(lo, x, hi, xi=DEFAULT_XI, kernel=DEFAULT_KERNEL):
+    """clamp(A,x,B): x<A なら A、x>B なら B、さもなければ x"""
+    return (lo - x) * lt(x, lo, xi, kernel) + x + (hi - x) * gt(x, hi, xi, kernel)

kappalogic/heat.py

@@ -0,0 +1,62 @@
+"""
+kappalogic.heat
+=================
+kernel="erf" を選んだときの sgn(x,xi,"erf") = erf(x/xi) は、
+1次元熱方程式 u_t = D*u_xx を階段状の初期条件(x<0で0, x>0で1)から
+時間tだけ発展させた厳密解
+    u(x,t) = (1 + erf(x/(2*sqrt(D*t)))) / 2
+とちょうど同じ形をしている(xi = 2*sqrt(D*t))。
+
+これを有限差分法によるシミュレーションと比較し、最大誤差6e-5で
+数値的に確認済み(dev_notes.md参照)。
+
+このモジュールは、その対応関係を使って
+  - xi <-> 時間 t の相互変換
+  - 物理的に妥当な(=実際に拡散方程式が従う速さの)アニーリングスケジュール
+    (xiはtに比例するのではなく sqrt(t) に比例して縮む)
+  - ガウス核(熱核そのもの: デルタ関数初期条件からの厳密解)による
+    "ソフトな一致度" 報酬関数
+を提供する。
+"""
+import numpy as np
+from scipy.special import erf
+
+
+def xi_of_time(t, D=1.0):
+    """拡散時間tに対応するxi。 xi = 2*sqrt(D*t)"""
+    return 2 * np.sqrt(D * np.asarray(t, dtype=float))
+
+
+def time_of_xi(xi, D=1.0):
+    """xiに対応する拡散時間t。 t = xi^2 / (4D)"""
+    xi = np.asarray(xi, dtype=float)
+    return xi ** 2 / (4 * D)
+
+
+def heat_step_profile(x, t, D=1.0):
+    """
+    階段状初期条件(x<0->0, x>0->1)を時間tだけ拡散させた温度分布の厳密解。
+    sgn(x, xi_of_time(t,D), kernel="erf") と等価 ( u=(1+sgn)/2 )。
+    """
+    return 0.5 * (1 + erf(np.asarray(x, dtype=float) / xi_of_time(t, D)))
+
+
+def heat_kernel_gaussian(x, t, D=1.0):
+    """
+    デルタ関数初期条件(1点に熱源)からの厳密解=熱核そのもの。
+    G(x,t) = 1/sqrt(4*pi*D*t) * exp(-x^2/(4*D*t))
+    """
+    x = np.asarray(x, dtype=float)
+    return np.exp(-x ** 2 / (4 * D * t)) / np.sqrt(4 * np.pi * D * t)
+
+
+def gaussian_match(a, b, t, D=1.0):
+    """
+    「a と b がどれだけ一致しているか」を熱核と同じ形のガウス関数で評価する
+    "ソフトな一致度" 報酬 (0〜1、a=bで最大)。
+    reg(a-b)(=硬い一致判定)とは違い、境界(a=b)でなだらかに減衰するので
+    勾配ベースの探索の目的関数に使うのに向く。t->0でreg的な鋭さに近づく。
+    """
+    d = np.asarray(a, dtype=float) - np.asarray(b, dtype=float)
+    xi = xi_of_time(t, D)
+    return np.exp(-(d / xi) ** 2)

kappalogic/info_theory.py

@@ -0,0 +1,40 @@
+"""
+kappalogic.info_theory
+=========================
+de Bruijnの恒等式: 熱拡散(heat.py)でぼやけていく確率密度の
+微分エントロピーS(t)の変化率は、フィッシャー情報量J(t)を使って
+dS/dt = D*J(t) と書ける。ガウス分布(熱方程式の厳密解)で
+数値的に確認済み(誤差~1e-10)。
+
+これはheat.py(拡散・熱核)とAND/OR/reg系(論理・indicator関数)を
+繋ぐ第三の軸として「情報理論的な量(エントロピー、フィッシャー情報量)」を
+この枠組みの中に置く、という位置づけ。
+"""
+import numpy as np
+
+
+def gaussian_variance(t, sigma2_0, D=1.0):
+    """熱拡散で時間発展するガウス分布の分散: sigma^2(t) = sigma2_0 + 2*D*t"""
+    return sigma2_0 + 2 * D * t
+
+
+def differential_entropy_gaussian(t, sigma2_0, D=1.0):
+    """ガウス分布の微分エントロピー S(t) = 0.5*log(2*pi*e*sigma^2(t))"""
+    var = gaussian_variance(t, sigma2_0, D)
+    return 0.5 * np.log(2 * np.pi * np.e * var)
+
+
+def fisher_information_gaussian(t, sigma2_0, D=1.0):
+    """ガウス分布のフィッシャー情報量 J(t) = 1/sigma^2(t)"""
+    return 1.0 / gaussian_variance(t, sigma2_0, D)
+
+
+def de_bruijn_check(t, sigma2_0, D=1.0, h=1e-6):
+    """
+    dS/dt (数値微分) と D*J(t) (de Bruijnの恒等式の予測値) を両方返す。
+    理論上この2つは一致するはず。
+    """
+    dS_dt = (differential_entropy_gaussian(t + h, sigma2_0, D)
+              - differential_entropy_gaussian(t - h, sigma2_0, D)) / (2 * h)
+    predicted = D * fisher_information_gaussian(t, sigma2_0, D)
+    return dS_dt, predicted

kappalogic/kernels.py

@@ -0,0 +1,59 @@
+"""
+kappalogic.kernels
+====================
+sgn(x) = kappa(x/xi) の kappa 部分を差し替え可能にするモジュール。
+
+なぜ差し替えたいか(2026-07 開発メモ):
+    kappa=tanh は理論の初期案そのままで、遠方で指数関数的に速く飽和する
+    (誤差 ~ exp(-2x/xi))。これは「論理ゲート」用途には理想的だが、
+    kappa=erf を選ぶと sgn(x,xi) = erf(x/xi) が
+        u(x,t) = (1+erf(x/(2*sqrt(D*t))))/2
+    という「階段状初期条件からの熱拡散」の厳密解の形と一致する
+    (xi = 2*sqrt(D*t))。有限差分シミュレーションで最大誤差6e-5で
+    数値的に確認済み(dev_notes.md参照)。これにより
+    「xiを小さくする/大きくする」という操作に物理的な意味(時間発展)
+    を与えることができる。
+
+    kappa=algebraic (x/sqrt(x^2+1)) は exp/erf を使わない分安く、
+    べき乗オーダーの裾を持つ(exp的に速く0にはならない)。
+    シンボリック計算(sympyでの厳密な代数式としての扱い)や、
+    誤差の裾を緩めに保ちたい場面向け。
+"""
+import numpy as np
+from scipy.special import erf as _erf
+
+KERNELS = {}
+
+
+def register_kernel(name):
+    def deco(fn):
+        KERNELS[name] = fn
+        return fn
+    return deco
+
+
+@register_kernel("tanh")
+def _tanh_kernel(z):
+    return np.tanh(z)
+
+
+@register_kernel("erf")
+def _erf_kernel(z):
+    return _erf(z)
+
+
+@register_kernel("algebraic")
+def _algebraic_kernel(z):
+    return z / np.sqrt(z ** 2 + 1)
+
+
+def apply_kernel(x, xi, kernel="tanh"):
+    """kappa(x/xi) を計算する。kernel は 'tanh' | 'erf' | 'algebraic' か callable。"""
+    z = np.asarray(x, dtype=float) / xi
+    if callable(kernel):
+        return kernel(z)
+    try:
+        fn = KERNELS[kernel]
+    except KeyError:
+        raise ValueError(f"unknown kernel '{kernel}'. choices: {list(KERNELS)} or a callable")
+    return fn(z)