Zero Domain Algebra: Foundations, Proofs, and an Empirical Instance

This paper introduces Zero Domain Algebra (ZDA), a formal framework for reasoning about zero-related events in computational systems. Rather than treating division or multiplication by zero as undefined or as a global collapse (as in Wheel Theory), ZDA records such events as labeled elements of a structured algebraic domain, equipped with horizontal operations (fusion, erasure, shadow-erasure), a projection into a shadow semilattice, and a partial resurrection map governed by an admissibility predicate. The contribution is methodological rather than purely algebraic. While the composite carrier is shown to be isomorphic to a familiar free semilattice, ZDA provides a formal vocabulary for an operational pattern observed in high-throughput data systems: erasure that preserves projection invariants without dedicated maintenance overhead. The paper documents this empirical instance through Loggr, a high-performance logging library where a non-evicting cache pattern emerged from practical design constraints and was subsequently formalized as the shadow-erasure operator described here. The work includes: (1) a system of axioms ensuring associativity, commutativity, idempotence, and partial monotonicity; (2) construction of a canonical model with existence proof; (3) structural results including the non-homomorphism theorem for resurrection and a universal property for composite formation; (4) characterization of resurrection policies and their monotonicity properties; (5) a formal comparison with partial algebras, error monads, annotated semirings, and Wheel Theory; (6) an empirical instance section documenting the non-evicting cache pattern in Loggr; and (7) a complete Python reference implementation with property-based testing. The paper is best understood as a formal grammar for provenance-aware error handling, validated through axiomatic semantics and an industrial pattern. It is intended as a foundation for further work on observability, formal verification of programs with partial arithmetic, and structured error propagation in data pipelines.