Price the typed quotient against direct jobs for every C (no new κ)

research/typed-primitive-price/.gitattributes

@@ -0,0 +1 @@
+inputs/* -text

research/typed-primitive-price/FROZEN-INPUTS.json

@@ -0,0 +1,26 @@
+[
+  {
+    "repository": "CrocSwap/integer-mult-bounds",
+    "commit": "dca175fed8ebde8980635fd3b4508b8cba89a1b0",
+    "path": "research/native-quotient-interface/REPAIRED-WARP-WORD.json.gz",
+    "snapshot": "inputs/typed-word.json.gz",
+    "git_blob": "b22174e7a93716a394f2feb45f57a3da4331275a",
+    "sha256": "143b655bdc7aa719d0e3f2a527ed748c50a186997c01c2f3134dd5653d42ae7d"
+  },
+  {
+    "repository": "CrocSwap/integer-mult-bounds",
+    "commit": "dca175fed8ebde8980635fd3b4508b8cba89a1b0",
+    "path": "research/native-quotient-interface/TYPED-QUOTIENT-INTERFACE.md",
+    "snapshot": "inputs/typed-interface.md",
+    "git_blob": "bf4ff1af66ecd566685b481b459b1d846b8f5edb",
+    "sha256": "5e48990d78d0e0b7ca2f79f24338be81e7b2fa2732c261f046d46877f2febbf3"
+  },
+  {
+    "repository": "CrocSwap/integer-mult-bounds",
+    "commit": "1eb8da6cfb35512c0cc2533413e5ca42f48e13c6",
+    "path": "research/kappa-round3-warp-20261022/ARITHMETIC.json",
+    "snapshot": "inputs/round3-arithmetic.json",
+    "git_blob": "c89e009ca4a5ad316c69f0371d885d72045ba415",
+    "sha256": "ab10f6a4a8a4f589d4b094aac663e002c43ec44774e6bd181c51915c7fa7e521"
+  }
+]

research/typed-primitive-price/PROOF.md

@@ -0,0 +1,156 @@
+# The typed quotient has no recursive primitive discount
+
+Prepared for Cinna Davis with substantial OpenAI Codex assistance. Apache-2.0.
+
+## 1. Exact direct implementations of the supplied interface
+
+Assume the exact typed ABI of PR4654 at
+`dca175fed8ebde8980635fd3b4508b8cba89a1b0`. Its 112 main pairs consist
+of 56 type A and 56 type B. On each pair, Q is a symmetric rank-one
+Gaussian and D a symmetric rank-seven Gaussian on disjoint axes:
+
+```
+A = diag(D,D) S_y(Q^-1),
+B = diag(D,QD) S_y(Q^-1) = S_y(1) diag(D,QD).
+```
+
+The second identity is exact: both B expressions send (X,Y) to
+`(DX, DX+QD Y)`. There is no order-two relation for Q in this proof.
+
+A direct A implementation uses two rank-seven D jobs and one rank-one
+query shear. The query copies X into an owned zero temporary, applies
+Q^-1 with its actual monomial normalizer, adds into Y and clears the
+temporary. This retains the predecessor's owned-erasure hypothesis; it
+does not erase a dirty borrowed field. A direct B uses two D jobs, one
+Q job on Y and one ordinary output addition. Thus each type costs exactly
+`2*7^t+1` in recursive paid moment, t=1-C.
+
+The raw inverse transposes have equally explicit implementations:
+
+```
+A^-T = diag(D^-1,D^-1) S_x(-Q^-1),
+B^-T = S_x(-1) diag(D^-1,Q^-1 D^-1).
+```
+
+The B scalar addition is on the left and acts last. Gaussian inverses
+retain their actual monomial normalizers; rank does not change. The
+verifier checks all four Laurent matrix identities, with independent D
+and Q symbols and every sign and inverse exponent intact.
+
+Across all 112 pairs, direct main execution costs **224 rank-seven jobs
+and 112 rank-one jobs**, in either orientation. It uses at most one owned
+query temporary at a time. The source's 408 helpers remain independent
+arbitrary inputs; implementing each source-normalized helper job directly
+adds its complete actual target moment H_t to the paid list. All helper
+monomial normalizers are retained. No helper target is counted twice.
+
+Some direct helper jobs have rank nine. The fallback therefore does not
+preserve the native word's rank-eight local child cap. The price comparison
+is not drop-in compiler admission: any replacement must recheck child ranks,
+strictification tails and allocation. If a consumer introduces these helpers
+only as fresh independent bystanders, its direct main implementation can
+instead omit both their inputs/targets and their matching direct paid jobs;
+that cancellation preserves the surplus, but changes the caller's inventory.
+
+This is an operator-level fallback and a comparison of recursive paid
+moments. ADDs, copies, clear/erase, monomial wrappers, fixed routing and
+helper normalizers have finite volume-linear work. We do not assert
+identical machine costs, construct a practical multiplier, or independently
+reprove the typed source's native/all-width/phase theorem.
+
+## 2. Strict dominance at every concave exponent
+
+Recounting both emitted source words and their helper endpoints gives
+
+```
+P = {1:2177,2:424,3:389,4:147,5:50,8:8},
+H = {3:2,6:7,7:47,8:139,9:213}.
+```
+
+The native minus direct recursive paid moment is
+
+```
+G(C) = P_t - H_t -224*7^t -112,  t=1-C.
+```
+
+It has G(0)=8. Normalize K(C)=G(C)/7^t. The constant -224
+has derivative zero. In `(P_t-H_t-112)/7^t` the rank coefficients are
+
+```
+{1:2065,2:424,3:387,4:147,5:50,6:-7,7:-47,8:-131,9:-213}.
+```
+
+For 0<=C<1, all derivative contributions are nonnegative except the
+rank-six term. The rank-one term alone contributes at least
+`2065/7 * log(7)`; the rank-six negative contribution has magnitude at
+most `7 log(7/6)`. Since log(7)>1 and log(7/6)<1,
+
+```
+K'(C) > 2065/7 -7 = 288 > 0.
+```
+
+The elementary log inequalities are also enclosed by the pinned exact
+rational interval engine. Therefore
+
+```
+G(C) >= 8 * 7^(-C) > 0,   0<=C<1.
+```
+
+The typed native word is strictly more expensive in recursive paid moment
+than the direct implementation of the *same* main ABI and helper targets,
+for every exponent in the range, including rank mass at C=0.
+
+This is stronger than a failed controller search and different from the
+A-only-path obstruction of PR4660. It applies to the local offer before
+any controller is chosen. A profitable consumer using this offer could
+instead use the cheaper direct implementation, with the same operator
+and independent helper targets. It does **not** prove that every such
+consumer or every Gaussian algorithm is impossible.
+
+## 3. Comparison with the actual round-three native discount
+
+Freeze PR4610 at `1eb8da6cfb35512c0cc2533413e5ca42f48e13c6`:
+
+```
+H0 = {4:28,7:7,8:47,9:326},
+P0 = {1:2201,2:412,3:510,4:127,5:40,8:8}.
+```
+
+Its ordinary all-A, block-eight main interface has direct paid cost
+`H0_t+224*8^t+112`. Put G0=P0_t-H0_t-224*8^t-112.
+Its normalized rank-eight gap G0/8^t starts at -6. The corresponding
+rank-one coefficient is 2089; the only negative derivative contribution
+below rank eight is -7 at rank seven. Hence
+
+```
+(G0/8^t)' > 2089/8 -7 = 2033/8 > 0.
+```
+
+Exact outward enclosures give G0<0 at C=0.0062073960 and G0>0 at
+C=0.0062073961. Thus the original supplier's unique direct-price crossing
+is in that interval. Above it the original offer, too, has no recursive
+discount over direct main jobs and direct helpers. This is a **local price
+crossing**, not an integer-multiplication exponent or a universal ceiling.
+
+At C=.004, the original offer still discounts the direct price by about
+16.9818753 per full invocation. This is useful controller budget; the
+typed quotient instead has a positive surcharge. Complete controller,
+strictification, compiler, BIT, precision and outer conditions remain
+necessary for any actual K claim.
+
+## 4. Source and verification boundary
+
+The source word, typed interface and round-three arithmetic are retained
+byte for byte, with Git blob and SHA256 authentication. Both paid censuses
+and every helper rank are recomputed from the emitted word. The source's
+Clifford and free-group proofs are premises here, not newly audited.
+
+The registered Python replay uses exact Laurent arithmetic and outward
+rational power/log enclosures. It rejects an unpaid B query, a wrong Q
+inverse, missing owned charges and source/profile drift. Passing it does
+not establish a new native construction, selected frontier or theorem.
+
+Credit Dugongue and PR4654, DaysSky's quotient source, Cao Yifan and PR4610,
+Cinna Davis and the PR4440/PR4470/native lineage, zxv, Jacob Alan Sussman,
+the PR4660 B-autonomy observation and all retained predecessor authors.
+The direct factorization of B is credited, not rediscovered here.

research/typed-primitive-price/README.md

@@ -0,0 +1,52 @@
+# The typed quotient costs more than its direct main primitives
+
+**No new K.** Under the exact A/B interface supplied by PR4654, the native
+word's recursive paid moment is strictly greater than a direct implementation
+of the same main operator and all independent helper jobs, for every
+`0<=C<1`. Its surcharge is at least **8 * 7^(-C)** per invocation.
+
+Read [PROOF.md](PROOF.md). A direct main implementation needs 224 rank-seven
+jobs and 112 rank-one jobs; all 408 helper jobs are also paid. Four exact
+Laurent identities cover both types in both orientations. Every sign,
+inverse power and helper normalizer is retained. This is a comparison of
+recursive prices; fixed routing, scalar, ownership and native admission
+obligations are stated separately.
+
+The direct helper implementation includes rank-nine jobs, so it does not
+retain the native word's rank-eight child cap. Its use in a compiler needs
+new rank/tail checks, or a caller that removes neutral fresh helper jobs
+from both target and paid lists. Local price dominance alone is not admission.
+
+For comparison, PR4610's original block-eight offer has a real discount
+until its unique local price crossing in
+**(0.0062073960, 0.0062073961)**. This crossing is a local budget threshold,
+not a new multiplication exponent or a global controller bound.
+
+```sh
+python3.12 -B scripts/research_package.py --package research/typed-primitive-price
+```
+
+The standard-library replay authenticates the frozen source Git blobs and
+SHA256 values, recounts both emitted paid profiles and all helper targets,
+checks the operator identities, proves the monotone all-exponent bounds,
+and verifies the committed [RESULT.json](RESULT.json). Original compressed
+and CRLF source bytes remain unchanged. `--write` is only an authoring path.
+
+No selected source or shared verifier changes. No selected cold replay,
+new phase/native audit, complete multiplier or independent human theorem
+acceptance is claimed. The typed source remains a constructive local
+interface; this result shows why its lower nominal paid profile alone
+does not justify another controller construction round.
+
+## Open next questions
+
+Seek a changed native word or centre recipe that restores a genuine local
+discount before searching large controllers. The original supplier still
+has about 16.9818753 units of direct-price discount at C=.004; any new
+controller must turn that into a positive complete moment with every idle,
+query, ownership and completion cost included.
+
+Credit Dugongue/PR4654, DaysSky, Cao Yifan/PR4610, the PR4660 B-autonomy
+observation, Cinna Davis's PR4470/controller lineage, zxv, Jacob Alan Sussman
+and the retained source authors. Prepared for Cinna Davis with substantial
+OpenAI Codex assistance; no subagents. Apache-2.0.

research/typed-primitive-price/RESULT.json

@@ -0,0 +1,90 @@
+{
+  "direct_main_paid": {
+    "1": 112,
+    "7": 224
+  },
+  "new_kappa": false,
+  "normalized_derivative_lower_bound": "288",
+  "original_discount_endpoint": [
+    "1551849/250000000",
+    "62073961/10000000000"
+  ],
+  "original_gap_above": {
+    "lower": "0.000000609979802177861027451394",
+    "upper": "0.000000609979802177861027451395"
+  },
+  "original_gap_below": {
+    "lower": "-0.000000157165757402536960401596",
+    "upper": "-0.000000157165757402536960401595"
+  },
+  "samples": {
+    "0": {
+      "original_direct_minus_native": {
+        "lower": "47.999999999999999999999999999999",
+        "upper": "48.000000000000000000000000000001"
+      },
+      "typed_native_minus_direct": {
+        "lower": "7.999999999999999999999999999999",
+        "upper": "8.000000000000000000000000000001"
+      }
+    },
+    "1/100": {
+      "original_direct_minus_native": {
+        "lower": "-28.953945191895344577529449792159",
+        "upper": "-28.953945191895344577529449792158"
+      },
+      "typed_native_minus_direct": {
+        "lower": "77.902661003205805150124181011979",
+        "upper": "77.902661003205805150124181011980"
+      }
+    },
+    "1/250": {
+      "original_direct_minus_native": {
+        "lower": "16.981875310258539619945498940638",
+        "upper": "16.981875310258539619945498940639"
+      },
+      "typed_native_minus_direct": {
+        "lower": "36.169081320591341659262855607882",
+        "upper": "36.169081320591341659262855607883"
+      }
+    },
+    "3/1000": {
+      "original_direct_minus_native": {
+        "lower": "24.706677945572085198228228950536",
+        "upper": "24.706677945572085198228228950537"
+      },
+      "typed_native_minus_direct": {
+        "lower": "29.152950244683753346945507106141",
+        "upper": "29.152950244683753346945507106142"
+      }
+    },
+    "3/500": {
+      "original_direct_minus_native": {
+        "lower": "1.591451854306711455285971916073",
+        "upper": "1.591451854306711455285971916074"
+      },
+      "typed_native_minus_direct": {
+        "lower": "50.149300571869503859726803947717",
+        "upper": "50.149300571869503859726803947718"
+      }
+    }
+  },
+  "scope": "Exact typed ABI and direct helper normalization; local moment comparison only",
+  "status": "PASS_TYPED_DIRECT_PRIMITIVE_DOMINANCE",
+  "typed_H": {
+    "3": 2,
+    "6": 7,
+    "7": 47,
+    "8": 139,
+    "9": 213
+  },
+  "typed_P": {
+    "1": 2177,
+    "2": 424,
+    "3": 389,
+    "4": 147,
+    "5": 50,
+    "8": 8
+  },
+  "uniform_gap_lower_bound": "8 * 7^(-C), 0<=C<1"
+}

research/typed-primitive-price/SOURCES.json

@@ -0,0 +1,24 @@
+{
+  "schema_version": 1,
+  "base_commit": "b58ad9ef4d4e861b0eaa5dba41742bdc072dca51",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "c35482cd9035843b15a634cc8276a7e1e40e8395",
+      "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602",
+      "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72"
+    },
+    {
+      "path": "research/higher-moment-strictification/verify.py",
+      "usage": "input",
+      "git_blob": "4b24a5096154736ce060474eb8c72dc64c303699",
+      "sha256": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326"
+    }
+  ]
+}