Pith. sign in

REVIEW 6 major objections 6 minor 57 references

CS-Agent: LLM-based Community Search via Dual-agent Collaboration

T0 review · 6 major / 6 minor · reviewed 2026-08-05 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read Two-LLM loop lifts community-search F1 by up to 73.5 points.

desk verdict A useful new benchmark and a plausible dual-agent framework for LLM community search, but the paper's central selection mechanism needs quantitative validation. read the letter →

arxiv 2508.09549 v2 pith:5YAL7W42 submitted 2025-08-13 cs.SI

Jiahao Hua , Long Yuan , Qingshuai Feng , Qiang Fan , Shan Huang This is my paper
classification cs.SI
keywords communitysearchlargelanguagemodelsmulti-agentplanningGraphCSbenchmarkoutputbiask-corek-trussk-edge-connectedcomponent
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper sets out to show that large language models, which fail badly when asked directly to find a community in a graph, can do the task well when the work is split between two agents: a Solver that proposes candidate vertex sets and a Validator that critiques them, followed by a Decider that picks the best candidate. To test this, the authors build GraphCS, a benchmark of more than 12,000 synthetic graphs over four cohesion metrics (k-core, k-truss, k-clique, and k-edge-connected component). Their experiments show LLMs are brittle: they frequently emit algorithms or code instead of the requested community, a failure they call output bias. The CS-Agent loop removes most of that bias and raises F1 by up to 73.5 points on the hardest instances without fine-tuning. If the finding holds, LLMs become a viable no-training alternative for community search on graphs small enough to verbalize.

What carries the argument

The load-bearing mechanism is the Solver–Validator dialogue with a Decider gate. The Solver generates candidate communities; the Validator produces both a quantified 0–5 score and vertex-level structural feedback; when the same community appears twice, the Validator's memory is cleared to prevent Degeneration-of-Thought, the tendency of LLMs to resist self-correction; the Decider then selects the final community by average Validator score, breaking ties by frequency and earliest refinement round. This converts one-shot answer generation into a guided search over candidate vertex sets.

What would settle it

Run CS-Agent with r=3 on GraphCS and, for each instance, record the Validator score of every candidate community and its true F1. If the correlation between score and F1 is near zero, or if a control Decider that picks a random candidate ties CS-Agent's mean F1, the selection mechanism is not doing the claimed work.

Watch

Extended reading notes

Core claim

The central claim is that community search can be cast as a two-role LLM interaction that outperforms every prompting baseline on the GraphCS benchmark. In each round the Solver returns a community; the Validator checks each vertex against the requested cohesion metric, gives a 0-5 score and textual suggestions; the Solver revises; after three rounds the Decider aggregates all candidates (by average score, occurrence frequency, and refinement depth) and returns the winner. The paper reports that this scheme raises F1 substantially, with the largest gains on hard k-ECC tasks: +73.5 points over the 0-CoT baseline and +61.6 over zero-shot on the PSG dataset, and it also beats majority-voting se

Load-bearing premise

The whole improvement rests on the Validator's scores and feedback being a reliable stand-in for true community quality (F1), so that refining toward feedback and choosing the top score actually finds the better community.

Editorial extensions

If this is right

  • CS-Agent can be wrapped around any prompting method (zero-shot, few-shot, 0-CoT) and improve it without training; gains are largest where the base method is weakest.
  • Three dialogue rounds are enough; extra rounds cost 25–30% more tokens and can hurt performance, so deployment can fix a small budget.
  • The Decider's selection makes the final answer at least as good as the best round in most cases and can exceed it, as reported for the k-Clique task.
  • The same improvement pattern appears on both PSG and LFR graphs, suggesting the framework transfers across different community-topology families.
  • The framework beats self-consistency voting, so generating many independent answers is not a substitute for feedback-guided refinement.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The same Solver–Validator–Decider loop could be applied to other structured-output graph problems, such as densest subgraph or constrained shortest paths, where a validator can check a metric but ground truth is expensive.
  • The memory-clearing heuristic is a generic counter to LLM overconfidence in iterative agents and could be tested independently on non-graph reasoning tasks.
  • Because the benchmark uses synthetic graphs under token limits, the practical payoff depends on a subgraph-selection strategy for real, large graphs; none is provided here, so scaling to DBLP-sized networks remains an open step.
  • A direct quantitative check of the Validator's proxy assumption would measure the correlation between Validator scores and ground-truth F1; the paper only shows a visual trend with one backbone model.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

6 major / 6 minor

Summary. The paper introduces GraphCS, a synthetic benchmark of roughly 12,000 graphs (PSG and LFR) covering four community-search metrics (k-Core, k-Truss, k-Clique, k-ECC), and CS-Agent, a dual-agent LLM framework in which a Solver generates candidate communities, a Validator scores them and provides textual feedback, and a Decider selects the final community. The authors evaluate four LLMs under zero-shot, few-shot, and 0-CoT prompting, document an "output bias" failure mode, and report that augmenting ChatGPT with CS-Agent yields large F1 gains (e.g., +73.5 and +61.6 F1 points on hard k-ECC in PSG) over the prompting baselines, with smaller gains when Few-shot is used. They also compare against self-consistency and study the number of dialogue rounds.

Significance. If the empirical claims hold, the paper is a useful contribution: GraphCS is a sizable benchmark, the output-bias analysis identifies a concrete and reproducible failure mode, and the Solver-Validator-Decider loop is a plausible way to improve LLM outputs on structured graph tasks. The self-consistency comparison is a good negative control. However, the evaluation as reported is not yet sufficiently controlled to support the headline gains. The main results use a single backbone LLM, report no variance estimates, select the dialogue-round parameter r on the same test data used in Table 3, and rely on a Decider whose load-bearing assumption—Validator scores track ground-truth F1—is supported only by a visual overlay in Figure 4. These are fixable with additional experiments and analysis, but they are load-bearing for the central claim.

major comments (6)
  1. [Sec. 4.2.3 and Sec. 5.5.1] The Decider selects the final community primarily by normalized average Validator scores (with tie-breaks on occurrence frequency and refinement depth), so the whole selection mechanism assumes that Validator scores are a faithful proxy for ground-truth F1. The only supporting evidence is Figure 4, a visual overlay of F1 and review-score curves for ChatGPT; no correlation coefficient, scatter plot, second backbone, or counterfactual selection baseline is provided. Please report a quantitative rank correlation (e.g., Spearman) between Validator scores and F1 across rounds/tasks, and compare the Decider's choice against selecting the max-F1 candidate, the last candidate, or majority voting. Without this, the reported gains could be due to refinement or format correction rather than Validator-guided selection.
  2. [Sec. 5.5.4 and Table 3] The dialogue-round parameter r=3 is selected on the same GraphCS test instances used to produce Table 3: the text states "we ultimately selected r=3 as the optimal configuration when conducting experiments." This is test-set tuning and can inflate the reported improvements. Please reserve a validation split for choosing r (or report results for r=1,2,3,4,5 on held-out data), and state how r was selected before presenting the headline numbers.
  3. [Sec. 5.1, Sec. 5.2.1, Table 3] All CS-Agent results in Table 3 use GPT-3.5-turbo only, despite the paper claiming a general framework. Table 2 shows large model-specific differences (e.g., Gemini Few-shot collapses to 0.0 F1 on several tasks), and Figure 4's score-F1 correlation is also single-model. Please run CS-Agent with at least one additional LLM from Table 2 (e.g., Gemini or Mixtral) on representative PSG/LFR subsets and report per-model gains, both to support generalization and to check whether Validator scores track F1 across models.
  4. [Sec. 5.1, Tables 2 and 3] No repeated trials or error bars are reported. For baselines, temperature is specified (tau=0.5, and tau=0.8 for self-consistency), but the sampling temperature and number of runs for CS-Agent are not given. Many Table 3 deltas are small (0.1-5 F1 points), and without variance estimates these could be sampling noise. Please report mean +/- std over at least 5 independent runs per condition, state exact sampling parameters for Solver, Validator, and Decider, and give the number of trials used for all reported F1 values.
  5. [Sec. 3.2 and Sec. 5.3] The evaluation requires converting free-form LLM output into a vertex set, but the paper never defines the parsing procedure or how parse failures are handled. Section 5.3 classifies outputs containing code or solution steps as "output bias" rather than as measurement error, which conflates formatting failures with substantive community-search quality. Since CS-Agent may partially succeed by enforcing output format, some of the F1 gain could be a parsing artifact. Please provide the extraction protocol, report the fraction of unparseable outputs per method, and include a sensitivity analysis (e.g., manual verification or constrained decoding) to separate format effects from community-quality effects.
  6. [Sec. 2 and Sec. 5] The task is community search with known ground truth, yet no exact non-LLM community-search algorithms are included. For all four metrics, standard algorithms (k-core decomposition, k-truss, clique enumeration, k-edge-connected components) exist and would provide a natural upper bound and calibration for the reported F1 values. Without such a comparison, absolute F1 numbers such as 80-87 on easy tasks are hard to interpret, and the practical claim that CS-Agent produces high-quality communities is not grounded. Please add exact-algorithm baselines, or explicitly scope the paper as a comparison among LLM prompting methods and justify why exact algorithms are excluded.
minor comments (6)
  1. [Sec. 5.4.1] The text reports "73.5%" and "61.6%" where Table 3 shows +73.5 and +61.6 F1 points. Use consistent notation (F1 points, not percent) to avoid ambiguity.
  2. [Figure 4] Axes and units are missing, and the caption uses "Bias" without defining it. Add axis labels, a legend, and a statement of what is plotted (e.g., F1 versus Validator score per round).
  3. [Sec. 5.3.1] The final sentence refers to "positional encoding robustness in LLM-based CS tasks," but the section concerns output bias, not positional encoding. This appears to be a typo and should be corrected.
  4. [Sec. 5.5.3] The text says "the SC method does not meet expectations in SC tasks," which should read "CS tasks." Also clarify that the self-consistency comparison uses k candidate outputs matched to r=3 dialogue rounds.
  5. [Sec. 1 and Sec. 6.1] The claim "to our knowledge, we are the first to apply LLMs to community search" should be reconciled with ComGPT [39], described as a GPT-guided framework for local community detection. Please clarify the distinction between community detection and community search, or soften the novelty claim.
  6. [Sec. 3] No data/code availability statement is provided. To make GraphCS and CS-Agent reproducible, please release the benchmark graphs, prompts, parsing code, and a versioned link.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the central claim is evaluated against external ground-truth F1, and no load-bearing step reduces to its own inputs by construction.

full rationale

The paper derives no formal predictions from first principles; its claims are empirical comparisons on a benchmark. The Decider selects a community using Validator-assigned scores, but the final evaluation computes F1 against ground-truth communities (Sec. 5.1, Eq. 1-3 and Sec. 4.2.3). Validator scores are not defined as F1 or derived from ground truth, so the selection mechanism is not circular by definition. The paper's only supporting evidence for the score-F1 relationship, Figure 4, is qualitative and not quantitatively supported, and the Decider's reliance on a same-family LLM proxy is a validity limitation, not a circularity. No fitted parameter is renamed as a prediction; dialogue rounds r=3 are tuned empirically, not used to fabricate predictions. Self-citations appear only as references for standard graph metrics and prior algorithms, not as load-bearing justification for the framework's mechanism. Thus no specific reduction of the kind required for circularity can be exhibited, and the derivation chain is self-contained with respect to the external F1 benchmark.

Assumptions & free parameters 5 free parameters · 4 assumptions · 0 invented entities

The central claim depends on several experimental choices (dialogue rounds, dataset generator parameters, temperatures) and on the assumption that LLM self-evaluation (Validator scores) aligns with external ground truth. No new physical entities are introduced.

free parameters (5)
  • dialogue rounds r = 3
    Tuned in Section 5.5.4 by comparing r=5 curves; chosen as optimal trade-off between performance and token cost.
  • PSG edge probabilities p_dense, p_sparse = 0.8, 0.2
    Set in Section 3.1 to generate core community structure; not varied.
  • LFR parameters tau1, tau2, mu = 1.8, 1.2, 0.1
    Set in Section 3.1 to control degree and community size distributions.
  • sampling temperature for baselines = 0.5 (0.8 for SC)
    Section 5.1; set to 0.5 for reproducibility and 0.8 for self-consistency diversity.
  • few-shot exemplar count = 1 randomly selected
    Section 3.2.1; one example is randomly chosen from manually constructed samples, affecting variability.
assumptions (4)
  • domain assumption Synthetic PSG and LFR graphs with planted communities represent the community search problem well enough to benchmark LLMs.
    Section 3.1 justifies synthetic data because real graphs exceed token limits; it assumes these generators capture realistic structure.
  • domain assumption The four cohesive metrics (k-Core, k-Truss, k-Clique, k-ECC) are the correct formalizations of community for evaluation.
    Section 2 defines them, but does not justify why these four suffice.
  • ad hoc to paper LLM output can be unambiguously parsed to a vertex set, and parsing failures are classified as output bias rather than measurement error.
    Section 5.3 defines output bias, but the exact parsing protocol is not given, so the boundary between bias and valid output is not independently checkable.
  • ad hoc to paper The Validator's scores are a valid reward for selecting final communities.
    Section 5.5.1 shows the score tracks F1 qualitatively, but the Decider uses these scores without a formal guarantee.

how reviews work

0 comments
Cite this review

Pith. "Pith review of CS-Agent: LLM-based Community Search via Dual-agent Collaboration." pith.science (2026). https://pith.science/paper/5YAL7W42

@misc{pith2026250809549,
  author       = {Pith},
  title        = {Pith review of: CS-Agent: LLM-based Community Search via Dual-agent Collaboration},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/5YAL7W42}},
  note         = {Machine review of arXiv:2508.09549}
}
read the original abstract

Large Language Models (LLMs) have demonstrated remarkable capabilities in natural language processing tasks, yet their application to graph structure analysis, particularly in community search, remains underexplored. Community search, a fundamental task in graph analysis, aims to identify groups of nodes with dense interconnections, which is crucial for understanding the macroscopic structure of graphs. In this paper, we propose GraphCS, a comprehensive benchmark designed to evaluate the performance of LLMs in community search tasks. Our experiments reveal that while LLMs exhibit preliminary potential, they frequently fail to return meaningful results and suffer from output bias. To address these limitations, we introduce CS-Agent, a dual-agent collaborative framework to enhance LLM-based community search. CS-Agent leverages the complementary strengths of two LLMs acting as Solver and Validator. Through iterative feedback and refinement, CS-Agent dynamically refines initial results without fine-tuning or additional training. After the multi-round dialogue, Decider module selects the optimal community. Extensive experiments demonstrate that CS-Agent significantly improves the quality and stability of identified communities compared to baseline methods. To our knowledge, this is the first work to apply LLMs to community search, bridging the gap between LLMs and graph analysis while providing a robust and adaptive solution for real-world applications.

Figures

Figures reproduced from arXiv: 2508.09549 by the authors.

Figure 1
Figure 1. Workflow of LLM-based community search: Given [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Framework of CS-Agent. 3.3 Evaluation Results Analysis We conduct extensive experiments on GraphCS benchmark, with detailed results presented in Section 5. Through analysis of the evaluation results, we summarize the key findings as follows: • LLMs possess preliminary community search abilities. LLMs demonstrate impressive performance on some specific tasks, with F1 value exceeding 90%. • Benefits from prompting met… view at source ↗
Figure 3
Figure 3. Output bias proportion over distinct LLMs models [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figures from the paper (2 more)
Figure 4
Figure 4. Figure 4: Bias between output community’s F1 value and the [PITH_FULL_IMAGE:figures/full_fig_p008_4.png]
Figure 5
Figure 5. Figure 5: Performance trends of different algorithms in multi [PITH_FULL_IMAGE:figures/full_fig_p009_5.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

57 extracted references · 44 canonical work pages

  1. [39]

    Li Ni, Haowen Shen, Lin Mu, Yiwen Zhang, and Wenjian Luo. 2024. Comgpt: detecting local community structure with large language models.arXiv preprint arXiv:2408.06658

    work page arXiv 2024

  2. [1]

    Zahra Abbasiantaeb, Yifei Yuan, Evangelos Kanoulas, and Mohammad Alianne- jadi. 2024. Let the llms talk: simulating human-to-human conversational qa via zero-shot llm-to-llm interactions. InProceedings of the 17th ACM International Conference on Web Search and Data Mining, 8–17

    work page 2024

  3. [2]

    Alessandro Acquisti and Ralph Gross. 2006. Imagined communities: awareness, information sharing, and privacy on the facebook. InInternational workshop on privacy enhancing technologies. Springer, 36–58

    work page 2006

  4. [3]

    Toufique Ahmed and Premkumar Devanbu. 2022. Few-shot training llms for project-specific code-summarization. InProceedings of the 37th IEEE/ACM in- ternational conference on automated software engineering, 1–5

    work page 2022

  5. [4]

    Vladimir Batagelj and Matjaz Zaversnik. 2003. An o (m) algorithm for cores decomposition of networks.arXiv preprint cs/0310049

    arXiv 2003

  6. [5]

    Tom B Brown. 2020. Language models are few-shot learners.arXiv preprint arXiv:2005.14165. Jiahao Hua, et al

    arXiv 2020

  7. [6]

    Yupeng Chang et al. 2024. A survey on evaluation of large language models. ACM transactions on intelligent systems and technology, 15, 3, 1–45

    work page 2024

  8. [7]

    Zhikai Chen et al. 2024. Exploring the potential of large language models (llms) in learning on graphs.ACM SIGKDD Explorations Newsletter, 25, 2, 42–61

    work page 2024

Show all 57 references
  1. [8]

    Zi Chen, Long Yuan, Li Han, and Zhengping Qian. 2021. Higher-order truss decomposition in graphs.IEEE Transactions on Knowledge and Data Engineering, 35, 4, 3966–3978

    2021

  2. [9]

    Zi Chen, Long Yuan, Xuemin Lin, Lu Qin, and Wenjie Zhang. 2022. Balanced clique computation in signed networks: concepts and algorithms.IEEE Trans- actions on Knowledge and Data Engineering, 35, 11, 11079–11092

    2022

  3. [10]

    Michelene TH Chi and Ruth Wylie. 2014. The icap framework: linking cognitive engagement to active learning outcomes.Educational psychologist, 49, 4, 219– 243

    2014

  4. [11]

    Aakanksha Chowdhery et al. 2023. Palm: scaling language modeling with pathways.Journal of Machine Learning Research, 24, 240, 1–113

    2023

  5. [12]

    Jonathan Cohen. 2008. Trusses: cohesive subgraphs for social network analysis. National security agency technical report, 16, 3.1, 1–29

    2008

  6. [13]

    Xinnan Dai, Haohao Qu, Yifen Shen, Bohang Zhang, Qihao Wen, Wenqi Fan, Dongsheng Li, Jiliang Tang, and Caihua Shan. 2024. How do large language models understand graph patterns? a benchmark for graph pattern compre- hension.arXiv preprint arXiv:2410.05298

    2024 arXiv

  7. [14]

    Yixiang Fang, Xin Huang, Lu Qin, Ying Zhang, Wenjie Zhang, Reynold Cheng, and Xuemin Lin. 2020. A survey of community search over big graphs.The VLDB Journal, 29, 353–392

    2020

  8. [15]

    Lillian M Fawcett and Alison F Garton. 2005. The effect of peer collaboration on children’s problem-solving ability.British journal of educational psychology, 75, 2, 157–169

    2005

  9. [16]

    1985.Algorithmic graph theory

    Alan Gibbons. 1985.Algorithmic graph theory. Cambridge university press

    1985

  10. [17]

    Jiayan Guo, Lun Du, Hengyu Liu, Mengyu Zhou, Xinyi He, and Shi Han. 2023. Gpt4graph: can large language models understand graph structured data? an empirical evaluation and benchmarking.arXiv preprint arXiv:2305.15066

    2023 arXiv

  11. [18]

    Qin Han, Weiping Hu, Jia Liu, Xiaojuan Jia, and Philip Adey. 2013. The influence of peer interaction on students’ creative problem-finding ability.Creativity Research Journal, 25, 3, 248–258

    2013

  12. [19]

    Xiaoxin He, Xavier Bresson, Thomas Laurent, Bryan Hooi, et al. 2023. Explana- tions as features: llm-based features for text-attributed graphs.arXiv preprint arXiv:2305.19523, 2, 4, 8

    2023 arXiv

  13. [20]

    Xiaoxin He, Yijun Tian, Yifei Sun, Nitesh Chawla, Thomas Laurent, Yann LeCun, Xavier Bresson, and Bryan Hooi. 2024. G-retriever: retrieval-augmented generation for textual graph understanding and question answering.Advances in Neural Information Processing Systems, 37, 132876–132907

    2024

  14. [21]

    Xinyu Hu, Pengfei Tang, Simiao Zuo, Zihan Wang, Bowen Song, Qiang Lou, Jian Jiao, and Denis Charles. 2023. Evoke: evoking critical thinking abilities in llms via reviewer-author prompt editing.arXiv preprint arXiv:2310.13855

    2023 arXiv

  15. [22]

    Jie Huang, Xinyun Chen, Swaroop Mishra, Huaixiu Steven Zheng, Adams Wei Yu, Xinying Song, and Denny Zhou. 2023. Large language models cannot self-correct reasoning yet.arXiv preprint arXiv:2310.01798

    2023 arXiv

  16. [23]

    Xin Huang, Hong Cheng, Lu Qin, Wentao Tian, and Jeffrey Xu Yu. 2014. Query- ing k-truss community in large and dynamic graphs. InProceedings of the 2014 ACM SIGMOD international conference on Management of data, 1311–1322

    2014

  17. [24]

    Xin Huang, Laks VS Lakshmanan, and Jianliang Xu. 2017. Community search over big graphs: models, algorithms, and opportunities. In2017 IEEE 33rd international conference on data engineering (ICDE). IEEE, 1451–1454

    2017

  18. [25]

    Bowen Jin, Gang Liu, Chi Han, Meng Jiang, Heng Ji, and Jiawei Han. 2024. Large language models on graphs: a comprehensive survey.IEEE Transactions on Knowledge and Data Engineering

    2024

  19. [26]

    Tom Kocmi et al. 2023. Findings of the 2023 conference on machine translation (wmt23): llms are here but not quite there yet. InWMT23-Eighth Conference on Machine Translation, 198–216

    2023

  20. [27]

    Takeshi Kojima, Shixiang Shane Gu, Machel Reid, Yutaka Matsuo, and Yusuke Iwasawa. 2022. Large language models are zero-shot reasoners.Advances in neural information processing systems, 35, 22199–22213

    2022

  21. [28]

    Zahra Kolagar and Alessandra Zarcone. 2024. Aligning uncertainty: leveraging llms to analyze uncertainty transfer in text summarization. InProceedings of the 1st Workshop on Uncertainty-A ware NLP (UncertaiNLP 2024), 41–61

    2024

  22. [29]

    Aobo Kong, Shiwan Zhao, Hao Chen, Qicheng Li, Yong Qin, Ruiqi Sun, Xin Zhou, Enzhi Wang, and Xiaohang Dong. 2023. Better zero-shot reasoning with role-play prompting.arXiv preprint arXiv:2308.07702

    2023 arXiv

  23. [30]

    Andrea Lancichinetti, Santo Fortunato, and Filippo Radicchi. 2008. Bench- mark graphs for testing community detection algorithms.Physical Review E—Statistical, Nonlinear, and Soft Matter Physics, 78, 4, 046110

    2008

  24. [31]

    Xin Li et al. 2024. Can large language models analyze graphs like professionals? a benchmark, datasets and models.Advances in Neural Information Processing Systems, 37, 141045–141070

    2024

  25. [32]

    Tian Liang, Zhiwei He, Wenxiang Jiao, Xing Wang, Yan Wang, Rui Wang, Yujiu Yang, Shuming Shi, and Zhaopeng Tu. 2023. Encouraging divergent thinking in large language models through multi-agent debate.arXiv preprint arXiv:2305.19118

    2023 arXiv

  26. [33]

    Boge Liu, Long Yuan, Xuemin Lin, Lu Qin, Wenjie Zhang, and Jingren Zhou

  27. [34]

    Qing Liu, Minjun Zhao, Xin Huang, Jianliang Xu, and Yunjun Gao. 2020. Truss- based community search over large directed graphs. InProceedings of SIGMOD. David Maier, Rachel Pottinger, AnHai Doan, Wang-Chiew Tan, Abdussalam Alawini, and Hung Q. Ngo, (Eds.) ACM, 2183–2197

    2020

  28. [35]

    Yuan Lu and Yu-Ting Lin. 2023. Characterised llms affect its evaluation of summary and translation. InProceedings of the 4th Workshop on Evaluation and Comparison of NLP Systems, 184–192

    2023

  29. [36]

    Chengyang Luo, Qing Liu, Yunjun Gao, and Jianliang Xu. 2025. Synergetic community search over large multilayer graphs.Proc. VLDB Endow., 18, 5, 1412–1424

    2025

  30. [37]

    Aman Madaan et al. 2023. Self-refine: iterative refinement with self-feedback. Advances in Neural Information Processing Systems, 36, 46534–46594

    2023

  31. [38]

    Lingkai Meng et al. 2024. A survey of distributed graph algorithms on massive graphs.ACM Computing Surveys, 57, 2, 1–39

    2024

  32. [40]

    Debjit Paul, Mete Ismayilzada, Maxime Peyrard, Beatriz Borges, Antoine Bosse- lut, Robert West, and Boi Faltings. 2023. Refiner: reasoning feedback on inter- mediate representations.arXiv preprint arXiv:2304.01904

    2023 arXiv

  33. [41]

    David MW Powers. 2020. Evaluation: from precision, recall and f-measure to roc, informedness, markedness and correlation.arXiv preprint arXiv:2010.16061

    2020 arXiv

  34. [42]

    Stephen B Seidman. 1983. Network structure and minimum degree.Social networks, 5, 3, 269–287

    1983

  35. [43]

    Standard Self-Reflection. [n. d.] Self-contrast: better reflection through incon- sistent solving perspectives

  36. [44]

    Murray Shanahan, Kyle McDonell, and Laria Reynolds. 2023. Role play with large language models.Nature, 623, 7987, 493–498

    2023

  37. [45]

    Noah Shinn, Federico Cassano, Ashwin Gopinath, Karthik Narasimhan, and Shunyu Yao. 2023. Reflexion: language agents with verbal reinforcement learn- ing.Advances in Neural Information Processing Systems, 36, 8634–8652

    2023

  38. [46]

    Jiabin Tang, Yuhao Yang, Wei Wei, Lei Shi, Lixin Su, Suqi Cheng, Dawei Yin, and Chao Huang. 2024. Graphgpt: graph instruction tuning for large language mod- els. InProceedings of the 47th International ACM SIGIR Conference on Research and Development in Information Retrieval, 491–500

    2024

  39. [47]

    Liyan Tang et al. 2023. Evaluating large language models on medical evidence summarization.NPJ digital medicine, 6, 1, 158

    2023

  40. [48]

    Alexander K Taylor, Anthony Cuturrufo, Vishal Yathish, Mingyu Derek Ma, and Wei Wang. 2024. Are large-language models graph algorithmic reasoners? arXiv preprint arXiv:2410.22597

    2024 arXiv

  41. [49]

    Heng Wang, Shangbin Feng, Tianxing He, Zhaoxuan Tan, Xiaochuang Han, and Yulia Tsvetkov. 2024. Can language models solve graph problems in natural language?Advances in Neural Information Processing Systems, 36

    2024

  42. [50]

    Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc Le, Ed Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. 2022. Self-consistency improves chain of thought reasoning in language models.arXiv preprint arXiv:2203.11171

    2022 arXiv

  43. [51]

    Ning Wu, Ming Gong, Linjun Shou, Shining Liang, and Daxin Jiang. 2023. Large language models are diverse role-players for summarization evaluation. InCCF International Conference on Natural Language Processing and Chinese Computing. Springer, 695–707

    2023

  44. [52]

    Zongyu Xu, Yihao Zhang, Long Yuan, Yuwen Qian, Zi Chen, Mingliang Zhou, Qin Mao, and Weibin Pan. 2023. Effective community search on large attributed bipartite graphs.International Journal of Pattern Recognition and Artificial Intelligence, 37, 02, 2359002

    2023

  45. [53]

    Jaewon Yang and Jure Leskovec. 2012. Defining and evaluating network com- munities based on ground-truth. InProceedings of the ACM SIGKDD workshop on mining data semantics, 1–8

    2012

  46. [54]

    Long Yuan, Lu Qin, Xuemin Lin, Lijun Chang, and Wenjie Zhang. 2017. I/o efficient ecc graph decomposition via graph reduction.The VLDB Journal, 26, 2, 275–300

    2017

  47. [55]

    Long Yuan, Lu Qin, Wenjie Zhang, Lijun Chang, and Jianye Yang. 2017. Index- based densest clique percolation community search in networks.IEEE Transac- tions on Knowledge and Data Engineering, 30, 5, 922–935

    2017

  48. [56]

    Long Yuan, Junyue Xu, Zi Chen, Chuan Ma, Jianqiu Xu, and Lu Qin. 2025. Efficient maximum balanced k-biplex search over bipartite graphs. In2025 IEEE 41st International Conference on Data Engineering (ICDE), 3098–3112

    2025

  49. [2020]

    Efficient (𝛼,𝛽)-core computation in bipartite graphs.The VLDB Journal, 29, 5, 1075–1099

Pith tools

Reviewed August 5, 2026 · model on record in the stance chip above.