{"id":"130b29a4-0a76-499c-94c5-41abb32a934f","arxiv_id":"2607.27213","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":7.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":0,"one_line_summary":"For Combinatorial DDGP instances with pruning edges, the feasible branch codes form an affine space over F_2 (given mirror separation and one reference solution), so the number of realizations is 2^{f + rank[M;V] − rank V}.","lead":"This paper gives a rank-count formula for the number of distance-geometry realizations when extra distance constraints are present, valid under a 'mirror-separation' genericity assumption. It provides a closed-form count from the graph template — instead of exponential tree search — for the Combinatorial Discretizable Distance Geometry Problem.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Rank-count exactness rests on unverified mirror-separation hypothesis; the paper's only example does not verify it.","rationale":"The paper's algebraic machinery (branch masks, cone/base generators, labeled violation matrix, Lemma 4) is internally consistent: the constructive direction K_F ⊆ Ξ_F is proved by sequential reflections, and the rank computation in Lemma 1 checks out. The single load-bearing point is the converse: that no shift outside K_F can preserve all active distances. This is precisely the mirror-separation hypothesis (Definition 9), and the theorem's proof uses it verbatim as the only non-algebraic input. The paper's Remark 1 attempts to show mirror separation is generic, but the argument is conditional on a non-identity criterion for Δ_{h,e} that is not established. The §7 example demonstrates the algebra but does not verify the converse computationally: it never checks whether any of the 120 codes outside the predicted 8 are feasible. Without such a check, or a proof of the criterion, the central claim is unverified for even the presented instance. My concern does not change the reader's verdict: the paper is honest and well-structured, but the advertised topological count is conditional on an unproved hypothesis. CONDITIONAL remains appropriate.","tokens_in":13911,"tokens_out":8848,"duration_ms":82862,"concrete_test":"Enumerate all 2^7 = 128 branch codes for the §7 example using the explicit coordinates in §7.2 and the active edge set F (discretization edges on L plus pruning edges {v3,v6} and {v4,v5}). Count how many codes satisfy all active squared-distance equalities. If the count equals 8, mirror separation holds for this instance; if it is >8, the rank formula is contradicted and Theorem 1's converse fails.","verdict_should_be":"UNCHANGED","load_bearing_attack":"Theorem 1's converse — that every feasible constrained shift lies in K_F = M(ker V) — is exactly the content of Definition 9 (mirror-separated parameters). Lemma 4 proves only the inclusion K_F ⊆ feasible shifts; the reverse inclusion is assumed, not derived. Remark 1's genericity argument is conditional on a 'non-identity criterion' for the discrepancy functions Δ_{h,e}(θ;s), which involve radical coordinates from sphere intersections; this criterion is neither proved nor checked for any template. The 7-vertex example in §7 verifies the algebraic ranks and traces a few geometric moves, but it does not enumerate the 2^7 = 128 branch codes to confirm that |Ξ| = 8. Thus the paper provides no evidence that mirror separation holds for any concrete instance. If mirror separation fails (even on a measure-zero set for a given template), the true count is larger than 2^{f+rank[M;V]−rank V}, and the advertised topological count is not weight-independent. The hypothesis is not a mild genericity condition; it asserts the absence of exactly the extra solutions the theorem aims to exclude.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper studies the Combinatorial Discretizable Distance Geometry Problem (Combinatorial DDGP) and proposes an algebraic method for counting realizations when pruning edges are present. It introduces branch codes, cone and base generators, a labeled violation matrix V, and the branch-shift space K_F = M(ker V). Lemma 4 shows constructively that every shift in K_F preserves all active edge lengths. The main Rank-Count Theorem (Theorem 1) then claims that, under a hypothesis called mirror-separated parameters (Definition 9) and assuming a reference solution exists, the feasible constrained branch codes form the affine coset s*_c ⊕ K_F, yielding the count 2^{f + rank[M;V] - rank V}. A seven-vertex example is worked out in detail, giving the claimed count 8.","tokens_in":14094,"tokens_out":5344,"duration_ms":57023,"significance":"If the mirror-separation hypothesis can be proved generic or verified for concrete instances, the rank formula would give a polynomial-time algebraic solution to a previously open counting problem, and the paper's algebraic decomposition of branch shifts is a valuable conceptual step. The internal algebra is coherent: the worked example's matrices, ranks, and kernel satisfy the stated identities, and Lemma 4's forward inclusion is plausible. However, the exact-count claim rests entirely on Definition 9, which is neither derived from more basic assumptions nor verified in any example. The paper therefore delivers a conditional framework rather than a complete resolution; its significance is correspondingly qualified.","major_comments":[{"comment":"The (⊆) direction of Theorem 1 is not a derivation but a restatement of the mirror-separation hypothesis. Definition 9 asserts exactly that every constrained shift outside K_F changes some active edge length, so the conclusion 'if h∉K_F then a contradiction' is the hypothesis itself. Thus the exactness of the rank-count formula is contingent on an assumption whose content is the absence of the extra solutions the theorem aims to exclude. The paper should state this dependence explicitly and separate the conditional algebraic theorem from the claimed solution of the counting problem.","section":"§6, Definition 9 and Theorem 1"},{"comment":"The genericity argument for mirror separation is unsupported. The discrepancy functions Δ_{h,e}(θ;s) involve coordinates obtained from sphere intersections, hence contain radicals; it is not automatic that a non-identity criterion implies the failure set has measure zero. Moreover, the criterion must be checked for every h∉K_F and every branch code s, and no such proof or verification is supplied. Consequently, the claim that mirror separation holds for almost all nondegenerate parameters is not established.","section":"§6, Remark 1"},{"comment":"The worked example does not verify mirror separation. It computes the algebraic objects and traces a few selected generator moves, but it does not enumerate the 32 constrained branch codes (or the 128 full codes) to confirm that the true count is 8, nor does it check the Definition 9 condition for every shift outside K_F. Thus the paper provides no evidence that the central hypothesis is satisfiable in any concrete non-vacuous instance. This is a load-bearing gap because the rank formula's exactness depends entirely on that hypothesis.","section":"§7"}],"minor_comments":[{"comment":"The phrase 'topological solution count' is potentially misleading: the count depends on the mirror-separation hypothesis, which is not shown to be a topological or weight-independent property. The wording should reflect the conditional nature.","section":"Abstract"},{"comment":"The geometric tracing is helpful, but a small table listing the 8 full branch codes (or at least the 4 constrained codes) and their coordinate realizations would make the example self-contained and would allow the reader to independently check the count.","section":"§7.2"},{"comment":"The sequential application of mirror blocks is plausible but compressed; a sentence justifying that the current embedding remains a branch embedding after each block application would improve readability.","section":"Lemma 4"}],"recommendation":"major_revision","confidential_remarks":"The main theorem is logically correct as a conditional statement, but the paper's advertised resolution of the counting problem depends on a hypothesis that is neither proved generic nor verified in any example. The example only checks the algebraic ranks. I would request a substantive addition: either a proof of the non-identity criterion under explicit algebraic conditions, a concrete instance where mirror separation is verified by exhaustive branch-code enumeration, or a clear reframing of the contribution as a conditional algebraic framework with the hypothesis flagged as an open condition."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"The paper builds something real: a labeled-violation matrix and an affine-space theorem for feasible branch codes in Combinatorial DDGP with pruning edges. That's new. Prior counting work covered DMDGP's contiguous orders and the unpruned 2^{n-K} case; this extends to arbitrary predecessor cliques and pruning edges. Lemma 4 is the constructive half, and it's solid: any generator combination in ker V produces a shift that preserves all active distances. I checked the 7-vertex example by hand—the masks, violation rows, ranks (rank[M;V]=4, rank V=2), and the final count of 8 are all internally consistent. The paper is also honest: it states Definition 9 as a hypothesis and flags that it exists to exclude extra solutions.\n\nThe soft spot is exactly what the reader's take says: the converse half of Theorem 1 is Definition 9 restated. Mirror separation asserts that every feasible shift lies in K_F = M(ker V), which is precisely the equality the theorem claims. Lemma 4 proves the inclusion K_F ⊆ feasible shifts; the reverse is assumed, not derived. Remark 1 offers a genericity route, but it's conditional on a non-identity criterion for discrepancy functions involving radicals from sphere intersections—neither proved nor checked. And the worked example doesn't enumerate the 128 branch codes to confirm |Ξ|=8, so it doesn't verify mirror separation for that instance either. This is a genuine gap, not a manufactured one.\n\nStill, the gap is clearly disclosed. The paper doesn't pretend mirror separation is proven; it presents a conditional rank-count theorem. If a future version can prove the non-identity criterion for a template family, verify mirror separation computationally for small instances, or anchor the result in the DMDGP special case, this becomes a strong, citable result. As it stands, the framework is valuable and the algebra is coherent, but the central advertised count is conditional on an unverified assumption.\n\nWho gets value? Distance geometry researchers working on DMDGP/DDGP counting, and anyone interested in algebraic methods for discrete geometry. It deserves a serious referee—send it to peer review, not desk reject. The referee should ask for one of those three things: a genericity proof, a verification protocol, or a DMDGP reduction.","headline":"A genuinely new algebraic framework for counting Combinatorial DDGP realizations, but the main theorem's exactness is packed into the mirror-separation assumption, so the result is conditional until that assumption is shown to hold generically or verified concretely.","tokens_in":14650,"tokens_out":2971,"would_cite":true,"duration_ms":28790,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":["51K05"],"pacs":[],"model":"deepseek-v4-flash","headline":"The number of realizations of a Combinatorial DDGP instance is determined by the ranks of two graph-derived binary matrices, provided mirror-separated parameters and a reference solution exist.","keywords":["Combinatorial DDGP","Distance Geometry Problem","solution counting","binary branch codes","rank formula","affine space over F2","pruning edges","partial reflections"],"falsifier":"Run Branch-and-Prune on a random nondegenerate Combinatorial DDGP instance, collect all feasible branch codes, and compare the set with s*_c ⊕ K_F predicted by the rank formula; any feasible code outside the predicted coset — equivalently, any total count other than 2^{f + rank[M;V] − rank V} — is a concrete counterexample to exactness, showing mirror separation failed for those parameters. A single such instance with exact rational coordinates would settle the matter.","tokens_in":13653,"feed_emoji":"🧮","tokens_out":6798,"duration_ms":65221,"temperature":0.7,"pith_summary":"This paper claims that for the Combinatorial Discretizable Distance Geometry Problem — a subclass where each new vertex has K predecessors forming a clique, so placements branch two ways — the number of geometric realizations can be computed exactly from the ranks of two binary matrices derived from the vertex-order template and the pruning edges. Previously, counting solutions in the presence of additional distance constraints (pruning edges) was open, because branch reflections no longer act on contiguous suffix intervals. The authors prove that, whenever a reference solution exists and the edge lengths satisfy a 'mirror-separated' genericity condition, the feasible binary branch codes form an affine space over the two-element field F2, so the count is 2^{f + rank[M;V] − rank V}, where f counts 'free' branch decisions. If correct, this turns solution counting from tree search into linear algebra over F2 and unifies the known power-of-two counts for unpruned and DMDGP instances.","feed_headline":"Binary rank formula gives exact distance-geometry solution count","feed_subtitle":"No tree search needed: feasible branch codes form an affine space over F2, so the count is a power of two times a rank term.","key_machinery":"The labeled violation matrix V together with the generator mask matrix M. M sends F2-coefficients of graph-derived generators (cone generators g_q for constrained branch vertices, base generators g_C for predecessor cliques) to net branch masks; V sends the same coefficients to labeled violation patterns indexed by (active edge, mirror clique). The feasible branch-shift space is K_F = M(ker V), and Lemma 1 shows dim K_F = rank[M;V] − rank V. The affine-coset identity Ξ_F = s*_c ⊕ K_F is the load-bearing mechanism: it converts 'which branch flips preserve all pruning distances' into a kernel computation over F2, and the free bits simply multiply the count by 2^f.","core_discovery":"The paper's central claim is the Rank-Count Theorem (Theorem 1): for K≥2, if at least one realization exists and the parameters are mirror-separated, then for any reference solution s*, the feasible constrained branch codes satisfy Ξ_F = s*_c ⊕ M(ker V). Equivalently, the feasible branch codes form an affine space over F2, and the total number of realizations is 2^{f + rank[M;V] − rank V}. The argument decomposes branch decisions into constrained and free bits, encodes each partial reflection as a cone or base generator labeled by its mirror clique, and builds a labeled violation matrix V whose rows are pairs (active edge, mirror label). Zero-violation generator combinations provably preserv","pith_inferences":["Our inference: if mirror separation holds generically as the paper's Remark 1 suggests, then computing the count is polynomial-time in the size of M and V (rank over F2), meaning exact solution counting for Combinatorial DDGP could become feasible for large instances without enumerating 2^{n−K} branches — a consequence the paper mentions as future work but does not itself prove.","Our inference: the mirror-separation condition is the real empirical question; one could test it by running Branch-and-Prune on random instances and checking whether the feasible set is exactly s*_c ⊕ K_F. If failures occur on a non-negligible set, the 'topological' character of the formula would need qualification.","Our inference: the labeled-violation idea might transfer to other discrete search problems where generators carry group labels, e.g., counting solutions of systems of polynomial equations with reflection symmetries; the rank formula would then be a template for counting without search.","Our inference: because the count is a power of two whenever a reference solution exists, any instance with a number of realizations not of the form 2^m would immediately certify either a mirror-separation failure or a degenerate parameter choice — a cheap empirical falsification check."],"forward_implications":["For any ordered Combinatorial DDGP template with pruning edges, the realization count is determined solely by ranks of two binary matrices — no coordinate search over the branch tree is needed to obtain the count.","The count is always a power of two when mirror separation holds and a reference solution exists: each independent feasible shift and each free branch decision doubles the number of realizations.","The framework recovers the classical cases: with no pruning edges, B_c is empty, f = n−K, and the formula gives 2^{n−K}; DMDGP counts appear as the contiguous-order special case.","The labeled violation matrix can be computed purely from the graph template and the set of active edges, so the rank formula is weight-independent and topological in that sense.","The algebraic filter K_F identifies exactly which reflection combinations preserve pruning distances, offering a certificate that could be integrated into Branch-and-Prune solvers to prune without coordinate checks."],"fun_headline_variants":["Rank-count theorem gives exact solution counts in distance geometry","Affine-space over F2 yields closed-form count of realizations","Exact counts from rank: feasible branch codes form affine space","Mirror-separated parameters unlock rank-based solution counts","No tree search: rank formula counts distance-geometry solutions"],"cache_read_input_tokens":2304,"weakest_assumption_plain":"The formula stands or falls on the mirror-separation hypothesis: any branch flip outside the algebraically predicted space must break at least one active edge length, because the paper only argues this genericity claim conditionally, not proves it.","fun_headline_variants_meta":{"raw":{"variants":["Rank-count theorem gives exact solution counts in distance geometry","Affine-space over F2 yields closed-form count of realizations","Exact counts from rank: feasible branch codes form affine space","Mirror-separated parameters unlock rank-based solution counts","No tree search: rank formula counts distance-geometry solutions"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000173,"raw_usage":{"total_tokens":1103,"prompt_tokens":720,"completion_tokens":383,"prompt_tokens_details":{"cached_tokens":256},"prompt_cache_hit_tokens":256,"prompt_cache_miss_tokens":464,"completion_tokens_details":{"reasoning_tokens":300}},"tokens_in":464,"tokens_out":383,"duration_ms":4186,"temperature":1.0,"reasoning_tokens":300,"cache_read_input_tokens":256,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-02T12:36:21.124736+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run Branch-and-Prune on a random nondegenerate Combinatorial DDGP instance, collect all feasible branch codes, and compare the set with s*_c ⊕ K_F predicted by the rank formula; any feasible code outside the predicted coset — equivalently, any total count other than 2^{f + rank[M;V] − rank V} — is a concrete counterexample to exactness, showing mirror separation failed for those parameters. A single such instance with exact rational coordinates would settle the matter.","supporting_citations":[],"review_version":1}