Theorem Prover Research Articles

Beyond Backtracking: Connections in Fine-Grained Concurrent Separation Logic

Concurrent separation logic has been responsible for major advances in the formal verification of fine-grained concurrent algorithms and data structures such as locks, barriers, queues, and reference counters. The key ingredient of the verification of a fine-grained program is an invariant, which relates the physical data representation (on the heap) to a logical representation (in mathematics) and to the state of the threads (using a form of ghost state). An invariant is typically represented as a disjunction of logical states, but this disjunctive nature makes invariants a difficult target for automated verification. Current approaches roughly suffer from two problems. They use backtracking to introduce disjunctions in an uninformed manner, which can lead to unprovable goals if an appropriate case analysis has not been made before choosing the disjunct. Moreover, they eliminate disjunctions too eagerly, which can cause poor efficiency. While disjunctions are no problem for automated provers based on classical (i.e., non-separating) logic, the challenges with disjunctions are prominent in the study of proof automation for intuitionistic logic. We take inspiration from that area—specifically, based on ideas from connection calculus , we design a simple multi-succedent calculus for separation logic with disjunctions featuring a novel concept of a connection . While our calculus is not complete, it has the advantage that it can be extended with features of the state-of-the-art concurrent separation logic Iris (such as modalities, higher-order quantification, ghost state, and invariants), and can be implemented effectively in the Coq proof assistant with little need for backtracking. We evaluate the practicality on 24 challenging benchmarks, 14 of which we can verify fully automatically.

Nonlinear Program Construction and Verification Method Based on Partition Recursion and Morgan's Refinement Rules

The traditional program refinement strategy cannot be refined to an executable program, and there are issues such as low verification reliability and automation. To solve the above problems, this paper proposes a nonlinear program construction and verification method based on partition recursion and Morgan's refinement rules. First, we use recursive definition technique to characterize the initial specification. The specification is then transformed into GCL(Guarded Command Language) programs using loop invariant derivation and Morgan's refinement rules. Furthermore, VCG (Verification Condition Generator) is used in the GCL program to generate the verification condition automatically. The Isabelle theorem prover then validates the GCL program's correctness. Finally, the GCL code generates a C++ executable program automatically via the conversion system. The effectiveness of this method is demonstrated using binary tree preorder traversal program construction and verification as an example. This method addresses the problem that the construction process's loop invariant is difficult to obtain and the refinement process is insufficiently detailed. At the same time, the method improves verification process automation and reduces the manual verification workload.

A Comprehensive Formalization of Propositional Logic in Coq: Deduction Systems, Meta-Theorems, and Automation Tactics

The increasing significance of theorem proving-based formalization in mathematics and computer science highlights the necessity for formalizing foundational mathematical theories. In this work, we employ the Coq interactive theorem prover to methodically formalize the language, semantics, and syntax of propositional logic, a fundamental aspect of mathematical reasoning and proof construction. We construct four Hilbert-style axiom systems and a natural deduction system for propositional logic, and establish their equivalences through meticulous proofs. Moreover, we provide formal proofs for essential meta-theorems in propositional logic, including the Deduction Theorem, Soundness Theorem, Completeness Theorem, and Compactness Theorem. Importantly, we present an exhaustive formal proof of the Completeness Theorem in this paper. To bolster the proof of the Completeness Theorem, we also formalize concepts related to mappings and countability, and deliver a formal proof of the Cantor–Bernstein–Schröder theorem. Additionally, we devise automated Coq tactics explicitly designed for the propositional logic inference system delineated in this study, enabling the automatic verification of all tautologies, all internal theorems, and the majority of syntactic and semantic inferences within the system. This research contributes a versatile and reusable Coq library for propositional logic, presenting a solid foundation for numerous applications in mathematics, such as the accurate expression and verification of properties in software programs and digital circuits. This work holds particular importance in the domains of mathematical formalization, verification of software and hardware security, and in enhancing comprehension of the principles of logical reasoning.

A Formal Theory of Choreographic Programming

Choreographic programming is a paradigm for writing coordination plans for distributed systems from a global point of view, from which correct-by-construction decentralised implementations can be generated automatically. Theory of choreographies typically includes a number of complex results that are proved by structural induction. The high number of cases and the subtle details in some of these proofs has led to important errors being found in published works. In this work, we formalise the theory of a choreographic programming language in Coq. Our development includes the basic properties of this language, a proof of its Turing completeness, a compilation procedure to a process language, and an operational characterisation of the correctness of this procedure. Our formalisation experience illustrates the benefits of using a theorem prover: we get both an additional degree of confidence from the mechanised proof, and a significant simplification of the underlying theory. Our results offer a foundation for the future formal development of choreographic languages.

The 11th IJCAR automated theorem proving system competition – CASC-J11

The CADE ATP System Competition (CASC) is the annual evaluation of fully automatic, classical logic, Automated Theorem Proving (ATP) systems. CASC-J11 was the twenty-seventh competition in the CASC series. Twenty-four ATP systems competed in the various competition divisions. This paper presents an outline of the competition design and a commentated summary of the results.

Reinforcement Learning for Guiding the E Theorem Prover

Automated Theorem Proving (ATP) systems search for aproof in a rapidly growing space of possibilities. Heuristicshave a profound impact on search, and ATP systems makeheavy use of heuristics. This work uses reinforcement learn-ing to learn a metaheuristic that decides which heuristic to useat each step of a proof search in the E ATP system. Proximalpolicy optimization is used to dynamically select a heuristicfrom a fixed set, based on the current state of E. The approachis evaluated on its ability to reduce the number of inferencesteps used in successful proof searches, as an indicator of in-telligent search.

SAT-Inspired Higher-Order Eliminations

We generalize several propositional preprocessing techniques to higher-order logic, building on existing first-order generalizations. These techniques eliminate literals, clauses, or predicate symbols from the problem, with the aim of making it more amenable to automatic proof search. We also introduce a new technique, which we call quasipure literal elimination, that strictly subsumes pure literal elimination. The new techniques are implemented in the Zipperposition theorem prover. Our evaluation shows that they sometimes help prove problems originating from Isabelle formalizations and the TPTP library.

A Review of Automated Reasoning and Its Applications in the 21st Century.

This article takes a look at the progress and advancement of automated reasoning and its applications in the 21st century. Reasoning refers to the method of reaching logical conclusions. The construction of computing systems that automate this process over some knowledge bases is the focus of automatic reasoning. Automated Reasoning is frequently regarded as a subfield of machine learning. It is also studied in theoretical computer science and philosophy. Some of the applications of automated reasoning include but not limited to Tableau-style systems, Automatic Theorem Proving, Superposition and Saturation, benchmarks and Classical First-Order Logic. The development of formal led to the development of artificial intelligence, which was essential in the development of artificial intelligence for reasoning.

Stateful Protocol Composition in Isabelle/HOL

Communication networks like the Internet form a large distributed system where a huge number of components run in parallel, such as security protocols and distributed web applications. For what concerns security, it is obviously infeasible to verify them all at once as one monolithic entity; rather, one has to verify individual components in isolation. While many typical components like TLS have been studied intensively, there exists much less research on analyzing and ensuring the security of the composition of security protocols. This is a problem since the composition of systems that are secure in isolation can easily be insecure. The main goal of compositionality is thus a theorem of the form: given a set of components that are already proved secure in isolation and that satisfy a number of easy-to-check conditions, then also their parallel composition is secure. Said conditions should of course also be realistic in practice, or better yet, already be satisfied for many existing components. Another benefit of compositionality is that when one would like to exchange a component with another one, all that is needed is the proof that the new component is secure in isolation and satisfies the composition conditions—without having to re-prove anything about the other components. This article has three contributions over previous work in parallel compositionality. First, we extend the compositionality paradigm to stateful systems : while previous approaches work only for simple protocols that only have a local session state, our result supports participants who maintain long-term databases that can be shared among several protocols. This includes a paradigm for declassification of shared secrets . This result is in fact so general that it also covers many forms of sequential composition as a special case of stateful parallel composition. Second, our compositionality result is formalized and proved in Isabelle/HOL, providing a strong correctness guarantee of our proofs. This also means that one can prove, without gaps, the security of an entire system in Isabelle/HOL, namely the security of components in isolation and the composition conditions, and thus derive the security of the entire system as an Isabelle theorem. For the components one can also make use of our tool PSPSP that can perform automatic proofs for many stateful protocols. Third, for the compositionality conditions we have also implemented an automated check procedure in Isabelle.

Proof Automation for Linearizability in Separation Logic

Recent advances in concurrent separation logic enabled the formal verification of increasingly sophisticated fine-grained ( i.e. , lock-free) concurrent programs. For such programs, the golden standard of correctness is linearizability , which expresses that concurrent executions always behave as some valid sequence of sequential executions. Compositional approaches to linearizability (such as contextual refinement and logical atomicity) make it possible to prove linearizability of whole programs or compound data structures ( e.g. , a ticket lock) using proofs of linearizability of their individual components ( e.g. , a counter). While powerful, these approaches are also laborious—state-of-the-art tools such as Iris, FCSL, and Voila all require a form of interactive proof. This paper develops proof automation for contextual refinement and logical atomicity in Iris. The key ingredient of our proof automation is a collection of proof rules whose application is directed by both the program and the logical state. This gives rise to effective proof search strategies that can prove linearizability of simple examples fully automatically. For more complex examples, we ensure the proof automation cooperates well with interactive proof tactics by minimizing the use of backtracking. We implement our proof automation in Coq by extending and generalizing Diaframe, a proof automation extension for Iris. While the old version (Diaframe 1.0) was limited to ordinary Hoare triples, the new version (Diaframe 2.0) is extensible in its support for program verification styles: our proof search strategies for contextual refinement and logical atomicity are implemented as modules for Diaframe 2.0. We evaluate our proof automation on a set of existing benchmarks and novel proofs, showing that it provides significant reduction of proof work for both approaches to linearizability.

Verification-Preserving Inlining in Automatic Separation Logic Verifiers

Bounded verification has proved useful to detect bugs and to increase confidence in the correctness of a program. In contrast to unbounded verification, reasoning about calls via (bounded) inlining and about loops via (bounded) unrolling does not require method specifications and loop invariants and, therefore, reduces the annotation overhead to the bare minimum, namely specifications of the properties to be verified. For verifiers based on traditional program logics, verification is preserved by inlining (and unrolling): successful unbounded verification of a program w.r.t. some annotation implies successful verification of the inlined program. That is, any error detected in the inlined program reveals a true error in the original program. However, this essential property might not hold for automatic separation logic verifiers such as Caper, GRASShopper, RefinedC, Steel, VeriFast, and verifiers based on Viper. In this setting, inlining generally changes the resources owned by method executions, which may affect automatic proof search algorithms and introduce spurious errors. In this paper, we present the first technique for verification-preserving inlining in automatic separation logic verifiers. We identify a semantic condition on programs and prove in Isabelle/HOL that it ensures verification-preserving inlining for state-of-the-art automatic separation logic verifiers. We also prove a dual result: successful verification of the inlined program ensures that there are method and loop annotations that enable the verification of the original program for bounded executions. To check our semantic condition automatically, we present two approximations that can be checked syntactically and with a program verifier, respectively. We implement these checks in Viper and demonstrate that they are effective for non-trivial examples from different verifiers.

Simplifying the axiomatization for ordered affine geometry via a theorem prover

Simplifying the axiomatization for ordered affine geometry via a theorem prover

Interactive theorem provers for university mathematics: an exploratory study of students’ perceptions

Programming is becoming increasingly common in mathematics degrees as it is a desirable skill for new graduates. However, research shows that its use is mostly restricted to computational or modelling tasks. This paper reports a study on students’ perceptions of and difficulties with Lean, an interactive theorem prover introduced as part of a transition to proof first-year module. The data consist of first-year university mathematics students’ questionnaire responses (n = 99) and sections of 37 semi-structured interviews with students from the same cohort. Findings highlight students’ difficulties with syntactic and strategic knowledge, in line with similar research on programming, and how conceptual knowledge is discussed in terms of conceptual-mathematics and conceptual-programming. Moreover, some students share how the experience with Lean changed their perception of mathematics by contributing to the epistemological shift from school to university, which is necessary for students to be successful. However, many students failed to engage with Lean due to its difficult syntax and because they perceived programming to be disconnected from the activity of proving and not worth the time investment needed to become proficient with this tool. We conclude with some reflections on the implications of this study for university teaching and suggestions for future research.

Mechanical Mathematicians

A new generation of automatic theorem provers eliminate bugs in software and mathematics.

RNNCTPs: A neural symbolic reasoning method using dynamic knowledge partitioning technology

Although traditional symbolic reasoning methods are highly interpretable, their application in knowledge graph link prediction is limited due to their low computational efficiency. In this paper, we propose a new neural symbolic reasoning method: RNNCTPs, which improves computational efficiency by re-filtering the knowledge selection of Conditional Theorem Provers (CTPs), and is less sensitive to the embedding size parameter. RNNCTPs is divided into relation selectors and predictors. The relation selectors are trained efficiently and interpretably, so that the whole model can dynamically generate knowledge for the inference of predictor. In all four datasets, this method shows competitive performance against traditional methods on the link prediction task, and can have higher applicability than CTPs on some datasets.

A Rule Based Theorem Prover: an Introduction to Proofs in Secondary Schools

The introduction of automated deduction systems in secondary schools face several bottlenecks. Beyond the problems related with the curricula and the teachers, the dissonance between the outcomes of the geometry automated theorem provers and the normal practice of conjecturing and proving in schools is a major barrier to a wider use of such tools in an educational environment. Since the early implementations of geometry automated theorem provers, applications of artificial intelligence methods, synthetic provers based on inference rules and using forward chaining reasoning are considered to be more suited for education proposes. Choosing an appropriate set of rules and an automated method that can use those rules is a major challenge. We discuss one such rule set and its implementation using the geometry deductive databases method (GDDM). The approach is tested using some chosen geometric conjectures that could be the goal of a 7th year class (approx. 12-year-old students). A lesson plan is presented, its goal is the introduction of formal demonstration of proving geometric theorems, trying to motivate students to that goal

Automated Grading of Automata with ACL2s

Almost all Computer Science programs require students to take a course on the Theory of Computation (ToC) which covers various models of computation such as finite automata, push-down automata and Turing machines. ToC courses tend to give assignments that require paper-and-pencil solutions. Grading such assignments takes time, so students typically receive feedback for their solutions more than a week after they complete them. We present the Automatic Automata Checker (A2C), an open source library that enables one to construct executable automata using definitions that mimic those found in standard textbooks. Such constructions are easy to reason about using semantic equivalence checks, properties and test cases. Instructors can conveniently specify solutions in the form of their own constructions. A2C can check for semantic equivalence between student and instructor solutions and can immediately generate actionable feedback, which helps students better understand the material. A2C can be downloaded and used locally by students as well as integrated into Learning Management Systems (LMS) like Gradescope to automatically grade student submissions and generate feedback. A2C is based on the ACL2s interactive theorem prover, which provides advanced methods for stating, proving and disproving properties. Since feedback is automatic, A2C can be deployed at scale and integrated into massively open online courses.

Proceedings 11th International Workshop on Theorem Proving Components for Educational Software

Proceedings 11th International Workshop on Theorem Proving Components for Educational Software

A Proof Tree Builder for Sequent Calculus and Hoare Logic

We have developed a web-based pedagogical proof assistant, the Proof Tree Builder, that lets you apply rules upwards from the initial goal in sequent calculus and Hoare logic for a simple imperative language. We equipped our tool with a basic proof automation feature and Z3 integration. Students in the automated reasoning course at Princeton University used our tool and found it intuitive. The Proof Tree Builder is available online at https://proof-tree-builder.github.io.

Interactive generation of new knowledge based on automatic means of logical inference

The work relates to the field of knowledge representation and algorithmization of their processing. To describe the subject of consideration by a set of statements and their processing, logical means of the first order type are used. Unlike the well-known achievements in the field of automatic proof (AP) in formal axiomatic theories, the automatic text synthesis of statements is complicated by the poor formalizability of the value of knowledge concept contained in the text. Based on the development of the calculus of positively-formed standardized formulas (pfs-formulas) the possibilities of analysis automation of the description of the subject matter and interactive generation of meaningful statements to improve this description are investigated. The proposed method of interactive knowledge generation integrates the capabilities of AP with algorithmized human-machine synthesis of new knowledge texts. AP in the calculus of pfs-formulas helps a person not only in the analysis of properties, but also in the choice of the required properties of the description of the subject matter. When the absence of a property desirable for a person in the analyzed knowledge is revealed by means of AP, the hypotheses is formed that logically guarantees the presence of the required property. Variants of hypotheses are automatically synthesized in a preliminary form, which are then refined interactively to improve the content of the generated text of new knowledge. The rules of synthesis are justified. Their application continues the inference in situations of inapplicability of the basic rule of inference in the calculus of pfs-formulas. The extension of calculus by the rules of synthesis transforms it as a first-order calculus of the deductive type into a means of deductive-abductive inference, which differs from the known works using abduction by the absence of a number of restrictions. Illustrative examples demonstrate the representation, analysis and generation of knowledge. These examples also show in interactive knowledge processing the importance of visualization of the processed text, provided by the large-block structure of pfs-formulas constructed from typical quantifiers. In conclusion, the results of the paper and possible directions for the development of the results are formulated.