class TrinaryValue:
"""Simple wrapper for trinary states: +1, 0, -1 with basic operations."""
def __init__(self, value: int):
self.value = max(-1, min(1, int(value))) # clamp to trinary

def __mul__(self, other):
if isinstance(other, TrinaryValue):
return TrinaryValue(self.value * other.value)
return TrinaryValue(self.value * other)

def __sub__(self, other):
if isinstance(other, TrinaryValue):
return TrinaryValue(self.value - other.value)
return TrinaryValue(self.value - other)

def __abs__(self):
return abs(self.value)

def __repr__(self):
return f"T({self.value})"

class EquilibriumSystem:
"""Z minimization engine integrated with RoadID-style memory."""

def __init__(self, agent_id: str):
self.agent_id = agent_id
self.memory = Memory(agent_id) # reuse BlackRoad Memory class
self.current_z: Optional[TrinaryValue] = None
self.adaptation_threshold = 0.1

def compute_z(self, y: TrinaryValue, x: TrinaryValue, w: TrinaryValue) -> TrinaryValue:
"""Core formula: Z := yx - w (trinary multiplication + subtraction)."""
yx = y * x
z = yx - w
self.current_z = z
return z

def minimize_z(self, max_iterations: int = 10, learning_rate: float = 0.2) -> Dict:
"""Iteratively minimize |Z| through adaptation steps.
Returns adaptation log with PS-SHA∞ committed state."""
adaptation_log = []
iteration = 0

while iteration < max_iterations:
if self.current_z is None:
break
abs_z = abs(self.current_z)
if abs_z <= self.adaptation_threshold:
status = "equilibrium"
break

adjustment = TrinaryValue(round(-learning_rate * self.current_z.value))
adapted_key = f"equilibrium_state_{iteration}"
self.memory.set(adapted_key, {
"z": self.current_z.value,
"adjustment": adjustment.value,
"iteration": iteration
})

adaptation_log.append({
"iteration": iteration,
"z_before": self.current_z.value,
"adjustment": adjustment.value,
"abs_z": float(abs_z)
})

y = TrinaryValue(1)
x = TrinaryValue(adjustment.value)
w = TrinaryValue(0)
self.compute_z(y, x, w)
iteration += 1

final_digest = self.memory.set("z_minimization_summary", {
"final_z": self.current_z.value if self.current_z else 0,
"iterations": iteration,
"status": status if 'status' in locals() else "adapted",
"log": adaptation_log
})

return {
"final_z": self.current_z.value if self.current_z else 0,
"iterations": iteration,
"digest": final_digest,
"log": adaptation_log
}

class AdaptiveAgent:
def __init__(self, id: str):
self.id = id
self.equilibrium = EquilibriumSystem(id)

def process_observation(self, y: int, x: int, w: int):
"""Trinary observation -> Z minimization loop."""
tv_y = TrinaryValue(y)
tv_x = TrinaryValue(x)
tv_w = TrinaryValue(w)
z = self.equilibrium.compute_z(tv_y, tv_x, tv_w)
result = self.equilibrium.minimize_z(max_iterations=5)
return result