Logic is Algebra
Logic really is just algebra, given one uses the right kind of algebra, and the right kind of logic. The right kind of algebra is abstraction algebra, and the right kind of logic is abstraction logic.
cs.LO↗
arXiv subjects
Steven Obua
Publications and source records attributed to Steven Obua.
Abstraction Logic: A New Foundation for (Computer) Mathematics
Abstraction logic is a new logic, serving as a foundation of mathematics. It combines features of both predicate logic and higher-order logic: abstraction logic can be viewed both as higher-order logic minus static types as well as predicate logic plus operators and variable binding. We argue that abstraction logic is the best foundational logic possible because it maximises both simplicity and practical expressivity. This argument is supported by the observation that abstraction logic has simpler terms and a simpler notion of proof than all other general logics. At the same time, abstraction logic can formalise both intuitionistic and classical abstraction logic, and is sound and complete for these logics and all other logics extending deduction logic with equality.
cs.LO↗
Parameterized Local Lexing
Building on the concept of local lexing the concept of parameterized local lexing is introduced.
cs.LO↗
Compiling Purely Functional Structured Programs
We present a marriage of functional and structured imperative programming that embeds in pure lambda calculus. We describe how we implement the core of this language in a monadic DSL which is structurally equivalent to our intended source language and which, when evaluated, generates pure lambda terms in continuation-passing-style.
cs.PL↗
Bootstrapping LCF Declarative Proofs
Suppose we have been sold on the idea that formalised proofs in an LCF system should resemble their written counterparts, and so consist of formulas that only provide signposts for a fully verified proof. To be practical, most of the fully elaborated verification must then be done by way of general purpose proof procedures. Now if these are the only procedures we implement outside the kernel of logical rules, what does the theorem prover look like? We give our account, working from scratch in the ProofPeer theorem prover, making observations about this new setting along the way.
cs.LO↗
Local Lexing
We introduce a novel parsing concept called local lexing. It integrates the classically separated stages of lexing and parsing by allowing lexing to be dependent upon the parsing progress and by providing a simple mechanism for constraining lexical ambiguity. This makes it possible for language design to be composable not only at the level of context-free grammars, but also at the lexical level. It also makes it possible to include lightweight error-handling directly as part of the language specification instead of leaving it up to the implementation. We present a high-level algorithm for local lexing, which is an extension of Earley's algorithm. We have formally verified the correctness of our algorithm with respect to its local lexing semantics in Isabelle/HOL.
cs.LO↗
Social Network Processes in the Isabelle and Coq Theorem Proving Communities
We identify the main actors in the Isabelle and Coq communities and describe how they affect and influence their peers. This work explores selected foundations of social networking analysis that we expect to be useful in the context of the ProofPeer project, which is developing a new model for interactive theorem proving based on collaboration and social interactions.
cs.SI↗
A formal proof of the Kepler conjecture
This article describes a formal proof of the Kepler conjecture on dense sphere packings in a combination of the HOL Light and Isabelle proof assistants. This paper constitutes the official published account of the now completed Flyspeck project.
math.MG↗
ProofPeer: Collaborative Theorem Proving
We define the concept of collaborative theorem proving and outline our plan to make it a reality. We believe that a successful implementation of collaborative theorem proving is a necessary prerequisite for the formal verification of large systems.
cs.LO↗
Capturing Hiproofs in HOL Light
Hierarchical proof trees (hiproofs for short) add structure to ordinary proof trees, by allowing portions of trees to be hierarchically nested. The additional structure can be used to abstract away from details, or to label particular portions to explain their purpose. In this paper we present two complementary methods for capturing hiproofs in HOL Light, along with a tool to produce web-based visualisations. The first method uses tactic recording, by modifying tactics to record their arguments and construct a hierarchical tree; this allows a tactic proof script to be modified. The second method uses proof recording, which extends the HOL Light kernel to record hierachical proof trees alongside theorems. This method is less invasive, but requires care to manage the size of the recorded objects. We have implemented both methods, resulting in two systems: Tactician and HipCam.
cs.LO↗
ProofPeer - A Cloud-based Interactive Theorem Proving System
ProofPeer strives to be a system for cloud-based interactive theorem proving. After illustrating why such a system is needed, the paper presents some of the design challenges that ProofPeer needs to meet to succeed. Contexts are presented as a solution to the problem of sharing proof state among the users of ProofPeer. Chronicles are introduced as a way to organize and version contexts.
cs.MS↗
Syntax and Semantics of Babel-17
We present Babel-17, the first programming language for purely functional structured programming (PFSP). Earlier work illustrated PFSP in the framework of a toy research language. Babel-17 takes this earlier work to a new level by showing how PFSP can be combined with pattern matching, object oriented programming, and features like concurrency, lazy evaluation, memoization and support for lenses.
cs.PL↗
Purely Functional Structured Programming
The idea of functional programming has played a big role in shaping today's landscape of mainstream programming languages. Another concept that dominates the current programming style is Dijkstra's structured programming. Both concepts have been successfully married, for example in the programming language Scala. This paper proposes how the same can be achieved for structured programming and PURELY functional programming via the notion of LINEAR SCOPE. One advantage of this proposal is that mainstream programmers can reap the benefits of purely functional programming like easily exploitable parallelism while using familiar structured programming syntax and without knowing concepts like monads. A second advantage is that professional purely functional programmers can often avoid hard to read functional code by using structured programming syntax that is often easier to parse mentally.
cs.PL↗
A revision of the proof of the Kepler conjecture
The Kepler conjecture asserts that no packing of congruent balls in three-dimensional Euclidean space has density greater than that of the face-centered cubic packing. The original proof, announced in 1998 and published in 2006, is long and complex. The process of revision and review did not end with the publication of the proof. This article summarizes the current status of a long-term initiative to reorganize the original proof into a more transparent form and to provide a greater level of certification of the correctness of the computer code and other details of the proof. A final part of this article lists errata in the original proof of the Kepler conjecture.
math.MG↗