{"id":"e6cbda19-3501-4d64-8783-605592f049b1","arxiv_id":"2411.16615","paper_version":2,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":5.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":3,"one_line_summary":"LCPool pools a graph by selecting top-scoring nodes and reconstructing edges from the nonzero pattern of A plus A squared plus A cubed.","lead":"Graph pooling shrinks a graph while preserving its key structure for a graph neural network. This paper proposes LCPool, which keeps high-scoring nodes and builds new edges between nodes that are within three hops in the original graph, and it frames several existing pooling methods as special cases of a local assignment view.","discovery_kind":"extension","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Table 6 contradicts the paper's claim that LCPool 'ranks highest for every backbone': on GNNc_h, nopool's average rank is 2.33 while lcpool's is 3.5, so the central empirical conclusion is not supported by the paper's own data.","rationale":"The paper's main contribution is a pooling operator plus a claim of general competitiveness. The empirical claim is load-bearing because without it there is no evidence the operator is useful beyond its construction. The strongest form of that claim—'ranks highest for every backbone'—is directly false on the paper's own Table 6. This is an internal inconsistency, not a disagreement with external consensus, so it is a correctness risk rather than a matter of taste. I agree with the reader that the fixed split and absence of significance tests are also problematic, but the contradiction in Table 6 is the sharper, less assumption-dependent version of the same concern. The theoretical framework (local assignment selection, Lemma 5, Proposition 6) appears algebraically coherent: the support substitution S → I+A preserves the pooled edge set under the stated unweighted-edge assumption, and the derivation in Appendix A.3 checks out. No code or data splits are provided, which reinforces the conditional status but does not by itself refute the method. The appropriate verdict remains CONDITIONAL: the authors should correct the ranking claim and supply a more robust experimental comparison. I do not argue for REJECT because the algebraic construction and the LCSMP score function are clearly specified and the flaws are fixable.","tokens_in":10167,"tokens_out":10330,"duration_ms":92423,"concrete_test":"Independently recompute the average ranks in Table 6 from the accuracy values in Tables 2–5, treating nopool as a full baseline. If lcpool is not the unique lowest-ranked method on all four backbones—and it is not, since on GNNc_h nopool has rank 2.33 while lcpool has 3.5—then the sentence 'our approach ranks highest for every backbone' is false and the conclusion must be revised.","verdict_should_be":"UNCHANGED","load_bearing_attack":"Section 4.5's central conclusion, that LCPool is 'more competitive and expressive in general' and 'ranks highest for every backbone', is the main experimental support for the proposed operator. The evidence as printed does not support it: Table 6 gives lcpool an average rank of 3.5 on GNNc_h, worse than nopool's 2.33, and on GNNc_p lcpool ties sagpool at 3.17. These ranks are derived from the paper's own Tables 2–5, so the discrepancy is internal and does not depend on any contested baseline choice or statistical convention. The verbal summary in Section 4.5 is therefore not merely unproven but contradicted by the presented numbers. A second empirical weakness compounds the first: all results come from one fixed 8:1:1 split and ten runs with no paired significance tests, so even differences not contradicted by Table 6 may be within run-to-run noise. The correctable nature of these issues keeps the verdict conditional, but as written the central empirical claim fails against its own table.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The manuscript proposes a graph pooling framework, local assignment selection, in which an assignment matrix S is constrained to have support only on one-hop neighborhoods; it then specializes to local cluster selection, where S can be replaced by I+A when edge weights are ignored, giving the closed-form edge update A' = ones(A + A^2 + A^3)(i_hat,i_hat) for undirected graphs. The proposed operator, LCPool, uses a new score function LCSMP that aggregates transformed feature differences among local neighbors, and is evaluated on six TUDatasets across four GNN backbones against five pooling baselines. The paper claims that LCPool is more competitive and expressive than the baselines, that it ranks highest for every backbone, and that the variant lcpool* with an extra GCN layer as v(·) does not outperform LCPool, thereby validating Proposition 7.","tokens_in":10378,"tokens_out":6011,"duration_ms":50748,"significance":"The theoretical framework is a useful formalization: it identifies a middle ground between node selection and dense assignment, highlights sparsity and adaptivity, and provides a simple, sparse-friendly edge update formula. Proposition 3 correctly embeds node selection as a special case, and Proposition 6 gives a compact derivation of the pooled adjacency. LCSMP is a reasonable and interpretable scoring layer. However, the empirical support as printed is contradicted by the paper's own tables, so the claimed practical advantage is not established. If the experiments are revised and the claims are corrected, the framework could be a modest but publishable contribution to graph pooling methodology.","major_comments":[{"comment":"The statement that LCPool 'ranks highest for every backbone' is contradicted by Table 6: on GNNc_h, lcpool has average rank 3.5, worse than nopool's 2.33, and on GNNc_p it only ties sagpool at 3.17. Since these ranks are derived from Tables 2-5, the discrepancy is internal and does not depend on any contested baseline choice. The ranking claim must be revised, or the ranking methodology must be clarified (for example, by excluding nopool, by using per-task wins, or by accounting for statistical ties).","section":"Section 4.5, Table 6"},{"comment":"The claim that the variant lcpool* 'does not outperform' LCPool is not supported by the reported numbers. On NCI1, lcpool* is higher in all four backbones (e.g., 81.80 vs 79.10 on GNNh, 81.00 vs 78.61 on GNNc_h, 81.80 vs 79.49 on GNNp, and 81.65 vs 80.61 on GNNc_p); on Mutagenicity, lcpool* is higher on GNNc_h (81.61 vs 80.51) and GNNc_p (80.83 vs 80.48); on DD, lcpool* is higher on GNNp (75.08 vs 74.32). Thus, as written, the comparison does not validate Proposition 7. The authors should either report significance tests and a clearly defined aggregate criterion, or explicitly acknowledge that lcpool* outperforms lcpool on several datasets and discuss the confound of additional model capacity.","section":"Section 4.5, Tables 2-5"},{"comment":"The experimental protocol rests on one fixed 8:1:1 split, ten runs, and no paired significance tests or multiple splits. Many reported differences are within one standard deviation (e.g., Table 3, PROTEINS: lcpool 74.91±1.89 vs nopool 74.02±1.67; Table 5, ENZYMES: lcpool 71.83±6.69 vs diffpool 76.17±3.88). Consequently, even after correcting the ranking claim, the paper would not establish that LCPool is systematically more competitive or expressive. Paired tests over multiple splits are needed to support the central empirical conclusion.","section":"Section 4.5 and Appendix B"}],"minor_comments":[{"comment":"There are numerous typos and grammatical errors, including 'shrinked', 'recommander', 'stuctures', 'adpoting', 'exsits', 'trainning', 'acer', and 'vaild'; these should be corrected in a revision.","section":"Throughout"},{"comment":"The condition 'sij is non-zero only when aij is not zero' should refer to entries of A* = I_N + A, not the original adjacency A; otherwise the requirement that a node contributes to itself is inconsistent with aii = 0 in the original adjacency matrix.","section":"Section 3.1, Prerequisite 1"},{"comment":"The sentence 'We assumpt that the input and coarsened graphs are undirected and have unweighted edges' should be reworded as 'We assume...'.","section":"Section 3.3.2"},{"comment":"The dataset name 'Muatagenicity' is misspelled; it should be 'Mutagenicity'.","section":"Table 2"},{"comment":"The conclusion repeats the empirical claims contradicted by Table 6 and the lcpool* comparison; it should be updated to match the revised results.","section":"Section 5"}],"recommendation":"major_revision","confidential_remarks":"The paper is a single-author preprint with an informal writing style. The core formalization is reasonable, but the experimental section contains direct internal contradictions that are central to the paper's claims. The editor may wish to require the author to re-run the experiments with multiple splits and paired significance tests, and to rewrite the empirical discussion. I do not see a novelty disclosure concern, but no code or data repository is mentioned."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Dan, quick take on arXiv:2411.16615. The LCPool idea is genuinely worth a look: it casts pooling as local assignment with a support constraint, gives a clean simplification under unweighted undirected graphs (A' = ones(A+A^2+A^3)(i_hat,i_hat)), and the LCSMP score is a reasonable difference-based scoring. Proposition 3 (node selection as a special case) is immediate but correctly noted. The proofs in the appendix are short and mostly check out; Lemma 5's substitution of I+A for S is legitimate because only support matters after ones().\n\nThe soft spots are in the experiments, and they're not minor. The paper claims LCPool 'ranks highest for every backbone' based on Table 6. But Table 6 itself shows nopool with average rank 2.33 on GNNc_h vs lcpool's 3.5, and a tie on GNNc_p. So the central empirical claim is contradicted by the paper's own numbers. The rankings also aren't accompanied by any significance tests; ten runs on a single 8:1:1 split is thin, and some differences are within one standard deviation. The missing k (pooling ratio) and lack of code/data splits would need to be fixed. Proposition 7's validation is weak: comparing lcpool* and lcpool across a few datasets doesn't prove that v(·) can be dismissed; the results are mixed (lcpool* wins on NCI1 in all four backbones). That claim needs rephrasing as empirical support, not proof.\n\nThat said, the framework is a contribution, and the operator is simple and implementable. The paper is short, readable, and honestly positions itself relative to SRC. The right move is to engage: send to peer review with a request for major revision. This is exactly the kind of paper a referee can have useful opinions on — the theory is salvageable, the experiments need to be redone honestly with multiple splits and proper statistics, and the claims need to match the tables.","headline":"LCPool offers a clean local-assignment framework and a usable sparse pooling operator, but its own experimental table contradicts the headline claim that it ranks highest on every backbone.","tokens_in":10915,"tokens_out":3484,"would_cite":false,"duration_ms":30532,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"Graph pooling by local cluster selection yields sparse, adaptive, edge-building coarsening.","keywords":["graph pooling","graph neural networks","local cluster selection","sparse assignment","LCSMP","graph classification","node selection","pooled adjacency update"],"falsifier":"Re-run the four backbones on the same six datasets with multiple random splits and paired significance tests; if LCPool's average rank no longer beats NoPool and SAGPool, then the competitiveness claim is not supported.","tokens_in":56,"feed_emoji":"🕸️","tokens_out":9590,"duration_ms":144654,"temperature":0.7,"pith_summary":"This paper is trying to establish that graph pooling can be improved by selecting local clusters rather than by dense assignment or by simply keeping a subset of original edges. Its procedure, local cluster selection, restricts the assignment matrix to self-loops and one-hop neighbours, which makes pooling adaptive to input size, compatible with sparse matrix multiplication, and able to build new edges between selected clusters. For unweighted undirected graphs the procedure simplifies to a closed-form adjacency update $A' = \\mathrm{ones}(A + A^2 + A^3)(\\hat{i},\\hat{i})$, with no assignment matrix to store. The paper proposes LCPool, a pooling operator that scores nodes from Laplacian feature differences, and reports experiments on six benchmark graph-classification datasets and four GNN backbones in which LCPool achieves the most top accuracies and the best average rank.","feed_headline":"Local-cluster pooling keeps graph size adaptive and builds new edges","feed_subtitle":"LCPool replaces dense assignment with a sparse one-hop score, shrinking graphs proportionally to their input.","key_machinery":"The load-bearing object is the local cluster selection identity: when the assignment matrix $S$ is replaced by the adjacency-with-self-loops $A^* = I_N + A$, the pooled adjacency for the selected index set $\\hat{i}$ becomes $A' = \\mathrm{ones}(A + A^T A + A^2 + A^T A^2)(\\hat{i},\\hat{i})$, which for undirected graphs collapses to $A' = \\mathrm{ones}(A + A^2 + A^3)(\\hat{i},\\hat{i})$. The identity does the main work because it converts a learned dense assignment into a sparse, parameter-free edge update based on one-hop and two-hop walks, and it is what makes adaptive graph sizes and sparse matrix multiplication possible. The second mechanism is the LCSMP score function $h_i = L_s(L_{fd}(\\sum_{k\\in N(i)} L_d(\\tilde{x}_i - \\tilde{x}_k)) + L_x(\\tilde{x}_i))$, which learns to detect clusters from differences among local neighbours rather than from node features alone.","core_discovery":"In the paper's own framing, the central claim is that a locally supported assignment matrix $S\\in\\mathbb{R}^{|V|\\times|V|}$, whose entries are non-zero only where the adjacency matrix with self-loops $A^* = I_N + A$ is non-zero, is enough to generate pooled graphs with the advertised advantages. From this starting point the paper proves that the pooled adjacency matrix can be written as $A' = \\mathrm{ones}(S'^T A S')$, and that under the common conditions of an unweighted graph and a one-hop feature-update function the assignment matrix can be replaced by $I_N + A$, giving $A' = \\mathrm{ones}(A + A^T A + A^2 + A^T A^2)(\\hat{i},\\hat{i})$ and, for undirected graphs, $A' = \\mathrm{ones}(A + A^2 + A^3)(\\hat{i},\\hat{i})$. The paper also argues that ordinary node selection is a special case of this framework with $S = I_N$, and that the separate cluster-function layer can be dropped when the preceding convolution already satisfies the one-hop condition. Its proposed LCPool operator selects the top-scored clusters using a learned score built from transformed neighbour differences, and the experimental section claims that this operator is more competitive and expressive than existing node-selection and dense-assignment pooling approaches.","pith_inferences":["If the adjacency identity is taken as a definition of a local cluster, then pooling is effectively selecting nodes whose two-hop and three-hop walk patterns are dense; this suggests a testable extension in which the polynomial degree $r$ in $\\mathrm{ones}(A + \\cdots + A^r)$ is varied and accuracy is tracked on graphs with different diameter distributions.","The Laplacian-difference score connects LCPool to spectral intuition, but the paper does not analyze it spectrally; one could test whether the learned score correlates with low-frequency eigenvectors, which would give an interpretation of why cluster selection helps.","The experimental claim is only as strong as the fixed-split, ten-run protocol; a natural robustness check is repeated cross-validation with paired significance tests across multiple splits, which the paper does not report."],"forward_implications":["Pooled graphs keep a size proportional to the input graph, so small graphs are not forced upward and large graphs are not excessively shrunk, unlike dense-assignment pooling with a fixed second dimension.","Because the assignment matrix is local and sparse, LCPool can be implemented with sparse matrix multiplications and therefore interoperates with sparse graph convolution layers.","Edges are constructed between selected clusters whenever their contributors are connected, and original edges are preserved when the diagonal of $S$ is non-zero, so the coarsened graph is more connected than a pure node-selection output.","For unweighted undirected graphs, the pooled adjacency is obtained directly as $\\mathrm{ones}(A + A^2 + A^3)(\\hat{i},\\hat{i})$, so no assignment matrix needs to be formed or stored during pooling.","The operator can be inserted into standard GNN backbones for graph classification, and the paper reports that it achieves the highest accuracy in the largest number of backbone-task combinations and the best average rank across the compared pooling methods."],"supporting_citations":[{"why":"Supplies the selection-reduction-connection formalization and the definition of adaptive pooling that motivate local assignment selection.","marker":"[6]"},{"why":"Dense-assignment pooling method used as a baseline; its fixed-size dense assignment is the main approach the paper argues against.","marker":"[7]"},{"why":"Introduces TopK node selection, the node-selection baseline that Proposition 3 casts as the special case $S=I_N$.","marker":"[12]"},{"why":"SAGPool, a node-selection pooling baseline, and the source of the mean-max readout used in the experimental backbones.","marker":"[13]"},{"why":"MinCut pooling, a dense-assignment baseline compared in the experiments.","marker":"[14]"},{"why":"ASAPool, an existing local-assignment pooling method that the paper fits into its framework and compares against.","marker":"[15]"},{"why":"Formalizes message passing, the graph-convolution mechanism on which the LCSMP score layer is built.","marker":"[17]"},{"why":"Provides the benchmark datasets used for the graph-classification experiments.","marker":"[18]"}],"fun_headline_variants":["Local cluster pooling shrinks graphs with sparse one-hop scores","Graph pooling via local clusters: sparse, adaptive, edge-building","One-hop cluster selection makes graph pooling sparse and adaptive","LCPool: local cluster selection for adaptive graph shrinking","Sparse one-hop pooling builds new edges and adapts graph size"],"cache_read_input_tokens":13056,"weakest_assumption_plain":"The claim that LCPool is the most competitive pooling operator rests on treating the average accuracy over ten runs on one fixed 8:1:1 split per dataset, with hyperparameters tuned only until every model converges, as a reliable comparison.","fun_headline_variants_meta":{"raw":{"variants":["Local cluster pooling shrinks graphs with sparse one-hop scores","Graph pooling via local clusters: sparse, adaptive, edge-building","One-hop cluster selection makes graph pooling sparse and adaptive","LCPool: local cluster selection for adaptive graph shrinking","Sparse one-hop pooling builds new edges and adapts graph size"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.00084,"raw_usage":{"total_tokens":3623,"prompt_tokens":871,"completion_tokens":2752,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":487,"completion_tokens_details":{"reasoning_tokens":2669}},"tokens_in":487,"tokens_out":2752,"duration_ms":18309,"temperature":1.0,"reasoning_tokens":2669,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-12T12:55:25.175283+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Re-run the four backbones on the same six datasets with multiple random splits and paired significance tests; if LCPool's average rank no longer beats NoPool and SAGPool, then the competitiveness claim is not supported.","supporting_citations":[{"cited_title":"Self-attention graph pooling","cited_arxiv_id":null,"evidence_quote":"SAGPool, a node-selection pooling baseline, and the source of the mean-max readout used in the experimental backbones."},{"cited_title":"Kriege, Franka Bause, Kristian Kersting, Petra Mutzel, and Marion Neumann","cited_arxiv_id":null,"evidence_quote":"Provides the benchmark datasets used for the graph-classification experiments."}],"review_version":1}