ACL2 Workshop 2026
Abstracts

Note: Below are abstracts for invited talks and abstracts for rump session talks, all to be listed on the program page.

INVITED TALKS
Sol Swords
(Arm Ltd.)
Hardware to Software Symbolic Simulation with FGL

[Slides]

Shuvendu Lahiri
(Microsoft Research)
Intent Formalization: Assessing the Quality of AI-Generated Formal Program Specifications

Agentic AI systems can now produce fluent code, but the core question persists: does the code reflect the user's actual intent? The long-standing gap between informal natural-language requirements and precise program behavior—the intent gap—is magnified by AI-generated code. The path to reliability runs through intent formalization: automatically translating informal intent into checkable specifications, ranging from lightweight tests to symbolic specs and domain-specific languages. As AI systems become creative at generating such specifications, the bottleneck shifts from writing specs to evaluating them.

We will discuss how this evaluation can be rigorous and largely automated. Using tests as a proxy oracle, we define metrics—soundness, completeness, and preciseness—to quantify how well a specification matches intent across both mainstream and verification-aware languages. Research prototypes demonstrate feasibility: tests to resolve intent ambiguities (TiCoder), quality assessment of symbolic specs (nl2postcond, Dafny spec validation), training a formal specification model (AutoVerus), and automated specification repair via agentic proof automation (F*). We will also discuss how intent formalization forms a pillar of neuro-formal code review, a method to enforce developer intent for code changes in pull requests.

[Slides]

RUMP SESSION TALKS
Please check back here later for more talks.
Matt Kaufmann
Konrad Slind
Translating HOL4 Developments into ACL2 (Progress Since Last Year)

We report on progress in translating HOL4 developments into ACL2. As reported in a rump session talk at ACL2 Workshop 2025, this work takes advantage of the ACL2(zfc) integration of set theory with ACL2, to provide a way to include HOL4 and ACL2 formalizations in a common ACL2 environment. The talk will be self-contained but will emphasize progress since the 2025 talk, including the following.

  • Translation of HOL4 theorems and datatype definitions, not just function definitions
  • Handling of quantifiers and lambdas (by lifting)
  • A small proof example, e.g., correspondence of trivial expression evaluators written in HOL and in ACL2.
  • A meta-level proof of soundness of the translation approach

[Slides]

J Moore Improvements to arithmetic-5/top

Robert Krug's book, arithmetic-5/top.lisp, provides a powerful set of rules for reasoning about arithmetic. Released about 17 years ago, arithmetic-5/top is explicitly included in over 400 books in the regression -- and that does not count the books that depend on those books or on books that use macros that include or may include arithmetic-5/top. But arithmetic-5/top sometimes sends the rewriter into loops resulting in call stack overflows. It is often impossible to prevent these loops by simply disabling a contributing rule because new loops can be caused by disabling key rules.

I have spent some time investigating many arithmetic-5 loops. The new release of arithmetic-5/top contains a feature that, when enabled, will avoid some of these loops without weakening the reasoning power too much. E.g., as of August, 2026, the new version could successfully process the full regression with this feature either enabled or disabled. However, for backwards compatibility, the feature is disabled by default, i.e., arithmetic-5/top will perform as it has for years, including its tendency to cause stack overflows. But now you can enable the feature and maybe it will do the proof you were attempting.

You might also check out the new doc topic named moore-mods-to-arithmetic-5 now found in arithmetic-5/top.lisp and you might also note the new built-in event set-call-depth-overflow-advice which allows the author of a book to provide a message that is printed if a call stack overflow occurs in a session in which that book is included.

In this rump session I will demonstrate the new features.

[Demo Script]

[Demo Output]

Gavin Meil Risc-V emulator and future proof of refinement of a multiprocessor RTL design

For my Ph.D. dissertation project I intend to use ACL2 to prove that an RTL design of a two-core multiprocessor with a two-level cache hierarchy refines a Risc-V-based ISA model including a sequentially consistent memory model. So far I have completed a model of the ISA based on the Risc-V RV32I unprivileged architecture and used it to emulate software compiled for Risc-V. I will present experimental results of the emulator and the strategy I intend to use to decompose the proof of refinement, as well as motivation and a request for feedback.

[Slides]

Jim White ACL2 For Trustworthy AI

Doug Lenat's last paper. Getting from Generative AI to Trustworthy AI: What LLMs might learn from Cyc, described 16 characteristics required for AI to be trusted with general tasks and actions. It is clear to everyone that stochastic inference alone cannot deliver on many of those criteria. Formal methods including symbolic inference and theorem proving is strong in exactly those areas where LLMs are weak. This session will be a lightning review of these ideas and ACL2 experiments I've worked on over the last year including a ReAct agent in ACL2, a KG for ACL2 including the community books, and a WASM engine generated with ACL2 to C. I will also briefly describe areas that I think are most promising for further work.

References:

[Slides]

Pablo Cayuela Pencil, Chalkboard, Q.E.D.: Hand-Derived Vieta Formulas Checked in ACL2

How do you go from formulas found with pencil and chalkboard to a theorem that holds for every degree? The talk follows one small example from start to finish. Expanding the product of (x - a_i) is organized as a hand-computable multiplication table, and unfolding its recurrence in two opposite orders produced two nested sum-product formulas for the coefficients. Symbolic checks covered only degrees up to 7, and an earlier draft had a wrong summation bound that only this check caught. In ACL2, the table becomes a short recursive function, and induction over an unbounded list of roots gives soundness against the plain product, a Cardano-Vieta relation for every coefficient, a proof that both hand-derived nested-sum formulas equal the table's coefficients and hence each other, and invariance under any permutation of the roots, using the community perm relation, which makes the elementary symmetric functions symmetric. Going down to individual terms, ACL2 also proves that the two readings are mirror images under i -> n+1-i, and that each one lists every product of n-p distinct roots exactly once, C(n, n-p) terms in all. The same books certify in both ACL2 and ACL2(r), so in ACL2(r) the theorems also reach irrational and complex roots, such as the poles -1 +/- j sqrt(2) of a control system. I also list the gaps found along the way and how each was closed: the Cardano-Vieta claim was stronger than the theorems proved, an independent Python cross-check had a sign error for odd degrees, and the mirror symmetry and the Pascal term count had only been checked by hand. Finally, I report how the book was developed with an AI coding agent, and what ACL2 did and did not validate. A text search of the community books finds no development of elementary symmetric polynomials, Vieta's formulas or Newton-Girard identities; I would like to ask whether anyone has done it, and how to represent multivariate polynomials so that the converse (the fundamental theorem of symmetric polynomials) and the Newton-Girard bridge to traces become tractable.

[Slides]

Ray Myers Porting WASM Semantics to ACL2 with coding agents

WebAssembly (Wasm) is a compilation target supported by popular languages including C, C++, Go, and Rust. WebAssembly has official mechanized semantics defined in the SpecTec DSL.

We present an agentic port of the Wasm 1.0 semantics from SpecTec into ACL2, intended to integrate with the Kestrel framework. We created this using the OpenHands agent with Claude Opus and Sonnet models, and the Ralph Wiggum style of orchestration.

We invite feedback on improvements to methodology so that this experimental port can be refined and expanded into a Wasm 2.0 semantics with real ACL2 applications.

[Slides]

TUTORIALS
Matt Kaufmann
J Moore
Some ACL2 Features That Might Not Be Widely Known in the Community

This talk will provide a whirlwind tour of some useful ACL2 features that might not be widely known. In addition to including a few demos, it will provide some brief descriptions with pointers to documentation.

[Slides] [Demos Script] [Demos Log]

Alessandro Coglio
Eric McCarthy
Grant Jurgensen
Eric Smith
4th Wave Meets 1st Wave: Leveraging Modern AI in ACL2

This tutorial will illustrate how to set up Claude Code, Codex, and possibly other LLMs to assist in the development of ACL2 code (including proofs), how to limit the AI's access via the appropriate security settings, and how to use the AI effectively and assuredly to speed up ACL2 work. We will show some concrete examples, including some that resulted in improvements to ACL2 itself.

[Slides]

Christopher Chen Smtlink3

Introduction to using Smtlink 3 to extend ACL2's theory reasoning capabilities.

Mike Dodds Building formal tools with AI agents

How can we use AI to build formal tools? Claude and I recently built ACL2Lean (https://github.com/OathTech/ACL2Lean), a tool that replays ACL2 proofs as kernel-checked Lean proofs. I'll talk about how we did this, and offer some tentative advice on wielding AI agents successfully.

Eric Smith The Axe Toolkit for Proofs About Programs

This tutorial will teach how to use the ACL2-based Axe Toolkit (books/kestrel/axe/) for such tasks as lifting/verifying binary code (Axe supports JVM, x86, RISC-V and ARM32), proving equivalence (e.g., of program and spec or of two programs) and running "formal unit tests" (small, highly automated proofs about code).