Tactics From Proofs

Proof guarantees the correctness of a formal specification with respect to formal requirements, and of an implementation with respect to a specification, and so provides valuable verification methods in high integrity system development. However, proof development by hand tends to be an erudite, error-prone and seemingly interminable task. Tactics are programs that drive theorem-provers, thus automating proof development and alleviating some of the problems mentioned above. The development of tactics for a particular application domain also extends the domain of application of the theorem-prover. A LCF-tactic is safe in that if it fails to be applicable to a particular conjecture, then it will not produce an incorrect proof. The current construction of tactics from proofs does not yield sufficiently robust tactics. Proofs tend to be specific to the details of a specification and so are not reusable in general, e.g. the same proof may not work when the definition of a conjecture is changed. The major challenges in proof development are deciding which proof rule and instantiations to apply in order to prove a conjecture. Discerning patterns in formal interactive proof development facilitates the construction of robust tactics that can withstand definitional changes in conjectures. Having developed an interactive proof for a conjecture, we develop the necessary abstractions of the proof steps used, to construct a tactic th at can be applicable to other conjectures in that domain. By so doing we encode human expertise used in the proof development, and make proofs robust and thus generally reusable. We apply our theory on the proofs of conjectures involving some set theory operators, and on the proof obligations that arise in the formal development of numerical specifications using the retrenchment method under the IEEE-854 floating-point standard in the PVS theorem-prover/proof-checker

The Computer Modelling of Mathematical Reasoning

xv, 403 p.; 23 cm

A characterization of regular and exact completions of pure existential completions

The notion of existential completion in the context of Lawvere's doctrines was introduced by the second author in his PhD thesis, and it turned out to be a restriction to faithful fibrations of Peter Hofstra's construction used to characterize Dialectica fibrations. The notions of regular and exact completions of elementary and existential doctrines were brought up in recent works by the first author with F. Pasquali and P. Rosolini, inspired by those done by M. Hyland, P. Johnstone and A. Pitts on triposes. Here, we provide a characterization of the regular and exact completions of (pure) existential completions of elementary doctrines by showing that these amount to the $\mathsf{reg}/\mathsf{lex}$ and $\mathsf{ex}/\mathsf{lex}$-completions, respectively, of the category of predicates of their generating elementary doctrines. This characterization generalizes a previous result obtained by the first author with F. Pasquali and P. Rosolini on doctrines equipped with Hilbert's $\epsilon$-operators. Relevant examples of applications of our characterization, quite different from those involving doctrines with Hilbert's $\epsilon$-operators, include the regular syntactic category of the regular fragments of first-order logic (and his effectivization) as well as the construction of Joyal's Arithmetic Universes

Unification in sort theories and its applications

In this article I investigate the properties of unification in sort theories. The usual notion of a sort consisting of a sort symbol is extended to a set of sort symbols. In this language sorted unification in elementary sort theories is of unification type finitary. The rules of standard unification with the addition of four sorted rules form the new sorted unification algorithm. The algorithm is proved sound and complete. The rule based form of the algorithm is not suitable for an implementation because there is no control and the used data structures are weak. Therefore we transform the algorithm into a deterministic sorted unification procedure. For the procedure sorted unification in pseudo-linear sort theories is proved decidable. The notions of a sort and a sort theory are developed in a way such that a standard calculus can be turned into a sorted calculus by replacing standard unification with sorted unification. To this end sorts may denote the empty set. Sort theories may contain clauses with more than one declaration and may change dynamically during the deduction process. The applicability of the approach is exemplified for the resolution and the tableau calculus

Towards automating duality

Dualities between different theories occur frequently in mathematics and logic --- between syntax and semantics of a logic, between structures and power structures, between relations and relational algebras, to name just a few. In this paper we show for the case of structures and power structures how corresponding properties of the two related structures can be computed fully automatically by means of quantifier elimination algorithms and predicate logic theorem provers. We illustrate the method with a large number of examples and we give enough technical hints to enable the reader who has access to the {\sc Otter} theorem prover to experiment herself

Set-Codes with Small Intersections and Small Discrepancies

We are concerned with the problem of designing large families of subsets over a common labeled ground set that have small pairwise intersections and the property that the maximum discrepancy of the label values within each of the sets is less than or equal to one. Our results, based on transversal designs, factorizations of packings and Latin rectangles, show that by jointly constructing the sets and labeling scheme, one can achieve optimal family sizes for many parameter choices. Probabilistic arguments akin to those used for pseudorandom generators lead to significantly suboptimal results when compared to the proposed combinatorial methods. The design problem considered is motivated by applications in molecular data storage and theoretical computer science