Proof Sketches Research Articles

Guided Equality Saturation

Rewriting is a principled term transformation technique with uses across theorem proving and compilation. In theorem proving, each rewrite is a proof step; in compilation, rewrites optimize a program term. While developing rewrite sequences manually is possible, this process does not scale to larger rewrite sequences. Automated rewriting techniques, like greedy simplification or equality saturation, work well without requiring human input. Yet, they do not scale to large search spaces, limiting the complexity of tasks where automated rewriting is effective, and meaning that just a small increase in term size or rewrite length may result in failure. This paper proposes a semi-automatic rewriting technique as a means to scale rewriting by allowing human insight at key decision points. Specifically, we propose guided equality saturation that embraces human guidance when fully automated equality saturation does not scale. The rewriting is split into two simpler automatic equality saturation steps: from the original term to a human-provided intermediate guide , and from the guide to the target. Complex rewriting tasks may require multiple guides, resulting in a sequence of equality saturation steps. A guide can be a complete term, or a sketch containing undefined elements that are instantiated by the equality saturation search. Such sketches may be far more concise than complete terms. We demonstrate the generality and effectiveness of guided equality saturation using two case studies. First, we integrate guided equality saturation in the Lean 4 proof assistant. Proofs are written in the style of textbook proof sketches, as a series of calculations omitting details and skipping steps. These proofs conclude in less than a second instead of minutes when compared to unguided equality saturation, and can find complex proofs that previously had to be done manually. Second, in the compiler of the Rise array language, where unguided equality saturation fails to perform optimizations within an hour and using 60 GB of memory, guided equality saturation performs the same optimizations with at most 3 guides, within seconds using less than 1 GB memory.

Why Is Proof the Only Way to Acquire Mathematical Knowledge?

ABSTRACT This paper proposes an account of why proof is the only way to acquire knowledge of some mathematical proposition’s truth. Admittedly, non-deductive arguments for mathematical propositions can be strong and play important roles in mathematics. But this paper proposes a necessary condition for knowledge that can be satisfied by putative proofs (and proof sketches), as well as by non-deductive arguments in science, but not by non-deductive arguments from mathematical evidence. The necessary condition concerns whether we can justly expect that if the mathematical proposition is actually false, despite the evidence for its truth, then this fact has an explanation.

Graphs defined on groups

‎This paper concerns aspects of various graphs whose vertex set is a group $G$‎ ‎and whose edges reflect group structure in some way (so that‎, ‎in particular‎, ‎they are invariant under the action of the automorphism group of $G$)‎. ‎The‎ ‎particular graphs I will chiefly discuss are the power graph‎, ‎enhanced power‎ ‎graph‎, ‎deep commuting graph‎, ‎commuting graph‎, ‎and non-generating graph‎. ‎My main concern is not with properties of these graphs individually‎, ‎but ‎‎‎‎rather with comparisons between them‎. ‎The graphs mentioned‎, ‎together‎ ‎with the null and complete graphs‎, ‎form a hierarchy (as long as $G$ is‎ ‎non-abelian)‎, ‎in the sense that the edge set of any one is contained in that‎ ‎of the next; interesting questions involve when two graphs in the hierarchy‎ ‎are equal‎, ‎or what properties the difference between them has‎. ‎I also ‎‎‎consider various properties such as universality and forbidden subgraphs‎, ‎comparing how these properties play out in the different graphs‎. ‎I have also included some results on intersection graphs of subgroups of‎ ‎various types‎, ‎which are often in a ``dual'' relation to one of the other‎ ‎graphs considered‎. ‎Another actor is the Gruenberg--Kegel graph‎, ‎or prime graph‎, ‎of a group‎: ‎this very small graph has a surprising influence over various‎ ‎graphs defined on the group‎. ‎Other graphs which have been proposed‎, ‎such as the nilpotence‎, ‎solvability‎, ‎and Engel graphs‎, ‎will be touched on rather more briefly‎. ‎My emphasis is on‎ ‎finite groups but there is a short section on results for infinite groups‎. ‎There are briefer discussions of general $Aut(G)$-invariant graphs‎, ‎and structures other than groups (such as semigroups and rings)‎. ‎Proofs‎, ‎or proof sketches‎, ‎of known results have been included where possible‎. ‎Also‎, ‎many open questions are stated‎, ‎in the hope of stimulating further‎ ‎investigation‎.

A Polynomial-Time Construction of a Hitting Set for Read-Once Branching Programs of Width 3

Recently, an interest in constructing pseudorandom or hitting set generators for restricted branching programs has increased, which is motivated by the fundamental issue of derandomizing space-bounded computations. Such constructions have been known only in the case of width 2 and in very restricted cases of bounded width. In this paper, we characterize the hitting sets for read-once branching programs of width 3 by a so-called richness condition. Namely, we show that such sets hit the class of read-once conjunctions of DNF and CNF (i.e. the weak richness). Moreover, we prove that any rich set extended with all strings within Hamming distance of 3 is a hitting set for read-once branching programs of width 3. Then, we show that any almost O(log n)-wise independent set satisfies the richness condition. By using such a set due to Alon et al. (1992) our result provides an explicit polynomial-time construction of a hitting set for read-once branching programs of width 3 with acceptance probability ɛ > 5/6. We announced this result at conferences more than ten years ago, including only proof sketches, which motivated a number of subsequent results on pseudorandom generators for restricted read-once branching programs. This paper contains our original detailed proof that has not been published yet.

Automatic and efficient variability-aware lifting of functional programs

A software analysis is a computer program that takes some representation of a software product as input and produces some useful information about that product as output. A software product line encompasses many software product variants, and thus existing analyses can be applied to each of the product variations individually, but not to the entire product line as a whole. Enumerating all product variants and analyzing them one by one is usually intractable due to the combinatorial explosion of the number of product variants with respect to product line features. Several software analyses (e.g., type checkers, model checkers, data flow analyses) have been redesigned/re-implemented to support variability. This usually requires a lot of time and effort, and the variability-aware version of the analysis might have new errors/bugs that do not exist in the original one. Given an analysis program written in a functional language based on PCF, in this paper we present two approaches to transforming (lifting) it into a semantically equivalent variability-aware analysis. A light-weight approach (referred to as shallow lifting ) wraps the analysis program into a variability-aware version, exploring all combinations of its input arguments. Deep lifting, on the other hand, is a program rewriting mechanism where the syntactic constructs of the input program are rewritten into their variability-aware counterparts. Compositionally this results in an efficient program semantically equivalent to the input program, modulo variability. We present the correctness criteria for functional program lifting, together with correctness proof sketches of shallow lifting. We evaluate our approach on a set of program analyses applied to the BusyBox C-language product line.

A Structured Argumentation Framework for Modeling Debates in the Formal Sciences

Scientific research in the formal sciences comes in multiple degrees of formality: fully formal work; rigorous proofs that practitioners know to be formalizable in principle; and informal work like rough proof sketches and considerations about the advantages and disadvantages of various formal systems. This informal work includes informal and semi-formal debates between formal scientists, e.g. about the acceptability of foundational principles and proposed axiomatizations. In this paper, we propose to use the methodology of structured argumentation theory to produce a formal model of such informal and semi-formal debates in the formal sciences. For this purpose, we propose ASPIC-END, an adaptation of the structured argumentation framework ASPIC+ which can incorporate natural deduction style arguments and explanations. We illustrate the applicability of the framework to debates in the formal sciences by presenting a simple model of some arguments about proposed solutions to the Liar paradox, and by discussing a more extensive—but still preliminary—model of parts of the debate that mathematicians had about the Axiom of Choice in the early twentieth century.

A contention adapting approach to concurrent ordered sets

With multicores being ubiquitous, concurrent data structures are increasingly important. This article proposes a novel approach to concurrent data structure design where the data structure dynamically adapts its synchronization granularity based on the detected contention and the amount of data that operations are accessing. This approach not only has the potential to reduce overheads associated with synchronization in uncontended scenarios, but can also be beneficial when the amount of data that operations are accessing atomically is unknown.Using this adaptive approach we create a contention adapting search tree (CA tree) that can be used to implement concurrent ordered sets and maps with support for range queries and bulk operations. We provide detailed proof sketches for the linearizability as well as deadlock and livelock freedom of CA tree operations. We experimentally compare CA trees to state-of-the-art concurrent data structures and show that CA trees beat the best of the data structures that we compare against by over 50% in scenarios that contain basic set operations and range queries, outperform them by more than 1200% in scenarios that also contain range updates, and offer performance and scalability that is better than many of them on workloads that only contain basic set operations.

Efficient execution of dynamically controllable simple temporal networks with uncertainty

A simple temporal network with uncertainty (STNU) is a data structure for representing and reasoning about temporal constraints where the durations of certain temporal intervals--the contingent links--are only discovered during execution. The most important property of an STNU is whether it is dynamically controllable (DC)--that is, whether there exists a strategy for executing its time-points that will guarantee that all of its constraints will be satisfied no matter how the durations of the contingent links turn out. The literature on STNUs includes a variety of DC-checking algorithms and execution algorithms. The fastest DC-checking algorithm reported so far is the $$O(N^3)$$O(N3)-time algorithm due to Morris (Integration of AI and OR techniques in constraint programming--11th international conference, CPAIOR 2014, volume 8451 of Lecture Notes in Computer Science. Springer, Berlin, pp 464---479, 2014). The fastest execution algorithm for dynamically controllable STNUs is the $$O(N^3)$$O(N3)-time algorithm due to Hunsberger (Proceedings of the 20th international symposium on temporal representation and reasoning (TIME-2013). IEEE Computer Society, Washington, 2013). This paper begins by providing the first comprehensive, rigorous, and yet streamlined treatment of the theoretical foundations of STNUs, including execution semantics, dynamic controllability, and a set of results that have been collected into what has recently been called the fundamental theorem of STNUs. The paper carefully argues from basic definitions to proofs of the major theorems on which all of the important algorithmic work on STNUs depends. Although many parts of this presentation have appeared in various forms, in various papers, the scattered nature of the STNU literature has allowed too many holes in the theory to persist, and has relied all too often on proof sketches that leave important details unexamined. The presentation combines results from many sources, while also introducing novel approaches and proofs. The paper concludes by presenting a modified version of a recent algorithm for managing the execution of dynamically controllable STNUs, the fastest reported so far in the literature. The modified version organizes its computations more efficiently and corrects an oversight in the original algorithm.

CTL-RP: A computation tree logic resolution prover

In this paper, we present a resolution-based calculus R CTL >,S for Computation Tree Logic (CTL) as well as an implementation of that calculus in the theorem prover CTL-RP. The calculus R CTL >,S requires a transformation of an arbitrary CTL formula to an equi-satisfiable clausal normal form formulated in an extension of CTL with indexed path formulae. The calculus itself consists of a set of resolution rules which can be used for an EXPTIME decision procedure for the satisfiability problem of CTL. We give a formal semantics for the clausal normal form, provide proof sketches for the soundness and completeness of the resolution rules, discuss the complexity of the decision procedure based on R CTL >,S, and present an approach to implementing the calculus R CTL >,S using first-order techniques. Finally, we give a comparison between CTL-RP and a tableau theorem prover for CTL.

Performance Analysis and Functional Verification of the Stop-and-Wait Protocol in HOL

Real-time systems usually involve a subtle interaction of a number of distributed components and have a high degree of parallelism, which makes their performance analysis quite complex. Thus, traditional techniques, such as simulation, or the state-based formal methods usually fail to produce reasonable results. In this paper, we propose to use higher-order-logic (HOL) theorem proving for the performance analysis of real-time systems. The idea is to formalize the real-time system as a logical conjunction of HOL predicates, whereas each one of these predicates define an autonomous component or process of the given real-time system. The random or unpredictable behavior found in these components is modeled as random variables. This formal specification can then be used in a HOL theorem prover to reason about both functional and performance related properties of the given real-time system. In order to illustrate the practical effectiveness of our approach, we present the analysis of the Stop-and-Wait protocol, which is a classical example of real-time systems. The functional correctness of the protocol is verified by proving that the protocol ensures reliable data transfers. Whereas, the average message delay relation is verified in HOL for the sake of performance analysis. The paper includes the protocol’s formalization details along with the HOL proof sketches for the major theorems.

Axiomatizing the Skew Boolean Propositional Calculus

The skew Boolean propositional calculus (\({SBPC}\)) is a generalization of the classical propositional calculus that arises naturally in the study of certain well-known deductive systems. In this article, we consider a candidate presentation of \({SBPC}\) and prove it constitutes a Hilbert-style axiomatization. The problem reduces to establishing that the logic presented by the candidate axiomatization is algebraizable in the sense of Blok and Pigozzi. In turn, this process is equivalent to verifying four particular formulas are derivable from the candidate presentation. Automated deduction methods played a central role in proving these four theorems. In particular, our approach relied heavily on the method of proof sketches.

PVS Strategies for Proving Abstraction Properties of Automata

Abstractions are important in specifying and proving properties of complex systems. To prove that a given automaton implements an abstract specification automaton, one must first find the correct abstraction relation between the states of the automata, and then show that this relation is preserved by all corresponding action sequences of the two automata. This paper describes tool support based on the PVS theorem prover that can help users accomplish the second task, in other words, in proving a candidate abstraction relation correct. This tool support relies on a clean and uniform technique for defining abstraction properties relating automata that uses library theories for defining abstraction relations and templates for specifying automata and abstraction theorems. The paper then describes how the templates and theories allow development of generic, high level PVS strategies that aid in the mechanization of abstraction proofs. These strategies first set up the standard subgoals for the abstraction proofs and then execute the standard initial proof steps for these subgoals, thus making the process of proving abstraction properties in PVS more automated. With suitable supplementary strategies to implement the “natural” proof steps needed to complete the proofs of any of the standard subgoals remaining to be proved, the abstraction proof strategies can form part of a set of mechanized proof steps that can be used interactively to translate high level proof sketches into PVS proofs. Using timed I/O automata examples taken from the literature, this paper illustrates use of the templates, theories, and strategies described to specify and prove two types of abstraction property: refinement and forward simulation.

A Shortest 2-Basis for Boolean Algebra in Terms of the Sheffer Stroke

In this article, we present a short 2-basis for Boolean algebra in terms of the Sheffer stroke and prove that no such 2-basis can be shorter. We also prove that the new 2-basis is unique (for its length) up to applications of commutativity. Our proof of the 2-basis was found by using the method of proof sketches and relied on the use of an automated reasoning program.

A Comparison of Mizar and Isar

The mathematical proof checker Mizar by Andrzej Trybulec uses a proof input language that is much more readable than the input languages of most other proof assistants. This system also differs in many other respects from most current systems. John Harrison has shown that one can have a Mizar mode on top of a tactical prover, allowing one to combine a mathematical proof language with other styles of proof checking. Currently the only fully developed Mizar mode in this style is the Isar proof language for the Isabelle theorem prover. In fact the Isar language has become the official input language to the Isabelle system, even though many users still use its low-level tactical part only. In this paper we compare Mizar and Isar. A small example, Euclid's proof of the existence of infinitely many primes, is shown in both systems. We also include slightly higher-level views of formal proof sketches. Moreover, a list of differences between Mizar and Isar is presented, highlighting the strengths of both systems from the perspective of end-users. Finally, we point out some key differences of the internal mechanisms of structured proof processing in either system.

THE ABC'S of Mice

This is the introductory half of a lecture given at the Association for Symbolic Logic Annual Meeting in Philadelphia in March, 2001. Our goal is to give logicians and advanced students who are unfamiliar with inner model theory a taste of what the subject is about at a level where it is possible to say something meaningful about the intuitions and proofs. At the same time, we wish to avoid overwhelming the reader, so we will leave out many well known closely related theorems and give only short proof sketches. Neither the results nor the proofs found here are due to the author. We will begin near the beginning but still touch on some modern aspects of the theory. The proofs and historical notes that we leave out can be found in the books and articles listed in the references. Our approach to the theory of 0# is a combination of that taken by Dodd in his book and by Steel in his lectures to students. Dodd's introduction is one of the author's favorite essays on inner model theory; another is the introduction to Martin-Steel [6]. In Section 2, we review the theory of 0# in a form that touches on some of the techniques that have been and continue to be generalized. These combine what is commonly called iteration and fine structure. In Section 3, we give a superficial description of what comes after 0#. Those interested in learning about more recent developments in inner model theory are encouraged to see the articles Lowe-Steel [5] and Steel [8], both of which are currently available online at http://www.math.berkeley.edu/~ steel.

Solving Open Questions and Other Challenge Problems Using Proof Sketches

In this article, we describe a set of procedures and strategies for searching for proofs in logical systems based on the inference rule condensed detachment. The procedures and strategies rely on the derivation of proof sketches – sequences of formulas that are used as hints to guide the search for sound proofs. In the simplest case, a proof sketch consists of a subproof – key lemmas to prove, for example – and the proof is completed by filling in the missing steps. In the more general case, a proof sketch consists of a sequence of formulas i>sufficient to find a proof, but it may include formulas that are not provable in the current theory. We find that even in this more general case, proof sketches can provide valuable guidance in finding sound proofs. Proof sketches have been used successfully for numerous problems coming from a variety of problem areas. We have, for example, used proof sketches to find several new two-axiom systems for Boolean algebra using the Sheffer stroke.