Coaxioms: flexible coinductive definitions by inference systems

Formal reasoning about inductively defined relations and structures is widely recognized not only for its mathematical interest but also for its importance in computer science, and has applications in verifying properties of programs and algorithms. Recently, several proof systems of inductively defined predicates based on sequent calculus including the cyclic proof system CLKID-omega and the infinite-descent proof system LKID-omega have attracted much attention. Although the relation among their provabilities has been clarified so far, the logical complexity of these systems has not been much studied. The infinite-descent proof system LKID-omega is an infinite proof system for inductive definitions and allows infinite paths in proof figures. It serves as a basis for the cyclic proof system. This paper shows that the logical complexity of the provability in LKID-omega is (Pi-1-1)-complete. To show this, first it is shown that the validity for inductive definitions in standard models is equivalent to the validity for inductive definitions in standard term models. Next, using this equivalence, this paper extends the truth predicate of omega-languages, as given in Girard's textbook, to inductive definitions by employing arithmetical coding of inductive definitions. This shows that the validity of inductive definitions in standard models is a (Pi-1-1) relation. Then, using the completeness of LKID-omega for standard models, it is shown that the logical complexity of the provability in LKID-omega is (Pi-1-1)-complete.

In this chapter two methods of automatic coloring of the Petri nets supported by formal reasoning using monotone Gentzen calculus are presented. Coloring is used to determine the State Machine subnets. The colors help to validate intuitively and formally consistency of all sequential processes in the considered discrete state model. The first of presented methods is based on determination of exact transversals of the concurrency hypergraph. The second method is based on an examination of the relationship between the sets of minimum siphons and traps. Use of the Gentzen calculus allows to obtain additional information (the proof trees) from the reasoning process. The proof trees represent a formal proof of correctness of the calculation performed during the determination of the State Machine subnets. The methods presented in the chapter can be used in design of the reconfigurable logic controllers.

The vision of automated support for the investigation of logics, proposed decades ago, has been implemented in many forms, producing numerous tools that analyze various logical properties (e.g., cut-elimination, semantics, and more). However, full ‘automation of automated reasoning’ in the sense of automatic generation of efficient provers has remained a ‘holy grail’ of the field. Creating a generic prover which can efficiently reason in a given logic is challenging, as each logic may be based on a different language, and involve different inference rules, that require different implementation considerations to achieve efficiency, or even tractability. Two recently introduced generic automated provers apply different approaches to tackle this challenge. \({\text {MetTeL}}\), based on the formalism of tableaux, automatically generates a prover for a given tableau calculus, by implementing generic proof-search procedures with optimizations applicable to many tableau calculi. \({\text {Gen2sat}}\), based on the formalism of sequent calculi, shifts the burden of search to the realm of off-the-shelf SAT solvers by applying a uniform reduction of derivability in sequent calculi to SAT. This paper examines these two generic provers, focusing in particular on criteria relevant for comparing their performance and usability. To this end, we evaluate the performance of the tools, and describe the results of a preliminary empirical study where user experiences of expert logicians using the two tools are compared.

In call-by-value languages, some mutually-recursive value definitions can be safely evaluated to build recursive functions or cyclic data structures, but some definitions (let rec x = x + 1) contain vicious circles and their evaluation fails at runtime. We propose a new static analysis to check the absence of such runtime failures. We present a set of declarative inference rules, prove its soundness with respect to the reference source-level semantics of Nordlander, Carlsson, and Gill (2008), and show that it can be (right-to-left) directed into an algorithmic check in a surprisingly simple way. Our implementation of this new check replaced the existing check used by the OCaml programming language, a fragile syntactic/grammatical criterion which let several subtle bugs slip through as the language kept evolving. We document some issues that arise when advanced features of a real-world functional language (exceptions in first-class modules, GADTs, etc.) interact with safety checking for recursive definitions.

We present the disconnection tableau calculus, which is a free-variable clausal tableau calculus where variables are treatedin a nonrigidmanner. The calculus essentially consists of a single inference rule, the so-called linking rule, which strongly restricts the possible clauses in a tableau. The method can also be viewed as an integration of the linking rule as used in Plaisted’s linking approach into a tableau format. The calculus has the proof-theoretic advantage that, in the case of a satisfiable formula, one can characterise a model of the formula, a property which most of the free-variable tableau calculi lack. In the paper, we present a rigorous completeness proof and give a procedure for extracting a model from a finitely failed branch.

In proof checkers and theorem provers (e.g. Coq [4] and ProPre [13]) recursive definitions of functions are shown to terminate automatically. In standard non-formalised termination proofs of recursive functions, a decreasing measure is sometimes used. Such a decreasing measure is usually difficult to find.By observing the proof trees of the proofs of termination of recursive functions in ProPre (the system used in Coq’s proofs of termination), [14] finds a decreasing measure which could be used to show termination in the standard non-formalised way. This is important because it establishes a method to find decreasing measures that help in showing termination. As the ProPre system made heavy use of structural rather than inductive rules, an extended more powerful version has been built with new proof trees based on new rules.In this article, we show that the ordinal measures found in [14] lose the decreasing property in the extended ProPre system and then, set out to show that the extended ProPre system will still be suitable for finding measures required by other systems (e.g. NQTHM). We do this by showing that exist other measures that can be associated to the proof trees developed in the extended ProPre system that respect the decreasing property. We also show that the new parameterised measure functions preserve the decreasing property up to a simple condition.

We have attempted to make this bibliography as comprehensive as possible with respect to published works relating to automated reasoning with analytic tableaux. The emphasis has been on the automated aspect rather than the tableaux. The literature published by logicians and philosophers relating to tableaux as a means for demonstrating valid arguments in logic is quite large and such literature, with few exceptions, has not been included in this collection. This leaves us with about 200 entries almost all of which are concerned with the attempts of computer scientists to automate formal reasoning using analytic tableaux and to apply the techniques to various problem areas. The entries have been divided into several categories: Early Work, Books and Proceedings, Classical Logic, Non-Classical Logic, Implementations, and Applications.

This paper compares two different styles of reasoning with inductively defined predicates, each style being encapsulated by a corresponding sequent calculus proof system. The first system supports traditional proof by induction, with induction rules formulated as sequent rules for introducing inductively defined predicates on the left of sequents. We show this system to be cut-free complete with respect to a natural class of Henkin models; the eliminability of cut follows as a corollary. The second system uses infinite (non-well-founded) proofs to represent arguments by infinite descent. In this system, the left rules for inductively defined predicates are simple case-split rules, and an infinitary, global condition on proof trees is required to ensure soundness. We show this system to be cut-free complete with respect to standard models, and again infer the eliminability of cut. The second infinitary system is unsuitable for formal reasoning. However, it has a natural restriction to proofs given by regular trees, i.e. to those proofs representable by finite graphs. This restricted "cyclic" system subsumes the first system for proof by induction. We conjecture that the two systems are in fact equivalent, i.e., that proof by induction is equivalent to regular proof by infinite descent.

graphical sentential logic, the system of alpha graphs, is much more than an historical curiosity. Although a large alpha graph is difficult to manipulate hand, the alpha graphs are admirably suited to automation. In particular, a simple decision procedure for the alpha graphs is tailor-made for the programming language LISP. This decision procedure is described in section I below and is implemented by a LISP program CSProve in section II. Section III gives examples of CSProve as it ran on a desktop computer and indicates how the program is easily adapted to parallel processing. The decision procedure differs from tableau methods and the widely used Robinson resolution method in at least two interesting ways: unlike resolution it does not require that a formula be put into a normal form before the method can be applied, and unlike both tableau methods and resolution it does not require any branching tree constructions. If the method were formulated as a proof procedure in the usual notation it would have only four onepremise inference rules of the form:

The logic FO(ID) uses ideas from the field of logic programming to extend first order logic with non-monotone inductive definitions. This paper studies a deductive inference method for PC(ID), its propositional fragment.We introduce a formal proof system based on the sequent calculus (Gentzen-style deductive system) for this logic. As PC(ID) is an integration of classical propositional logic and propositional inductive definitions, our deductive system integrates inference rules for propositional calculus and definitions.We prove the soundness and completeness of this deductive system for a slightly restricted fragment of PC(ID). We also give a counter-example to show that cut-elimination does not hold in this proof system.

By a semi-formal system we understand a proof system which includes infinitary inference rules. The use of inference rules with infinitely many premises was already suggested by David Hilbert in his paper “Die Grundlegung der elementaren Zahlentheorie” [6] and was later systematically used by Kurt Schutte in his work on proof theory. The heigths of proof trees in a semi-formal system are canonically measured by ordinals. Therefore, in contrast to Gentzen’s original approach, ordinals enter proof theoretic research via semi-formal systems in a completely canonical way.

Existential types provide a simple and elegant foundation for understanding generative abstract data types of the kind supported by the Standard ML module system. However, in attempting to extend ML with support for recursive modules, we have found that the traditional existential account of type generativity does not work well in the presence of mutually recursive module definitions. The key problem is that, in recursive modules, one may wish to define an abstract type in a context where a name for the type already exists, but the existential type mechanism does not allow one to do so. We propose a novel account of recursive type generativity that resolves this problem. The basic idea is to separate the act of generating a name for an abstract type from the act of defining its underlying representation. To define several abstract types recursively, one may first ‘forward-declare’ them by generating their names, and then supply each one's identity secretly within its own defining expression. Intuitively, this can be viewed as a kind of backpatching semantics for recursion at the level of types . Care must be taken to ensure that a type name is not defined more than once, and that cycles do not arise among ‘transparent’ type definitions. In contrast to the usual continuation-passing interpretation of existential types in terms of universal types, our account of type generativity suggests a destination-passing interpretation. Briefly, instead of viewing a value of existential type as something that creates a new abstract type every time it is unpacked, we view it as a function that takes as input a pre-existing undefined abstract type and defines it. By leaving the creation of the abstract type name up to the client of the existential, our approach makes it significantly easier to link abstract data types together recursively.

Existential types provide a simple and elegant foundation for understanding generative abstract data types, of the kind supported by the Standard ML module system. However, in attempting to extend ML with support for recursive modules, we have found that the traditional existential account of type generativity does not work well in the presence of mutually recursive module definitions. The key problem is that, in recursive modules, one may wish to define an abstract type in a context where a name for the type already exists, but the existential type mechanism does not allow one to do so.We propose a novel account of recursive type generativity that resolves this problem. The basic idea is to separate the act of generating a name for an abstract type from the act of defining its underlying representation. To define several abstract types recursively, one may first "forward-declare" them by generating their names, and then define each one secretly within its own defining expression. Intuitively, this can be viewed as a kind of backpatching semantics for recursion at the level of types . Care must be taken to ensure that a type name is not defined more than once, and that cycles do not arise among "transparent" type definitions.In contrast to the usual continuation-passing interpretation of existential types in terms of universal types, our account of type generativity suggests a destination-passing interpretation. Briefly, instead of viewing a value of existential type as something that creates a new abstract type every time it is unpacked, we view it as a function that takes as input a pre-existing undefined abstract type and defines it. By leaving the creation of the abstract type name up to the client of the existential, our approach makes it significantly easier to link abstract data types together recursively.

Our goal is to define a type of partial recursive functions in constructive type theory. In a series of previous articles, we studied two different formulations of partial functions and general recursion. We could obtain a type only by extending the theory with either an impredicative universe or with coinductive definitions. Here we present a new type constructor that eludes such entities of dubious constructive credentials. We start by showing how to break down a recursive function definition into three components: the first component generates the arguments of the recursive calls, the second evaluates them, and the last computes the output from the results of the recursive calls. We use this dissection as the basis for the introduction rule of the new type constructor. Every partial recursive function is associated with an inductive domain predicate; evaluation of the function requires a proof that the input values satisfy the predicate. We give a constructive justification for the new construct by interpreting it into the base type theory. This shows that the extended theory is consistent and constructive.

Cut elimination for a logic with induction and co-induction