Pith. sign in

REVIEW 5 major objections 6 minor 29 references

The paper claims that the best way to use LLM-generated natural-language rules is to score each rule with the LLM and let a regularized logistic regression combine the scores; handing the rules back to the LLM for reasoning degrades accurac

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

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

Logistic regression over LLM-generated natural-language rules outperformed letting the LLM reason with those rules on six binary text tasks.

T0 review reviewed 2026-08-04 challenge →

load-bearing objection Clean hybrid pipeline and an interesting negative result on LLM rule injection, but the load-bearing LLM judgment step is uncharacterized and the headline differences aren't significance-tested. the 5 major comments →

arxiv 2510.19698 v3 pith:MJWNTKKP submitted 2025-10-22 cs.AI

RLIE: Rule Generation with Logistic Regression, Iterative Refinement, and Evaluation for Large Language Models

Yang Yang , Hua XU , Zhangyi Hu , Yutao Yue This is my paper
classification cs.AI
keywords rule learninglarge language modelslogistic regressioninterpretable rulesneuro-symbolic reasoningiterative refinementnatural language hypothesesternary judgments
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

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 tries to establish that a hybrid pipeline—LLMs write natural-language rules and make per-sample rule judgments, while a regularized logistic regression learns global rule weights—outperforms asking the LLM to reason with the rules directly. Across six text-classification datasets, the simplest strategy, applying the learned weights directly, ranks in the top two on accuracy and achieves the best F1 on all six tasks, while injecting rules, weights, and the linear model's prediction into the LLM context fails to help and often hurts. The authors interpret this as evidence for a division of labor: LLMs are reliable for semantic generation and local interpretation, but unreliable for fine-grained probabilistic integration. If correct, the paper offers a practical, transparent way to build interpretable classifiers from LLM-proposed rules and a caution against using LLMs as probabilistic reasoners.

Core claim

RLIE learns a compact set of weighted natural-language rules through four stages: LLM-based rule generation with coverage filtering; feature construction where each sample becomes a ternary vector of rule judgments in {-1,0,+1}, with 0 marking abstention; elastic-net logistic regression that learns global weights and selects rules; and iterative refinement that feeds prediction-error hard examples back to the LLM. The central finding is that the Linear-only inference mode—using the learned weights directly as the classifier—performs best on nearly every dataset, while the three LLM-augmented modes, which receive the rules, the weights, and sometimes the model's own prediction as a reference,

What carries the argument

The central object is the ternary judgment matrix Phi^{(t)}(x_i) = (z_{i,1},...,z_{i,m}), where each z_{i,j} is the LLM's local judgment of whether rule j applies to sample i, valued +1 (positive), -1 (negative), or 0 (abstain). The mechanism is to treat these judgments as features in an elastic-net logistic regression, which provides global weighting, sparse rule selection, calibration, and a thresholded prediction. The abstention option makes rule coverage explicit, and the iterative refinement loop selects hard examples by prediction error |p_i - y_i| to drive new rule generation.

Load-bearing premise

The load-bearing premise is that the LLM's per-text judgments about whether each rule applies—yes, no, or not applicable—are accurate and consistent enough to be used as features, and the paper does not measure their reliability.

What would settle it

Replace the LLM's ternary judgments with random labels on the same datasets, or repeat the protocol with a different LLM and prompt template; if the ordering of the four inference strategies changes or the Linear-only advantage disappears, the central division-of-labor claim is specific to the particular LLM and prompt rather than a general principle.

Watch this falsifier. Get emailed when new claim-graph text bears on it.

If this is right

  • For LLM-generated rule sets, the recommended inference mode is direct weighted application rather than feeding the rules back to the LLM.
  • Providing learned rule weights to an LLM does not yield stable accuracy gains, so LLM internalization of probabilistic importance is unreliable.
  • Even a correct reference prediction from the linear model can be overridden by the LLM under complex prompting, so LLM-augmented reasoning should not be assumed to be a safe post-hoc layer.
  • The iterative refinement loop yields compact rule sets (capacity 10) that are transparent and auditable, suitable for explanation and human review.
  • Because the local LLM interface is fixed, the global combiner can be swapped for more expressive probabilistic models without changing the rule-generation stage.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The authors do not measure the consistency or calibration of the LLM's ternary judgments; a plausible editorial extension is that the ceiling of the whole framework is set by that local judgment quality, so improving per-rule judgment reliability should transfer directly to final accuracy.
  • The comparison is conducted on fixed small splits of 200 training and 200 validation samples; on larger datasets the LLM-based inference modes might close the gap, so the Linear-only conclusion may be regime-specific.
  • A testable extension suggested by the abstention design is to calibrate the abstain output probabilistically (e.g., via Platt scaling) rather than treating it as a hard 0, and to check whether that lifts the linear combiner further.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

5 major / 6 minor

Summary. The paper proposes RLIE, a four-stage framework for learning weighted natural-language rule sets with LLMs: (1) an LLM generates candidate rules from training examples; (2) elastic-net logistic regression learns weights over LLM-produced ternary rule judgments; (3) iterative refinement selects hard examples and prompts the LLM to generate new or revised rules; (4) evaluation compares direct inference via the logistic model (E1) with three LLM-augmented inference strategies (E2: rules only, E3: rules + weights, E4: rules + weights + linear prediction). Experiments on six HypoBench datasets with gpt-4o-mini report accuracy and macro-F1. The central empirical claim is that E1 (Linear-only) achieves the best performance on 'nearly all' datasets, while injecting the learned rules and weights into the LLM degrades accuracy, supporting a division of labor in which LLMs handle local semantic judgments and a probabilistic combiner handles global aggregation. The paper also reports comparisons with zero-shot inference, zero-shot generation, IO Refinement, and HypoGeniC, and claims superior or competitive performance with lower variance.

Significance. If the central claim holds, the paper would provide a useful and counterintuitive empirical result: a hybrid neuro-symbolic pipeline with a simple logistic-regression combiner outperforms LLM-augmented reasoning on these tasks, and LLMs are best kept at local rule application. The framework is clear, the experiments use held-out test sets with fixed splits and repeated runs, and the paper reports mean and standard deviation for all methods. However, the evidence as presented is not yet sufficient to support the strength of the claims. The load-bearing gaps are (a) the absence of any reliability analysis for the LLM ternary judgments that serve as the only input features, (b) the lack of statistical significance testing given that several headline differences are within one standard deviation, (c) the absence of reproducible artifacts (code, full prompts, data splits, learned rule examples) and an ablation of the iterative-refinement stage, and (d) a comparison limited to LLM-based baselines that does not substantiate the claim of 'superior over all performance.' The central idea is promising, but the current manuscript needs substantial additional analysis before the conclusions ca

major comments (5)
  1. [Section 3.1 (Eq. 1), Section 3.2 (Eq. 2), Section 5.2] The entire pipeline rests on the LLM's ternary judgment z_{i,j}=LLM(x_i,h_j) in {−1,0,+1}. These judgments are used as the only features for logistic regression, for coverage filtering, for hard-example selection, and for E1 predictions. Yet the paper reports no reliability analysis: no repeated-call agreement, no parse-error rate, no calibration of z against true labels, and no prompt-variation experiments. If these judgments are noisy or prompt-sensitive, the learned weights, the pruning decisions, and the E1-vs-E2/E3/E4 comparison could be artifacts of one LLM and one prompt template. A minimal analysis (e.g., rerunning with alternate phrasings, reporting agreement and per-rule accuracy of z) is necessary before the 'division of labor' conclusion is supported.
  2. [Section 5.2, Table 2] The headline claim 'Linear-only achieves the best performance on nearly all datasets' is not backed by significance tests. In Table 2, several differences are within one standard deviation: Dreaddit accuracy (E1=69.11±1.17 vs E4=69.00±1.33), Headlines (65.56±1.50 vs 65.33±1.86), Citations (identical 59.38±3.12), and LLM Detect (58.67±2.65 vs 56.67±3.51). In Table 1, IO Refinement outperforms RLIE on Dreaddit accuracy (74.89±3.47 vs 69.11±1.17) and LLM Detect accuracy (60.33±17.32 vs 58.67±2.65). Paired bootstrap tests or repeated-measures ANOVA are needed to support 'superior performance' and 'degradation' claims.
  3. [Section 9, Appendix C] The reproducibility statement says code 'will be made publicly available upon publication,' and Appendix C states that prompts 'can be access after this paper is accepted.' Thus the manuscript under review provides no code, no full prompts for all six datasets, no exact data splits, and no example of a learned rule set or its weights. For a paper whose contributions are interpretability and rule quality, the absence of any concrete learned rules or weights is a substantial gap. Please include the actual prompts, data splits, and representative learned rules/weights in the appendix or supplement.
  4. [Section 1, Section 5.1, Table 1] The claim that RLIE 'achieves superior over all performance compared to a range of LLM-based methods' is not supported by the presented baselines. Only two LLM-based rule learners and two zero-shot LLM baselines are compared; no classical rule learning method (e.g., RIPPER, RuleFit) or standard supervised classifier is included. Even among the included methods, IO Refinement achieves higher accuracy and F1 on Dreaddit and on LLM Detect, and HypoGeniC achieves higher F1 on Retweets. The novelty claim of being 'the first' to combine LLMs with probabilistic rule learning is also not substantiated with a literature survey. Please moderate these claims or add the missing comparisons.
  5. [Section 3.3, Section 5] The contribution of the iterative refinement stage is not ablated. The main results compare the full RLIE pipeline with external baselines, but there is no comparison to RLIE without refinement (e.g., one-shot rule generation followed by logistic regression). Since the paper claims that error-driven refinement improves rule quality and final performance, an ablation isolating this stage is necessary to validate its role.
minor comments (6)
  1. [Abstract] Typo: 'Generated rules are the evaluated' should be 'Generated rules are then evaluated'; 'surprising degrade' should be 'surprisingly degrades.'
  2. [Section 3.1, Eq. (1)] Superscript inconsistency: z^{(1)}_{i,j} = LLM(x_i, h^{(i)}_j) should use h^{(1)}_j rather than h^{(i)}_j.
  3. [Table 2 caption] Typo: 'valuated' should be 'evaluated.'
  4. [Appendix C] The appendix only shows prompts for the Retweets task. Provide prompts for all datasets or state in the main text that they are included in a supplement. Also 'can be access' should be 'can be accessed.'
  5. [Figure 7, Figure 8 prompts] Minor language issue: 'you can used the weighted patterns' should be 'you can use the weighted patterns.'
  6. [Section 5.2] The statement that LLMs 'can be inconsistent when required to strictly adhere to complex, explicit instructions' is a general claim without a citation. Add a reference or soften the wording.

Circularity Check

0 steps flagged

No significant circularity; the paper is a standard supervised pipeline evaluated on held-out splits.

full rationale

The paper's central claims are empirical, based on a clearly separated train/validation/test protocol: rule weights are fit on S_tr with Elastic Net logistic regression, hyperparameters are selected on S_val, and all four inference strategies (E1–E4) are evaluated on S_te. E1 is a direct logistic-regression prediction from LLM ternary rule judgments; E2–E4 are different prompt conditions given those rules, weights, and/or the E1 prediction. None of these quantities is defined in terms of the target result, and no test-set information is used to fit the model. The LLM ternary judgments z_{i,j} are input features, not a predicted output; concern about their noise or prompt-sensitivity is a data-quality/robustness limitation, not a circular reduction. The discussion of 'division of labor' is an empirical interpretation of Table 2 rather than a theorem derived from its own assumptions. Self-citations occur only in related-work context (e.g., Hyperlogic) and are not load-bearing for the framework's correctness or for the empirical comparison. There is no imported uniqueness theorem, no ansatz smuggled in via self-citation, and no renaming of a known result as a new derivation. Thus the paper is self-contained in its evaluation and exhibits no circularity of the kinds enumerated.

Axiom & Free-Parameter Ledger

8 free parameters · 6 axioms · 0 invented entities

RLIE introduces no new physical entities. It relies on LLM-generated natural-language rules, ternary judgments, and an elastic-net logistic combiner, plus several hand-set hyperparameters. The most consequential assumptions are the reliability of LLM judgments and the linear log-odds model.

free parameters (8)
  • Rule-set capacity H = 10
    Chosen by hand in Section 4.3; bounds the number of rules and therefore the expressiveness of the final rule set.
  • New rules generated per iteration h = 5
    Chosen by hand in Section 4.3; controls the amount of candidate diversity per refinement step.
  • Samples used for generation / hard examples k = 20
    Chosen by hand in Section 4.3; affects the initial generation sample and the hard-example selection each iteration.
  • Coverage threshold γ = 0.2
    Chosen by hand in Section 4.3; discards low-coverage rules and shapes the feature set fed to logistic regression.
  • Elastic-net regularization (λ, α) = selected via stratified K-fold CV on validation set
    Tuned on validation data in Section 3.2; directly controls sparsity and weight values.
  • Early stopping margin δ, patience p, max iterations R_max
    Mentioned in Section 3.3 but values are not given; they affect the final checkpoint and rule set.
  • Classification threshold τ = 0.5
    Fixed default in Section 3.2; changes the reported accuracy/F1 if moved.
  • LLM sampling temperature = 1e-5
    Set in Section 4.3 to make LLM outputs deterministic; does not guarantee identical outputs across runs.
axioms (6)
  • standard math Elastic-net penalized logistic regression yields well-defined and appropriate weight estimates for binary rule indicators.
    Invoked in Section 3.2 and based on Zou & Hastie (2005); the central combiner is a standard statistical model.
  • domain assumption LLM ternary judgments z_{i,j} ∈ {−1,0,+1} are accurate and consistent enough to serve as regression features.
    Section 3.1 relies entirely on these judgments; the paper reports no agreement, confidence calibration, or parse-error analysis.
  • domain assumption The log-odds of the positive label is linear in the rule judgment features.
    The logistic model in Section 3.2 assumes linearity; the paper itself notes this assumption may not fully hold in Section 3.4/E4.
  • domain assumption The six HypoBench tasks with 200/200/300 splits are representative of inductive rule-learning settings.
    All conclusions are drawn from these six datasets and small splits described in Section 4.1/4.3.
  • ad hoc to paper When the rule set exceeds capacity H, pruning by individual validation accuracy is a good proxy for set-level utility.
    Section 3.3 step 3 prunes on individual accuracy, ignoring redundancy and interactions among rules.
  • ad hoc to paper Coverage threshold γ=0.2 and capacity H=10 are adequate without sensitivity analysis.
    Set once in Section 4.3; no ablation or sensitivity study is provided, so the main results could depend on these values.

reviewed 2026-08-04 · how reviews work

0 comments
Cite this review

Pith. "Pith review of RLIE: Rule Generation with Logistic Regression, Iterative Refinement, and Evaluation for Large Language Models." pith.science (2026). https://pith.science/paper/MJWNTKKP

@misc{pith2026251019698,
  author       = {Pith},
  title        = {Pith review of: RLIE: Rule Generation with Logistic Regression, Iterative Refinement, and Evaluation for Large Language Models},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/MJWNTKKP}},
  note         = {Machine review of arXiv:2510.19698}
}
Share X Bluesky LinkedIn Reddit HN
read the original abstract

Large Language Models (LLMs) can propose rules in natural language, sidestepping the need for a predefined predicate space in traditional rule learning. Yet many LLM-based approaches ignore interactions among rules, and the opportunity to couple LLMs with probabilistic rule learning for robust inference remains underexplored. We present RLIE, a unified framework that integrates LLMs with probabilistic modeling to learn a set of weighted rules. RLIE has four stages: (1) Rule generation, where an LLM proposes and filters candidates; (2) Logistic regression, which learns probabilistic weights for global selection and calibration; (3) Iterative refinement, which updates the rule set using prediction errors; and (4) Evaluation, which compares the weighted rule set as a direct classifier with methods that inject rules into an LLM. We evaluate multiple inference strategies on real-world datasets. Applying rules directly with their learned weights yields superior performance, whereas prompting LLMs with the rules, weights, and logistic-model outputs surprisingly degrades accuracy. This supports the view that LLMs excel at semantic generation and interpretation but are less reliable for precise probabilistic integration. RLIE clarifies the potential and limitations of LLMs for inductive reasoning and couples them with classic probabilistic rule combination methods to enable more reliable neuro-symbolic reasoning.

Figures

Figures reproduced from arXiv: 2510.19698 by Hua Xu, Yang Yang, Yutao Yue, Zhangyi Hu.

Figure 1
Figure 1. Figure 1: The pipeline of the RLIE framework. (1) Rule Generation: An LLM proposes an initial set of rules from a small sample of training data. (2) Logistic Regression: A regularized logistic regression model is trained on the full training set to learn probabilistic weights for the current rules. (3) Iterative Refinement: Prediction errors from the regression model are used to mine hard examples, which are then us… view at source ↗
Figure 2
Figure 2. Figure 2: Prompt for providing observations. 13 [PITH_FULL_IMAGE:figures/full_fig_p013_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Prompt for the first iteration of rule generation. [PITH_FULL_IMAGE:figures/full_fig_p014_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: Prompt for iterative refinement. 15 [PITH_FULL_IMAGE:figures/full_fig_p015_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Prompt for single hypothesis inference. 16 [PITH_FULL_IMAGE:figures/full_fig_p016_5.png] view at source ↗
Figure 6
Figure 6. Figure 6: Prompt for “LLM + Rules” style inference. [PITH_FULL_IMAGE:figures/full_fig_p017_6.png] view at source ↗
Figure 7
Figure 7. Figure 7: Prompt for “LLM + Rules + Weights” style inference. [PITH_FULL_IMAGE:figures/full_fig_p018_7.png] view at source ↗
Figure 8
Figure 8. Figure 8: Prompt for “LLM + Rules + Weights + Linear Prediction” style inference. [PITH_FULL_IMAGE:figures/full_fig_p019_8.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

29 extracted references · 6 linked inside Pith

  1. [1]

    Agentichypothesis: A survey on hypothesis generation using llm systems

    Adib Bazgir, Yuwen Zhang, et al. Agentichypothesis: A survey on hypothesis generation using llm systems. Towards Agentic AI for Science: Hypothesis Generation, Comprehension, Quantification, and Validation, 2025

    2025

  2. [2]

    Generalisation through negation and predicate invention

    David M Cerna and Andrew Cropper. Generalisation through negation and predicate invention. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 38, pp.\ 10467--10475, 2024

    2024

  3. [3]

    Fast effective rule induction

    William W Cohen et al. Fast effective rule induction. In Proceedings of the twelfth international conference on machine learning, pp.\ 115--123, 1995

    1995

  4. [4]

    Learning programs by learning from failures

    Andrew Cropper and Rolf Morel. Learning programs by learning from failures. Machine Learning, 110 0 (4): 0 801--856, 2021

    2021

  5. [5]

    Inductive logic programming at 30

    Andrew Cropper, Sebastijan Duman c i \'c , Richard Evans, and Stephen H Muggleton. Inductive logic programming at 30. Machine Learning, 111 0 (1): 0 147--172, 2022

    2022

  6. [6]

    Human-like few-shot learning via bayesian reasoning over natural language

    Kevin Ellis. Human-like few-shot learning via bayesian reasoning over natural language. Advances in Neural Information Processing Systems, 36: 0 13149--13178, 2023

    2023

  7. [7]

    Friedman and Bogdan E

    Jerome H. Friedman and Bogdan E. Popescu. Predictive learning via rule ensembles. The Annals of Applied Statistics, 2 0 (3): 0 916--954, 2008. doi:10.1214/07-AOAS148. URL https://projecteuclid.org/journals/annals-of-applied-statistics/volume-2/issue-3/Predictive-learning-via-rule-ensembles/10.1214/07-AOAS148.full

    doi:10.1214/07-aoas148 2008

  8. [8]

    A brief overview of rule learning

    Johannes F \"u rnkranz and Tom \'a s Kliegr. A brief overview of rule learning. In International symposium on rules and rule markup languages for the semantic web, pp.\ 54--69. Springer, 2015

    2015

  9. [9]

    Neuro-symbolic hierarchical rule induction

    Claire Glanois, Zhaohui Jiang, Xuening Feng, Paul Weng, Matthieu Zimmer, Dong Li, Wulong Liu, and Jianye Hao. Neuro-symbolic hierarchical rule induction. In International Conference on Machine Learning, pp.\ 7583--7615. PMLR, 2022

    2022

  10. [10]

    Learning mdl logic programs from noisy data

    C \'e line Hocquette, Andreas Niskanen, Matti J \"a rvisalo, and Andrew Cropper. Learning mdl logic programs from noisy data. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 38, pp.\ 10553--10561, 2024

    2024

  11. [11]

    Hypobench: Towards systematic and principled benchmarking for hypothesis generation

    Haokun Liu, Sicong Huang, Jingyu Hu, Yangqiaoyu Zhou, and Chenhao Tan. Hypobench: Towards systematic and principled benchmarking for hypothesis generation. arXiv preprint arXiv:2504.11524, 2025

    arXiv 2025

  12. [12]

    Explainable artificial intelligence: a comprehensive review

    Dang Minh, H Xiang Wang, Y Fen Li, and Tan N Nguyen. Explainable artificial intelligence: a comprehensive review. Artificial Intelligence Review, 55 0 (5): 0 3503--3568, 2022

    2022

  13. [13]

    Learning accurate and interpretable decision rule sets from neural networks

    Litao Qiao, Weijia Wang, and Bill Lin. Learning accurate and interpretable decision rule sets from neural networks. In Proceedings of the AAAI conference on artificial intelligence, volume 35, pp.\ 4303--4311, 2021

    2021

  14. [14]

    Phenomenal yet puzzling: Testing inductive reasoning capabilities of language models with hypothesis refinement

    Linlu Qiu, Liwei Jiang, Ximing Lu, Melanie Sclar, Valentina Pyatkin, Chandra Bhagavatula, Bailin Wang, Yoon Kim, Yejin Choi, Nouha Dziri, et al. Phenomenal yet puzzling: Testing inductive reasoning capabilities of language models with hypothesis refinement. arXiv preprint arXiv:2310.08559, 2023

    Pith/arXiv arXiv 2023

  15. [15]

    Logic regression

    Ingo Ruczinski, Charles Kooperberg, and Michael LeBlanc. Logic regression. Journal of Computational and graphical Statistics, 12 0 (3): 0 475--511, 2003

    2003

  16. [16]

    Explaining patterns in data with language models via interpretable autoprompting

    Chandan Singh, John X Morris, Jyoti Aneja, Alexander M Rush, and Jianfeng Gao. Explaining patterns in data with language models via interpretable autoprompting. arXiv preprint arXiv:2210.01848, 2022

    Pith/arXiv arXiv 2022

  17. [17]

    Neuro-symbolic rule lists

    Sascha Xu, Nils Philipp Walter, and Jilles Vreeken. Neuro-symbolic rule lists. arXiv preprint arXiv:2411.06428, 2024

    Pith/arXiv arXiv 2024

  18. [18]

    Scalable bayesian rule lists

    Hongyu Yang, Cynthia Rudin, and Margo Seltzer. Scalable bayesian rule lists. In International conference on machine learning, pp.\ 3921--3930. PMLR, 2017

    2017

  19. [19]

    Truly unordered probabilistic rule sets for multi-class classification

    Lincen Yang and Matthijs van Leeuwen. Truly unordered probabilistic rule sets for multi-class classification. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pp.\ 87--103. Springer, 2022

    2022

  20. [20]

    Hyperlogic: Enhancing diversity and accuracy in rule learning with hypernets

    Yang Yang, Wendi Ren, and Shuang Li. Hyperlogic: Enhancing diversity and accuracy in rule learning with hypernets. Advances in Neural Information Processing Systems, 37: 0 3564--3587, 2024 a

    2024

  21. [21]

    Large language models for automated open-domain scientific hypotheses discovery

    Zonglin Yang, Xinya Du, Junxian Li, Jie Zheng, Soujanya Poria, and Erik Cambria. Large language models for automated open-domain scientific hypotheses discovery. arXiv preprint arXiv:2309.02726, 2023

    Pith/arXiv arXiv 2023

  22. [22]

    Moose-chem: Large language models for rediscovering unseen chemistry scientific hypotheses

    Zonglin Yang, Wanhao Liu, Ben Gao, Tong Xie, Yuqiang Li, Wanli Ouyang, Soujanya Poria, Erik Cambria, and Dongzhan Zhou. Moose-chem: Large language models for rediscovering unseen chemistry scientific hypotheses. arXiv preprint arXiv:2410.07076, 2024 b

    arXiv 2024

  23. [23]

    Ruag: Learned-rule-augmented generation for large language models

    Yudi Zhang, Pei Xiao, Lu Wang, Chaoyun Zhang, Meng Fang, Yali Du, Yevgeniy Puzyrev, Randolph Yao, Si Qin, Qingwei Lin, et al. Ruag: Learned-rule-augmented generation for large language models. arXiv preprint arXiv:2411.03349, 2024

    Pith/arXiv arXiv 2024

  24. [24]

    Hypothesis generation with large language models

    Yangqiaoyu Zhou, Haokun Liu, Tejes Srivastava, Hongyuan Mei, and Chenhao Tan. Hypothesis generation with large language models. arXiv preprint arXiv:2404.04326, 2024

    Pith/arXiv arXiv 2024

  25. [25]

    Regularization and Variable Selection via the Elastic Net

    Hui Zou and Trevor Hastie. Regularization and Variable Selection via the Elastic Net . Journal of the Royal Statistical Society: Series B (Statistical Methodology), 67 0 (2): 0 301--320, 2005

    2005

  26. [26]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION format.date year duplicate empty "emp...

  27. [27]

    @esa (Ref

    \@ifxundefined[1] #1\@undefined \@firstoftwo \@secondoftwo \@ifnum[1] #1 \@firstoftwo \@secondoftwo \@ifx[1] #1 \@firstoftwo \@secondoftwo [2] @ #1 \@temptokena #2 #1 @ \@temptokena \@ifclassloaded agu2001 natbib The agu2001 class already includes natbib coding, so you should not add it explicitly Type <Return> for now, but then later remove the command n...

  28. [28]

    \@lbibitem[] @bibitem@first@sw\@secondoftwo \@lbibitem[#1]#2 \@extra@b@citeb \@ifundefined br@#2\@extra@b@citeb \@namedef br@#2 \@nameuse br@#2\@extra@b@citeb \@ifundefined b@#2\@extra@b@citeb @num @parse #2 @tmp #1 NAT@b@open@#2 NAT@b@shut@#2 \@ifnum @merge>\@ne @bibitem@first@sw \@firstoftwo \@ifundefined NAT@b*@#2 \@firstoftwo @num @NAT@ctr \@secondoft...

  29. [29]

    first" vs

    @open @close @open @close and [1] URL: #1 \@ifundefined chapter * \@mkboth \@ifxundefined @sectionbib * \@mkboth * \@mkboth\@gobbletwo \@ifclassloaded amsart * \@ifclassloaded amsbook * \@ifxundefined @heading @heading NAT@ctr thebibliography [1] @ \@biblabel @NAT@ctr \@bibsetup #1 @NAT@ctr @ @openbib .11em \@plus.33em \@minus.07em 4000 4000 `\.\@m @bibit...

This paper was first reviewed by deepseek-v4-flash on August 4, 2026.