Papers for

hardware verification engineers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Microarchitecture aware assertion generation improves cpu verification

MicroAssert: Microarchitecture-Aware Structured Assertion Generation for CPU Verification

Abstract: Automatic assertion generation reduces manual verification effort, yet existing approaches struggle to capture microarchitectural behaviors and cross-region interactions in CPUs. We present MicroAssert, a microarchitecture-aware framework that identifies functional regions directly from RTL and generates local and composite assertions through structured contracts and deterministic verification primitives. Coverage-guided feedback further improves verification completeness by progressively expanding proof-relevant RTL coverage. Evaluated on five open-source RISC-V CPUs against three existing assertion generation approaches, MicroAssert achieves 100% syntax correctness and complete branch, statement, and toggle coverage, with an average proven rate of 74.82% and Proof Core coverage of 90.96%. Mutation testing further demonstrates its advantage, achieving an average error detection rate of 28.73%, 1.99 to 3.51 times higher than existing methods. These results demonstrate the effectiveness of microarchitecture-aware assertion generation.

Wed 18 NovHardware ArchitectureSoftware Engineering
The gist
Verifying that computer processors work correctly is very complicated because of their detailed internal structure. The authors present MicroAssert, a new method that understands the processor's inner parts to automatically create checks that confirm the processor behaves as expected. MicroAssert improves test coverage and detects errors more effectively than earlier methods. This helps make sure CPUs are reliable without as much manual effort.
Open → 2611.24872v1

Agentic inference boosts verification code quality and cost efficiency

Inference-Time Scaling in Agentic Hardware Verification Workflows: A Multi-Strategy Characterization Across Protocol Complexity

Abstract: Inference-time scaling, allocating more compute during generation rather than pre-training, has demonstrated dramatic quality improvements for LLM reasoning tasks. Its behaviour in structured hardware verification code generation, where outputs must satisfy compiler correctness, protocol semantics, and functional coverage constraints simultaneously, is less understood. We present a systematic, simulator-grounded study of inference-time compute scaling for agentic UVM testbench synthesis targeting AMBA protocol bridges. Four inference strategies---zero-shot (\$0.04), raw-feedback iterative (\$0.81), structured inner-loop (\$0.95), and full dual-loop agentic synthesis (\$1.06)---are evaluated across four AMBA targets (Protocol Complexity Index 11.8--22.6) using the Protocol Verification Completeness (PVC) metric, functional coverage, and a six-class UVM error taxonomy (E1--E6). Our central finding is that structured diagnostic feedback acts as an inference-time compute multiplier: the structured inner loop yields roughly $15\times$ more PVC per inference dollar than raw EDA-tool feedback (marginal efficiency, S1$\to$S2 vs. S0$\to$S1). The mechanism is fault targeting, not token reduction: raw compiler feedback drives the testbench to compile but cannot surface functional protocol faults that leave the code syntactically valid, whereas structured E1--E6 bundles diagnose and resolve them. All outputs are judged by a cycle-accurate Mentor Questa toolchain rather than by model self-assessment; the dual-loop strategy reaches PVC $\geq$ 0.95 with zero scoreboard errors on every target, and the generated environments surfaced a latent RTL bug in two of the four reference designs. These results establish a principled compute-quality trade-off curve for LLM-aided verification environment generation and motivate inference-budget-aware deployment strategies for industrial EDA workflows.

Wed 18 NovHardware ArchitectureSoftware Engineering
The gist
Generating correct test environments for hardware verification is tricky because the code must work perfectly with complex protocols and compilers. The authors studied how increasing computing power during code generation—rather than before—affects quality and cost. They found that using structured feedback that targets specific types of errors is much more efficient than just relying on raw compiler messages. This better feedback helps find and fix subtle protocol bugs that look correct to the compiler but fail functionally. Their approach also uncovered hidden bugs in two test designs, showing real-world impact.
Open → 2611.23905v1

Knowledge driven AI speeds microchip architecture design space search

KD-DSE: A Knowledge-Driven LLM Framework for Fast Microarchitecture Design Space Exploration

Abstract: Domain-specific architectures have made design space exploration (DSE) a bottleneck of processor design, yet each candidate costs a full simulation, so exhaustive search is out of reach. Surrogate models need thousands of simulations before they predict reliably, and LLM agents that search directly hallucinate, lack cold-start architectural knowledge, and follow a fixed per-round policy. We present KD-DSE, a knowledge- driven LLM framework for fast microarchitecture DSE. KD- DSE couples a five-state constrained agent with real gem5- McPAT evaluation, retrieves architect-curated guidance from an Architecture Knowledge Base conditioned on the current search state and bottleneck diagnosis, and allocates its budget with a diagnosis-guided two-phase exploration strategy. On a 29- parameter out-of-order core with a budget of 18 simulations, KD-DSE achieves about 4.8% higher hypervolume and about 21.7% lower ADRS than the state-of-the-art MicroEvo, and the ablation attributes the gain chiefly to the Knowledge Base. These results indicate that constraining LLM reasoning and grounding it in architectural knowledge can drive fast and effective microarchitecture DSE. The code will be open-sourced upon acceptance.

Tue 17 NovHardware Architecture
The gist
Designing computer processors involves testing many chip configurations, which takes a lot of time because each test is slow. The authors created KD-DSE, a system that uses artificial intelligence guided by expert knowledge to pick smarter tests and make better decisions during design. This means it can find good processor designs faster and with fewer tests than existing methods. Their results showed a significant improvement using real simulations and architectural insights.
Open → 2611.22411v1

Interactive protocol certifies unsolvable logical problems faster

A Multi-Prover Interactive Protocol for Certification of Resolution Refutations

Abstract: A resolution refutation of a SAT-formula $\varphi$ is an independently checkable certificate proving that $\varphi$ is unsatisfiable. However, the refutations of $\varphi$ can be exponentially larger than $\varphi$. So, a verifier needs worst-case exponential time in the size of $\varphi$ to check their correctness. We present ResCertify, an interactive probabilistic protocol in which the verifier interacts with multiple independent, untrusted provers (MIP) to check the refutation with very low probability of error. The verifier runs in linear time in the size of $\varphi$. The provers require time $\mathcal{O}(n \cdot |Φ|)$, where $Φ$ is the resolution refutation and $n$ is the number of variables of $\varphi$. If they can be trusted to act as a multilinear oracle on certain queries, a single prover suffices, and the runtime can be improved to $\mathcal{O}(|Φ|)$. Finally, while the focus of our work is theoretical, we also report on a proof-of-concept implementation of ResCertify.

Tue 10 NovLogic in Computer Science
The gist
Sometimes, finding proof that a set of logical rules cannot all be true at the same time takes a long time, because the proof can be huge. The authors present a new method where a fast verifier interacts with several independent helpers to check these proofs quickly and with very few errors. This approach reduces the verification time dramatically for the verifier, even though the helpers need more time to prepare their answers. They also show how using just one helper can work under some assumptions and give an example implementation of their method.
Open → 2611.14783v1

Bit-exact simulation models reproduce precise nvidia gpu special functions

SFU-Sim: Bit-Exact Reverse Engineering of NVIDIA MUFU and Validation of PTX Paths

Abstract: Reproducing the numerical behavior of a GPU requires predicting the exact output of special function instructions. Vendor documents give only the function semantics and error bounds. These do not fix the output bit pattern. We present SFU-Sim, which builds bit-exact models of NVIDIA multi-function unit (MUFU) instructions by black-box reverse engineering on real GPUs. We first model a single bare MUFU instruction. We then add the surrounding operations found in the disassembly to model full PTX paths. The model covers 12 common MUFU forms and two BF16 forms on the tested Blackwell GPU. Using SIN/COS as a complete case study, we show how we analyze the PTX-to-SASS compilation path and recover the segment structure, the equivalent coefficient tables, and the finite-width arithmetic. On NVIDIA GPUs of three architectures (Ampere, Ada Lovelace, and Blackwell), we exhaustively compare every tested PTX path over its specified input domain. FP16 and FP32 paths cover all $2^{16}$ and $2^{32}$ input encodings, respectively. The model output matches the hardware bit for bit, with zero mismatches. SFU-Sim computes each output directly from its input. It needs neither a lookup table of all inputs nor access to a physical GPU. It can serve as a bit-exact special function component for instruction simulators. It can also serve as an arithmetic reference for hardware design and functional verification that target the same numerical behavior. SFU-Sim and its validation programs are open source at https://github.com/hzX40000000/SFU-Sim

Tue 10 NovHardware Architecture
The gist
Graphics cards use special instructions to calculate things like sine and cosine, but the exact output bits are not public. The authors created SFU-Sim, a tool that copies the exact bit output of these special GPU instructions by carefully studying real hardware without needing internal details. They tested it exhaustively on different NVIDIA GPU models and found it matches perfectly. This tool can help simulate GPU computations exactly or verify new hardware designs.
Open → 2611.13879v1

Automated verification catches bugs in ai-written hardware designs

Will AI mess my RTL? A snapshot-based approach to verifying AI-written RTL

Abstract: With the growing interest in using AI (Artificial Intelligence) for RTL (Register-Transfer Level) hardware development, robust and comprehensive verification has become more important than ever. As Large Language Models (LLMs) increasingly assist in creating and modifying RTL designs, ensuring that these changes preserve existing functionality is paramount for building trust in AI-driven workflows. We present SVApshot, a fully automated framework that leverages LLMs to generate and systematically attempt to correct SystemVerilog Assertions (SVA) for RTL modules, completely removing the human from the generation loop. SVApshot introduces a novel snapshot methodology that captures the current functionality of a design as a comprehensive set of formal assertions, creating a regression suite for validating future changes--whether made by humans or AI. The framework features automated duplicate detection, assertion set expansion, and iterative repair of failing assertions using LLM-guided debugging with formal verification feedback. Our experimental evaluation across diverse RTL modules demonstrates high coverage for complex modules, with successful detection of both manually-injected and AI-introduced bugs. Additionally, this framework opens the door for automatic generation of formal testbenches to benchmark LLMs for hardware design, moving beyond binary pass/fail metrics towards nuanced assertion-based scoring.

Mon 9 NovSoftware EngineeringHardware Architecture
The gist
As people use artificial intelligence to write parts of computer chips, it becomes important to make sure these changes don’t break anything. The authors created a fully automated tool called SVApshot that checks and fixes the rules describing how chip parts should behave. This tool uses AI to write tests and updates them when something goes wrong, without needing human help. Their tests show it finds bugs added by both humans and AI, helping make AI-designed hardware more reliable.
Open → 2611.12712v1

Graph neural networks speed up clock mesh timing and power analysis

A Surrogate Model for Variation-Aware Clock-Mesh Analysis and Design-Space Exploration using Graph Neural Networks

Abstract: Clock meshes are widely used in high-performance VLSI systems to minimize skew and tolerate On-Chip Variation (OCV) in nanometer technologies. However, analyzing meshes is difficult because reconvergent paths and multi-source drivers prevent static timing analysis (STA) tools from handling mesh loops, making SPICE the industrial standard. SPICE simulations are accurate but slow, so clock-mesh synthesis relies on approximate models that overlook critical effects such as non-linear buffer driving caused by input slew and input skew. We propose a Graph Neural Network (GNN) based surrogate model of the clock mesh with a new graph representation and a new architecture that predicts power while also improving the delay and slew predictions at the sinks and capturing the skew histogram under OCV. Trained on SPICE data and tested on unseen real designs, our model achieves average errors of $3.40$~ps in delay, $4.14$~ps in slew and $4.46$~ps in skew, compared with $6.28$~ps, $12.35$~ps, and $11.62$~ps for our prior model, and $74.37$~ps delay and $27.51$~ps skew for the approximate method used in current state-of-the-art works. Our model predicts power within $3.4\%$ of SPICE on average, while delivering $18\times$-$1706\times$ speed-ups over the approximate method under OCV modeling, enabling faster and more accurate clock-mesh design-space exploration. A case study on a real design further shows that our surrogate model finds buffering candidates that, at a balanced tradeoff, improves $99^{\text{th}}$-percentile skew by $49.1\%$, reduces power by $25.7\%$, and reduces area by $37.3\%$ at the cost of a $6.8\%$ increase in $99^{\text{th}}$-percentile maximum slew as compared to the state-of-the-art work.

Sun 1 NovHardware ArchitectureMachine Learning
The gist
Clock meshes help keep computer chips running smoothly by balancing timing signals, but checking their performance usually takes a long time with detailed simulations. The authors developed a smart computer model using graph neural networks that can quickly and accurately predict how clock meshes behave, including timing delays, signal quality, and power consumption. Their new method matches detailed simulation results much more closely than older quick methods and runs dozens to thousands of times faster. This improvement helps chip designers explore better clock mesh designs faster, saving power and area while keeping signals well balanced.
Open → 2611.01473v1

Rtl simulators tested with grammar guided large model fuzzing

GI-RTL-Fuzz: Grammar-Informed RTL Generation with LLMs for End-to-End Differential Simulator Fuzzing

Abstract: Register-Transfer Level (RTL) simulators are fundamental to modern IC design workflows, yet like any complex software, they frequently contain critical bugs that compromise simulation accuracy. To systematically stress-test these tools, we introduce GI-RTL-Fuzz, a grammar-informed fuzzing framework that leverages Large Language Models (LLMs) to generate high-quality RTL test cases. Our key innovation is guiding the LLM's generation process using Backus-Naur Form (BNF) grammar coverage information, enabling the exploration of complex and rarely-tested language features. By performing differential testing against different RTL simulators, our framework uncovered a significant number of previously unknown inconsistencies in both the linting process and simulation results of major Verilog simulators.

Wed 28 OctHardware ArchitectureCryptography and Security
The gist
RTL simulators help design computer chips but can have bugs that cause errors. The authors introduce a tool that uses AI to create complex test programs for these simulators, guided by the rules of the programming language. This method finds hidden bugs by comparing outputs from different simulators. Their approach uncovered many new errors in how these simulators check and run designs.
Open → 2610.38489v1

Rtl repair benchmarks measure model behavior and scoring differences

What Do RTL Repair Benchmarks Actually Measure?

Abstract: RTL repair benchmarks should measure whether a model can fix broken RTL given a specification. To this end, we construct and hash-bind RTLRepairDataset, 5,784 (broken, fixed) training pairs; RTLRepairBench, 459 held-out cases with 374 syntactic and 85 behavioral mutations; and an evaluation harness supporting simulation and formal equivalence. We then use this infrastructure to identify two measurement confounds. First, simulation and formal scoring give opposite signs for the apparent effect of providing a specification in one evaluated cohort; reset-aware rescoring attributes almost all of the simulation-formal disagreement to reset and first-cycle comparison semantics. Second, on 274 mined model failures, the specification-only minus specification-conditioned recovery point estimate ranges from -8.5 to +18.3 percentage points across six models. Thus, a conventional repair score need not isolate whether the model used the faulty RTL. We translate these findings into evaluation controls: report initialization, reset, first-cycle, and unknown-value semantics; disclose oracle coverage and undecided cases; and include a specification-only baseline. Together, the resources and audit provide both a benchmark for behavioral repair and a protocol for diagnosing what contributes to its measured score. We release the benchmark, the training set, construction code, sanitized aggregate evidence, and reproduction materials at https://github.com/Evaaaz/RTLRepairBench.

Tue 20 OctArtificial Intelligence
The gist
Fixing broken hardware designs (called RTL) automatically is tricky, and testing if a model really knows how to fix them can be confusing. The authors made a big set of broken and fixed design pairs, plus a tool to test fixes in different ways. They found that two common ways to check fixes often disagree because of how initial conditions are handled. Also, sometimes a model’s reported fix success doesn't clearly show if it used the broken design or not. They suggest ways to better report and understand these tests. The authors also share their dataset and tools openly for others to use.
Open → 2610.28595v1

E-Layout improves chip timing and area by reshaping circuit logic

E-Layout: Layout-Stage Logic Restructuring via RL-Optimized Equality-Saturated Graph Retrieval-Augmented Generation

Abstract: Achieving high sign-off performance in advanced ICs increasingly depends on layout-stage optimization under realistic physical conditions. While recent efforts have moved toward synthesis-layout fusion, most existing works still focus on bringing estimated physical information earlier into synthesis, whose optimization does not fully correlate with real layout-stage behavior. Meanwhile, layout-stage optimization remains largely restricted to a fixed logic structure, relying mainly on buffering and sizing. This fundamentally constrains the optimization space under realistic physical conditions. To address this, we present E-Layout, an ML-driven framework for post-placement layout restructuring. E-Layout jointly optimizes logic transformation and physical implementation across multiple subcircuits under design-level timing feedback. This enables the selection of the most timing-beneficial set of disjoint restructured subcircuits to form the optimized circuit. Specifically, it first constructs equivalence-preserving logic alternatives via e-graph equality saturation, then couples logic selection with physical realization through a graph-based retrieval-augmented generation (RAG) model, and finally refines these local logic-physical decisions with reinforcement learning under design-level timing feedback. Evaluated on 9 diverse designs, it achieves on average 6% TNS improvement and 2% WNS improvement, while even reducing area by 1%, over an industry-leading commercial physical design flow.

Mon 19 OctHardware Architecture
The gist
Making computer chips run better and faster depends a lot on how their tiny parts are arranged and connected. The authors created E-Layout, a smart method that reshapes the way chip circuits are organized after their parts are placed, using a mix of logic changes and physical adjustments. It tries out many equivalent ways to redesign the circuits and uses machine learning to pick the best combos for timing and size. Testing on several chip designs, E-Layout showed improvements in speed and reduced the chip area slightly compared to top industry methods.
Open → 2610.26432v1

LLM agents improve hardware test coverage with independent data checks

Independent Data-Integrity Verification for LLM-Driven Functional Coverage Closure in Hardware Design

Abstract: LLM agents can write directed tests that close functional coverage, but coverage only shows that a state was reached, not that the data on the way there was correct. This is a long-known point in verification and we do not claim it as new. We describe a small coverage-closure agent that applies it to an LLM loop: coverage is read from the report that the simulation itself exports (cocotb-coverage YAML) and never taken from the model's account, and data integrity is checked by scoreboards that are separate from the model. On three architecturally distinct RTL designs (an asynchronous FIFO, a UART transmitter and an AHB2APB bridge) the agent raised coverage from 91.7%, 88.9% and 67.4% to 100% within its 8-iteration budget in every logged run, using one design-agnostic agent. A reactive scoreboard monitor attached to the FIFO's base testbench also found a clock-domain-crossing bug in the author's own stimulus code. The monitor is not yet attached to the LLM-generated tests, so their data integrity is not independently checked; one manual check on a single FIFO test is reported as preliminary. We list the weaknesses of this evidence: three designs, no baseline, no ablation, and logged runs that come from several agent checkpoints.

Thu 15 OctHardware ArchitectureArtificial IntelligenceSoftware Engineering
The gist
Hardware designs are tested to ensure they work correctly by checking if all possible situations happen during tests, called coverage. The authors show that using AI language models (LLMs) can create tests that reach all coverage states, but reaching a state doesn't mean the data is right. They add extra checks that independently verify data along the way, improving confidence in the tests. This method was tested on three different hardware designs and successfully improved coverage to 100% every time within a limited number of test runs.
Open → 2610.21570v1

Multiplication associativity is provably hard for SAT solvers

Associativity of Multiplication Is Hard for Resolution

Abstract: SAT solvers are empirically known to perform poorly when reasoning about multiplication. Yet for over a decade we have lacked a theoretical explanation for this phenomenon. CDCL SAT solvers implicitly search for resolution proofs, and no lower bound on proof size has ruled out the existence of short proofs that solvers simply fail to find. We give the first lower bound of this kind by showing that general resolution proofs of the associativity of $n$-bit multiplication require size $2^{Ω((n/\log n)^{1/4})}$. This lower bound holds for a broad class of multiplier encodings based on partial product summation, including the standard array and Wallace-tree multipliers used to bit-blast multiplication in SMT solvers. This result resolves an open problem of Beame and Liew. The proof constructs a reduction from a perfect-matching principle on bounded-degree bipartite expander graphs to multiplier associativity. Itsykson, Slabodkin, and Sokolov proved that this principle is hard for resolution. The lower bound for multiplier associativity follows. The same reduction, when combined with Håstad's recent lower bound for the perfect-matching principle of the odd grid, yields an exponential lower bound for multiplier associativity in the stronger bounded-depth Frege proof systems.

Tue 6 OctComputational ComplexityLogic in Computer Science
The gist
Multiplying numbers is a basic math operation, but computers that solve logical puzzles called SAT solvers struggle to prove that multiplication works the same way no matter how you group numbers (associativity). The authors show that the logical steps needed to prove this are very large and complex, explaining why these solvers perform poorly. They connect this difficulty to another well-known hard logic problem and prove strong limits on how simple any proof can be.
Open → 2610.08988v1

VTen boosts verification speed and cuts code for hardware accelerators

vTen: Tensor-Centric Verification Framework for Domain-Specific Accelerators

Abstract: The semantic gap between tensor-centric software models and signal-level hardware testbenches creates significant productivity bottlenecks in verifying Domain-Specific Accelerators (DSAs). Existing frameworks like Cocotb suffer from prohibitive synchronization overheads due to fine-grained interactions. To address this, we propose vTen, a data-centric framework that strictly decouples verification intent from execution mechanics. By leveraging a declarative DSL and kernel-granular batching, vTen minimizes host-simulator interaction frequency. Evaluation on a production-scale 3D U-Net accelerator demonstrates that vTen achieves a 2x performance improvement in simulation latency and a 60.3% reduction in code complexity compared to Cocotb.

Tue 6 OctDistributed, Parallel, and Cluster ComputingHardware Architecture
The gist
Verifying specialized computer chips called Domain-Specific Accelerators (DSAs) is usually slow and complicated because software tests and hardware checks don’t communicate efficiently. The authors introduce vTen, a new framework that separates what the tests should do from how they run, using a simple language and grouping operations together. This approach reduces the time spent waiting for communication by half and makes the test code much simpler. They tested vTen on a real 3D U-Net accelerator and found both faster verification and cleaner code.
Open → 2610.08372v1

Evidence-guided method improves debugging of hardware code failures

Evidence-Guided Repository-Level RTL Repair

Abstract: Repository-level RTL repair must localize a failure that spans files, modules, and clock cycles, then propagate the fix consistently. Existing methods reason over source code, which reveals possible behaviors but not the failed execution, and cannot tell whether a local fix was propagated consistently. We therefore present an evidence-guided framework with three modules. Failure grounding converts a problem statement into a reproduced failing run and a failure anchor. Waveform-guided localization uses a localization toolbox to narrow the observed violation into a candidate mechanism and an evidence trail. Consistency-aware repair and validation then expand that seed into a coordinated patch and replay the same scenario to check that the violation disappears. We conducted experiments on HWE-Bench and achieved better performance than the baseline.

Fri 2 OctHardware Architecture
The gist
Fixing bugs in hardware descriptions can be tricky because the problem might spread over multiple files and moments in time. The authors created a new way that uses actual failure data to pinpoint where things go wrong and then carefully checks that the fix truly solves the problem across the entire hardware design. Their approach uses evidence from hardware run simulations to guide the repair process more accurately than methods that only look at the code. Tests showed their method worked better on a known benchmark.
Open → 2610.03219v1

Improved tristate number multiplication with formal proof and precision

Improved Tristate Multiplication With Formalization in Rocq

Abstract: We give a new multiplication algorithm for tristate numbers improving upon the state-of-the-art implementation from the Linux kernel in terms of precision and formal proofs. Our algorithm is significantly more precise as shown by experimental evaluation (at the peak, giving better results in 95.59% cases compared to the previous work for 31-bit samples). Importantly, we achieve this additional precision with performance comparable to the previous algorithm, as demonstrated by benchmarks. Finally, we formalize and prove the soundness of the algorithm in the Rocq proof assistant, adding to the trust in the resulting implementation. Our algorithm is now part of the upstream Linux kernel. Our soundness proof in Rocq for the new multiplication algorithm works for all bit widths, while the SAT/SMT-based machine-checked proof accompanying the previous algorithm was restricted to 8 bits. We also provide Rocq proofs for the soundness and optimality of the newly added tnum union operation and the existing tnum addition algorithm from the Linux kernel. Our optimality proof for tnum addition presents a simpler and straightforward lemma compared to prior work.

Wed 30 SeptLogic in Computer Science
The gist
Multiplying numbers that have a special three-state form is tricky, and getting exact answers quickly is important for computers like Linux. The authors created a new way to multiply these tristate numbers that is more accurate than the previous method used in the Linux kernel. They also made sure this new method is reliable by proving it mathematically with a tool called Rocq. Their method works equally fast as before but gives better results almost all the time, and it applies to numbers of any size.
Open → 2609.39009v1

Large language models improve hardware verification with semantic guidance

Enhancing Word-Level Property Directed Reachability with LLM-Driven Semantic Guidance

Abstract: Property Directed Reachability (PDR) is a prominent algorithm for hardware formal verification. However, bit-level PDR often struggles with datapath-heavy designs because bit-blasting obscures high-level semantics. While word-level PDR addresses this by reasoning over bit-vector and array theories, its performance remains bottlenecked by discovering proof-relevant word-level relations. We propose LLM4PDR, a framework leveraging Large Language Models (LLMs) to guide word-level PDR search through three mechanisms: (1) Predicate Generation, extracting state relationships as candidate predicates during inductive generalization; (2) Clause Generation, producing candidate frame lemmas to accelerate convergence after formal validation; and (3) Assertion Generation, synthesizing helper assertions that strengthen the target property under counterexample-guided refinement. We implement LLM4PDR in the Pono model checker and evaluate it on arithmetic micro-benchmarks, HLS-generated pipelines, open-source RTL components, and hardware model checking competition (HWMCC) instances. Results show LLM-generated guidance improves both solved instances and runtime on datapath-heavy and control-plus-datapath designs. The strongest configuration solves 28 of 33 arithmetic benchmarks, compared to 13 for vanilla Pono and 11 for AVR. On HLS pipelines and open-source RTL, different modes provide complementary speedups: clause guidance is effective for deep pipelines and predicate guidance for bus and memory-controller designs. On HWMCC benchmarks, benefits are instance-dependent, demonstrating notable speedups and timeout avoidance on hard cases. These results suggest that LLM-generated, verifier-checked semantic hints can serve as a practical complement to conventional word-level PDR.

Thu 24 SeptHardware Architecture
The gist
Checking hardware designs to make sure they work as expected is hard because detailed bit-level methods lose sight of the bigger picture. The authors developed a way to help formal verification tools by using large language models to suggest helpful hints based on the design’s meaning. Their method improves how quickly and effectively verification runs on complex hardware like pipelines and memory controllers. Tests showed their approach solves more verification tasks and speeds up checking compared to previous methods.
Open → 2609.30131v1

Harness evolution improves hardware verification task coverage but with mixed gains

Automatic Harness Evolution for Hardware Design Verification: Can LLMs Consolidate Gains Across Discovered Harnesses?

Abstract: Agent behavior depends on the harness surrounding a language model, but it remains unclear whether language models can reliably improve such harnesses for hardware-design tasks. We study automatic harness evolution around a fixed subject model on 12 proprietary design-verification root-cause localization tasks. Across five trials per task, automatically evolved harnesses increased completed attempts by 71-76% and any-hit task coverage by 80-100%, while total correct attempts improved by only 18-24%. The strongest success reproducible at least twice result improved by one task, and later candidates exchanged gains across tasks rather than preserving them. An auxiliary candidate improved on a four-task validation set excluded from search but tied its baseline on a subsequent 12-task replay containing both search and validation tasks, so the selected gain did not persist across the full pool. Across the tested lineage, useful search, evidence, and finalization behaviors appeared in different candidates but did not consistently consolidate into a single harness that dominated across tasks and metrics. In a separate CVDP cross-benchmark case study, an automatically evolved defined-width repair harness produced 35.6% more functional passes than its 142-task reference baseline; the final functional verifier scored completed outputs but was not shown to the subject agent during repair. These results support archive-aware selection when evolution yields complementary specializations without consistent consolidation.

Thu 24 SeptSoftware EngineeringMachine Learning
The gist
Language models help verify hardware designs, but they need tools called harnesses to guide them. The authors tested if these harnesses can be automatically improved to help the model find problems better. They found that while the tool improvements increased how many tasks were started and covered, the actual correct results improved less and gains were not consistent across tasks. This suggests that better selection methods are needed to combine these improvements effectively.
Open → 2609.28908v1

Hardware fuzzing needs better tools and clear reporting to grow

SoK: You Find What You Seek: Rethinking Oracles, Guidance, and Input Generation in Hardware Fuzzing

Abstract: Hardware fuzzing is an active area in security verification research, yet its industrial adoption remains in its early stages. This SoK examines which lessons from software fuzzing carry over to hardware and where unique approaches are needed. By analyzing 52 fuzzers across RTL/IP, CPU, NoC, and SoC designs, we introduce an analytical framework that frames verification as a bounded search. This search is defined by its objective, oracle, guidance, input generation, target abstraction, and budget. Consequently, a campaign only uncovers failures it can effectively reach, recognize, and prioritize before exhausting its resources. We distinguish two roles for hardware fuzzing: (1) augmenting constrained-random verification (CRV) via feedback-guided coverage and (2) directed adversarial testing based on threat models and security specifications. Through our framework, we identify what each campaign can observe and generate, providing a basis for assessing the evidence behind reported results. Our analysis suggests that mainstream adoption of hardware fuzzing will require reusable interfaces, target-specific verification assets, reproducible evaluations, and transparent reporting of cost and user effort.

Wed 23 SeptCryptography and SecurityHardware Architecture
The gist
Testing computer chips for security problems is harder than testing software, and the ways people fuzz software don't always work well for hardware. The authors looked at many hardware fuzzing methods and made a framework to understand how they search for bugs and what limits their success. They found hardware fuzzing can help in two main ways: improving existing testing methods and performing focused attacks based on security goals. They also suggest that hardware fuzzing will become more useful if it has reusable tools, clear results, and better ways to share effort and costs.
Open → 2609.27300v1

Agentic-IC3 improves hardware model checking with semantic guidance

Agentic-IC3: Enabling Semantic Proof Search in IC3 Model Checking

Abstract: IC3 is a state-of-the-art algorithm for hardware model checking that proves safety properties by incrementally constructing an inductive invariant consisting of a set of lemmas. Its effectiveness depends on generalization heuristics that identify useful lemmas and guide proof search. However, many leading IC3 hardware model checkers operate on lowered, bit-level representations, where high-level design relationships are difficult to exploit for generalization. Those operating at a higher level remain limited in exploiting high-level design structure and semantics. We present Agentic-IC3, built on Pono's word-level model-checking infrastructure, which integrates a language-model agent into IC3 to guide semantic proof search using register-transfer-level (RTL) design information. The framework exposes an agent-oriented interface to a persistent IC3 backend, allowing the agent to interact with an explicit, evolving proof state throughout verification. Across successive proof obligations, the agent relates intermediate proof states and solver feedback to the RTL and proposes high-level lemmas through both SAT and UNSAT generalization. Beyond generalization, the agent can introduce derived observation signals to express design relationships succinctly and obtain more informative feedback, and backtrack to revise proposals that lead to unproductive proof branches. The backend checks proposals before updating the proof state, preserving soundness and providing feedback for further reasoning. On a suite of 14 benchmarks spanning security information-flow verification and functional verification of communication protocols, processors, and functional units, Agentic-IC3 solves 10 cases within a one-hour timeout, including 4 unsolved by all three evaluated baselines: rIC3, Pono-IC3Bits, and A-IC3.

Tue 22 SeptLogic in Computer ScienceHardware Architecture
The gist
Checking if hardware designs are safe and work correctly is very hard, especially when using low-level details. The authors built Agentic-IC3, a smarter proof checker that uses high-level design meanings to search for proofs more effectively. It combines a language model with existing tools to suggest useful proof steps and fixes ones that don’t help. This approach solved more test problems than previous expert systems, especially for complex hardware like processors and communication protocols.
Open → 2609.27162v1

Formally verified data links assertions to behavior in hardware designs

EquivSVA: A Formally Verified Dataset of Behavioral Assertions Across Equivalent RTL Implementations

Abstract: Large language models are increasingly used to generate SystemVerilog Assertions from natural-language specifica- tions and register-transfer-level designs. Existing datasets and benchmarks support important goals such as large- scale training, formal evaluation, specification-to-assertion generation, and mutation-based testing. A complemen- tary need is to study whether a generated assertion cap- tures externally observable behavior or depends on inci- dental details of one RTL implementation. We present EquivSVA, a formally verified dataset organized around behavior families. Each family contains four structurally distinct RTL implementations of the same externally ob- servable behavior, shared interface-level gold properties, three controlled mutants, and formal-validation evidence. EquivSVA contains 120 behavior families across 12 cat- egories, 480 reference RTL implementations, 914 gold properties, and 360 mutants. Every final family passes a fixed 17-job validation suite covering RTL equivalence, gold-property proofs, property reachability, mutant dis- tinguishability, and gold-property checks on mutants. We also provide fixed family-safe train, development, and test splits. As a small demonstration of the analyses en- abled by the dataset, we evaluate the publicly released, Apache-2.0-licensed Qwen2.5-Coder-7B-Instruct model on the held-out test split. Of 293 interface-only generated properties, 93 are formally sound, and the number of sound properties varies across equivalent implementations for 14 of 24 test families. These results illustrate how behavior-family organization can support controlled stud- ies of assertion-generation robustness without requiring changes in intended functionality. The dataset, generators, validation scripts, and case-study artifacts are publicly released at https://github.com/aditigupta96/EquivSVA.

Tue 22 SeptMachine Learning
The gist
Often, computer tools generate checks called assertions for hardware designs based on descriptions in human language. However, these checks may accidentally rely on specific details of one version of a design instead of its overall behavior. The authors created a large, carefully checked dataset containing multiple different hardware designs that all do the same thing, along with matching assertions verified to capture the actual behavior. This lets people test whether a generated check truly reflects the intended function rather than incidental design choices. They also showed how to evaluate a popular AI model on this dataset to measure how reliable its generated checks are across different versions.
Open → 2609.26751v1

Positive feedback adiabatic logic shows energy benefits in 16nm FinFET circuits

Evaluating Positive Feedback Adiabatic Logic in 16nm FinFET with a Realistic Power-Clock

Abstract: Adiabatic logic reuses the energy stored on load capacitances through quasi-reversible switching, enabling a lower minimum energy consumption than conventional static CMOS. Yet its practicality in FinFET technologies and at multi-GHz clock rates has yet to be investigated. This work provides a systematic evaluation of Positive Feedback Adiabatic Logic (PFAL) simulated in the TSMC 16nm FinFET process. A set of PFAL standard-cell gates were realised, along with two representative combinational circuits - a 2$\times$2 multiplier and a 4-bit comparator - and compared against static CMOS logic using the energy--delay product (EDP) and the energy advantage metric $η= E_{\mathrm{CMOS}} / E_{\mathrm{PFAL}}$. Transient simulations reveal three sources of non-adiabatic loss: two specific to the PMOS/NMOS latch, threshold-voltage-related loss and a previously unreported redundant charging of the output node and one related to the complexity of PFAL logic trees. The low-threshold Buffer/NOT cell achieves a minimum EDP of $1.23\times10^{-26}$J$\cdot$s at $V_{\mathrm{CLK}} = 0.6$V and $f_{\mathrm{CLK}} = 7.94$GHz, while PFAL preserves an energy benefit over static CMOS of up to roughly $5\times$ at reduced frequencies and elevated supply voltages. A parallel-coupled quadrature voltage-controlled oscillator is designed as a realistic four-phase power-clock generator. With this non-ideal supply, the Buffer/NOT energy stays within $2\%$ of the ideal sinusoidal case at $3$GHz. A loading study quantifies the phase shift and amplitude reduction induced by increasing fan-out. Overall, the results provide a design-oriented evaluation of PFAL in 16nm FinFET and a motivation to exploit adiabatic logic for future low-power system architectures.

Thu 17 SeptHardware Architecture
The gist
Computers use energy whenever they switch electrical signals, and adiabatic logic is a technique that recycles some of that energy to save power. The authors tested a type of adiabatic logic called PFAL in a realistic modern chip process and found it can use up to five times less energy than traditional chip designs at lower speeds. They identified sources of energy loss unique to this method and showed their design works well even with a practical power supply. This suggests PFAL could help build more energy-efficient chips in the future.
Open → 2609.19999v1

AutoTrans automates secure RISC-V assertion translation with AI help

AutoTrans: AI-Assisted Automatic Translation of Security Assertions for RISC-V Processors

Abstract: Reusing a set of verified security assertions across RISC-V processor targets remains one of the most expensive bottlenecks in hardware security verification. Manual translation takes hours per assertion. Raw LLM translation is fast but unreliable, introducing signal hallucination, where the model invents port names absent from the target RTL and produces outputs that may vary across model updates or even within the same model version. This paper presents AutoTrans, an automated framework that addresses the above shortcomings. First, a new lightweight Regular Expression-based System Verilog signal extractor is proposed to identify the signals for generating security assertions. This step is necessary to prevent signal hallucination. Second, a template is introduced to create prompt and pinned inference parameters that guarantee a byte-identical prompt assembly on every run, making the pipeline output resilient to model updates. Moreover, the introduced template for LLM prompting is capable of generating security assertions from English-only security descriptions of RISC-V processors, with no manual authoring. Third, a formal verification process (JasperGold FPV) is integrated, which guarantees that the generated security assertions verify the security of the RISC-V processor rather than silently entering the result set. The workflow is applied on Deepseek V4 to translate security assertions from one RISC-V to another (e.g., for IBEX from NS31A RISC-V). The experiment shows that AutoTrans achieves 78\% Auto Translation Acceptance Rate (TAR) automatically and without human intervention and 100\% Final TAR after refinement by humans.

Wed 9 SeptCryptography and SecurityHardware Architecture
The gist
Translating security checks from one RISC-V processor to another is usually slow and error-prone when done by hand. The authors built AutoTrans, a tool that uses AI combined with careful signal detection and prompt control to automatically generate these security assertions reliably. It also verifies the generated assertions formally to ensure they really check security. Tests show AutoTrans works well on real processors, needing little or no human fixes after AI translation.
Open → 2609.10057v1