Traditional Calculi Research Articles

Sequent-type rejection systems for finite-valued non-deterministic logics

A rejection system, also referred to as a complementary calculus, is a proof system axiomatising the invalid formulas of a logic, in contrast to traditional calculi which axiomatise the valid ones. Rejection systems therefore introduce a purely syntactic way of determining non-validity without having to consider countermodels, which can be useful in procedures for automated deduction and proof search. Rejection calculi have first been formally introduced by Łukasiewicz in the context of Aristotelian syllogistic and subsequently rejection systems for many well-known logics have been proposed. In this paper, we deal with rejection systems for so-called non-deterministic finite-valued logics, a special case of non-deterministic many-valued logics which were introduced by Avron and Lev as a generalisation of traditional many-valued logics. More specifically, we introduce a systematic method for constructing sequent-style rejection systems for any given non-deterministic finite-valued logic. Furthermore, as special instances of our method, we provide concrete calculi for specific paraconsistent logics which can be characterised in terms of non-deterministic two- and three-valued semantics, respectively.

Distilling abstract machines

It is well-known that many environment-based abstract machines can be seen as strategies in lambda calculi with explicit substitutions (ES). Recently, graphical syntaxes and linear logic led to the linear substitution calculus (LSC), a new approach to ES that is halfway between small-step calculi and traditional calculi with ES. This paper studies the relationship between the LSC and environment-based abstract machines. While traditional calculi with ES simulate abstract machines, the LSC rather distills them: some transitions are simulated while others vanish, as they map to a notion of structural congruence. The distillation process unveils that abstract machines in fact implement weak linear head reduction, a notion of evaluation having a central role in the theory of linear logic. We show that such a pattern applies uniformly in call-by-name, call-by-value, and call-by-need, catching many machines in the literature. We start by distilling the KAM, the CEK, and a sketch of the ZINC, and then provide simplified versions of the SECD, the lazy KAM, and Sestoft's machine. Along the way we also introduce some new machines with global environments. Moreover, we show that distillation preserves the time complexity of the executions, i.e. the LSC is a complexity-preserving abstraction of abstract machines.

A Noncommutative Algebraic Operational Calculus for Boundary Problems

We set up a left ring of fractions over a certain ring of boundary problems for linear ordinary differential equations. The fraction ring acts naturally on a new module of generalized functions. The latter includes an isomorphic copy of the differential algebra underlying the given ring of boundary problems. Our methodology employs noncommutative localization in the theory of integro-differential algebras and operators. The resulting structure allows to build a symbolic calculus in the style of Heaviside and Mikusinski, but with the added benefit of incorporating boundary conditions where the traditional calculi allow only initial conditions. Admissible boundary conditions include multiple evaluation points and nonlocal conditions. The operator ring is noncommutative, containing all integrators initialized at any evaluation point.

Interactive Theorem Proving with Tasks

Interactive theorem proving systems for mathematics require user interfaces which allow for user interaction that is as natural as possible. However, this interaction is often limited by the traditional calculi underlying most theorem proving systems. This is particularly problematic with respect to the application of assertions and intuitive presentation of proof states. In this paper we show how a more flexible user interaction can be realized when traditional calculi for classical logic are replaced by a less restrictive reasoning engine, the recently developed CORE [2] system. We describe the task level which is built on top of the CORE system and combines the Proof by Pointing approach [5] with a flexible mechanism for the application of assertions that avoids decomposition and abstracts from the syntactical form of an assertion. We demonstrate how proof steps that are difficult to implement in other systems, like forward application of assertions, are quite naturally supported by the underlying CORE system and are therefore straightforward to realize at the task level.