mirror of
https://github.com/blackboxprogramming/BlackRoad-Operating-System.git
synced 2026-03-17 06:57:17 -05:00
0108860bff
Create comprehensive research-lab pack structure with mathematical and quantum computing modules from blackroad-prism-console: Math Modules: - hilbert_core.py: Hilbert space symbolic reasoning - collatz/: Distributed Collatz conjecture verification - linmath/: Linear mathematics C library - lucidia_math_forge/: Symbolic proof engine - lucidia_math_lab/: Experimental mathematics Quantum Modules: - lucidia_quantum/: Quantum core - quantum_engine/: Circuit simulation Experiments: - br_math/: Gödel gap, quantum experiments Includes pack.yaml manifest and comprehensive README. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
130 lines
3.8 KiB
Python
130 lines
3.8 KiB
Python
"""Trinary logic engine supporting custom operators and visualizations."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import importlib.util
|
|
import json
|
|
from dataclasses import dataclass, field
|
|
from pathlib import Path
|
|
from typing import Any, Dict, List, NamedTuple, Union
|
|
|
|
import numpy as np
|
|
|
|
|
|
_NX_SPEC = importlib.util.find_spec("networkx")
|
|
if _NX_SPEC is not None: # pragma: no cover - exercised indirectly
|
|
import networkx as nx # type: ignore
|
|
else: # pragma: no cover - exercised indirectly
|
|
nx = None # type: ignore
|
|
|
|
|
|
class SimpleEdge(NamedTuple):
|
|
source: Any
|
|
target: Any
|
|
attrs: Dict[str, Any]
|
|
|
|
|
|
@dataclass
|
|
class SimpleDiGraph:
|
|
"""Lightweight stand-in when ``networkx`` is unavailable."""
|
|
|
|
edges: List[SimpleEdge] = field(default_factory=list)
|
|
|
|
def add_edge(self, source: Any, target: Any, **attrs: Any) -> None:
|
|
self.edges.append(SimpleEdge(source, target, dict(attrs)))
|
|
|
|
|
|
GraphReturn = Union["nx.DiGraph", SimpleDiGraph]
|
|
|
|
|
|
import json
|
|
from dataclasses import dataclass
|
|
from pathlib import Path
|
|
from typing import Dict, List
|
|
|
|
import networkx as nx
|
|
import numpy as np
|
|
|
|
|
|
TRIT_VALUES: List[int] = [-1, 0, 1]
|
|
|
|
|
|
@dataclass
|
|
class TrinaryLogicEngine:
|
|
"""Engine that evaluates trinary logic expressions."""
|
|
|
|
operators: Dict[str, Dict]
|
|
|
|
@classmethod
|
|
def from_json(cls, path: str | Path) -> "TrinaryLogicEngine":
|
|
with open(path, "r", encoding="utf-8") as fh:
|
|
data = json.load(fh)
|
|
return cls(data)
|
|
|
|
def operate(self, op: str, a: int, b: int | None = None) -> int:
|
|
"""Evaluate a trinary operation."""
|
|
|
|
if op == "NOT":
|
|
if b is not None:
|
|
raise ValueError("NOT takes a single argument")
|
|
return int(self.operators[op][str(a)])
|
|
if b is None:
|
|
raise ValueError("Binary operator requires two arguments")
|
|
return int(self.operators[op][str(a)][str(b)])
|
|
|
|
def truth_table(self, op: str) -> np.ndarray:
|
|
"""Return the truth table for an operator as a matrix."""
|
|
|
|
if op == "NOT":
|
|
table = np.zeros((len(TRIT_VALUES), 2), dtype=int)
|
|
for i, a in enumerate(TRIT_VALUES):
|
|
table[i] = [a, self.operate(op, a)]
|
|
return table
|
|
table = np.zeros((len(TRIT_VALUES), len(TRIT_VALUES)), dtype=int)
|
|
for i, a in enumerate(TRIT_VALUES):
|
|
for j, b in enumerate(TRIT_VALUES):
|
|
table[i, j] = self.operate(op, a, b)
|
|
return table
|
|
|
|
def truth_table_ascii(self, op: str) -> str:
|
|
"""Render a truth table as ASCII art."""
|
|
|
|
table = self.truth_table(op)
|
|
return "\n".join(" ".join(f"{v:+d}" for v in row) for row in table)
|
|
|
|
def to_graph(self, op: str) -> GraphReturn:
|
|
"""Visualize operator relations as a directed graph.
|
|
|
|
Returns a :class:`networkx.DiGraph` when the optional ``networkx``
|
|
dependency is installed. Otherwise a :class:`SimpleDiGraph` is used.
|
|
"""
|
|
|
|
graph: GraphReturn
|
|
if nx is not None:
|
|
graph = nx.DiGraph() # type: ignore[call-arg]
|
|
else:
|
|
graph = SimpleDiGraph()
|
|
|
|
if op == "NOT":
|
|
for a in TRIT_VALUES:
|
|
res = self.operate(op, a)
|
|
graph.add_edge(a, res, op=op)
|
|
return graph
|
|
def to_graph(self, op: str) -> nx.DiGraph:
|
|
"""Visualize operator relations as a directed graph."""
|
|
|
|
g = nx.DiGraph()
|
|
if op == "NOT":
|
|
for a in TRIT_VALUES:
|
|
res = self.operate(op, a)
|
|
g.add_edge(a, res, op=op)
|
|
return g
|
|
|
|
for a in TRIT_VALUES:
|
|
for b in TRIT_VALUES:
|
|
res = self.operate(op, a, b)
|
|
graph.add_edge((a, b), res, op=op)
|
|
return graph
|
|
g.add_edge((a, b), res, op=op)
|
|
return g
|