{"id":"85acff0d-243f-4028-8df0-4fe24f6fd39a","arxiv_id":"2506.06551","paper_version":1,"verdict":"REJECT","confidence":"MODERATE","novelty_score":5.0,"correctness_risk":"high","formal_verification":"none","parameter_count":3,"one_line_summary":"Ten elementary cellular automata rules, found by exhaustive search, are used in a 4x4 error-scoring scheme claimed to give unique, evenly distributed, partially invertible hashes, with the proof of uniqueness left as an assertion.","lead":"This paper proposes using 10 of the 256 elementary cellular automata rules as a non-cryptographic hash, built from a 4x4 error-minimization compression scheme, and claims unique hashes, a lossy inverse, and retroactive hashing. The report presents exploratory Java-code results and visual edge detection, but no derivation or rigorous evidence backs the central uniqueness claims.","discovery_kind":"new_application","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Global injectivity claim is unsupported: local 4x4 codeword uniqueness does not compose under overlapping iterations, and the reported lossy inverse contradicts it.","rationale":"The paper's central claim is a global injectivity statement: no collisions for input of any given size. The only evidence offered is exhaustive verification of a local 4x4 truth table plus random sampling at 8x8. The reader's weakest assumption correctly identifies the gap: local uniqueness of the full 32-codeword set does not imply global injectivity of the iterative overlapping hash, and the paper provides no compositional argument. The lossy inverse in Section 3.3 is independent evidence against injectivity, since a deterministic invertible map on a finite set would reconstruct inputs with zero error. The compression variant is even more directly contradictory to the no-collision claim by pigeonhole. My read does not change the reader's REJECT verdict; the central claim remains unsupported and is in tension with the paper's own reported error rates. I would, however, encourage the author to reframe the paper as a reproducible tool report with verified 4x4 truth-table statistics and explicit limitations, which could be a useful contribution.","tokens_in":6543,"tokens_out":6884,"duration_ms":68913,"concrete_test":"Implement the hash exactly as described and exhaustively enumerate all 2^16 4x4 binary inputs in hash-in-place mode; compare the output multiset to 65536 distinct values. If the output is not 16 bits (e.g., it stores only 4-bit codewords), then by pigeonhole there are at most 16 distinct tile outputs and the 'any size' claim is vacuous. For the composition concern, repeat with a feasible nontrivial shape such as 4x8 (2^32, checkable by sampling plus a birthday bound, or by directed search over Hamming distance-1 inputs) and compare outputs at the avalanche depth specified in Section 3.4. An independent reimplementation should also verify whether the Section 2 replacement rule is consistent with the published example table, since the notation is ambiguous.","verdict_should_be":"UNCHANGED","load_bearing_attack":"Section 3.1 establishes only a truth-table statistic: for each of the 65536 4x4 inputs, the full 32-codeword set recorded by the error-min/max search is distinct. Section 3.4 then asserts 'any given input of any size or shape is unique and collisions don’t happen for a given size' because 'every neighborhood has a unique solution.' That inference is invalid. The hash-in-place operation replaces each bit by a codeword determined from an overlapping 4x4 neighborhood and then iterates at doubled distances (Section 2). Injectivity of a local map on non-overlapping tiles is not preserved under overlapping composition: two different global arrays can agree on every local neighborhood signature yet differ in how those signatures are interleaved or iterated. No argument, invariant, or exhaustive check bridges this gap; Section 4.2 explicitly limits exhaustive verification to 4x4 and uses random testing at 8x8. Moreover, Section 3.3 reports a deterministic inverse with 0.02–0.7 errors per bit. If the forward hash were injective on arrays of a given size, the inverse of the image would recover the input exactly; persistent reconstruction error implies that the codeword-level representation is lossy and hence many-to-one. The paper's response in Section 3.4, that uniqueness lives in the 32-codeword set, does not rescue the claim unless the actual stored hash contains all 32 codewords per tile at every iteration, which the compression and hash-in-place modes described in Section 3.5 do not. In compression mode, the 4x4 tile to 4-bit codeword map is impossible by pigeonhole (65536 inputs, 16 outputs).","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes ten elementary cellular automata rules as the basis of a non-cryptographic hash. The hash operates by partitioning input into wrapped 4x4 neighborhoods, using an error-minimization/maximization search to associate each neighborhood with 4-bit codewords, and then iterating at power-of-two neighbor distances. The author claims that several of these rules yield unique codewords, perfectly even codeword distributions, no collisions for inputs of a given size, a deterministic lossy inverse, retroactive logic operations on hashed data, and an application to edge detection. The paper reports exhaustive enumeration of all 65536 4x4 inputs for the rule-selection truth tables, random testing at 8x8, and visual results on bitmap images.","tokens_in":6805,"tokens_out":4174,"duration_ms":42607,"significance":"The paper's main value is empirical: it identifies explicit rule sets with notable local behavior on 4x4 neighborhoods and demonstrates a plausible image-hashing application. The exhaustive 65536-entry verification for 4x4 tiles and the explicit lists of rules are strengths that would be useful if the global claims were properly substantiated. However, the central advertised property—that arbitrary-size inputs have unique hashes with no collisions—is not established and is in tension with other reported properties, notably the lossy inverse and the compression mode. If the global injectivity claim were replaced by a more modest claim about local uniqueness and observed behavior, the contribution would be an exploratory application note rather than a rigorous hash-function construction.","major_comments":[{"comment":"The inference from local 4x4 codeword uniqueness to global injectivity is invalid. Section 3.1 establishes a truth-table statistic: for each of the 65536 4x4 inputs, the recorded codeword set is distinct. Section 3.4 then states that 'any given input of any size or shape is unique and collisions don't happen for a given size' because every neighborhood has a unique solution. This does not follow. The hash-in-place operation uses overlapping 4x4 neighborhoods and iterates at doubled distances (Section 2); injectivity of a local map on non-overlapping tiles does not compose under overlapping updates. Section 4.2 explicitly states that 8x8 behavior is only randomly tested, not exhaustively verified. A proof, invariant, or exhaustive check bridging the local-to-global step is required, but none is provided.","section":"Sections 3.1 and 3.4"},{"comment":"The reported lossy inverse directly contradicts the no-collision claim for the stored hash representation. Section 3.3 reports a deterministic inverse producing 0.02 to 0.7 errors per bit. If the forward hash were injective on arrays of a given size, the inverse of any hash value would be the unique preimage and would recover the input exactly. Persistent reconstruction error implies that the forward map is many-to-one on the representation actually hashed. The response in Section 3.4 that uniqueness resides in the full 32-codeword set does not resolve this, because the hash-in-place and compression modes described in Section 3.5 do not store all 32 codewords per input tile.","section":"Section 3.3 vs. Section 3.4"},{"comment":"The compression mode cannot be injective. Section 3.5 states that the data size quarters each iteration in compression mode, meaning a 16-bit 4x4 tile is mapped to a 4-bit codeword. By the pigeonhole principle, any such map from a larger domain to a smaller codeword space must have collisions. This contradicts the blanket statement in Section 3.4 that 'collisions don't happen for a given size.' Unless the hash output is defined to include all codewords for every tile, which is not the description of the implemented modes, the no-collision claim is false for compression.","section":"Section 3.5"},{"comment":"The retroactive-hashing claim is overgeneralized relative to the evidence. The paper states that the shift of logic operations is 'uniform within an ECA rule hash and extends to any depth of iteration,' but the supporting evidence is a row-weighted truth table and the statement that equivalences 'appear to carry over to size 8 in random testing.' The column-weighted table contains many entries marked '77' (no valid operation), so the claim cannot hold for the full advertised rule set. A proof or at least an exhaustive small-size verification for the relevant operations and iterations is needed before claiming a general property.","section":"Section 3.2"}],"minor_comments":[{"comment":"The word 'determinine' should be 'determine'.","section":"Section 1.1"},{"comment":"The word 'avalailable' should be 'available'.","section":"Section 4.1"},{"comment":"The sentence about trigintaduonions is not self-contained: the claim that a complete codeword set 'can be encoded as trigintaduonions' and that 'no negative members' exist because the sixteenth's place is the negative bit is unexplained and appears unrelated to the hash's functionality.","section":"Section 3.1"},{"comment":"The phrase 'maxxed or minned' is informal and should be rephrased as 'maximized or minimized'.","section":"Section 4.2"}],"recommendation":"reject","confidential_remarks":"The manuscript reads more as a project report than a journal article: the central claims are asserted from author-run experiments, the global injectivity claim is contradicted by the compression mode and the lossy inverse, and the presentation is informal. If the author were to resubmit with the global claims removed or rigorously restricted to the local 4x4 truth-table properties and with the retroactive-hashing claim properly scoped, the empirical observations might form the basis of a shorter application note. As it stands, the load-bearing claims are not defensible."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Dear colleague,\n\nRead this one if you want a clear example of a local truth-table result being over-extrapolated to global claims. The genuinely new thing is the construction: running ECA rules through a wrapped 4x4 error-scoring codeword lookup, and the exhaustive identification of 10 rules whose 32-codeword sets are unique and evenly distributed across all 65536 inputs. That is a concrete, checkable result, and the author's code appears to support it. The retroactive logic-gate transform in Section 3.2 is also a real observation, though only verified on the row-weighted set and randomly at size 8.\n\nThe soft spots are load-bearing, not cosmetic. Section 3.4 claims 'any given input of any size or shape is unique and collisions don't happen for a given size' on the strength of every 4x4 neighborhood having a unique solution. That inference is invalid: injectivity of an overlapping, iterated local map is not guaranteed by local uniqueness of non-overlapping tiles, and Section 4.2 admits only 4x4 was exhaustively tested, with random sampling at 8x8. Meanwhile Section 3.3 reports a lossy inverse with 0.02 to 0.7 errors per bit. If the forward map were injective on arrays of fixed size, the inverse of an image would recover the input exactly. Persistent reconstruction error means many-to-one. And compression mode, which maps 16-bit tiles to 4-bit codewords, is impossible by pigeonhole. These are not nitpicks; they invalidate the central claims as stated.\n\nWhat is not wrong: the author is transparent about the exploratory status, repeatedly noting active development and explicitly limiting exhaustive verification to 4x4. The paper does not hide its own limitations; it just fails to connect them to the abstract's findings. The trigintaduonion paragraph and the FFT analogy are ornamental and could be cut without loss.\n\nWho gets value: someone working on non-cryptographic image hashing might mine the 4x4 rule set and the gate-transform tables as a starting point. But the paper as written is a project report, not a result.\n\nRecommendation: I would send it to a serious referee, but only because the exhaustive 4x4 statistics are real and the overclaims are fixable. The referee should require the authors to either prove or drop the global injectivity claim, acknowledge the pigeonhole limit on compression, and compare against existing non-cryptographic hashes. With that revision it could become a modest but honest tool report. As is, it should not be published as a claim of a collision-free hash.\n\nBest,","headline":"A reproducible 4x4 exhaustive-search nugget, but the collision-free/invertible hash claims do not survive contact with the paper's own lossy inverse and 4:1 compression mode.","tokens_in":7455,"tokens_out":2438,"would_cite":false,"duration_ms":24287,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":["37B15"],"pacs":[],"model":"deepseek-v4-flash","headline":"Ten elementary cellular automata rules form a collision-free, invertible hash over wrapped 4x4 neighborhoods.","keywords":["elementary cellular automata","non-cryptographic hash","codeword truth table","lossy compression","retroactive hashing","edge detection","Fast Walsh-Hadamard structure","collision-free hash"],"falsifier":"Take the row-weighted rule set, hash every distinct binary grid of a modest larger size (for example every 8x4 or two-iteration 8x8 grid) and check whether any two different inputs produce the same hash; one collision would refute the Section 3.4 claim. A complementary check is to run the voting inverse on a large sample of hashed outputs and ask whether two different inputs ever invert to the same original, which would contradict the claimed one-to-one behavior.","tokens_in":6205,"feed_emoji":"🧮","tokens_out":9619,"duration_ms":78483,"temperature":0.7,"pith_summary":"This paper presents ten of the 256 elementary cellular automata rules as a non-cryptographic hash function. The central claim is that, when each wrapped 4x4 neighborhood is replaced by a 4-bit codeword chosen by an error-minimizing or error-maximizing score, every one of the 65,536 possible neighborhoods has a unique codeword and the codewords are distributed evenly. From that local uniqueness the author concludes that any input of any size has a unique hash and that collisions do not happen for a given size. The construction also offers a deterministic but lossy inverse, operations that can be applied inside the hashed state, and a powers-of-two neighborhood structure that parallels the Fast Fourier and Fast Walsh-Hadamard transforms. The paper supports these properties with code experiments and visual tests rather than a mathematical proof, and it describes the inverse-error rates as ranging from 0.02 to 0.7 errors per bit.","feed_headline":"Ten cellular automata rules hash without collisions","feed_subtitle":"A 4x4-window hash you can invert, edit while hashed, and run edge detection on.","key_machinery":"The load-bearing object is the codeword truth table produced by the error-scoring rule. For a fixed elementary cellular automaton rule, each of the 65,536 possible 4x4 grids is set up with row 0 as the input and rows 1-3 as the automaton's output; the 16 candidate row-0 patterns are scored by summing discrepancies between the original input and the generated output, weighted by $2^r$ (row weighting) or $2^c$ (column weighting). The best and worst scores form a 4-bit minimizing/maximizing codeword pair, and collecting the pairs over all 4x4 inputs gives the truth table that subsequent hashing looks up. Iteration compares neighborhoods at distances $2^d$, the same powers-of-two spacing as the FFT and fast Walsh-Hadamard transform, and the claim is that composing these lookups preserves uniqueness and even distribution. The same table also stores the logic-gate transforms that make retroactive hashing work.","core_discovery":"The discovery the paper wants to establish is that a small family of elementary cellular automata rules, applied to wrapped 4x4 binary neighborhoods, acts as a collision-free non-cryptographic hash with unusual extra capabilities. Two overlapping sets of eight rules are identified, one weighted by $2^r$ (rules 0, 15, 51, 85, 170, 204, 240, 255) and one weighted by $2^c$ (rules 0, 15, 85, 90, 165, 170, 240, 255). For both sets the paper reports unique codeword solutions for every 4x4 input and perfectly even codeword distribution across the full 65,536-entry truth table, and it takes this local uniqueness to imply that every input of any size has a unique hash with no collisions for a fixed size. On top of that, the hash is invertible by a voting procedure, reversible enough to reconstruct approximate originals, and supports retroactive hashing, meaning two hashed values can be logic-combined with a transformed gate so that watermarks or bitmasks can be applied without restoring the original data. The same iteration scheme, with neighbor distances doubling each round, is the nested powers-of-two pattern of the FFT, with hash lookups replacing sums.","pith_inferences":["A reader should treat the global no-collisions statement as an open conjecture: exhaustive uniqueness on every 4x4 neighborhood does not by itself prove that repeated hashing of larger grids remains injective, since the paper only samples 8x8 tiles and does not bound collision probabilities.","If the retroactive logic-gate transforms are as uniform as reported for the row-weighted rules, the construction gives a lightweight, non-cryptographic analogue of computing on encrypted data, with the caveat that its minimal avalanche and linear rules are not secure by cryptographic standards.","The reported lossy inverse error rates (0.02 to 0.7 errors per bit) sit in tension with the collision-free claim; a direct experiment relating inverse reconstruction error to injectivity would clarify whether the two properties can both hold.","A natural next test is to move from 4x4 to 8x8 tiles, where each tile has 256 possible codewords and exhaustive enumeration of all $2^{64}$ inputs is infeasible; proving uniqueness there would require a symmetry argument rather than a truth-table sweep."],"forward_implications":["Binary data of any size can be hashed to a fixed output size, either by hashing in place or by compressing so the data quarters in size each iteration, with the paper's claim that collisions do not happen for a given size.","Hashed values can be logically combined without inversion, which would allow watermarks, IP-address bitmasks, or similar updates to be applied directly to a hashed image.","A deterministic voting-based inverse reconstructs an approximation of the original input, with measured losses of 0.02 to 0.7 errors per bit depending on parameters.","At shallow depths the hash acts as an edge detector: flat man-made surfaces merge toward a single color while natural texture stays chaotic, with sharp transitions at edges and corners.","The algorithm can be organized like an FFT butterfly network, suggesting an $O(N \\log N)$-style structure where each tile is a lookup into the precomputed codeword table."],"supporting_citations":[{"why":"Defines the 256 elementary cellular automata rules and their symmetry classes, which the codeword truth tables are built from.","marker":"[7]"},{"why":"Identifies the XOR-additive rules; the chosen rule sets overlap with that list, and the paper uses this connection to explain the linear logic-gate transforms.","marker":"[4]"},{"why":"Supplies the Fast Walsh-Hadamard transform structure that the paper's powers-of-two neighborhood spacing is compared to.","marker":"[6]"}],"fun_headline_variants":["Collision-free hashing with just 10 cellular automata rules","Invertible hash from 10 cellular automata rules, no collisions","Ten ECA rules hash uniquely, invertibly, and detect edges","Cellular automata: a hash that's collision-free and reversible","Unique hashing with 10 elementary cellular automata rules"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The load-bearing premise is that the unique, evenly distributed codeword behavior verified exhaustively on the 4x4 truth table continues to hold when codeword outputs are re-hashed at deeper iterations, so that no two inputs of the same larger size ever collide.","fun_headline_variants_meta":{"raw":{"variants":["Collision-free hashing with just 10 cellular automata rules","Invertible hash from 10 cellular automata rules, no collisions","Ten ECA rules hash uniquely, invertibly, and detect edges","Cellular automata: a hash that's collision-free and reversible","Unique hashing with 10 elementary cellular automata rules"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000654,"raw_usage":{"total_tokens":2982,"prompt_tokens":915,"completion_tokens":2067,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":531,"completion_tokens_details":{"reasoning_tokens":1977}},"tokens_in":531,"tokens_out":2067,"duration_ms":14255,"temperature":1.0,"reasoning_tokens":1977,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-07T05:55:07.914382+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Take the row-weighted rule set, hash every distinct binary grid of a modest larger size (for example every 8x4 or two-iteration 8x8 grid) and check whether any two different inputs produce the same hash; one collision would refute the Section 3.4 claim. A complementary check is to run the voting inverse on a large sample of hashed outputs and ask whether two different inputs ever invert to the same original, which would contradict the claimed one-to-one behavior.","supporting_citations":[{"cited_title":"Wolfram Media, 2002","cited_arxiv_id":null,"evidence_quote":"Defines the 256 elementary cellular automata rules and their symmetry classes, which the codeword truth tables are built from."},{"cited_title":"Weisstein","cited_arxiv_id":null,"evidence_quote":"Identifies the XOR-additive rules; the chosen rule sets overlap with that list, and the paper uses this connection to explain the linear logic-gate transforms."},{"cited_title":"Fast walsh–algorithmcode.hadamard transform — Wikipedia, the free encyclopedia, 2024","cited_arxiv_id":null,"evidence_quote":"Supplies the Fast Walsh-Hadamard transform structure that the paper's powers-of-two neighborhood spacing is compared to."}],"review_version":1}