Research · Papers · Adders, counters and the heap law · MF-023
Exact multiplicative complexity of two exposed-sum ripple chains
MC(I_L) = 2L
Published 2026-08-29
For everyone
Plain summary
MF-023 determines the exact gate count for two coupled bit-by-bit adders. Each ripple chain has length L, shares one input operand, and outputs every sum bit along with both final carries. Multiplicative complexity measures the minimum number of multiplication-like gates required when bit additions and copies are free. That exact count is 2L. Because every intermediate sum is exposed, an observer can reconstruct every internal carry bit. The carry patterns contain independent features that cannot be simplified away. A standard construction using two majority gates per column achieves this 2L bound. The result applies strictly to circuits that publish all intermediate sums; it does not cover circuits that output only final sums, permit multiple valid outputs, or fuse their sums into subsequent logic. The register takes no position on prior art.
Result
Let I_L denote the deterministic interface of two length-L ripple chains sharing one operand, exposing all sum bits and both final carries. The exact multiplicative complexity is
MC(I_L) = 2L.
The lower bound holds because the exposed outputs affinely recover all internal carries, and the branch-distinguishing leading monomials of those carries are linearly independent. The standard two-majority-per-column construction achieves the matching upper bound. Exact rank certificates replay for L = 1, ..., 10. At L = 2, an independent replay confirms the banked full-interface value MC = 4. The equality holds specifically for this exposed-sum deterministic joint-ripple interface.
Setting and definitions
The system consists of two ripple chains of length L sharing one operand. The interface exposes every intermediate sum bit and both final carry bits. Multiplicative complexity (MC) counts nonlinear gates over GF(2), treating affine operations as costless. An internal carry is affinely recovered when expressed as an affine combination of the exposed outputs. The lower-bound certificate relies on the linear independence of the branch-distinguishing leading monomials of these recovered carries. The upper bound corresponds to the standard circuit using two majority gates per column.
Method
The exact count combines a rank lower bound with an explicit circuit construction. Because the exposed sums and final carries affinely reconstruct all internal carries, the independence of their branch-distinguishing leading monomials forces MC >= 2L. The two-majority-per-column implementation matches this count at 2L gates.
The register records exact rank certificate replays for L = 1 through 10. An independent replay at L = 2 reproduces the value MC = 4; the corresponding certificate and replay receipts are available in this paper's downloadable evidence pack.
Discussion
This 2L law applies strictly to the interface exposing all intermediate sums and final carries. The register explicitly excludes final-only interfaces, relational interfaces, and consumer-fused interfaces, where less intermediate carry information may be exposed. No correction, restoration, or scope flags are recorded for MF-023. Curation notes confirm that no prior-art comparison is made and no novelty claim is asserted.
For everyone — the takeaway
What this means
Each bit position adds exactly two counted gates to the theoretical minimum. Because the circuit exposes every intermediate sum, it reveals all internal carries and prevents any shortcut that might otherwise hide them. Standard adders already achieve this minimum. If a design conceals intermediate sums, allows flexible output encodings, or merges additions directly into downstream operations, it falls outside this bound.
Register references
- MF-023
- Package-3
joint_carry_direct_sum_certificate.json - CONT
package3_replay_receipt.json - Prior art: the register does not record this.
Every artifact named above is bundled in, or hashed by, this paper's evidence pack below.
Evidence pack
Everything needed to check this entry against its receipts: the register text, a manifest with a SHA-256 hash for every named receipt, and 2 of 2 receipt files bundled (5 KB). Anything not bundled is still hashed in the manifest and lives in the compute-box working trees.
Changelog
Last reviewed 2026-08-29
- 2026-08-29Published on this site.