Pith. sign in

REVIEW 4 major objections 4 minor 1 cited by

ReasoningV: Efficient Verilog Code Generation with Adaptive Hybrid Reasoning Model

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

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

Pith's one-line read This paper claims that a 7B-parameter open Verilog model, trained on a small verified dataset with two-stage tuning and adaptive reasoning, reaches 57.8% pass@1 on VerilogEval-human and cuts token use by up to 78%.

desk verdict A well-executed Verilog code-generation systems paper with a plausible but unsecured SOTA claim; the missing train/test overlap check is the load-bearing gap, and the paper deserves a serious referee with that condition. read the letter →

arxiv 2504.14560 v3 pith:2ARNYYMH submitted 2025-04-20 cs.AR cs.AI

Haiyan Qin , Zhiwei Xie , Jingjing Li , Liangchen Li , Xiaotong Feng , Junzhan Liu , Wang Kang This is my paper · ORCID
classification cs.ARcs.AI
keywords VerilogcodegenerationlargelanguagemodelsRTLreasoningpathsadaptiveinferencefunctionalverificationparameter-efficientfine-tuninghardwaredesignautomation
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 tries to show that a compact, open Verilog code generator can reach the level of much larger and closed commercial models by fixing three things: training data quality, reasoning depth, and inference cost. It builds ReasoningV-5K, a dataset of 5,334 functionally verified problem–solution–testbench triples with distilled reasoning paths, trains a 7B model in two stages, and adds a lightweight difficulty classifier that routes easy tasks to direct generation and hard tasks to extended reasoning. If correct, the result is that targeted data and training design matter more than model scale for RTL code generation, and that reasoning can be made affordable. The strongest reported outcome is 57.8% pass@1 on VerilogEval-human, 10.4 points ahead of the prior best open-source model and close to a leading commercial model, while the adaptive mechanism reduces token consumption by up to 78%.

What carries the argument

The load-bearing mechanism is the three-stage pipeline built around a small verified reasoning dataset. ReasoningV-5K is constructed by filtering roughly 690K PyraNet samples down to 5,334 instances that compile, pass simulation against their testbenches, and carry distilled reasoning paths; this dataset supplies both the supervised reasoning signal and the difficulty labels. Two-stage training first applies LoRA on a large general Verilog corpus for foundational syntax, then full-parameter fine-tuning on ReasoningV-5K for reasoning depth. At inference, a Judge Adapter—a LoRA classifier on the same backbone—labels each problem Easy, Medium, or Hard and selects direct, standard, or extended reasoning modes with matching token budgets. These components together are what the paper credits for both accuracy and efficiency.

What would settle it

Compare every ReasoningV-5K problem statement and solution against VerilogEval and RTLLM using token n-gram overlap and AST similarity; if a substantial fraction of benchmark problems appears in the training set, the reported gains could be memorization, and a held-out set of newly written hardware problems would be needed to confirm generalization.

Watch

Extended reading notes

Core claim

The central claim is that a hybrid reasoning strategy—intrinsic reasoning trained into the weights plus an inference-time router that adapts reasoning depth to problem difficulty—yields state-of-the-art Verilog generation among open models. ReasoningV-Complete, built on a 7B base, reaches 57.8% pass@1 on VerilogEval-human, 73.6% on VerilogEval-machine, and 44.6% on RTLLM, surpassing the previous best open-source model by 10.4 percentage points and coming within 1.7 points of Gemini-2.0-flash while using a fraction of the parameters. The adaptive variant preserves most of this accuracy while using up to 78% fewer tokens than always running full reasoning, and on the machine benchmark it matches the full-reasoning pass@1 exactly.

Load-bearing premise

The claims stand on the assumption that the PyraNet-derived training samples in ReasoningV-5K do not overlap with the VerilogEval and RTLLM evaluation problems, so the reported pass@1 gains reflect generalization rather than memorization.

Editorial extensions

If this is right

  • A 7B open model trained this way can outperform larger open models, so scaling parameters is not the only route to better RTL generation.
  • Adaptive reasoning can reduce inference cost by up to 78% without sacrificing accuracy on structured benchmarks, making reasoning-based Verilog generation practical at scale.
  • Functionally verified training samples with reasoning paths are sufficient to improve pass@1 substantially over synthetic or syntax-only datasets.
  • The same recipe—verified data, two-stage training, and difficulty routing—could transfer to other hardware description languages or formal-verification tasks.

Reading between the lines

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

  • If the benchmark scores are not inflated by training/evaluation overlap, the 10.4-point gain over the previous open model suggests that data verification and reasoning paths can substitute for much larger scale; the paper does not report a contamination analysis, so this remains an open check.
  • The judge adapter's routing policy could likely be distilled into a smaller network or merged into the main model, further cutting the small overhead of classification; the paper does not explore this.
  • Applying the same adaptive-reasoning scheme to other code-generation domains with cheap verifiers, such as Python unit tests or SQL, would be a natural test of whether the efficiency gains generalize beyond Verilog; the paper limits experiments to hardware benchmarks.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 4 minor

Summary. The paper proposes ReasoningV, a 7B-parameter Verilog code generation model built on Qwen2.5-Coder-7B, with three main contributions: (1) ReasoningV-5K, a 5,334-instance dataset filtered from PyraNet and augmented with functionally verified solutions, testbenches, and distilled reasoning paths; (2) a two-stage training procedure that performs LoRA fine-tuning on the large OriGen dataset in Stage 1 and full-parameter fine-tuning on ReasoningV-5K in Stage 2; and (3) an adaptive reasoning mechanism that uses a lightweight Judge Adapter to classify problem difficulty and select direct, standard, or extended reasoning modes to reduce token consumption. The paper reports 57.8% pass@1 on VerilogEval-human and 73.6% on VerilogEval-machine, claiming state-of-the-art results among open-source models and up to 78% token savings with the adaptive mode.

Significance. If the results hold, this is a practically valuable contribution to hardware code generation: a 7B open model approaching the VerilogEval-human performance of Gemini-2.0-flash, with an efficient adaptive-inference mechanism that could lower deployment costs. The release of the model, dataset, and code supports reproducibility and follow-up work, and the two-stage training recipe plus the verified dataset are potentially reusable assets for the community. The paper also includes standard benchmarks, pass@k metrics, and functional verification with Icarus Verilog, which strengthens the empirical foundation. However, the significance is conditional on ruling out training/evaluation contamination and on obtaining cleaner ablation evidence, because the headline pass@1 numbers and the claimed SOTA margin currently rest on the untested assumption that the filtered PyraNet-derived training data is disjoint from the VerilogEval and RTLLM evaluation problems.

major comments (4)
  1. [III-A and IV-A] The paper provides no overlap or contamination analysis between the ReasoningV-5K training set, which is derived from the GitHub/LLM-sourced PyraNet dataset, and the VerilogEval and RTLLM evaluation benchmarks, which are HDLBits-derived and often present in public Verilog repositories. The functional verification described in Section III-A uses each sample's own testbench, so it cannot detect whether a benchmark problem appears in the training data. This is a load-bearing issue for the reported pass@1 gains and SOTA claims; please add a decontamination analysis (e.g., exact-match, n-gram overlap, or AST similarity between the 5,334 training instances and the 329 evaluation problems) and report the number of matched samples and the performance after excluding them.
  2. [III-B / Table VI] The ablation of the two-stage training method confounds dataset size with training approach: RV-RET uses full-parameter training on only 5K instances, while RV-CT uses LoRA on 220K instances. The conclusion that Stage 2 alone cannot compensate for insufficient foundational knowledge is therefore not supported, because the comparison does not control for the amount of training data. Please add controlled ablations, such as full-parameter training on OriGen-220K, LoRA on ReasoningV-5K, or data-size-matched variants, to isolate the contribution of data scale versus parameter-update strategy.
  3. [IV-C / Table VII] The claim that adaptive reasoning preserves performance while reducing tokens is not uniformly supported by the data: on VerilogEval-human, RV-Adaptive (53.0% pass@1) is 4.8 percentage points lower than Forced Hard (57.8%), although it matches or slightly exceeds Forced Hard on VerilogEval-machine and RTLLM. Please report statistical uncertainty (e.g., confidence intervals or multiple seeds) for pass@1 and explicitly characterize the benchmark-dependent accuracy/efficiency tradeoff. Also, the abstract states token savings of "up to 75%" while the introduction and Section III-C state "up to 78%"; this should be made consistent.
  4. [III-C] The Judge Adapter is a core component of the adaptive mechanism, but the paper does not report its classification accuracy on a held-out set, nor the distribution of selected modes on the evaluation benchmarks. Without these details, it is difficult to determine whether the observed token savings come from genuinely effective difficulty routing or from a skewed difficulty distribution in the benchmarks. Please include Judge Adapter accuracy and the mode selection frequencies for VerilogEval-human, VerilogEval-machine, and RTLLM.
minor comments (4)
  1. [Abstract] The abstract says token savings of "up to 75%" while the introduction and experiments say "up to 78%"; please unify these numbers.
  2. [Abstract and IV-B] The claim of exceeding the "previous best open-source model by 10.4 percentage points" is imprecise because Qwen2.5-Coder-32B (47.6% pass@1 on VerilogEval-human) outperforms OriGen-Gen-LoRA (47.4%); the comparison should be explicitly stated as against the previous best Verilog-specific open-source model, not all open-source models.
  3. [IV-A, Eq. (1)] The text after Eq. (1) says that "pi represents the probability that a randomly sampled solution is correct" and then "estimate pi as the fraction of correct solutions among these samples"; the notation is inconsistent with the formula, which uses c and n. Please revise this sentence to correctly define c and the estimator.
  4. [III-C] The operational description states that the Judge Adapter is disabled during code generation; please clarify how the selected reasoning mode is applied after the adapter's classification, since the reader cannot see the intended control flow from the text.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the reported pass@1 and token-efficiency numbers are measured on external benchmarks, not derived from the training data or from author-defined quantities.

full rationale

ReasoningV is an empirical systems paper: the headline claims are pass@1 numbers on VerilogEval-human, VerilogEval-machine, and RTLLM, computed with the benchmark-provided testbenches using Icarus Verilog (Sec. IV-A2). These evaluation targets are external to the ReasoningV-5K training set, and no parameter is fitted to reproduce those benchmark numbers. The two-stage training (LoRA on OriGen, then full-parameter fine-tuning on ReasoningV-5K) is standard supervised fine-tuning; the reported gains over the base model are measurements, not consequences of an equation that encodes the result. The adaptive reasoning mechanism's token savings are also measured averages across generated tokens, and its performance is reported on the same external benchmarks. The main caveats in the paper are data-quality and generalization concerns rather than circularity: the dataset's functional testbenches are themselves generated with DeepSeek-R1 guidance (Sec. III-A3), so the in-dataset 'functional verification' is not fully independent, and the paper does not provide a formal overlap or contamination analysis between PyraNet-derived ReasoningV-5K and the VerilogEval/RTLLM evaluation problems. These are legitimate threats to the generalization claim, but they do not make the evaluation circular, because the reported benchmark results are judged by benchmark-provided testbenches rather than by the model's own generated tests. The paper's self-citations and references to prior benchmarks are contextual or comparative, not load-bearing derivations of the central results. Overall, no circular step of the kind defined in the review criteria could be exhibited.

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

The central claims rest on data provenance and verification validity; the dataset overlap and AI-generated testbench quality are the main unverified premises. The model itself uses standard LM training, so the only free choices are hyperparameters that route compute.

free parameters (5)
  • Cosine similarity threshold = 0.8
    Empirically determined in dataset deduplication; directly controls which PyraNet samples are retained.
  • LoRA rank and alpha = rank=32, alpha=32
    Hyperparameters for Stage 1 PEFT; no search reported.
  • Token budgets for reasoning modes = 512/1280/4096
    Hand-chosen max_new_tokens for Easy, Medium, and Hard modes; directly determine the reported token savings.
  • Judge Adapter training sample count = 10,000
    Number of questions distilled from DeepSeek-V3 to train the difficulty classifier.
  • Sampling temperature = 0.2
    Inference temperature for pass@k evaluation; affects all reported scores.
assumptions (4)
  • domain assumption PyraNet is a representative, non-contaminated source of Verilog problems.
    Section III-A filters PyraNet; if PyraNet overlaps with eval benchmarks, results are inflated.
  • domain assumption Icarus Verilog simulation correctly determines functional correctness.
    Used for both dataset filtering and benchmark evaluation; synthesizability and timing are not checked.
  • domain assumption DeepSeek-R1 generated reasoning paths and testbenches correctly encode problem intent.
    Section III-A-3: testbenches generated with DeepSeek-R1; if wrong, 'verified' samples are mislabeled.
  • standard math Causal language modeling loss is an appropriate objective for learning to generate Verilog with reasoning.
    Standard LM training; not an ad hoc assumption.
invented entities (2)
  • Judge Adapter
    purpose: A LoRA classifier that labels problem difficulty to route between direct, standard, and extended reasoning modes.
    Trained and evaluated only within this paper; no external falsifiable handle is provided.
  • ReasoningV-5K dataset
    purpose: Training data of verified problem-solution-testbench triplets with reasoning paths.
    The dataset is released, but the paper provides no independent validation beyond the ReasoningV model itself.

how reviews work

0 comments
Cite this review

Pith. "Pith review of ReasoningV: Efficient Verilog Code Generation with Adaptive Hybrid Reasoning Model." pith.science (2026). https://pith.science/paper/2ARNYYMH

@misc{pith2026250414560,
  author       = {Pith},
  title        = {Pith review of: ReasoningV: Efficient Verilog Code Generation with Adaptive Hybrid Reasoning Model},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/2ARNYYMH}},
  note         = {Machine review of arXiv:2504.14560}
}
read the original abstract

Large Language Models (LLMs) have advanced Verilog code generation significantly, yet face challenges in data quality, reasoning capabilities, and computational efficiency. This paper presents ReasoningV, a novel model employing a hybrid reasoning strategy that integrates trained intrinsic capabilities with dynamic inference adaptation for Verilog code generation. Our framework introduces three complementary innovations: (1) ReasoningV-5K, a high-quality dataset of 5,000 functionally verified instances with reasoning paths created through multi-dimensional filtering of PyraNet samples; (2) a two-stage training approach combining parameter-efficient fine-tuning for foundational knowledge with full-parameter optimization for enhanced reasoning; and (3) an adaptive reasoning mechanism that dynamically adjusts reasoning depth based on problem complexity, reducing token consumption by up to 75\% while preserving performance. Experimental results demonstrate ReasoningV's effectiveness with a pass@1 accuracy of 57.8\% on VerilogEval-human, achieving performance competitive with leading commercial models like Gemini-2.0-flash (59.5\%) and exceeding the previous best open-source model by 10.4 percentage points. ReasoningV offers a more reliable and accessible pathway for advancing AI-driven hardware design automation, with our model, data, and code available at https://github.com/BUAA-CLab/ReasoningV.

Figures

Figures reproduced from arXiv: 2504.14560 by the authors.

Figure 1
Figure 1. Overall architecture of the ReasoningV framework. [PITH_FULL_IMAGE:figures/full_fig_p004_1.png] view at source ↗
Figure 2
Figure 2. Multi-stage data filtering pipeline for ReasoningV-5K dataset construction. [PITH_FULL_IMAGE:figures/full_fig_p005_2.png] view at source ↗
Figure 3
Figure 3. Verilog Reasoning Path and Testbench Generation. [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figures from the paper (1 more)
Figure 4
Figure 4. Figure 4: Pass@1 Performance vs. Model Size on VerilogEval-Human. [PITH_FULL_IMAGE:figures/full_fig_p008_4.png]

Discussion (0). Continue with ORCID 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. CircuitWeave: Topology-Behavior Alignment for Executable Multimodal RTL Generation

    cs.AR 2026-07 conditional novelty 6.0 of 10

    Contract-mediated fusion of schematic topology and textual behavior improves adapted 4B multimodal RTL generation by up to +8.46 pass@1 on VerilogEval-Human versus text-only.

Reference graph

Works this paper leans on

39 extracted references · 10 canonical work pages · cited by 1 Pith paper

  1. [1]

    Chip-chat: Chal- lenges and opportunities in conversational hardware design,

    J. Blocklove, S. Garg, R. Karri, and H. Pearce, “Chip-chat: Chal- lenges and opportunities in conversational hardware design,” in 2023 ACM/IEEE 5th Workshop on Machine Learning for CAD (MLCAD) . IEEE, 2023, pp. 1–6

    work page 2023

  2. [2]

    Aivril: Ai-driven rtl gen- eration with verification in-the-loop,

    H. Sami, P.-E. Gaillardon, V . Tenace et al. , “Aivril: Ai-driven rtl gen- eration with verification in-the-loop,” arXiv preprint arXiv:2409.11411 , 2024

    arXiv 2024

  3. [3]

    Openabc-d: A large- scale dataset for machine learning guided integrated circuit synthesis,

    A. B. Chowdhury, B. Tan, R. Karri, and S. Garg, “Openabc-d: A large- scale dataset for machine learning guided integrated circuit synthesis,” arXiv preprint arXiv:2110.11292 , 2021

    arXiv 2021

  4. [4]

    Verigen: A large language model for verilog code generation,

    S. Thakur, B. Ahmad, H. Pearce, B. Tan, B. Dolan-Gavitt, R. Karri, and S. Garg, “Verigen: A large language model for verilog code generation,” ACM Transactions on Design Automation of Electronic Systems, vol. 29, no. 3, pp. 1–31, 2024

    2024

  5. [5]

    Openllm-rtl: Open dataset and benchmark for llm-aided design rtl generation,

    S. Liu, Y . Lu, W. Fang, M. Li, and Z. Xie, “Openllm-rtl: Open dataset and benchmark for llm-aided design rtl generation,” in Proceedings of the 43rd IEEE/ACM International Conference on Computer-Aided Design, 2024, pp. 1–9

    2024

  6. [6]

    Verilogcoder: Autonomous verilog coding agents with graph-based planning and abstract syntax tree (ast)- based waveform tracing tool,

    C.-T. Ho, H. Ren, and B. Khailany, “Verilogcoder: Autonomous verilog coding agents with graph-based planning and abstract syntax tree (ast)- based waveform tracing tool,” arXiv preprint arXiv:2408.08927 , 2024

    arXiv 2024

  7. [7]

    EDA-Aware RTL Generation with Large Language Models

    H. Sami, P.-E. Gaillardon, V . Tenace et al. , “Eda-aware rtl generation with large language models,” arXiv preprint arXiv:2412.04485 , 2024

    work page Pith review arXiv 2024

  8. [8]

    Evaluating large language models trained on code,

    M. Chen, J. Tworek, H. Jun, Q. Yuan, H. P. D. O. Pinto, J. Kaplan, H. Edwards, Y . Burda, N. Joseph, G. Brockman et al., “Evaluating large language models trained on code,” arXiv preprint arXiv:2107.03374 , 2021

    arXiv 2021

Show all 39 references
  1. [9]

    Autovcoder: A systematic framework for automated verilog code gen- eration using llms,

    M. Gao, J. Zhao, Z. Lin, W. Ding, X. Hou, Y . Feng, C. Li, and M. Guo, “Autovcoder: A systematic framework for automated verilog code gen- eration using llms,” in 2024 IEEE 42nd International Conference on Computer Design (ICCD) . IEEE, 2024, pp. 162–169

    2024

  2. [10]

    Rtl- coder: Fully open-source and efficient llm-assisted rtl code generation technique,

    S. Liu, W. Fang, Y . Lu, J. Wang, Q. Zhang, H. Zhang, and Z. Xie, “Rtl- coder: Fully open-source and efficient llm-assisted rtl code generation technique,” IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems , 2024

    2024

  3. [11]

    Verilogeval: Evaluating large language models for verilog code generation,

    M. Liu, N. Pinckney, B. Khailany, and H. Ren, “Verilogeval: Evaluating large language models for verilog code generation,” in 2023 IEEE/ACM International Conference on Computer Aided Design (ICCAD) . IEEE, 2023, pp. 1–8

    2023

  4. [12]

    Rtllm: An open-source benchmark for design rtl generation with large language model,

    Y . Lu, S. Liu, Q. Zhang, and Z. Xie, “Rtllm: An open-source benchmark for design rtl generation with large language model,” in 2024 29th Asia and South Pacific Design Automation Conference (ASP-DAC) . IEEE, 2024, pp. 722–727

    2024

  5. [13]

    Rtl-repo: A benchmark for evaluating llms on large-scale rtl design projects,

    A. Allam and M. Shalan, “Rtl-repo: A benchmark for evaluating llms on large-scale rtl design projects,” in 2024 IEEE LLM Aided Design Workshop (LAD). IEEE, 2024, pp. 1–5

    2024

  6. [14]

    Betterv: Con- trolled verilog generation with discriminative guidance,

    Z. Pei, H.-L. Zhen, M. Yuan, Y . Huang, and B. Yu, “Betterv: Con- trolled verilog generation with discriminative guidance,” arXiv preprint arXiv:2402.03375, 2024

    2024 arXiv

  7. [15]

    Origen: Enhancing rtl code generation with code-to-code augmentation and self-reflection,

    F. Cui, C. Yin, K. Zhou, Y . Xiao, G. Sun, Q. Xu, Q. Guo, D. Song, D. Lin, X. Zhang et al. , “Origen: Enhancing rtl code generation with code-to-code augmentation and self-reflection,” arXiv preprint arXiv:2407.16237, 2024

    2024 arXiv

  8. [16]

    Pyranet: A multi-layered hierarchical dataset for verilog,

    B. Nadimi, G. O. Boutaib, and H. Zheng, “Pyranet: A multi-layered hierarchical dataset for verilog,” arXiv preprint arXiv:2412.06947, 2024

    2024

  9. [17]

    Mg-verilog: Multi- grained dataset towards enhanced llm-assisted verilog generation,

    Y . Zhang, Z. Yu, Y . Fu, C. Wan, and Y . C. Lin, “Mg-verilog: Multi- grained dataset towards enhanced llm-assisted verilog generation,” in 2024 IEEE LLM Aided Design Workshop (LAD) . IEEE, 2024, pp. 1–5

    2024

  10. [18]

    Codev: Empowering llms for verilog generation through multi-level summarization,

    Y . Zhao, D. Huang, C. Li, P. Jin, Z. Nan, T. Ma, L. Qi, Y . Pan, Z. Zhang, R. Zhang et al. , “Codev: Empowering llms for verilog generation through multi-level summarization,” arXiv preprint arXiv:2407.10424 , 2024

    2024 arXiv

  11. [19]

    Open ai codex: An inevitable future?

    A. Kumar and P. Sharma, “Open ai codex: An inevitable future?” International Journal for Research in Applied Science and Engineering Technology, vol. 11, pp. 539–543, 2023

    2023

  12. [20]

    Towards the imagenets of ml4eda,

    A. B. Chowdhury, S. Thakur, H. Pearce, R. Karri, and S. Garg, “Towards the imagenets of ml4eda,” in 2023 IEEE/ACM International Conference on Computer Aided Design (ICCAD) . IEEE, 2023, pp. 1–7

    2023

  13. [21]

    Revisiting verilogeval: A year of improvements in large-language models for hardware code generation,

    N. Pinckney, C. Batten, M. Liu, H. Ren, and B. Khailany, “Revisiting verilogeval: A year of improvements in large-language models for hardware code generation,” ACM Transactions on Design Automation of Electronic Systems , 2025

    2025

  14. [22]

    Hdlcore: A training-free framework for mitigating hallucinations in llm-generated hdl,

    H. Ping, S. Li, P. Zhang, A. Cheng, S. Duan, N. Kanakaris, X. Xiao, W. Yang, S. Nazarian, A. Irimia, and P. Bogdan, “Hdlcore: A training-free framework for mitigating hallucinations in llm-generated hdl,” 2025. [Online]. Available: https://arxiv.org/abs/2503.16528

    2025 arXiv

  15. [23]

    Verimind: Agentic llm for automated verilog generation with a novel evaluation metric,

    B. Nadimi, G. O. Boutaib, and H. Zheng, “Verimind: Agentic llm for automated verilog generation with a novel evaluation metric,” arXiv preprint arXiv:2503.16514, 2025

    2025 arXiv

  16. [24]

    Paradigm-based automatic hdl code generation using llms,

    W. Sun, B. Li, G. L. Zhang, X. Yin, C. Zhuo, and U. Schlichtmann, “Paradigm-based automatic hdl code generation using llms,” 2025. [Online]. Available: https://arxiv.org/abs/2501.12702

    2025 arXiv

  17. [25]

    Large language model for verilog generation with code-structure- guided reinforcement learning,

    N. Wang, B. Yao, J. Zhou, X. Wang, Z. Jiang, and N. Guan, “Large language model for verilog generation with code-structure- guided reinforcement learning,” 2025. [Online]. Available: https: //arxiv.org/abs/2407.18271

    2025 arXiv

  18. [26]

    Kodcode: A diverse, challenging, and verifiable synthetic dataset for coding,

    Z. Xu, Y . Liu, Y . Yin, M. Zhou, and R. Poovendran, “Kodcode: A diverse, challenging, and verifiable synthetic dataset for coding,” arXiv preprint arXiv:2503.02951, 2025

    2025 arXiv

  19. [27]

    Synopsys design compiler,

    S. D. Compiler, “Synopsys design compiler,” Pages/default. aspx, 2016

    2016

  20. [28]

    A comparative study on reasoning patterns of openai’s o1 model,

    S. Wu, Z. Peng, X. Du, T. Zheng, M. Liu, J. Wu, J. Ma, Y . Li, J. Yang, W. Zhou, Q. Lin, J. Zhao, Z. Zhang, W. Huang, G. Zhang, C. Lin, and J. H. Liu, “A comparative study on reasoning patterns of openai’s o1 model,” 2024. [Online]. Available: https://arxiv.org/abs/2410.13639

    2024 arXiv

  21. [29]

    Stop overthinking: A survey on efficient reasoning for large language models,

    Y .-N. YangSui, J. GuanchuWang, J. TianyiZhang, A. HongyiLiu, S. H. Zhong, and X. HanjieChen, “Stop overthinking: A survey on efficient reasoning for large language models,” arXiv preprint arXiv:2503.16419, 2025

    2025 arXiv

  22. [30]

    A survey of efficient reasoning for large reasoning models: Language, multimodality, and beyond,

    X. Qu, Y . Li, Z. Su, W. Sun, J. Yan, D. Liu, G. Cui, D. Liu, S. Liang, J. He et al. , “A survey of efficient reasoning for large reasoning models: Language, multimodality, and beyond,”arXiv preprint arXiv:2503.21614, 2025

    2025

  23. [31]

    Dynamic llm routing and selection based on user preferences: Balancing performance, cost, and ethics,

    D. B. Piskala, V . Raajaa, S. Mishra, and B. Bozza, “Dynamic llm routing and selection based on user preferences: Balancing performance, cost, and ethics,” arXiv preprint arXiv:2502.16696 , 2025

    2025 arXiv

  24. [32]

    Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning,

    D. Guo, D. Yang, H. Zhang, J. Song, R. Zhang, R. Xu, Q. Zhu, S. Ma, P. Wang, X. Bi et al., “Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning,” arXiv preprint arXiv:2501.12948 , 2025

    2025 arXiv

  25. [33]

    s1: Simple test-time scaling,

    N. Muennighoff, Z. Yang, W. Shi, X. L. Li, L. Fei-Fei, H. Hajishirzi, L. Zettlemoyer, P. Liang, E. Cand `es, and T. Hashimoto, “s1: Simple test-time scaling,” arXiv preprint arXiv:2501.19393 , 2025

    2025 arXiv

  26. [34]

    Icarus verilog: open-source verilog more than a year later,

    S. Williams and M. Baxter, “Icarus verilog: open-source verilog more than a year later,” Linux Journal, vol. 2002, no. 99, p. 3, 2002

    2002

  27. [35]

    Qwen technical report,

    J. Bai, S. Bai, Y . Chu, Z. Cui, K. Dang, X. Deng, Y . Fan, W. Ge, Y . Han, F. Huang et al. , “Qwen technical report,” arXiv preprint arXiv:2309.16609, 2023

    2023 arXiv

  28. [36]

    Lora: Low-rank adaptation of large language models,

    E. J. Hu, Y . Shen, P. Wallis, Z. Allen-Zhu, Y . Li, S. Wang, L. Wang, W. Chen et al., “Lora: Low-rank adaptation of large language models,” ICLR, vol. 1, no. 2, p. 3, 2022

    2022

  29. [37]

    Introducing pytorch fully sharded data parallel (fsdp) api,

    Y . Zhao, R. Varma, C.-C. Huang, S. Li, M. Xu, and A. Desmaison, “Introducing pytorch fully sharded data parallel (fsdp) api,” https: //pytorch.org/blog/introducing-pytorch-fully-sharded-data-parallel-api/, 2022, [Online; accessed 17-Apr-2025]

    2022

  30. [38]

    Decoupled weight decay regularization,

    I. Loshchilov and F. Hutter, “Decoupled weight decay regularization,”

  31. [2019]

    Available: https://arxiv.org/abs/1711.05101

    [Online]. Available: https://arxiv.org/abs/1711.05101

    arXiv

Pith tools

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