brik64 2.0.0__tar.gz

brik64-2.0.0/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: brik64
+Version: 2.0.0
+Summary: BRIK-64 Digital Circuitality — 64 formally verified monomers for Python
+Project-URL: Homepage, https://brik64.dev
+Project-URL: Repository, https://github.com/brik64/brik64-lib-python
+Project-URL: Documentation, https://docs.brik64.dev
+Author-email: "BRIK-64 Inc." <admin@brik64.dev>
+License: Proprietary
+Keywords: brik64,digital-circuitality,formal-methods,monomers,verified
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# brik64 — Digital Circuitality for Python
+
+64 formally verified atomic operations (monomers) implementing the BRIK-64 Digital Circuitality architecture.
+
+## Install
+
+```bash
+pip install brik64
+```
+
+## Usage
+
+```python
+from brik64 import mc, eva
+
+# Arithmetic
+result = mc.arithmetic.add8(200, 100)  # saturating: 255
+q, r = mc.arithmetic.div8(17, 5)       # (3, 2)
+
+# EVA algebra
+pipeline = eva.seq(mc.arithmetic.add8, lambda x: x * 2)
+```
+
+## License
+
+Proprietary — © 2026 BRIK-64 Inc.

brik64-2.0.0/README.md

@@ -0,0 +1,26 @@
+# brik64 — Digital Circuitality for Python
+
+64 formally verified atomic operations (monomers) implementing the BRIK-64 Digital Circuitality architecture.
+
+## Install
+
+```bash
+pip install brik64
+```
+
+## Usage
+
+```python
+from brik64 import mc, eva
+
+# Arithmetic
+result = mc.arithmetic.add8(200, 100)  # saturating: 255
+q, r = mc.arithmetic.div8(17, 5)       # (3, 2)
+
+# EVA algebra
+pipeline = eva.seq(mc.arithmetic.add8, lambda x: x * 2)
+```
+
+## License
+
+Proprietary — © 2026 BRIK-64 Inc.

brik64-2.0.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "brik64"
+version = "2.0.0"
+description = "BRIK-64 Digital Circuitality — 64 formally verified monomers for Python"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "Proprietary" }
+authors = [{ name = "BRIK-64 Inc.", email = "admin@brik64.dev" }]
+keywords = ["brik64", "digital-circuitality", "verified", "formal-methods", "monomers"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://brik64.dev"
+Repository = "https://github.com/brik64/brik64-lib-python"
+Documentation = "https://docs.brik64.dev"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/brik64"]

brik64-2.0.0/src/brik64/__init__.py

@@ -0,0 +1,5 @@
+"""BRIK-64 Digital Circuitality — 64 formally verified monomers."""
+from brik64 import mc, eva
+
+__version__ = "2.0.0"
+__all__ = ["mc", "eva"]

brik64-2.0.0/src/brik64/eva/__init__.py

@@ -0,0 +1,50 @@
+"""EVA algebra — composition operators for BRIK-64 monomers."""
+from typing import Any, Callable, TypeVar
+
+A = TypeVar("A")
+B = TypeVar("B")
+C = TypeVar("C")
+
+
+def seq(f: Callable[[A], B], g: Callable[[B], C]) -> Callable[[A], C]:
+    """⊗ Sequential composition: g(f(x))."""
+    def composed(x: A) -> C:
+        return g(f(x))
+    return composed
+
+
+def par(f: Callable, g: Callable) -> Callable:
+    """∥ Parallel composition: (f(a), g(b))."""
+    def composed(a: Any, b: Any) -> tuple:
+        return (f(a), g(b))
+    return composed
+
+
+def cond(pred: Callable[[Any], bool], then_f: Callable, else_f: Callable) -> Callable:
+    """⊕ Conditional composition: pred(x) ? then_f(x) : else_f(x)."""
+    def composed(x: Any) -> Any:
+        return then_f(x) if pred(x) else else_f(x)
+    return composed
+
+
+def pipeline(*fns: Callable) -> Callable:
+    """Chain multiple functions sequentially."""
+    def composed(x: Any) -> Any:
+        result = x
+        for f in fns:
+            result = f(result)
+        return result
+    return composed
+
+
+def compose(*fns: Callable) -> Callable:
+    """Compose functions right-to-left (mathematical convention)."""
+    def composed(x: Any) -> Any:
+        result = x
+        for f in reversed(fns):
+            result = f(result)
+        return result
+    return composed
+
+
+__all__ = ["seq", "par", "cond", "pipeline", "compose"]

brik64-2.0.0/src/brik64/mc/__init__.py

@@ -0,0 +1,4 @@
+"""BRIK-64 monomers — 64 atomic verified operations."""
+from brik64.mc import arithmetic, logic, memory, control, io, string, crypto, system
+
+__all__ = ["arithmetic", "logic", "memory", "control", "io", "string", "crypto", "system"]

brik64-2.0.0/src/brik64/mc/arithmetic.py

@@ -0,0 +1,49 @@
+"""F0 — Arithmetic monomers (MC_00–MC_07)."""
+
+_U8_MAX = 255
+_I64_MIN = -(2**63)
+_I64_MAX = 2**63 - 1
+
+
+def add8(a: int, b: int) -> int:
+    """MC_00: saturating u8 addition."""
+    return min(a + b, _U8_MAX)
+
+
+def sub8(a: int, b: int) -> int:
+    """MC_01: saturating u8 subtraction."""
+    return max(a - b, 0)
+
+
+def mul8(a: int, b: int) -> int:
+    """MC_02: saturating u8 multiplication."""
+    return min(a * b, _U8_MAX)
+
+
+def div8(a: int, b: int) -> tuple[int, int]:
+    """MC_03: u8 division → (quotient, remainder). div-by-zero → (0, 0)."""
+    if b == 0:
+        return (0, 0)
+    return (a // b, a % b)
+
+
+def mod8(a: int, b: int) -> int:
+    """MC_04: u8 modulo. mod-by-zero → 0."""
+    if b == 0:
+        return 0
+    return a % b
+
+
+def abs64(a: int) -> int:
+    """MC_05: i64 absolute value."""
+    return abs(a)
+
+
+def neg64(a: int) -> int:
+    """MC_06: i64 negation, clamped to i64 range."""
+    return max(_I64_MIN, -a)
+
+
+def clamp(val: int, lo: int, hi: int) -> int:
+    """MC_07: clamp value to [lo, hi]."""
+    return max(lo, min(val, hi))

brik64-2.0.0/src/brik64/mc/control.py

@@ -0,0 +1,45 @@
+"""F3 — Control monomers (MC_24–MC_31)."""
+from typing import Any, Callable
+
+_MAX_LOOPS = 1_000_000
+
+
+def mc_if(cond: bool, then_val: Any, else_val: Any) -> Any:
+    """MC_24: conditional select."""
+    return then_val if cond else else_val
+
+
+def mc_loop(n: int, f: Callable[[int], None]) -> None:
+    """MC_25: bounded loop (capped at 1,000,000 iterations)."""
+    for i in range(min(n, _MAX_LOOPS)):
+        f(i)
+
+
+def nop() -> None:
+    """MC_26: no operation."""
+    pass
+
+
+def halt(code: int = 0) -> int:
+    """MC_27: return exit code."""
+    return code
+
+
+def cmp_eq(a: Any, b: Any) -> bool:
+    """MC_28: equality comparison."""
+    return a == b
+
+
+def cmp_lt(a: Any, b: Any) -> bool:
+    """MC_29: less-than comparison."""
+    return a < b
+
+
+def cmp_gt(a: Any, b: Any) -> bool:
+    """MC_30: greater-than comparison."""
+    return a > b
+
+
+def mc_call(f: Callable, *args: Any) -> Any:
+    """MC_31: call a function."""
+    return f(*args)

brik64-2.0.0/src/brik64/mc/crypto.py

@@ -0,0 +1,48 @@
+"""F6 — Crypto monomers (MC_48–MC_55)."""
+import hashlib
+import hmac as _hmac
+import secrets
+
+
+def hash_sha256(data: bytes) -> bytes:
+    """MC_48: SHA-256 hash."""
+    return hashlib.sha256(data).digest()
+
+
+def hash_hex(data: bytes) -> str:
+    """MC_49: SHA-256 hex digest."""
+    return hashlib.sha256(data).hexdigest()
+
+
+def xor_bytes(a: bytes, b: bytes) -> bytes:
+    """MC_50: XOR two byte sequences (truncates to shorter length)."""
+    return bytes(x ^ y for x, y in zip(a, b))
+
+
+def rotate_left(val: int, shift: int, bits: int = 32) -> int:
+    """MC_51: rotate left."""
+    shift %= bits
+    mask = (1 << bits) - 1
+    return ((val << shift) | (val >> (bits - shift))) & mask
+
+
+def rotate_right(val: int, shift: int, bits: int = 32) -> int:
+    """MC_52: rotate right."""
+    shift %= bits
+    mask = (1 << bits) - 1
+    return ((val >> shift) | (val << (bits - shift))) & mask
+
+
+def constant_eq(a: bytes, b: bytes) -> bool:
+    """MC_53: timing-safe equality comparison."""
+    return _hmac.compare_digest(a, b)
+
+
+def zero_bytes(n: int) -> bytes:
+    """MC_54: generate n zero bytes."""
+    return bytes(n)
+
+
+def bytes_to_hex(data: bytes) -> str:
+    """MC_55: bytes to hex string."""
+    return data.hex()

brik64-2.0.0/src/brik64/mc/io.py

@@ -0,0 +1,63 @@
+"""F4 — I/O monomers (MC_32–MC_39)."""
+import os
+import sys
+
+
+def read_file(path: str) -> str | None:
+    """MC_32: read file contents."""
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            return f.read()
+    except OSError:
+        return None
+
+
+def write_file(path: str, content: str) -> bool:
+    """MC_33: write file contents."""
+    try:
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(content)
+        return True
+    except OSError:
+        return False
+
+
+def append_file(path: str, content: str) -> bool:
+    """MC_34: append to file."""
+    try:
+        with open(path, "a", encoding="utf-8") as f:
+            f.write(content)
+        return True
+    except OSError:
+        return False
+
+
+def read_str() -> str:
+    """MC_35: read line from stdin."""
+    try:
+        return input()
+    except EOFError:
+        return ""
+
+
+def write_stdout(s: str) -> None:
+    """MC_36: write to stdout."""
+    sys.stdout.write(s)
+
+
+def write_stderr(s: str) -> None:
+    """MC_37: write to stderr."""
+    sys.stderr.write(s)
+
+
+def file_exists(path: str) -> bool:
+    """MC_38: check if file exists."""
+    return os.path.exists(path)
+
+
+def file_size(path: str) -> int:
+    """MC_39: get file size in bytes. Returns -1 on error."""
+    try:
+        return os.path.getsize(path)
+    except OSError:
+        return -1

brik64-2.0.0/src/brik64/mc/logic.py

@@ -0,0 +1,45 @@
+"""F1 — Logic monomers (MC_08–MC_15)."""
+
+
+def and8(a: int, b: int) -> int:
+    """MC_08: bitwise AND."""
+    return a & b & 0xFF
+
+
+def or8(a: int, b: int) -> int:
+    """MC_09: bitwise OR."""
+    return (a | b) & 0xFF
+
+
+def xor8(a: int, b: int) -> int:
+    """MC_10: bitwise XOR."""
+    return (a ^ b) & 0xFF
+
+
+def not8(a: int) -> int:
+    """MC_11: bitwise NOT."""
+    return (~a) & 0xFF
+
+
+def shl8(a: int, shift: int) -> int:
+    """MC_12: left shift. shift >= 8 → 0."""
+    if shift >= 8:
+        return 0
+    return (a << shift) & 0xFF
+
+
+def shr8(a: int, shift: int) -> int:
+    """MC_13: right shift. shift >= 8 → 0."""
+    if shift >= 8:
+        return 0
+    return (a >> shift) & 0xFF
+
+
+def bool_and(a: bool, b: bool) -> bool:
+    """MC_14: logical AND."""
+    return a and b
+
+
+def bool_or(a: bool, b: bool) -> bool:
+    """MC_15: logical OR."""
+    return a or b

brik64-2.0.0/src/brik64/mc/memory.py

@@ -0,0 +1,52 @@
+"""F2 — Memory monomers (MC_16–MC_23)."""
+from typing import Any
+
+_MAX_ALLOC = 65536
+
+
+def load(mem: dict, key: Any) -> Any | None:
+    """MC_16: load from memory map."""
+    return mem.get(key)
+
+
+def store(mem: dict, key: Any, value: Any) -> bool:
+    """MC_17: store into memory map."""
+    mem[key] = value
+    return True
+
+
+def push(stack: list, value: Any) -> list:
+    """MC_18: push onto stack."""
+    stack.append(value)
+    return stack
+
+
+def pop(stack: list) -> tuple[Any | None, list]:
+    """MC_19: pop from stack → (value, stack)."""
+    if not stack:
+        return (None, stack)
+    val = stack.pop()
+    return (val, stack)
+
+
+def peek(stack: list) -> Any | None:
+    """MC_20: peek top of stack."""
+    return stack[-1] if stack else None
+
+
+def alloc(size: int) -> list:
+    """MC_21: allocate list of given size (capped at 65536)."""
+    return [None] * min(size, _MAX_ALLOC)
+
+
+def free(mem: dict, key: Any) -> bool:
+    """MC_22: free key from memory map."""
+    if key in mem:
+        del mem[key]
+        return True
+    return False
+
+
+def len_mem(mem: dict | list) -> int:
+    """MC_23: length of memory structure."""
+    return len(mem)

brik64-2.0.0/src/brik64/mc/string.py

@@ -0,0 +1,45 @@
+"""F5 — String monomers (MC_40–MC_47)."""
+
+_MAX_STR_LEN = 4096
+
+
+def concat(a: str, b: str) -> str:
+    """MC_40: concatenate strings (capped at 4096 chars)."""
+    return (a + b)[:_MAX_STR_LEN]
+
+
+def substr(s: str, start: int, end: int) -> str:
+    """MC_41: substring [start, end)."""
+    return s[start:end]
+
+
+def trim(s: str) -> str:
+    """MC_42: trim whitespace."""
+    return s.strip()
+
+
+def length(s: str) -> int:
+    """MC_43: string length."""
+    return len(s)
+
+
+def contains(s: str, sub: str) -> bool:
+    """MC_44: check if s contains sub."""
+    return sub in s
+
+
+def starts_with(s: str, prefix: str) -> bool:
+    """MC_45: check prefix."""
+    return s.startswith(prefix)
+
+
+def ends_with(s: str, suffix: str) -> bool:
+    """MC_46: check suffix."""
+    return s.endswith(suffix)
+
+
+def char_at(s: str, idx: int) -> str | None:
+    """MC_47: character at index. Returns None if out of bounds."""
+    if idx < 0 or idx >= len(s):
+        return None
+    return s[idx]

brik64-2.0.0/src/brik64/mc/system.py

@@ -0,0 +1,44 @@
+"""F7 — System monomers (MC_56–MC_63)."""
+import os
+import sys
+import time
+
+
+def time_unix() -> int:
+    """MC_56: Unix timestamp in seconds."""
+    return int(time.time())
+
+
+def time_ms() -> int:
+    """MC_57: Unix timestamp in milliseconds."""
+    return int(time.time() * 1000)
+
+
+def env_get(key: str) -> str | None:
+    """MC_58: get environment variable."""
+    return os.environ.get(key)
+
+
+def env_set(key: str, value: str) -> None:
+    """MC_59: set environment variable."""
+    os.environ[key] = value
+
+
+def pid() -> int:
+    """MC_60: current process ID."""
+    return os.getpid()
+
+
+def args() -> list[str]:
+    """MC_61: command-line arguments."""
+    return sys.argv[:]
+
+
+def exit_code(code: int) -> int:
+    """MC_62: return exit code (does not exit)."""
+    return code
+
+
+def sleep_ms(ms: int) -> None:
+    """MC_63: sleep for ms milliseconds (capped at 60,000ms)."""
+    time.sleep(min(ms, 60_000) / 1000.0)

brik64-2.0.0/tests/test_arithmetic.py

@@ -0,0 +1,22 @@
+from brik64.mc.arithmetic import add8, sub8, mul8, div8, mod8, abs64, neg64, clamp
+
+
+def test_add8_saturating():
+    assert add8(200, 100) == 255
+    assert add8(1, 2) == 3
+
+
+def test_sub8_saturating():
+    assert sub8(5, 10) == 0
+    assert sub8(10, 3) == 7
+
+
+def test_div8_zero():
+    assert div8(10, 0) == (0, 0)
+    assert div8(17, 5) == (3, 2)
+
+
+def test_clamp():
+    assert clamp(10, 0, 5) == 5
+    assert clamp(-1, 0, 10) == 0
+    assert clamp(5, 0, 10) == 5