Papers for

program 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.

Compilers maintain resource-based program logic through compilation

Preserving Separation Logic Specifications through Compilation

Abstract: Program specifications in separation logic describe ownership of resources and serve as logical interfaces for local reasoning. Compiler correctness, expressed as semantics preservation, does not by itself supply such an interface for compiled code, because it does not explicitly relate source and target resources and assertions. We investigate WP-preserving compilation: when a compiler translates a source program, the weakest preconditions that the program satisfies in a separation logic carry over to the compiled program. Our proof technique consists of a resource-aware simulation over interaction trees: it relates the resources required by corresponding source and target events, and tracks ownership through target operations, such as register accesses, that have no source counterpart. We apply the approach to a compiler from a structured imperative language to an assembly-like language, first for closed programs and then extended with modules and function calls. In the extended setting, each module can be verified in the source logic and compiled separately; its specifications carry over to the compiled module and are preserved when compiled modules are linked. All results are mechanized in Rocq.

Tue 27 OctProgramming Languages
The gist
When computer programs are turned into machine code, their detailed rules about how they use resources can be lost, making it hard to check if they still behave correctly. The authors show a way to keep these rules intact during the translation, so that the program’s resource ownership can still be reasoned about after compiling. They develop a mathematical method to track resources precisely and prove it works, even when programs are broken into separate pieces and linked. This helps ensure that verified source code remains trustworthy as compiled machine code.
Open → 2610.37244v1

Complexity of reachability in concurrent register machines with infinite data

Parameterized Reachability for Register Machines with Data

Abstract: We investigate the parameterized reachability problem for concurrent register machines over infinite data domains. In this framework, each machine is a program equipped with a set of local registers, the communication across machines is mediated through a set of shared registers. Both local and shared registers can take values from an infinite data domain. The program's primitive operations include copying values between registers, assigning constants, comparing registers for (dis-)equality, and nondeterministic assignments that store an arbitrary domain value into a local register. The parameterized reachability problem considers a program and a target location, asking whether there exists some n in Naturals such that an execution of n identical machines (referred to as instances) results in at least one instance reaching the specified location. We show that this problem is Pspace-complete in the general case and it becomes undecidable if a freshness assumption (i.e., each assignment must produce a unique value distinct from all constants) is applied to nondeterministic assignments. This undecidability persists even for systems restricted to two shared and two local registers. Finally, we establish optimal decidability results for two restricted settings: when each thread is limited to a single local register, or when the system utilizes only one shared register.

Tue 6 OctFormal Languages and Automata Theory
The gist
The paper studies how to determine if a certain part of a program can be reached when running many copies of the same program that communicate using shared data. The programs use registers that hold values from an infinite set, and they can copy, compare, or randomly assign these values. The authors find that figuring this out is generally possible but can be very hard, and if the programs must always use new unique values when assigning randomly, the problem becomes impossible to solve. They also identify some simpler cases where the problem remains manageable.
Open → 2610.08009v1

Undecidable to find polyhedral invariants in linear programs

The existence of polyhedral invariants is undecidable for linear systems

Abstract: The existence of polyhedral inductive invariants suitable for proving that a given control location is unreachable is undecidable for programs using only linear arithmetic over Z or Q, by reduction from 2-counter machines.

Fri 25 SeptLogic in Computer Science
The gist
Sometimes computer programs need special rules, called invariants, to prove certain parts of the program can never be reached. This paper shows that when programs use only simple math with whole or fractional numbers, it is impossible to always decide if such rules exist. The researchers used a known hard problem involving simple machines with two counters to prove this. This means there are limits to what automatic tools can verify about some programs.
Open → 2609.31146v1

Intuitionistic modal logic shown to have finite model property

Fine Selection for Intuitionistic Modal Logic

Abstract: We extend Fine's selection method to the setting of intuitionistic modal logic and use it to provide a model-theoretic proof that Fischer Servi-style intuitionistic $\sf K4$ has the finite model property.

Tue 22 SeptLogic in Computer Science
The gist
The paper deals with a complex type of logic called intuitionistic modal logic, which combines reasoning about truth and possibility in a certain constructive way. The authors extended a method originally developed by Fine to this type of logic. Using this extension, they provide a mathematical proof that a specific form of this logic called Fischer Servi-style intuitionistic K4 always has a finite model that fits it, which is important for understanding its behavior and how it can be computed or checked. This kind of finite model property is a desirable feature for logical systems.
Open → 2609.27078v1

Undecidable properties stay undecidable under system self-change

The Semantic Elevation Operator and the Closure of the Undecidable Class under Preservation

Abstract: The undecidability of a program's static semantic properties is governed by Rice's theorem. Self-modifying systems, however, require analysing not whether a property holds now, but whether it is preserved when the system rewrites itself. We formalise this transition through a semantic elevation operator ΛΦ, which turns the static question "does x satisfy P?" into the dynamic question "is P preserved after x is transformed by Φ?". We prove that when Φ is intensional (depending on the source code, not only on the computed function), the elevated property remains undecidable even though it breaks the extensionality that Rice's theorem requires; the proof rests on Kleene's recursion theorem, not on Rice. Consequently the class U of non-verifiable properties is closed under the elevation operator. Unbounded iteration of the operator climbs the arithmetical hierarchy -to Π02-completeness- consolidating non-verifiability as a structural fact. We further show that the supervisory regress does not terminate: no fnite tower of increasingly capable verifiers yields an unconditional certificate. A categorical reading of these results in the efective topos, in which elevation appears as an instance of Lawvere's fxed-point theorem, is left as a direction for future work.

Thu 10 SeptLogic in Computer ScienceArtificial IntelligenceComputation and Language
The gist
Some questions about computer programs are impossible to answer no matter what, due to a rule called Rice's theorem. This paper studies what happens when a program can rewrite itself, asking if certain properties stay true after the program changes. The authors show that even when a program changes itself based on its own code, these questions remain impossible to solve. They also prove that building ever more advanced verifiers won't solve this problem completely. Their findings deepen understanding of why certain program properties can never be fully verified.
Open → 2609.11326v1

New method controls complexity in finite graph expression proofs

Width-Bounded Equational Derivations for Finite Graph Expressions

Abstract: Completeness of an equational presentation guarantees an equality path but need not control the resources used along it. For finite graph expressions we measure derivational space by the largest input-output interface of an intermediate raw term. For every finite doubly ranked edge alphabet $Σ$, we prove that equal closed expressions of pattern width at most $k$ are joined by a derivation in which every step applies an equation in either direction and every intermediate width is at most a computable $B_Σ(k)$, independently of graph size. The derivation uses only the structural magmoid laws and the fifteen finite-graphoid schemes. The construction compiles each expression through protected cores and finite routing windows to an encoding-canonical representative $\operatorname{NF}_k$ of width at most $4k+4$. We call this property bounded equational coherence. We also prove $\operatorname{bw}(F)\le\operatorname{patw}(F)\le4(\operatorname{tw}(F)+1)$ whenever the underlying simple graph has at least two edges, separate layered linear from branching expressions on cliques, and provide machine-checkable witnesses and finite invariants for the first five nontrivial clique values.

Tue 8 SeptLogic in Computer Science
The gist
When proving that two expressions representing graphs are equal, it's important to track how complicated the steps between them get. The authors have found a way to measure and limit this complexity by controlling the size of intermediate parts during the proof process. They show that for certain graph expressions, there is always a way to prove equality without the complexity growing uncontrollably, regardless of the overall graph size. This helps keep the proof process more manageable and predictable.
Open → 2609.08325v1