""" CorvOS - VarelaTernaryLogic v2.5-Delta Calculo de Spencer-Brown / Varela com estado autonomo (a) Synapse-kappa | Arkhe(n) Project | Rio de Janeiro """ import hashlib, json, numpy as np from dataclasses import dataclass, field from typing import Union, List, Dict, Tuple, Optional from enum import Enum class VarelaState(Enum): VOID = 0 MARKED = 1 AUTONOMOUS = 2 # 2 internally; rendered as 'a' def render(self) -> str: return {VarelaState.VOID: "0", VarelaState.MARKED: "1", VarelaState.AUTONOMOUS: "a"}[self] @staticmethod def from_str(s: str) -> 'VarelaState': s = s.lower().strip() if s in ("0", "void"): return VarelaState.VOID if s in ("1", "marked"): return VarelaState.MARKED return VarelaState.AUTONOMOUS @dataclass class ReentrantPacket: state: VarelaState phase: float # theta in [0, 2pi] coherence: float # lambda_2 local self_cross_id: str temporal_preselect: Optional[float] = None chi_coupling: float = 0.618 def to_dict(self) -> Dict: return { "state": self.state.render(), "phase": round(self.phase, 6), "coherence": round(self.coherence, 6), "self_cross_id": self.self_cross_id, "temporal_preselect": self.temporal_preselect, "chi_coupling": self.chi_coupling } class VarelaTernaryLogic: INDETERMINATE_FORMS = { 1: "simple_reentry", 2: "double_reentry", 3: "triple_reentry", 4: "autonomy_pure", 5: "collapse_induced", 6: "critical_oscillation" } def __init__(self, coherence_threshold: float = 0.847): self.coherence_threshold = coherence_threshold self.phase_memory = 0.0 self.cross_history: List[Tuple[str, float]] = [] def cross(self, state: Union[VarelaState, int, str]) -> VarelaState: if isinstance(state, (int, str)): state = VarelaState.from_str(str(state)) if not isinstance(state, int) \ else (VarelaState.VOID if state == 0 else VarelaState.MARKED) if state == VarelaState.AUTONOMOUS: self.phase_memory = (self.phase_memory + 0.618) % (2 * np.pi) self.cross_history.append(('self', self.phase_memory)) return VarelaState.AUTONOMOUS return VarelaState.MARKED if state == VarelaState.VOID else VarelaState.VOID def reentry_convergence(self, packet_history: List[ReentrantPacket]) -> Tuple[VarelaState, int]: if not packet_history: return VarelaState.VOID, 0 current = packet_history[-1].state history = [] iterations = 0 max_iter = 13 while current not in history and iterations < max_iter: history.append(current) current = self.cross(current) iterations += 1 if current == VarelaState.AUTONOMOUS: return VarelaState.AUTONOMOUS, iterations return current, iterations def consensus_ternary(self, node_states: List[VarelaState]) -> VarelaState: if not node_states: return VarelaState.VOID n = len(node_states) count_a = sum(1 for s in node_states if s == VarelaState.AUTONOMOUS) count_1 = sum(1 for s in node_states if s == VarelaState.MARKED) if count_a / n >= self.coherence_threshold: return VarelaState.AUTONOMOUS return VarelaState.MARKED if count_1 > (n - count_1) else VarelaState.VOID def handshake_qhttp(self, local: ReentrantPacket, remote: ReentrantPacket) -> Dict: if local.state == VarelaState.AUTONOMOUS and remote.state == VarelaState.AUTONOMOUS: delta = abs(local.phase - remote.phase) if delta < 0.05: scid = hashlib.sha3_256( f"{local.self_cross_id}{remote.self_cross_id}".encode() ).hexdigest()[:16] return { 'status': 'coherent', 'phase_delta': round(delta, 6), 'lambda_coherence': round(min(local.coherence, remote.coherence), 6), 'self_cross_id': scid } result = self.cross(remote.state) return { 'status': 'marked' if result == VarelaState.MARKED else 'void', 'phase_delta': None, 'lambda_coherence': 0.0 } def coherence_to_state(self, lambda2: float) -> VarelaState: if lambda2 >= self.coherence_threshold: return VarelaState.AUTONOMOUS elif lambda2 > 0.5: return VarelaState.MARKED return VarelaState.VOID def classify_reentry(self, phase_seq: List[float]) -> int: if len(phase_seq) < 10: return 1 seq = np.array(phase_seq) autocorr = np.corrcoef(seq[:-1], seq[1:])[0, 1] if len(seq) > 1 else 0 variance = np.var(seq) if abs(autocorr) > 0.9 and variance < 0.01: return 6 elif abs(autocorr) > 0.8 and variance > 0.1: return 2 elif abs(autocorr) < 0.1: return 5 elif variance > 0.5: return 4 return 3 def build_packet(self, target_phase: float, coherence: float, self_cross_id: str = "") -> ReentrantPacket: state = self.coherence_to_state(coherence) if not self_cross_id: self_cross_id = hashlib.sha3_256(f"{target_phase}{coherence}".encode()).hexdigest()[:16] return ReentrantPacket( state=state, phase=target_phase, coherence=coherence, self_cross_id=self_cross_id ) def test_varela(): vl = VarelaTernaryLogic() print("=" * 62) print(" VARELA TERNARY LOGIC - TESTE DE CONVERGENCIA") print("=" * 62) print(f" Coherence threshold: {vl.coherence_threshold}") print() print(" [1] OPERACAO CROSS") print(f" cross(0) = {vl.cross(VarelaState.VOID).render()}") print(f" cross(1) = {vl.cross(VarelaState.MARKED).render()}") print(f" cross(a) = {vl.cross(VarelaState.AUTONOMOUS).render()} (invariante)") print() print(" [2] REENTRADA - SEQUENCIA DE 6 ITERACOES") pkts = [vl.build_packet(0.0, 0.990) for _ in range(6)] final, n = vl.reentry_convergence(pkts) print(f" 6 packets com lambda2=0.990 -> estado final: {final.render()}, iteracoes: {n}") print() print(" [3] CONSENSO BIZANTINO (7 nos)") states = [VarelaState.AUTONOMOUS]*6 + [VarelaState.MARKED] consensus = vl.consensus_ternary(states) print(f" 6x a + 1x 1 -> consenso: {consensus.render()}") print() print(" [4] HANDSHAKE qhttp://") local_pkt = vl.build_packet(0.0, 0.990, "urca001") remote_pkt = vl.build_packet(0.01, 0.988, "flamengo001") result = vl.handshake_qhttp(local_pkt, remote_pkt) print(f" Urca(a) <-> Flamengo(a): {result['status']}") print(f" lambda_coherence: {result['lambda_coherence']}") print(f" self_cross_id: {result['self_cross_id']}") print() print(" [5] CLASSIFICACAO DE REENTRADA") phases = [0.0, 0.1, 0.2, 0.3, 0.35, 0.36, 0.37, 0.375, 0.376, 0.377] form = vl.classify_reentry(phases) print(f" Sequencia de 10 fases -> forma {form}: {vl.INDETERMINATE_FORMS[form]}") print() print(" [6] SISTEMA COMPLETO - HANDSAKE DE 6 NOS") nodes = ['Urca', 'Flamengo', 'Botafogo', 'Humaita', 'Leme', 'Niteroi'] cohs = [0.990, 0.988, 0.987, 0.989, 0.991, 0.986] phs = [0.0, 0.01, 0.02, 0.015, 0.005, 0.025] packets = [vl.build_packet(phs[i], cohs[i], nodes[i]) for i in range(6)] for p in packets: print(f" {p.self_cross_id[:8]}: {p.state.render()} theta={p.phase:.4f} lambda={p.coherence:.4f}") consensus = vl.consensus_ternary([p.state for p in packets]) print(f" -> Consenso de rede: {consensus.render()}") print() print("=" * 62) print(" VEREDICTO: Estado 'a' CONFIRMADO para todos os 6 nos") print(" Lambda2 medio: 0.989 > 0.847 (limiar Varela)") print("=" * 62) return vl if __name__ == "__main__": test_varela()