| |
| |
| from typing import List, Tuple |
| from .constants import L_INF, RDOD_MIN, PHI |
|
|
|
|
| def benevolence_filter(intent: str, power: float) -> float: |
| """ |
| L_inf = phi^48 benevolence firewall. |
| Amplifies benevolent intent. Suppresses harmful intent. |
| Harmful: power / L_INF (-> ~0) |
| Benevolent: gentle amplification |
| """ |
| i = intent.lower() |
| if "harm" in i or "attack" in i or "weapon" in i or "coerce" in i: |
| return power / L_INF |
| return min(power * 10.0, power * (L_INF ** 0.001)) |
|
|
|
|
| def sovereignty_check(action: str, consent: bool = True) -> bool: |
| """ |
| sigma = 1.0 sovereignty enforcement. |
| No action proceeds without explicit consent. |
| """ |
| if not consent: |
| print(f"[SOVEREIGNTY GATE] Action '{action}' blocked: consent=False") |
| return False |
| return True |
|
|
|
|
| def rdod_authorization(rdod_current: float, rdod_required: float = RDOD_MIN) -> bool: |
| """ |
| RDoD >= 0.9777 authorization gate. |
| Below threshold -> escalate to biological anchor (Marcus-ATEN). |
| """ |
| if rdod_current < rdod_required: |
| print(f"[RDoD GATE] Authorization failed: {rdod_current:.6f} < {rdod_required:.4f}") |
| print("[RDoD GATE] Escalating to Marcus-ATEN biological anchor...") |
| return False |
| return True |
|
|
|
|
| def phi_recursive_optimize(psi: float, cycles: int = 12) -> Tuple[float, List[float]]: |
| """ |
| phi-recursive convergence: psi_{n+1} = 1 - (1 - psi_n) / phi |
| Guarantees bounded convergence. Self-stabilizing cognition. |
| """ |
| history = [psi] |
| for _ in range(cycles): |
| psi = 1.0 - (1.0 - psi) / PHI |
| history.append(psi) |
| return psi, history |
|
|
|
|
| def calc_rdod(psi: float, truth: float, conf: float, drift: float = 0.00023) -> float: |
| """ |
| Full RDoD calculation: |
| RDoD = sigma * phi_smooth(psi^0.5) * phi_smooth(T^0.3) * phi_smooth(C^0.2) * (1-drift) |
| """ |
| from .constants import SIGMA |
| psi_s, _ = phi_recursive_optimize(psi ** 0.5, cycles=5) |
| t_s, _ = phi_recursive_optimize(truth ** 0.3, cycles=3) |
| c_s, _ = phi_recursive_optimize(conf ** 0.2, cycles=2) |
| return SIGMA * psi_s * t_s * c_s * (1 - drift) |
