{"id":"3ad89f34-2d5f-4e20-8954-a7d4305f470d","arxiv_id":"1908.07763","paper_version":1,"verdict":"ACCEPT","confidence":"HIGH","novelty_score":6.0,"correctness_risk":"low","formal_verification":"none","parameter_count":0,"one_line_summary":"The Grundy value of any Delete Nim position (x,y) equals v2((x∨y)+1), where ∨ is bitwise OR.","lead":"This paper defines Delete Nim, a two-heap game in which a move deletes one heap, removes one stone from the other, and optionally splits the rest. It proves a closed-form formula for the Grundy number using bitwise OR and the 2-adic valuation.","discovery_kind":"new_application","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Theorem 4 depends on an unstated zero-heap convention; if heaps must stay positive, G((1,1))=0 but the formula gives 1.","rationale":"The reader's verdict identified the zero-heap convention as the weakest assumption, and I agree this is the only load-bearing soft spot. I checked the two key steps of Theorem 4. The 'no option with the same value' step is valid: if h=v2((x∨y)+1), then for h=0 both heaps are even and every option has odd total, so no option has value 0; for h>0, a same-value option would have lower h bits of its OR all 1 and bit h zero, forcing the option sum modulo 2^{h+1} into [2^h,2^{h+1}−1], which implies bit h of the chosen heap is 1, contradicting bit h of x∨y being 0. The 'every smaller value attained' step constructs x'=x−2^{h'}, y'=2^{h'}−1; because x_{h'}=1, subtracting 2^{h'} clears exactly bit h' and leaves lower bits of x unchanged, so x'_{h'}=0 while y' has all lower bits 1, giving valuation h'. This is correct. The sole gap is that the game definition does not say whether heap sizes may be 0, and the construction and the representation of non-split moves depend on it. This should be resolved by an explicit convention rather than by changing the mathematics. Hence I recommend a conditional acceptance rather than outright rejection.","tokens_in":3234,"tokens_out":18669,"duration_ms":167259,"concrete_test":"Write a short brute-force Grundy computation for all positions (x,y) with 0≤x,y≤8 under two interpretations: (A) heaps of size 0 are allowed, so the options from a chosen heap of size n are all pairs (a,n−1−a) with a=0,...,n−1; (B) both heaps must be positive, so options are restricted to 1≤a≤n−2 and no move is available from n=1. Compare each computed G with v2((x∨y)+1). Under (A) all values match Theorem 4; under (B) (1,1) yields 0 instead of 1. This settles that Theorem 4 is true exactly when zero heaps are explicitly permitted.","verdict_should_be":"CONDITIONAL","load_bearing_attack":"The central proof is sound under the convention that a heap of size 0 is a legal position, but the paper never states this convention. In the second half of Theorem 4's proof, to realize h'<h the authors take x'=x−2^{h'} and y'=2^{h'}−1. For h'=0 this is y'=0, and the non-split move is likewise represented as (x−1,0). This is the only way the mex argument attains the value 0 from positions with h>0. If the rules instead require two positive heaps, then from (1,1) the move removes the last stone and cannot leave two positive heaps, so G((1,1))=0, while the formula yields v2((1∨1)+1)=1; the theorem is then false. The proof otherwise checks out: the h>0 no-option-with-same-value argument correctly uses the fact that v2((u∨v)+1)=h forces the lower h bits of u∨v to be 1 and bit h to be 0, and the construction for h'<h indeed gives valuation exactly h'. The issue is definitional, not a flaw in the mex reasoning once the convention is fixed.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper introduces Delete Nim, a two-heap impartial game in which a move consists of deleting one heap, removing one stone from the remaining heap, and optionally splitting that remaining heap into two heaps. The main result, Theorem 4, gives a closed formula for the Sprague-Grundy value of any position (x,y): G((x,y)) = v2((x∨y)+1), where ∨ is bitwise OR and v2 is the 2-adic valuation. The proof is a direct mex argument: it shows no option has the same v2 value and that every smaller value is attained by an explicit option. Theorem 5 then gives an isomorphism between Delete Nim and a previously studied variant, VDN, transferring the formula to that game. The paper is short, elementary, and self-contained apart from the standard Sprague-Grundy theory.","tokens_in":3494,"tokens_out":16531,"duration_ms":215230,"significance":"If the intended convention on empty heaps is made explicit, the result is a neat, verifiable closed form for the G-values of a natural impartial game. The proof is genuinely constructive: the option attaining each smaller G-value is given explicitly, and the obstruction to attaining the same G-value is shown directly from the 2-adic structure. There are no fitted parameters, no circular dependencies, and the isomorphism to VDN is clean. The novelty is modest, but the connection between bitwise OR and G-values is a pleasant addition to the small catalogue of games with simple G-value formulas.","major_comments":[{"comment":"The proof of the 'attaining smaller values' direction uses the position (x−2^{h'}, 2^{h'}−1). For h'=0 this is (x−1,0), and the un-split move is also represented as (x−1,0). The paper never states the convention that heap sizes may be zero and that a position may consist of one empty and one non-empty heap. This is load-bearing: if positions are required to be two positive heaps, the move set is different and Theorem 4 is false under that reading; for example, from (1,1) the move that removes the last stone cannot produce two positive heaps, so (1,1) would have no options and G((1,1))=0, whereas the formula gives v2(2)=1. Please state explicitly in the definition of Delete Nim that heap sizes are nonnegative integers and that a move that does not split is recorded as (n,0). The same convention is needed for the isomorphism in Theorem 5, since F(x,y)=(x−1,y−1) sends positive VDN positions to Delete Nim positions with possible zero entries.","section":"Section 2, Theorem 4 proof"}],"minor_comments":[{"comment":"The expression v2((x−1)∨(y−1)+1) is ambiguous; write v2(((x−1)∨(y−1))+1) to make the scope of the +1 clear.","section":"Section 2, after Theorem 5"},{"comment":"In the h>0 case, the sentence 'Then x_h = 1 or y_h = 1, which is a contradiction' relies on the fact that h=v2((x∨y)+1) forces the h-th bit of x∨y to be 0; this should be stated explicitly.","section":"Section 2, Theorem 4 proof"},{"comment":"There are a few typographical errors: 'Aknowledgements' should be 'Acknowledgements', 'Cleary' should be 'Clearly', and the text says Bouton's result is from 1902 while the reference gives 1901.","section":"Title page / Abstract"},{"comment":"The case vp(0)=∞ in the definition of the p-adic valuation is never used in the formula, since (x∨y)+1 is always positive; it can be kept for completeness but is unnecessary.","section":"Section 1, definitions"}],"recommendation":"major_revision","confidential_remarks":"The only substantive issue is the unstated empty-heap convention. If the authors add one or two sentences fixing that convention, the proof and the formula are correct as far as I can tell. I did not independently verify the VDN result cited as [6]; the authors should ensure the attribution and the end-position statement in Theorem 5 match the source. The paper is short but does contain a genuine closed-form result, so I think it is appropriate for the journal after the requested clarification."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Short version: this is a small, correct, self-contained result. The authors define Delete Nim and prove the Grundy value is v2((x∨y)+1). The result is new: the cited VDN [6] only gives P-positions, and the full Grundy formula plus the isomorphism F((x,y))=(x-1,y-1) are not there. The mex proof checks out; I went through the two halves of Theorem 4 and the construction for h'<h works exactly as written.\n\nThe soft spots are mostly clarity. The paper never states that heap sizes are allowed to be zero. The proof relies on positions like (x-1,0) and (2^{h'}-1,0) when h'=0, so if a referee reinterprets 'two heaps' as positive heaps and requires a mandatory split, the theorem's formula can fail (e.g., from (1,1) the formula gives 1 but the only move would leave no positive heaps). This is an ambiguity, not a mathematical error: under the standard convention that empty heaps are valid and splitting is optional, the proof is sound. A short remark in Section 2 would fix it.\n\nThere is also a notational stumble in the proof of Theorem 4: the same symbols x',y' are used for the next position and for the binary digits of that next position, and the step 'Then x_h=1 or y_h=1' silently uses x'+y'+1 ∈ {x,y}. It's not hard to follow, but it will cost reviewers a few minutes. The conclusion's claim that this is 'the only case' needing OR is a bit strong, but it is hedged with 'to the best of our knowledge' and is harmless.\n\nNothing about the data or citation pattern worries me. No fitted parameters, no self-citation, no circularity.\n\nThis paper is for combinatorial game theorists and recreational math readers. It is a small but genuine contribution, well matched to a modest venue. I would accept it after minor revisions clarifying the zero-heap convention and the notation. Yes, it deserves a serious referee.","headline":"A small, correct, self-contained result: Delete Nim's Grundy value is v2((x∨y)+1), with a sound mex proof and a useful isomorphism to VDN.","tokens_in":3981,"tokens_out":7556,"would_cite":true,"duration_ms":61926,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":["91A46"],"pacs":[],"model":"deepseek-v4-flash","headline":"The G-value of every Delete Nim position $(x,y)$ is $v_2((x\\vee y)+1)$, the exponent of $2$ in one plus the bitwise OR of the heap sizes.","keywords":["Delete Nim","G-value","2-adic valuation","bitwise OR","combinatorial game theory","P-position","Variant of Delete Nim"],"falsifier":"Compute $G((1,2))$ by hand: the theorem predicts $v_2((1\\vee 2)+1)=v_2(4)=2$. Under the paper's convention the options are $(0,0)$, $(1,0)$, and $(0,1)$, whose G-values are $0$, $1$, and $1$, so the mex is $2$; if zero heaps are banned, only the move to the empty position remains, so the mex is $1$, a direct counterexample to the formula under the stricter convention.","tokens_in":3066,"feed_emoji":"🎮","tokens_out":22867,"duration_ms":401245,"temperature":0.7,"pith_summary":"This paper introduces Delete Nim, a two-heap impartial game in which a move deletes one heap, removes one stone from the remaining heap, and optionally splits that heap into two. The central claim is a complete closed form for the G-value: for any position $(x,y)$, $G((x,y)) = v_2((x\\vee y)+1)$, where $v_2$ counts the exponent of $2$ dividing a number and $\\vee$ is bitwise OR. The proof is a mex argument: no move from a position has its claimed value, and every smaller value is reached by some explicit move. This matters because closed-form G-values are rare, and the same formula then solves the Variant of Delete Nim by subtracting one from each heap size.","feed_headline":"One bitwise formula gives every Delete Nim position its value","feed_subtitle":"The value of any position is the exponent of 2 in one plus the bitwise OR of the heap sizes.","key_machinery":"The central object is the pair of heap sizes $(x,y)$ together with the function $v_2((x\\vee y)+1)$, where $v_2(n)$ is the 2-adic valuation, meaning the exponent of the highest power of 2 dividing $n$. The argument's engine is the mex recursion for G-values (mex is the minimum excluded value): $G$ at a position is the smallest nonnegative integer not attained among the G-values of its options. To prove the formula, the paper shows (i) from a position with value $h$, no option has value $h$, because any move changes the bit pattern of $x \\vee y$; and (ii) for each $h' < h$, the explicit construction $x' = x - 2^{h'}$, $y' = 2^{h'}-1$ (after choosing a heap whose $h'$-th bit is 1) gives a legal move to a position with value $h'$. The isomorphism $F((x,y)) = (x-1,y-1)$ then transfers the formula to the Variant of Delete Nim.","core_discovery":"On the paper's own terms, the discovery is that the G-value of Delete Nim is exactly the 2-adic valuation of one plus the bitwise OR of the two heap sizes: $G((x,y)) = v_2((x\\vee y)+1)$. Concretely, write $x$ and $y$ in binary, OR them bit by bit, add 1, and count how many times 2 divides the result; that count is the G-value, which in turn decides the winner in any disjoint sum. Because $v_2((x\\vee y)+1)=0$ exactly when the OR is even, the losing positions are precisely those in which both heap sizes are even. The proof separates into two claims: no legal move preserves the value $h$, and for every $h' < h$ some legal move produces a position with value $h'$. A shift map $F((x,y))=(x-1,y-1)$ is then shown to be an isomorphism between the variant game VDN and Delete Nim, so VDN's G-values are $v_2(((x-1)\\vee (y-1))+1)$.","pith_inferences":["The theorem depends on allowing heap sizes of 0 in positions such as $(n,0)$; if empty heaps were forbidden and splitting made mandatory, the same recursion would give different values, so the empty-heap convention is part of the game's definition.","Because the formula is governed by the highest power of 2 dividing $(x\\vee y)+1$, the game has a recursive structure in which positions with large value reduce to a heap of size $2^{h'}-1$ and a remaining heap; this suggests a natural family of games where the subtracted number is a fixed $k$, with values perhaps given by variants of $v_2((x\\vee y)+k)$.","The fact that P-positions are exactly the even-even pairs hints that the outcome is invariant under scaling both heaps by a power of 2, a pattern that could be tested in a three-heap analogue."],"forward_implications":["A Delete Nim position is a P-position (previous player wins) exactly when both heap sizes are even, because $v_2((x\\vee y)+1)=0$ in precisely that case.","The G-value of any position can be computed in time proportional to the number of bits: take the bitwise OR of the heap sizes, add one, and count trailing zero bits.","The isomorphism $(x,y)\\mapsto(x-1,y-1)$ gives the full G-value computation for the Variant of Delete Nim, whose P-positions were previously known.","By the standard disjoint-sum theorem for impartial games, the value of any disjoint sum of Delete Nim positions is the bitwise XOR of the individual $v_2$ values, so sums can be analyzed once each position is evaluated.","The formula is a rare case in which the OR operation, rather than XOR, controls the outcome values, as the paper notes."],"supporting_citations":[{"why":"Gives the motivating Nim P-position criterion via XOR, which frames the G-value problem.","marker":"[1]"},{"why":"Introduces the G-value via mex recursion that the theorem evaluates.","marker":"[4]"},{"why":"Presents the same G-value and disjoint-sum theory used to interpret the values.","marker":"[5]"},{"why":"Defines the Variant of Delete Nim and states its P-positions; the isomorphism in Theorem 5 extends this to full G-values.","marker":"[6]"}],"fun_headline_variants":["Delete Nim solved: G-value is v2 of (OR+1)","Even heaps lose: bitwise OR reveals Delete Nim winners","One OR, one add, count twos: Delete Nim's G-value","Bitwise OR plus one counts twos: Delete Nim solved"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The load-bearing premise is that an empty heap counts as a legal heap, so positions like $(n,0)$ are allowed and the move that takes one stone without splitting is represented as $(n,0)$; without that convention the move set and the formula both change.","fun_headline_variants_meta":{"raw":{"variants":["Delete Nim solved: G-value is v2 of (OR+1)","Even heaps lose: bitwise OR reveals Delete Nim winners","One OR, one add, count twos: Delete Nim's G-value","Bitwise OR plus one counts twos: Delete Nim solved"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000795,"raw_usage":{"total_tokens":3441,"prompt_tokens":825,"completion_tokens":2616,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":441,"completion_tokens_details":{"reasoning_tokens":2540}},"tokens_in":441,"tokens_out":2616,"duration_ms":19430,"temperature":1.0,"reasoning_tokens":2540,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-14T11:57:12.037191+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Compute $G((1,2))$ by hand: the theorem predicts $v_2((1\\vee 2)+1)=v_2(4)=2$. Under the paper's convention the options are $(0,0)$, $(1,0)$, and $(0,1)$, whose G-values are $0$, $1$, and $1$, so the mex is $2$; if zero heaps are banned, only the move to the empty position remains, so the mex is $1$, a direct counterexample to the formula under the stricter convention.","supporting_citations":[{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Gives the motivating Nim P-position criterion via XOR, which frames the G-value problem."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Introduces the G-value via mex recursion that the theorem evaluates."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Presents the same G-value and disjoint-sum theory used to interpret the values."},{"cited_title":"Stankova and T","cited_arxiv_id":null,"evidence_quote":"Defines the Variant of Delete Nim and states its P-positions; the isomorphism in Theorem 5 extends this to full G-values."}],"review_version":1}