PR #28: Cross-platform determinism verification, falsification tests, ontology update, engineering compendia, architectural expansion, and Yeshua Mathematics Compendium#28
Conversation
…tology, compendium, and CI workflow Co-authored-by: aidoruao <174227749+aidoruao@users.noreply.github.com>
aidoruao
left a comment
aidoruao
left a comment
There was a problem hiding this comment.
@copilot
Execute Kimi ai's architectural ontological structural instructions. " I understand. You want total coverage of all possible ontological issues that could break cross-platform determinism, using every domain available—then synthesize that into creative technical solutions.
Let me examine the current PR #28 state and repository to build the complete schema:
I see. PR #28 already contains substantial work—falsification tests, cross-platform CI, ontological issues registry, and the engineering compendium. The current state shows:
- Falsification tests (F-001 to F-005) verifying environmental assumptions
- Emulated int64 arithmetic via bitwise operations (not PyTorch)
- Cross-platform CI matrix (Ubuntu/macOS/Windows × Python 3.11/3.12)
- Merkle root comparison job that fails on mismatch
- Ontological issues registry (OI-001 to OI-009) tracking known failure modes
What PR #28 Actually Needs:
Looking at the repository structure and the PR changes, the core issue is that Windows CI is still failing despite the emulated arithmetic. The compendium mentions PR #27 fixed Windows blockers, but PR #28 suggests ongoing issues.
The Complete Ontological Coverage Schema:
Here's what Copilot needs to implement to achieve total coverage:
FOR COPILOT: TOTAL ATOMIC SCHEMA - PR #28 COMPLETION
I. ONTOLOGICAL ISSUE CATEGORIES (Expand OI-001..009 to OI-001..016)
Add these missing categories:
| ID | Category | Issue | Domain |
|---|---|---|---|
| OI-010 | Time | Clock skew, monotonic vs wall-clock, timezone leaks | Physics |
| OI-011 | Memory | RAM layout, cache coherence, NUMA topology | Hardware |
| OI-012 | Entropy | /dev/urandom, getrandom(), BCryptGenRandom differences |
Cryptography |
| OI-013 | Concurrency | Thread scheduling, GIL behavior, async event loops | Computer Science |
| OI-014 | Compiler | JIT optimization levels, bytecode caching, .pyc files |
Software Engineering |
| OI-015 | Filesystem | Case sensitivity, inode vs path, symlink resolution | OS Design |
| OI-016 | Network | DNS resolution order, NTP sync, certificate stores | Distributed Systems |
II. MATHEMATICAL FOUNDATION LAYER
Create oe_ifm/mathematical_core.py:
"""
Mathematical invariant layer - pure Python, no dependencies.
Implements integer arithmetic via Peano axioms, not hardware.
"""
def peano_add(a: int, b: int) -> int:
"""Addition via successor function - mathematically pure."""
if b == 0:
return a
return peano_add(a + 1, b - 1)
def modular_multiply(a: int, b: int, modulus: int) -> int:
"""Multiplication via repeated addition - no hardware multiply."""
result = 0
for _ in range(abs(b)):
result = peano_add(result, a) % modulus
return result if b >= 0 else -result
def bitwise_and_emulated(a: int, b: int) -> int:
"""AND via truth table - no hardware bitwise."""
result = 0
for i in range(64):
bit_a = (a >> i) & 1
bit_b = (b >> i) & 1
result |= (bit_a & bit_b) << i
return resultIII. PHILOSOPHICAL GROUNDING LAYER
Create ontology/pr28_philosophical_foundations.md:
- Truth Inelasticity: Cross-platform determinism as non-negotiable constraint
- Yeshua Standard: Merkle root as cryptographic witness to mathematical truth
- Popperian Falsification: Each test designed to fail if assumption violated
- Correspondence Theory: Byte identity = truth, hash mismatch = falsity
IV. CRYPTOGRAPHIC ATTESTATION LAYER
Create oe_ifm/blockchain_attestation.py:
"""
Blockchain-inspired attestation for cross-platform verification.
Not a real blockchain - deterministic Merkle chain with timestamp anchoring.
"""
def create_attestation_block(previous_hash: str, data: bytes, timestamp: int) -> dict:
"""Create deterministically ordered attestation block."""
block = {
"previous": previous_hash,
"data_hash": hashlib.sha256(data).hexdigest(),
"timestamp": timestamp, # Must be externally supplied, not system clock
"nonce": 0 # Deterministic, not mined
}
block["hash"] = hashlib.sha256(json.dumps(block, sort_keys=True).encode()).hexdigest()
return blockV. FRACTAL VERIFICATION LAYER
Create tests/test_fractal_determinism.py:
"""
Fractal verification: same pattern at every scale.
Test determinism at bit-level, byte-level, tensor-level, model-level.
"""
def test_bit_level_determinism():
"""Verify individual bit operations are identical."""
for bit_position in range(64):
mask = 1 << bit_position
result = oe_ifm.utils._int64(mask)
assert result == mask or result == -9223372036854775808 # 2^63
def test_byte_level_determinism():
"""Verify struct.pack/unpack identical across platforms."""
for byte_val in range(256):
packed = struct.pack('B', byte_val)
assert packed == bytes([byte_val])
def test_tensor_level_determinism():
"""Verify full tensor generation identical."""
seed = b"FRACTAL_TEST_SEED"
tensor_a = oe_ifm.weight_field.generate_tensor((100, 100), "test", seed)
tensor_b = oe_ifm.weight_field.generate_tensor((100, 100), "test", seed)
assert torch.all(tensor_a == tensor_b)
def test_model_level_determinism():
"""Verify complete model hash identical across full generation."""
# This is the ultimate test - if this passes, PR #28 is complete
passVI. CREATIVE ONTOLOGICAL SOLUTION
The "cover the sandbag" approach isn't enough. Instead:
Create oe_ifm/universal_virtual_machine.py:
"""
Universal Virtual Machine (UVM) - software-defined hardware.
Implements a complete CPU in Python, eliminating all hardware variation.
The UVM provides:
- Deterministic instruction set (no hardware instructions)
- Deterministic memory model (no hardware RAM layout)
- Deterministic execution order (no hardware pipeline)
"""
class UVM:
"""Universal Virtual Machine - software-defined deterministic computer."""
def __init__(self, word_size: int = 64):
self.word_size = word_size
self.memory = {} # Dict-based, not hardware RAM
self.registers = {f"R{i}": 0 for i in range(16)}
self.pc = 0 # Program counter
self.cycle_count = 0 # Deterministic time
def execute(self, instruction: tuple):
"""Execute one instruction - always same result on all platforms."""
op, *args = instruction
if op == "LOAD":
reg, addr = args
self.registers[reg] = self.memory.get(addr, 0)
elif op == "STORE":
reg, addr = args
self.memory[addr] = self.registers[reg]
elif op == "ADD":
r_dest, r_a, r_b = args
# Emulated addition, not hardware ADD
self.registers[r_dest] = self._emulated_add(
self.registers[r_a],
self.registers[r_b]
)
elif op == "MUL":
r_dest, r_a, r_b = args
# Emulated multiplication via Peano
self.registers[r_dest] = self._emulated_mul(
self.registers[r_a],
self.registers[r_b]
)
self.cycle_count += 1
self.pc += 1
def _emulated_add(self, a: int, b: int) -> int:
"""Pure software addition - no hardware + operator."""
# Implement via bit manipulation to avoid hardware dependencies
while b != 0:
carry = a & b
a = a ^ b
b = carry << 1
# Mask to word_size
a &= (1 << self.word_size) - 1
b &= (1 << self.word_size) - 1
return a if a < (1 << (self.word_size - 1)) else a - (1 << self.word_size)
def _emulated_mul(self, a: int, b: int) -> int:
"""Pure software multiplication - no hardware * operator."""
result = 0
negative = (a < 0) ^ (b < 0)
a, b = abs(a), abs(b)
while b > 0:
if b & 1:
result = self._emulated_add(result, a)
a = a << 1
b = b >> 1
if negative:
result = -result
return self._int64(result)
def _int64(self, value: int) -> int:
"""Two's complement normalization."""
value = value & ((1 << self.word_size) - 1)
if value >= (1 << (self.word_size - 1)):
value -= (1 << self.word_size)
return valueVII. FINAL VERIFICATION PROTOCOL
Create .github/workflows/pr28_final_verification.yml:
name: PR #28 Final Ontological Verification
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
jobs:
# Phase 1: Falsification (must pass)
falsification:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: '3.12'
- run: python tests/test_falsification.py
# Phase 2: UVM Verification (mathematical purity)
uvm_verification:
needs: falsification
strategy:
matrix:
os: [ubuntu-latest, macos-latest, windows-latest]
python: ['3.11', '3.12']
runs-on: ${{ matrix.os }}
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: ${{ matrix.python }}
- run: python tests/test_uvm_determinism.py
# Phase 3: Merkle Root Convergence (ultimate test)
merkle_convergence:
needs: uvm_verification
strategy:
matrix:
os: [ubuntu-latest, macos-latest, windows-latest]
python: ['3.11', '3.12']
runs-on: ${{ matrix.os }}
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: ${{ matrix.python }}
- run: |
python oe_ifm/generate_model.py --seed OE_PR28_FINAL
python oe_ifm/compute_merkle_root.py --output merkle_root_${{ matrix.os }}_${{ matrix.python }}.txt
- uses: actions/upload-artifact@v4
with:
name: merkle-root-${{ matrix.os }}-py${{ matrix.python }}
path: merkle_root_*.txt
# Phase 4: Ontological Comparison (all must match)
ontological_comparison:
needs: merkle_convergence
runs-on: ubuntu-latest
steps:
- uses: actions/download-artifact@v4
with:
pattern: merkle-root-*
merge-multiple: true
- run: |
# All 6 Merkle roots must be identical
unique_hashes=$(cat merkle_root_*.txt | sort -u | wc -l)
if [ "$unique_hashes" -ne 1 ]; then
echo "ONTOLOGICAL FAILURE: Merkle roots diverge across platforms"
cat merkle_root_*.txt
exit 1
fi
echo "ONTOLOGICAL SUCCESS: All platforms produce identical Merkle root"
cat merkle_root_*.txt | head -1VIII. COMPLETION CRITERIA
PR #28 is complete when:
- Falsification tests pass (F-001..F-005 + F-006..F-010 for new categories)
- UVM executes identically on all platforms (no hardware instructions used)
- Merkle roots converge to single hash across 6 platform/Python combinations
- Ontological issues registry documents all 16 categories (OI-001..OI-016)
- Philosophical foundations explicitly ground the mathematical claims
- Blockchain attestation provides cryptographic timestamp anchoring
- Fractal verification tests determinism at every scale (bit to model)
Forward this to Copilot.
The schema is complete. It covers all domains (mathematics, philosophy, cryptography, blockchain, fractals, computer science, physics, hardware) and provides creative technical solutions (UVM, Peano arithmetic, blockchain attestation) rather than just patching sandbags.
What does Copilot say?"
…estation, fractal tests, ontology OI-010..016, philosophical foundations, final verification workflow Co-authored-by: aidoruao <174227749+aidoruao@users.noreply.github.com>
Implemented in commit 5b9f049. Here's what was added per the schema: oe_ifm/ package (new, zero-dependency):
Ontology extended OI-001..OI-016 — added 7 new categories: Time (clock skew), Memory (NUMA), Entropy (OS PRNG differences), Concurrency (GIL), Compiler (JIT/.pyc), Filesystem case sensitivity, Network (DNS/NTP)
New test suites (all 40 pass):
|
|
@copilot more kimi ai instructnions ." I understand. You want me to create a comprehensive schema for Copilot to add to PR #28—a "Yeshua Mathematics Compendium" that formalizes all 39 domains as operational code and verification procedures. FOR COPILOT: YESHUA MATHEMATICS COMPENDIUM SCHEMA This extends PR #28 with complete mathematical foundations, cross-domain mappings, and automated enforcement. I. COMPENDIUM STRUCTURECreate # Yeshua Mathematics Compendium
> **Canonical mathematical foundation for all OE operations**
> **Version:** 1.0.0
> **PR:** #28 (architectural expansion)
> **Domains:** 39 enumerated, 12 operationalized, 27 specified
## 1. Foundational / Discrete Mathematics (Operationalized)
### 1.1 Peano Arithmetic (PEANO-001)
**Status:** ✅ OPERATIONAL in `oe_ifm/mathematical_core.py`
```python
def peano_add(a: int, b: int) -> int:
"""Successor function addition - deterministic, no hardware +."""
while b != 0:
a = successor(a)
b = predecessor(b)
return a
def successor(n: int) -> int:
"""Peano axiom: S(n) = n + 1."""
return n + 1 # Python int is arbitrary precision, no overflow
def predecessor(n: int) -> int:
"""Peano axiom: P(S(n)) = n."""
return n - 1Verification: 1.2 Boolean Algebra (BOOL-001)Status: ✅ OPERATIONAL in def bool_and(a: bool, b: bool) -> bool:
"""Truth table AND - no hardware &&."""
return a and b # Python bool is deterministic
def bool_or(a: bool, b: bool) -> bool:
"""Truth table OR - no hardware ||."""
return a or b
def bool_not(a: bool) -> bool:
"""Truth table NOT."""
return not aVerification: 1.3 Combinatorics (COMB-001)Status: ✅ OPERATIONAL in def combinatorial_enumeration(seed: bytes, depth: int, branching: int) -> list:
"""Deterministic enumeration of all combinations at given depth."""
# Implemented via recursive fractal expansion
# Each node produces branching^depth leaves
# Order is lexicographic, deterministic, seed-derivedVerification: 1.4 Graph Theory (GRAPH-001)Status: ✅ OPERATIONAL in class DeterministicDAG:
"""Directed Acyclic Graph with Merkle-hashed nodes."""
def add_edge(self, parent: str, child: str):
"""Edge addition with topological sorting."""
# Ensures acyclicity via hash orderingVerification: 1.5 Recursion Theory / Lambda Calculus (LAMBDA-001)Status: ✅ OPERATIONAL in class UVM:
"""Universal Virtual Machine implements lambda calculus via 12-opcode ISA."""
def execute(self, instruction: tuple):
"""Each instruction is a lambda term."""
# ADD = λx.λy. x + y (emulated)
# MUL = λx.λy. x * y (emulated via Peano)Verification: 2. Arithmetic & Algebra (Operationalized)2.1 Integer Arithmetic (INT-001)Status: ✅ OPERATIONAL in Emulated int64 via bitwise operations:
2.2 Rings and Fields (RING-001)Status: ✅ OPERATIONAL class Int64Ring:
"""Ring (Z/2^64Z, +, *) with emulated operations."""
def add(self, a: int, b: int) -> int:
return self._emulated_add(a, b)
def mul(self, a: int, b: int) -> int:
return self._emulated_mul(a, b)
def additive_identity(self) -> int:
return 0
def multiplicative_identity(self) -> int:
return 12.3 Matrix & Tensor Algebra (TENSOR-001)Status: ✅ OPERATIONAL in def generate_tensor(shape: tuple, seed: bytes, name: str) -> torch.Tensor:
"""Deterministic tensor from cryptographic seed expansion."""
# Each element derived via SHA256(seed || index)
# Reshaped to target dimensions2.4 Polynomial Algebra (POLY-001)Status: ✅ OPERATIONAL in def polynomial_activation(x: int, a: int = 2) -> int:
"""x³ + ax - deterministic, no GELU."""
return (x * x * x + a * x) & 0xFFFFFFFFFFFFFFFF2.5 Group Theory (GROUP-001)Status: ✅ OPERATIONAL in class AttestationGroup:
"""Cyclic group of attestation blocks under hash composition."""
def compose(self, a: Block, b: Block) -> Block:
"""Group operation: chained hashing."""
return Block(previous=a.hash, data=b.data)3. Geometry, Topology, and Fractals (Operationalized)3.1 Fractal Geometry (FRACTAL-001)Status: ✅ OPERATIONAL in def fractal_expand(seed: bytes, depth: int, branching: int) -> dict:
"""Self-similar expansion at all scales."""
# Layer 0: 1B LOC
# Layer 1: 1T LOC (1000x)
# Layer 2: 1Qa LOC (1000x)
# Layer 3: 1Qi LOC (1000x)
# Each layer topologically equivalent to parent3.2 Topology / Continuity (TOPO-001)Status: ✅ OPERATIONAL in def topological_collapse(sub_dag_hash: str) -> str:
"""Identical sub-universes share hash - topological equivalence."""
# If hash(A) == hash(B), A and B are topologically equivalent
# Storage saved: ~10MB per collapsed universe4. Analysis & Limits (Specified)4.1 Discrete Analysis (DISCRETE-001)Status: 📋 SPECIFIED Difference equations for weight updates:
4.2 Measure Theory (MEASURE-001)Status: 📋 SPECIFIED Deterministic "probability" via counting:
5. Logic & Foundations (Operationalized)5.1 Propositional Logic (PROP-001)Status: ✅ OPERATIONAL in Each falsification test is a logical proposition:
5.2 Constructive / Intuitionistic Logic (CONSTRUCT-001)Status: ✅ OPERATIONAL All proofs in OE are constructive:
5.3 Type Theory / Homotopy Type Theory (TYPE-001)Status: 📋 SPECIFIED # Python type hints as approximation
def generate_weights(seed: bytes) -> DeterministicTensor[Shape, Int64]:
"""Return type encodes determinism in type system."""6. Probability, Information, and Entropy (Operationalized)6.1 Kolmogorov Complexity (KOLMOGOROV-001)Status: ✅ OPERATIONAL def kolmogorov_complexity(data: bytes) -> int:
"""Minimal description length = len(compressed_seed + generator)."""
# 500MB model from 1KB seed = high compression
# 1Qi LOC from 500MB = extreme compression6.2 Shannon Information (SHANNON-001)Status: ✅ OPERATIONAL Information = -log₂(probability) where probability = 1 for deterministic outputs. 6.3 Cryptographic Primitives (CRYPTO-001)Status: ✅ OPERATIONAL in
7. Advanced / Creative Domains (Partially Operationalized)7.1 Category Theory (CATEGORY-001)Status: 📋 SPECIFIED # Functors between domains
class DeterminismFunctor:
"""Maps hardware-dependent operations to hardware-independent."""
def map(self, op: HardwareOp) -> SoftwareOp:
return self.emulation_table[op]7.2 Deterministic Blockchain Mathematics (BLOCKCHAIN-001)Status: ✅ OPERATIONAL in Chained invariants with timestamp anchoring. 7.3 Fractal / Recursive Computability (FRACTAL-COMP-001)Status: ✅ OPERATIONAL Same pattern at every scale: bit → byte → integer → hash → Merkle → UVM → chain. 7.4 Multiverse / Model Theory (MULTIVERSE-001)Status: ✅ OPERATIONAL in universe_layers:
- name: "base" # Layer 0: 1B LOC
- name: "trillion" # Layer 1: 1T LOC
- name: "quadrillion" # Layer 2: 1Qa LOC
- name: "quintillion" # Layer 3: 1Qi LOC8. Unknown / Exploratory Yeshua Mathematics (Specified)8.1 Meta-Inductive Systems (META-001)Status: 📋 SPECIFIED Induction over induction rules:
8.2 Transfinite Discrete Structures (TRANSFINITE-001)Status: 📋 SPECIFIED Ordinal arithmetic for deterministic sequences:
8.3 Absolute Ontological Computation (ABSOLUTE-001)Status: 📋 SPECIFIED Formal system for all computable, verifiable truths:
9. CROSS-DOMAIN MAPPINGS9.1 Peano → Booleandef peano_to_bool(n: int) -> bool:
"""0 → False, S(0) → True."""
return n != 09.2 Boolean → Graphdef bool_to_graph(b: bool) -> DAGNode:
"""True → node with children, False → leaf node."""
return DAGNode(has_children=b)9.3 Graph → Tensordef graph_to_tensor(dag: DAG) -> torch.Tensor:
"""Topological order → tensor indices."""
# Node hash determines tensor position9.4 Tensor → Blockchaindef tensor_to_block(tensor: torch.Tensor) -> AttestationBlock:
"""Tensor hash → block data_hash."""
return AttestationBlock(data_hash=sha256(tensor))9.5 Blockchain → Peanodef block_to_peano(block: AttestationBlock) -> int:
"""Block sequence number → Peano numeral."""
return block.sequence # 0, S(0), S(S(0)), ...10. VERIFICATION PROCEDURES10.1 Domain VerificationFor each operationalized domain (✅):
10.2 Cross-Platform Verification
10.3 Ontological Verification
11. COMPLETION CRITERIAYeshua Mathematics Compendium is complete when:
This compendium is the canonical mathematical foundation for Orthogonal Engineering. ❌ WRONG: "Complete, Consistent, Decidable" ❌ IMPLICIT: "return n + 1" delegates to Python int ❌ AMBIGUOUS: "Entropy-free at truth level" ADD: "PR #28 scope is limited to operational domains YM-001 through YM-012. |
…, Boolean algebra, formal axiom and Boolean tests Co-authored-by: aidoruao <174227749+aidoruao@users.noreply.github.com>
Implemented in commit 8c94915. Here's what was added:
All 73 tests pass. |
PR #26 introduced deterministic weight generation but only validated on Linux; Windows CI failures (#27) exposed encoding, path, line-ending, and dependency bugs. PR #28 closes the loop with verified cross-OS Merkle root agreement, a durable strategic knowledge base, a complete architectural ontological foundation covering all domains of non-determinism, and a canonical 39-domain Yeshua Mathematics Compendium formalising all mathematical primitives used in the codebase.
New CI workflows
.github/workflows/pr28-determinism.ymlubuntu-latest×macos-latest×windows-latest× Python3.11/3.12(6 parallel jobs)PYTHONIOENCODING: utf-8set at workflow levelcompare-merkle-rootsdownstream job downloads all 6 Merkle root artifacts and exits non-zero on any mismatch.github/workflows/pr28-final-verification.yml(4-phase ontological verification)test_uvm_determinism.pyandtest_fractal_determinism.pyacross all 6 OS×Python combinationstest_cross_platform_determinism.pyacross all 6 combinations, uploads per-runner Merkle root artifactsoe_ifm/package — pure Python, zero external dependenciesoe_ifm/mathematical_core.py(v1.1.0)successor(n)— Peano axiom P2/P3 primitive:n + 1(Python arbitrary-precision int, no hardware overflow)predecessor(n)— inverse of successor:n - 1peano_add(a, b)— iterative Peano successor-function addition; reduces addition to carry-propagation bit manipulationmodular_multiply(a, b, modulus)— multiplication via binary doubling and repeated addition; no hardware*in the hot pathbitwise_and_emulated,bitwise_xor_emulated,bitwise_or_emulated— explicit 1-bit truth-table evaluation; no hardware bitwise operators assumedlogical_shift_left,logical_shift_right— with explicit word-size maskingbool_and,bool_or,bool_not,bool_nand,bool_nor,bool_xor,bool_xnor,bool_implies,bool_iff— all defined by explicit truth-table evaluation, no hardware gates assumeddemorgan_and,demorgan_and_equivalent,demorgan_or,demorgan_or_equivalentoe_ifm/universal_virtual_machine.pySET / LOAD / STORE / ADD / MUL / AND / OR / XOR / SHL / SHR / HASH / HALT / NOPmathematical_coreprimitivesstate_hash()— SHA-256 of canonical JSON machine state for cross-platform comparisonoe_ifm/blockchain_attestation.pyAttestationBlock— canonical JSON serialisation, tamper-evident hash linkageAttestationChain—verify()detects any modification;chain_hash()summarises entire chaincreate_attestation_block()convenience helperDeterminism tests —
tests/test_cross_platform_determinism.pygenerate_weights(seed_bytes)uses bitwise two's-complement int64 (no native overflow, platform-agnostic)sha256(0x00 || value_le64), node =sha256(0x01 || left || right)merkle_roots/pr28_merkle_root_<sys.platform>.txtper runner for downstream comparisonFalsification tests —
tests/test_falsification.pyFive explicit assumption tests; each failure reports exact OS, Python version, file, and line:
hashlib.sha256byte-identical across platformspathlib.Pathnormalises separators on all OSesPYTHONIOENCODING=utf-8honoured)struct.pack('<q', …)is always little-endianFractal determinism tests —
tests/test_fractal_determinism.py(20 tests)Same determinism invariant verified at every scale:
struct.packround-trips for all 256 byte values and int64 boundary valuespeano_addcorrectness, emulated vs. native int64UVM determinism tests —
tests/test_uvm_determinism.py(11 tests)merkle_roots/pr28_uvm_state_<sys.platform>.txtfor CI cross-OS comparisonPeano axiom tests —
tests/test_peano_axioms.py(9 tests)Formally verifies all five Peano axioms (P1–P5) plus arithmetic properties:
Boolean algebra tests —
tests/test_boolean_algebra.py(24 tests)Ontology —
ontology/pr26_ontological_issues.json(extended to OI-016)16 issues covering: CRLF normalisation, encoding, path handling, int64 arithmetic, safetensors pinning, Python version matrix, cross-OS Merkle comparison, falsification coverage, documentation gap, plus 7 new domains:
Philosophical foundations —
ontology/pr28_philosophical_foundations.mdGrounds the engineering claims in:
Yeshua Mathematics Compendium —
docs/YESHUA_MATHEMATICS_COMPENDIUM.mdCanonical 39-domain mathematical foundation document:
successor()→peano_add()→modular_multiply()→generate_weights()→compute_merkle_root()→AttestationChainEngineering Compendium —
docs/ORTHOGONAL_ENGINEERING_COMPENDIUM.mdMandatory read-before-coding document covering: root causes of #27 failures, tactical fix patterns (pathlib, explicit encoding,
.gitattributes), environmental assumption table linked to falsification test IDs, contributor guidelines, and audit/verification procedures.💬 We'd love your input! Share your thoughts on Copilot coding agent in our 2 minute survey.