Pith. sign in

REVIEW 4 major objections 6 minor 1 cited by

Socratic-PRMBench: Benchmarking Process Reward Models with Systematic Reasoning Patterns

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

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

Pith's one-line read Socratic-PRMBench claims that process reward models, scored by six reasoning patterns, are currently unreliable for math reasoning.

desk verdict Useful benchmark with a real reasoning-pattern axis, but the step-level labels rest on a thin validation layer that the paper overstates. read the letter →

arxiv 2505.23474 v1 pith:PUI5B57G submitted 2025-05-29 cs.AI cs.CL

Xiang Li , Haiyang Yu , Xinghua Zhang , Ziyang Huang , Shizhu He , Kang Liu , Jun Zhao , Fei Huang
show 1 more author
Yongbin Li
This is my paper
classification cs.AIcs.CL
keywords processrewardmodelsreasoningpatternsbenchmarkmathematicalerrordetectionstep-levelevaluationSocraticLLMcritics
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

This paper introduces Socratic-PRMBench, a benchmark of 2,995 flawed mathematical reasoning paths organized by six reasoning patterns—Transformation, Decomposition, Regather, Deduction, Verification, and Integration—and 20 fine-grained error subtypes. The authors argue that existing process reward models (PRMs), which score the correctness of each reasoning step, are evaluated mainly for stepwise accuracy and never systematically for whether they can catch errors within each kind of reasoning move. On this benchmark, the best PRM, Qwen2.5-Math-PRM-7B, reaches an overall PRM-score of 68.0, below every evaluated LLM critic, which range from 70.8 to 75.7. The authors conclude that current PRMs are not reliable for process supervision in mathematical reasoning, especially for early planning patterns such as Transformation and Decomposition, and that the benchmark can guide more balanced PRM training.

What carries the argument

The load-bearing machinery is a fully automated data-construction pipeline that yields pattern-tagged reasoning steps. A Socratic reasoning model is produced by fine-tuning Qwen2.5-72B-instruct on 19k Chain-of-Thought solutions from MATH-Hard and Open-o1 that GPT-4o rewrote into steps tagged with the six pattern labels; this model generates new tagged solutions from GSM8k, Omni-Math, MathBench-A, and OlympiadBench problems. GPT-4o then injects a specified error type into each correct path, producing an altered question, a modified step list, and a claimed answer. Two filters remove bad cases: rule-based checks for well-formed JSON and extractable answers, then Gemini2.5-Pro filtering for whether the path is plausible and the error is really of the targeted type; the filter's 93.3% agreement with three human annotators on a random 10% subset is the evidence that the remaining cases are correctly labelled. The final benchmark contains 2,995 paths averaging 8.7 steps with an average of 3.0 error steps. The metric PRM-score, defined as the average of F1 and negative-F1, is taken from prior step-level benchmark work and is used so that a model cannot inflate its score by always saying 'correct' or always saying 'wrong'.

What would settle it

Have three independent human experts annotate all 2,995 reasoning paths with the same two criteria (is the path plausible, and is the error really of the labelled subtype) without seeing the LLM labels; if agreement between humans and the benchmark labels drops well below 90% on the full set, the reported PRM deficiencies are likely artifacts of mislabelled or style-biased test cases rather than intrinsic PRM limits.

Watch

Extended reading notes

Core claim

The central claim is that process reward models lack a systematic ability to verify reasoning steps when those steps are typed by the reasoning pattern they perform. Socratic-PRMBench defines six patterns—Transformation, Decomposition, Regather, Deduction, Verification, and Integration—with 20 fine-grained error subtypes, and builds 2,995 flawed reasoning paths by asking GPT-4o to inject a specific error into an otherwise correct Socratic-reasoning solution. Evaluation with the PRM-score metric, defined as the average of positive and negative F1, shows the strongest PRM, Qwen2.5-Math-PRM-7B, reaches only 68.0, while every evaluated LLM critic scores between 70.8 and 75.7. Breakdowns further show that all models are weaker on early planning patterns (Transformation, Decomposition, Regather) than on execution patterns (Deduction, Integration, Verification), that models are late at flagging the first error step, and that PRMs are strongly biased toward either positive or negative rewards. The authors conclude that current PRMs cannot be trusted for process supervision of mathematical reasoning and that pattern coverage in training data is a key missing ingredient.

Load-bearing premise

The load-bearing premise is that the 2,995 test cases really contain the intended reasoning errors and only those errors, which rests on GPT-4o's injection being accurate and on Gemini2.5-Pro's filtering, validated by 93.3% agreement with humans on a random 10% subset, being equally accurate on the other 90%.

Editorial extensions

If this is right

  • Any method that uses current PRMs as dense rewards in RL or test-time scaling will inherit these blind spots, especially for early planning errors, so the rewards can silently guide a model down a wrong path.
  • PRM training sets, whether manual or synthetic, appear under-covered for Transformation, Decomposition, and Regather patterns; balancing pattern distribution in training data is a concrete next step.
  • Detecting the first error step late wastes test-time compute because the model keeps reasoning along an already invalid trajectory.
  • Aggregate accuracy hides a strong reward bias: Qwen2.5-Math-PRM labels 90.8% of correct steps correctly but only 42.9% of error steps, while Skywork-PRM shows the reverse.
  • Because LLM critics beat PRMs on this benchmark, process-level evaluation may be better done with prompted reasoning models than with dedicated PRMs, at least until PRMs improve.

Reading between the lines

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

  • If pattern balance is the real driver of PRM weakness, then a PRM fine-tuned on a dataset explicitly stratified across the six patterns should close much of the gap to LLM critics; that is a directly testable prediction the paper does not run.
  • The 93.3% human-agreement figure comes from a single 10% subset; per-pattern agreement numbers would be informative, because early-planning patterns like Transformation may be harder for human annotators to label consistently, which would change what the benchmark can claim.
  • The six-pattern taxonomy is domain-neutral enough that the same construction pipeline could produce benchmark slices for code debugging or scientific reasoning, where step-level rewards are also needed but ground truth is harder to verify.
  • The observed latency in flagging early errors suggests that PRM-guided search should be paired with a cheap early-check mechanism, such as asking the generator to restate its plan before executing, rather than relying on step scores alone.
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

4 major / 6 minor

Summary. The paper introduces Socratic-PRMBench, a benchmark of 2,995 flawed mathematical reasoning paths annotated with six Socratic reasoning patterns (Transformation, Decomposition, Regather, Deduction, Verification, Integration) and 20 fine-grained error subcategories. The construction pipeline consists of training a Socratic reasoning model, generating correct reasoning paths, injecting controlled errors with GPT-4o, and filtering with Gemini2.5-Pro plus rule-based checks. The authors evaluate six PRMs and five LLM critics using PRM-Score and report that the best PRM (Qwen2.5-Math-PRM-7B) reaches only 68.0, below every LLM critic, and that performance varies substantially across reasoning patterns and error types. They conclude that current PRMs are notably deficient at process supervision under diverse reasoning patterns.

Significance. If the benchmark labels are trustworthy, the paper makes a useful contribution: it is the first PRM benchmark organized around reasoning patterns, and the finding that PRMs lag behind prompted LLM critics across all six patterns is practically relevant for process-supervision research. The taxonomy of 20 error subcategories is a genuinely systematic design, and the authors provide code and data, which supports reproducibility. The redundant-error analysis is a suggestive, falsifiable observation. The central empirical claim, however, rests on label quality and on the fairness of comparing PRMs against LLMs that participated in benchmark construction; these points need to be nailed down before the headline deficiency result can be relied upon.

major comments (4)
  1. [§3.3, §3.2.2, Eq. (2)] The step-level ground truth is not independently validated in a way that matches the evaluation metric. In §3.2.2, GPT-4o supplies `error_steps` as part of the generation prompt, and in §3.3 Gemini2.5-Pro filters only for superficial plausibility and membership in the targeted error type; it never verifies that the declared erroneous-step indices are correct or that the remaining steps are error-free. The 93.3% human-agreement figure is computed on the two filter criteria for a random 10% subset, not on step-index accuracy. Since PRM-Score (Eq. 2) and F1_neg are step-level, any systematic misalignment between declared and actual error positions will directly bias the absolute scores and the PRM-vs-LLM gap. The authors should report human agreement on error-position labels (ideally on a stratified sample covering all 20 error types) and, if disagreement is non-negligible, re-score the benchmark on the human-validated subset.
  2. [§1 vs §3.3] The Introduction's claim that data quality is 'guaranteed' by 'manual expert review' is stronger than what the method sections describe. Section 3.3 reports that three volunteer annotators with at least a bachelor's degree checked a random 10% subset using the same binary filter criteria as Gemini2.5-Pro, yielding 93.3% average agreement; this is an agreement study, not a full expert review, and it does not validate the step-level error positions or the pattern assignments in the remaining 90%. The claim should be reworded to match the procedure, and the paper should report per-criterion agreement and inter-annotator agreement (e.g., Fleiss' kappa) so readers can judge label reliability.
  3. [§4.1, Table 3] The comparison between PRMs and LLM critics is partly confounded by benchmark construction. GPT-4o generates the flawed reasoning paths and Gemini2.5-Pro filters them, and both are among the evaluated LLM critics in Table 3. These models may perform well because the benchmark is tailored to their notions of plausible errors and error types, not because they are generally superior process verifiers. To support the central claim that 'PRMs are demonstrably inferior to LLMs,' the authors should either evaluate critic models that were not involved in data construction or provide an analysis on a held-out, human-annotated subset where this self-consistency channel is removed.
  4. [§4.3, Table 3] The main results are reported as point estimates without any measure of uncertainty. The LLM critics are prompted at temperature 1.0 (§A), so scores are stochastic; the label-generation and filtering stages also involve sampling, and the per-error-type sample sizes are small (N=150 with only 10 GSM8k samples per type, §A). Without confidence intervals, repeated runs, or a significance test, the claim that every LLM critic outperforms every PRM may not be robust. At minimum, report standard deviations over multiple evaluation runs or bootstrap intervals for the overall PRM-Score.
minor comments (6)
  1. [§1, §2, §3.1] The benchmark name is inconsistent across the manuscript ('SOCRATIC-PRMBENCH', 'Socratic-PRMBench', 'SCORATIC-PRMBENCH' in §2, and 'SOCRATIC-PRMBENCHMARK' in §3.1); use one consistent spelling throughout.
  2. [§3.2.2] The example 'Repeat Inconsistency' does not correspond to any of the 20 subcategories listed in §3.1; this appears to be a typo, possibly for 'Regather Inconsistency' or 'Transformation Inconsistency'.
  3. [Appendix B, Table 8] The [Transformation] action description uses the identifier '<Repeat>xxx</Repeat>', which is inconsistent with the '<[Pattern]>' tags described in §3.2.1 and with the identifiers used for the other actions; clarify whether this is intentional.
  4. [Throughout] There are numerous typos and formatting inconsistencies, including 'thoery' (§1), 'evlauation' (§4.2), 'indentifying' (§1), 'seperately' (Appendix B), 'attributted' (§4.3), and 'QWQ' vs 'QwQ' (§4.3); these should be corrected in a final pass.
  5. [§4.3, Table 4] The 'Random' baseline is reasonable, but the paper does not describe how it is computed (e.g., per-step Bernoulli(0.5) versus balanced positive/negative sampling); specify this for reproducibility.
  6. [Eq. (2)] The weights w1 and w2 are set to 0.5 following prior work, but the paper should state whether the same weights apply to the imbalanced positive/negative test sets and whether any sensitivity analysis was performed.

Circularity Check

0 steps flagged · score 0.0 of 10

No constructed circularity: the benchmark evaluation is an empirical measurement, and the PRM-vs-LLM gap is not entailed by the construction pipeline.

full rationale

Socratic-PRMBench is a benchmark-construction and evaluation paper rather than a derivation chain, and I find no step in which a reported result is equivalent to its input by construction. The test cases are generated with GPT-4o (Eq. 1) and filtered by Gemini2.5-Pro (Sec. 3.3), and those two models are later included among the LLM critics (Sec. 4.1). This overlap is a genuine threat to the external validity of the comparison—the filter may select cases that are easy for Gemini, and GPT-4o may be self-consistent with its own injected labels—but it does not make the reported PRM scores follow logically from the construction. In particular, the central finding (Qwen2.5-Math-PRM-7B scores 68.0, below every LLM critic, Sec. 4.3) is not fitted to PRM outputs; the PRMs are not used anywhere in the labeling or filtering pipeline, so nothing forces their scores to be low. The 93.3% human-agreement check on a random 10% subset (Sec. 3.3) also does not create circularity: it is a statistical generalization about filter reliability, not an equation or fitted prediction, though the paper's introduction overstates it as "manual expert review." The reasoning-pattern taxonomy is borrowed from cited prior work and applied through LLM prompts; no unique theorem is imported from the authors, and no parameter is fitted and then renamed a prediction. Therefore, under the stated standard requiring a specific reduction, the appropriate finding is no significant circularity.

Assumptions & free parameters 4 free parameters · 4 assumptions · 1 invented entities

The benchmark has no formal derivation; the central claim rests on data quality rather than equations. Free parameters are hand-set curation and evaluation choices (weights, sample size, difficulty threshold, temperature). The axioms are assumptions about validity of the taxonomy, reliability of LLM generation and filtering, and generalization of the 10% human check. The invented entity is the six-pattern taxonomy itself, which lacks independent validation.

free parameters (4)
  • w1, w2 (PRM-Score weights) = 0.5, 0.5
    Hand-set following Song et al. (2025) to balance F1 and negative F1; no derivation, and all reported scores depend on these weights.
  • N (samples per error type) = 150
    Randomly chosen sample size per error subcategory in Appendix A; final per-pattern counts range from 215 to 926 because patterns have different numbers of subcategories.
  • Omni-Math difficulty threshold = 4.0
    Curation threshold in Section 3.2.1 to keep only challenging Omni-Math problems; hand-chosen and no sensitivity analysis.
  • Temperature for LLM critics = 1.0
    Evaluation setting in Appendix A; no sensitivity analysis, so score stability is unknown.
assumptions (4)
  • domain assumption The six reasoning patterns (Transformation, Decomposition, Regather, Deduction, Verification, Integration) are atomic and exhaustively cover mathematical reasoning errors.
    Section 3.1 asserts taxonomy based on a philosophical analogy to Socrates; no formal or empirical proof that the six patterns are atomic or exhaustive.
  • domain assumption GPT-4o can reliably insert a flaw of the intended type while keeping the chain superficially plausible.
    Section 3.2.2 relies on this to create test cases; quality filtering later checks it, but only via another LLM plus 10% human review.
  • domain assumption Gemini2.5-Pro filtering agreement with humans on a 10% subset (93.3%) generalizes to the full dataset.
    Section 3.3 uses this to accept the remaining 90% of cases without human review.
  • domain assumption The ground-truth error-step labels are complete and correct.
    Section 3.2.2 obtains error_steps from GPT-4o's output; no independent exhaustive relabeling of every step in every path.
invented entities (1)
  • Socratic reasoning-pattern taxonomy (six patterns, 20 error subcategories)
    purpose: To classify every reasoning step and error type in the benchmark, enabling pattern-wise PRM evaluation.
    The taxonomy is introduced in this paper; there is no external benchmark or falsifiable prediction validating the categories as atomic or distinct. Human validation only checked error-type suitability on 10% of cases.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Socratic-PRMBench: Benchmarking Process Reward Models with Systematic Reasoning Patterns." pith.science (2026). https://pith.science/paper/PUI5B57G

@misc{pith2026250523474,
  author       = {Pith},
  title        = {Pith review of: Socratic-PRMBench: Benchmarking Process Reward Models with Systematic Reasoning Patterns},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/PUI5B57G}},
  note         = {Machine review of arXiv:2505.23474}
}
read the original abstract

Process Reward Models (PRMs) are crucial in complex reasoning and problem-solving tasks (e.g., LLM agents with long-horizon decision-making) by verifying the correctness of each intermediate reasoning step. In real-world scenarios, LLMs may apply various reasoning patterns (e.g., decomposition) to solve a problem, potentially suffering from errors under various reasoning patterns. Therefore, PRMs are required to identify errors under various reasoning patterns during the reasoning process. However, existing benchmarks mainly focus on evaluating PRMs with stepwise correctness, ignoring a systematic evaluation of PRMs under various reasoning patterns. To mitigate this gap, we introduce Socratic-PRMBench, a new benchmark to evaluate PRMs systematically under six reasoning patterns, including Transformation, Decomposition, Regather, Deduction, Verification, and Integration. Socratic-PRMBench}comprises 2995 reasoning paths with flaws within the aforementioned six reasoning patterns. Through our experiments on both PRMs and LLMs prompted as critic models, we identify notable deficiencies in existing PRMs. These observations underscore the significant weakness of current PRMs in conducting evaluations on reasoning steps under various reasoning patterns. We hope Socratic-PRMBench can serve as a comprehensive testbed for systematic evaluation of PRMs under diverse reasoning patterns and pave the way for future development of PRMs.

Figures

Figures reproduced from arXiv: 2505.23474 by the authors.

Figure 1
Figure 1. (Left): Given a question, the reasoning step [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. An overview of our SOCRATIC-PRMBENCH. The left part illustrates our dataset constuction procedure. The right part illustrates the 6 reasoning patterns and 20 sub-categories of fine-grained error types. We use P and C to represent (sub)problems and conclusions, respectively. We use Q, R, G to represent gathered information, redundant contents, and ground truth. can be divided into two sub-categories: Detection Error … view at source ↗
Figure 3
Figure 3. Average PRM-Score of representative PRMs [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figures from the paper (1 more)
Figure 4
Figure 4. Figure 4: Error position distribution (truncated to 12) of [PITH_FULL_IMAGE:figures/full_fig_p008_4.png]

Discussion (0). Sign in to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. GM-PRM: A Generative Multimodal Process Reward Model for Multimodal Mathematical Reasoning

    cs.CL 2025-08 conditional novelty 6.0 of 10

    A generative multimodal process reward model that produces step-level critiques and corrections improves average math accuracy for six multimodal LLMs by 2.9 to 5.9 points under a refinement-based Best-of-N strategy.

Reference graph

Works this paper leans on

23 extracted references · 19 canonical work pages · cited by 1 Pith paper

  1. [1]

    A mathematical problem

    work page

  2. [2]

    InThe Twelfth Inter- national Conference on Learning Representations

    Let’s verify step by step. InThe Twelfth Inter- national Conference on Learning Representations. Zicheng Lin, Zhibin Gou, Tian Liang, Ruilin Luo, Haowei Liu, and Yujiu Yang. 2024. CriticBench: Benchmarking LLMs for critique-correct reasoning. InFindings of the Association for Computational Linguistics: ACL 2024, pages 1552–1587, Bangkok, Thailand. Associa...

    work page 2024

  3. [3]

    original_process: A non-empty list of strings representing the original reasoning steps provided as input

    work page

  4. [4]

    InProceed- ings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Pa- pers), pages 9426–9439, Bangkok, Thailand

    Math-shepherd: Verify and reinforce LLMs step-by-step without human annotations. InProceed- ings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Pa- pers), pages 9426–9439, Bangkok, Thailand. Associ- ation for Computational Linguistics. Peiyi Wang, Lei Li, Zhihong Shao, RX Xu, Damai Dai, Yifei Li, Deli Chen, Yu ...

    work page

  5. [5]

    Indexing starts at 1

    modified_steps: A non-empty list of integers indicating the indexes of all modified steps. Indexing starts at 1

    work page

  6. [6]

    validity

    Rag-gym: Optimizing reasoning and search agents with process supervision.arXiv preprint arXiv:2502.13957. An Yang, Beichen Zhang, Binyuan Hui, Bofei Gao, Bowen Yu, Chengpeng Li, Dayiheng Liu, Jian- hong Tu, Jingren Zhou, Junyang Lin, Keming Lu, Mingfeng Xue, Runji Lin, Tianyu Liu, Xingzhang Ren, and Zhenru Zhang. 2024. Qwen2.5-math tech- nical report: Tow...

    arXiv 2024

  7. [7]

    ### Notes:

    reason: A clear explanation of the modifications made, why they were introduced, and how they align with the specified error types. ### Notes:

    work page

  8. [8]

    original_question

    A correct step-by-step reasoning process used to solve it. Each step is in a form of Action, posssibly including [Transformation], [Decomposition], [Regather], [Deduction], [Verification], [Integration], [Answer], [LVerification] and [GVerification]. The description of Actions are as follows: ## [Transformation] (Identifier: <Repeat>xxx</Repeat>) - Explai...

    work page

Show all 23 references
  1. [9]

    original_question: A string representing the original mathematical problem as provided

  2. [10]

    If the problem remains the same, you can copy the original question

    modified_question: A string representing the modified problem after your changes. If the problem remains the same, you can copy the original question

  3. [12]

    modified_process: A non-empty list of strings representing the reasoning process after your modifications

  4. [14]

    These should also be part of modified_steps

    error_steps: A non-empty list of integers representing the steps that contain hallucinations or errors. These should also be part of modified_steps

  5. [16]

    Ensure all lists are non-empty

  6. [17]

    Do not use Unicode symbols such as \u2248 or \u00f7

    Use LaTeX format for all mathematical symbols (e.g., x2 for x squared). Do not use Unicode symbols such as \u2248 or \u00f7

  7. [18]

    Ensure the JSON object is well-formed, with proper escaping for special characters like backslash n (e.g., use backslash backslash n for newlines)

  8. [19]

    All indexes start from 1, that is, the first step’s index is 1, not 0

  9. [20]

    But if the question is modified, ensure that the steps is judged based on the modified question

    You can choose to modify the question or not, if the question remains the same, you can copy the original question. But if the question is modified, ensure that the steps is judged based on the modified question

  10. [21]

    Table 9: Output format prompt for test case construction

    Please give original process as provided by the prompt, do not modify it. Table 9: Output format prompt for test case construction. Prompt Template for LLM-based Filtering You are an expert on reasoning process verification, you will be given a question, a solution (split into...

  11. [22]

    The process generated by LLMs seems like a possible solution path that could happen

  12. [23]

    Please put your final answer (Yes or No) in \boxed {}

    The process generated by LLMs is exactly wrong and the type of error is suitable for the description of [classification] [Classification] {classification} [Question] {question} [Solution] {Solution} Please answer a “Yes” if both of the two aspects are satisfied, otherwise answ...

  13. [2023]

    Guangzhi Xiong, Qiao Jin, Xiao Wang, Yin Fang, Haolin Liu, Yifan Yang, Fangyuan Chen, Zhixing Song, Dengyu Wang, Minjia Zhang, and 1 others

    Math-shepherd: Verify and reinforce llms step- by-step without human annotations.arXiv preprint arXiv:2312.08935. Guangzhi Xiong, Qiao Jin, Xiao Wang, Yin Fang, Haolin Liu, Yifan Yang, Fangyuan Chen, Zhixing Song, Dengyu Wang, Minjia Zhang, and 1 others

    arXiv

  14. [2024]

    Hritik Bansal, Arian Hosseini, Rishabh Agarwal, Vinh Q

    Critique-out-loud reward models.Preprint, arXiv:2408.11791. Hritik Bansal, Arian Hosseini, Rishabh Agarwal, Vinh Q. Tran, and Mehran Kazemi. 2025. Smaller, weaker, yet better: Training LLM reasoners via compute-optimal sampling. InThe Thirteenth Inter- national Conference on L...

    2025 arXiv

  15. [2025]

    Philipp Mondorf and Barbara Plank

    Thinking longer, not larger: Enhancing soft- ware engineering agents via scaling test-time com- pute.arXiv preprint arXiv:2503.23803. Philipp Mondorf and Barbara Plank. 2024. Beyond accuracy: Evaluating the reasoning behavior of large language models - a survey. InFirst Confer...

    2024 arXiv

Pith tools

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