{"id":"ffd18b52-03ef-4111-844b-c1f49850d532","arxiv_id":"2607.05016","paper_version":1,"verdict":"CONDITIONAL","confidence":"HIGH","novelty_score":3.5,"correctness_risk":"low","formal_verification":"none","parameter_count":0,"one_line_summary":"There is no computable extensional map that turns arbitrary approximation programs for the same computable real into one unique finite code, so protocols must fix a canonical representation up front.","lead":"The paper shows that a computable real number is not enough for crypto protocols: you also need a fixed, unique byte presentation. Without that, different implementations can hash or encrypt the same abstract value into different protocol bytes.","discovery_kind":"new_application","skeptic_critique":{"model":"grok-4.5","headline":"No significant objection identified","rationale":"The paper’s strongest claim is a faithful reformulation of a classical computability limit into protocol-design language. The reader already isolates the precise modelling choice (external non-decidable name space versus representation system) and correctly notes that the barrier does not apply once one works inside a decidable subclass that carries its own equality test. That observation is accurate but does not undermine the claim the paper actually makes; it merely restates the design consequence the paper itself draws (Corollary 1 and the design trilemma). Because the mathematics is elementary, fully checkable from the text, and not overstated, and because the positive recommendation (fix a normative presentation before demanding byte-input invariance) is already implicit in existing standards, no load-bearing technical concern remains that would move the verdict. The CONDITIONAL status already assigned by the reader—on grounds of modest novelty, didactic packaging, and an unfinished outlook taxonomy—is therefore the appropriate final assessment.","tokens_in":20922,"tokens_out":524,"duration_ms":4452,"concrete_test":"Independently re-derive the reduction of Lemma 1 (halting problem → equality of two Cauchy names) and verify that the same reduction immediately yields the non-existence of any partial computable c satisfying c(e)=c(f)⇔ x_e=x_f on all of I_app, exactly as stated in Theorem 1; if the reduction goes through without additional assumptions, the barrier stands.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central negative claim (Theorem 1) is a direct, correctly stated consequence of the classical undecidability of equality of computable reals (Lemma 1). The paper is explicit that the totality of approximation programs is not itself a representation system with decidable L (Section 3.3), so the barrier applies only to that external name space and does not claim to obstruct protocols that already restrict to a decidable, canonically normalizable subclass such as (Q, Σ_Q). The reader’s weakest-assumption note therefore correctly describes the intended scope rather than an unacknowledged hole: once a protocol fixes a decidable language of names that already admits a computable equality or normalization test, the barrier is simply outside the design space the paper recommends. No internal inconsistency, hidden model assumption, or over-claim about cryptographic security is present in the load-bearing argument.","agreement_with_reader":"agree"},"referee_report":{"model":"grok-4.5","summary":"The paper develops a representation-theoretic framing for cryptographic protocol objects. It separates algorithmically approximable reals (A_app), finite exact describability in a system (A_fin(S)), and canonical normalizability of a system, and states a canonicalization barrier (Theorem 1): there is no partially computable extensional map that sends arbitrary machine indices of fast rational Cauchy names of computable reals to unique finite codes with c(e)=c(f) iff the denoted values are equal. As an operational core it proposes the rational system with a fixed encoding specification Sigma_Q, so A_ex = Q, and generalizes the idea to canonically serializable object classes (files, hashes, transaction IDs, payloads). Worked toy examples (XOR stream cipher, toy RSA, toy hash) and the author's snaproot hash-anchoring protocol illustrate that mathematical determinacy of a value does not yield operational byte uniqueness without a normative presentation, after which byte-level correctness and well-definedness arguments become available without further serialization or rounding decisions.","tokens_in":21016,"tokens_out":808,"duration_ms":6260,"significance":"If accepted as a framing paper, the contribution is a clear transfer of classical computable-analysis limits (undecidability of equality of computable reals) into the language of cryptographic protocol specification, together with an explicit design trilemma and a taxonomy of operational representation levels (exact byte identity, fixed serialization, canonical value presentation). The paper is explicit that Theorem 1 is not a new undecidability result, that the toy schemes carry no security claims, and that canonicity is always relative to a fixed specification. Strengths include the self-contained reduction sketch for Lemma 1, the carefully scoped injectivity lemma (Lemma 2), the worked examples that make representation dependence concrete, and the honest limitations section. The novelty is primarily didactic and organizational rather than technical; for a cs.CR or interdisciplinary venue that values conceptual clarification of protocol interfaces, that can still be useful.","major_comments":[{"comment":"The central negative result (Theorem 1 / Corollary 1) is correctly stated as an immediate consequence of classical undecidability of equality on A_app (Lemma 1). The manuscript already acknowledges this in the introduction and Section 4. For journal publication the contribution claim should be tightened further so that readers cannot mistake the paper for a new undecidability theorem: the original content is the protocol-theoretic reading, the design trilemma, and the transfer to canonically serializable object classes, not the barrier itself.","section":null},{"comment":"Section 7.5 and the well-definedness argument in Section 8.3 rest heavily on snaproot, which the paper correctly labels as the author's own case study and not independent external evidence (Limitations). The illustration is useful, but the manuscript should either (a) add at least one independent, widely deployed standard (e.g., a concrete DER/CBOR/JCS interoperability failure or success) as a second real-world anchor, or (b) clearly demote snaproot to a purely didactic example so that the empirical weight of the real-world claim matches the evidence.","section":null},{"comment":"Definition 4 (canonically serializable object class) and the informal shorthand 'A_ex-compatible' transfer the rational-core idea to files, hashes, and payloads. The transfer is conceptually natural, but the formal link between the number-theoretic notions of Section 3 and the protocol-object notion of Section 3.5 remains mostly analogical. A short proposition or remark stating precisely which properties of (Q, Sigma_Q) are inherited by an arbitrary class K under a fixed (C, enc, dec) would make the taxonomy load-bearing rather than terminological.","section":null}],"minor_comments":[],"recommendation":"minor_revision","confidential_remarks":null},"author_rebuttal":null,"desk_editor":{"model":"grok-4.5","letter":"The punchline is simple: mathematical uniqueness of a real value is not the same as operational uniqueness of the bytes a protocol actually hashes or encrypts. The paper makes that distinction precise with three representation notions (A_app, A_fin(S), canonical normalizability), a clean design trilemma, and the rational core (Q, Σ_Q). Theorem 1 is just the classical undecidability of equality of computable reals restated as a barrier to a universal extensional canonicalizer; the reduction sketch is standard and correct, and the paper is explicit that it is not claiming a new undecidability result.\n\nWhat is actually new is the packaging: the joint framing of computable analysis and cryptographic serialization, the taxonomy of exact byte identity / fixed serialization / canonical value presentation, and the fully worked toy examples (XOR stream, toy RSA, toy hash) plus the snaproot case study that make the distinction concrete for protocol designers. The injectivity lemma is elementary and correctly scoped—it does not overclaim canonicity. Citations to Turing, Weihrauch, RFC 8785, ASN.1/DER, Ed25519 encodings are appropriate; the paper does not pretend the practical need for deterministic serialization is original.\n\nSoft spots are real but proportionate. Novelty is modest by the author’s own admission. Snaproot is the author’s own illustration, not independent evidence. The protocol-relative commitment taxonomy in the outlook is only sketched. The paper is still a working draft. None of these undermine the central negative claim or the positive design recommendation (fix a normative representation before demanding byte-input invariance).\n\nThis is for people who write or review protocol specs and care about interoperability and well-definedness arguments at the byte layer. It is not a crypto-security paper and does not claim to be. I would send it to peer review: the math is elementary and checkable, the framing is useful, and a serious referee can push the author to sharpen the classical-vs-didactic separation and finish the outlook. Worth engaging if you work on serialization, commitments, or the interface between analysis and protocol objects.","headline":"Solid conceptual transfer of classical computable-analysis limits into crypto protocol language; useful taxonomy and worked examples, modest novelty, high soundness.","tokens_in":21713,"tokens_out":524,"would_cite":false,"duration_ms":4825,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"grok-4.5","headline":"Mathematical uniqueness of a value is not the same as a unique protocol byte sequence; arbitrary approximation programs of computable reals cannot be uniformly turned into canonical codes.","keywords":["computable real numbers","canonical serialization","representation theory","cryptographic protocols","canonicalization barrier","computable analysis","protocol interoperability"],"falsifier":"Exhibit a single partially computable function that, given any two machine indices of fast rational Cauchy names, returns identical finite codes exactly when the named reals are equal (or prove that some concrete, unrestricted protocol already does this without restricting the name language).","tokens_in":21715,"feed_emoji":"🔐","tokens_out":689,"duration_ms":5314,"temperature":0.7,"pith_summary":"This paper argues that cryptographic protocols do not run on abstract mathematical values; they run on finite byte sequences, so the way a value is presented matters as much as which value it is. It separates three ideas: values that can be algorithmically approximated (the computable reals), values that admit a finite exact description inside a fixed representation system, and systems that are canonically normalizable so that every value has one computable normal form. The central negative claim is a canonicalization barrier: there is no computable procedure that takes arbitrary approximation programs for computable reals and outputs unique finite codes that coincide exactly when the reals are equal. The practical upshot is that protocols wanting byte-input invariance must restrict their inputs to a previously fixed, canonically normalizable presentation, of which the rational system with a normative fraction encoding is the core example. The same requirement is transferred to everyday protocol objects such as files, hashes, transaction IDs, and serialized payloads, and is illustrated with toy encryption and hashing examples plus a blockchain hash-anchoring protocol.","feed_headline":"No algorithm turns every real approximation into one unique code","feed_subtitle":"Protocols that need identical bytes for equal values must fix a normal form first, not accept arbitrary programs.","key_machinery":"The canonicalization barrier (Theorem 1): a classical undecidability-of-equality argument (via reduction from the halting problem) re-read as the non-existence of a universal extensional map from approximation-program indices to unique finite value codes. It is paired with the operational core class (Q, Sigma_Q) of rationals under a fixed canonical fraction encoding.","core_discovery":"There is no partially computable extensional canonicalizer that is defined on all machine indices of fast rational Cauchy names of computable reals and produces the same finite code exactly when two names denote the same real. Protocols that need semantically equal values to produce identical protocol bytes must therefore restrict their input interface to a fixed, canonically normalizable presentation (such as the rational core class with specification Sigma_Q) rather than accepting arbitrary approximation programs.","pith_inferences":[],"forward_implications":[],"fun_headline_variants":["No algorithm maps all real approximations to one unique code","Protocols need fixed normal forms not arbitrary real programs","No computable canonicalizer unifies every real presentation","Equal reals lack unique finite codes from free approximations","Fix a normal form: free real names stay non-canonical"],"cache_read_input_tokens":16512,"weakest_assumption_plain":"The barrier applies only when inputs are arbitrary approximation programs from an undecidable name space of all total Cauchy names; if the protocol already restricts to a decidable subclass of names that carries a computable equality test, the obstruction does not apply.","fun_headline_variants_meta":{"raw":{"variants":["No algorithm maps all real approximations to one unique code","Protocols need fixed normal forms not arbitrary real programs","No computable canonicalizer unifies every real presentation","Equal reals lack unique finite codes from free approximations","Fix a normal form: free real names stay non-canonical"]},"model":"grok-4.5","effort":"low","cost_usd":0.004738,"raw_usage":{"total_tokens":1429,"prompt_tokens":863,"num_sources_used":0,"completion_tokens":60,"cost_in_usd_ticks":47380000,"prompt_tokens_details":{"text_tokens":863,"audio_tokens":0,"image_tokens":0,"cached_tokens":256},"completion_tokens_details":{"audio_tokens":0,"reasoning_tokens":506,"accepted_prediction_tokens":0,"rejected_prediction_tokens":0}},"tokens_in":863,"tokens_out":60,"duration_ms":4766,"temperature":1.0,"reasoning_tokens":506,"cache_read_input_tokens":256,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-07-11T10:02:47.342322+00:00","model_set":{"reader":"grok-4.5"},"falsifier":"Exhibit a single partially computable function that, given any two machine indices of fast rational Cauchy names, returns identical finite codes exactly when the named reals are equal (or prove that some concrete, unrestricted protocol already does this without restricting the name language).","supporting_citations":[],"review_version":1}