A PVS Theory for Term Rewriting Systems

A mechanical proof of the Knuth---Bendix Critical Pair Theorem in the higher-order language of the theorem prover PVS is described. This well-known theorem states that a Term Rewriting System is locally confluent if and only if all its critical pairs are joinable. The formalization of this theorem follows Huet's well-known structure of proof in which the restriction on strong normalization or Noetherian was dropped and the result presented as a lemma. In order to formalize the Knuth---Bendix Critical Pair Theorem we rely on previously developed PVS theories for abstract reduction systems, named ars, and term rewriting systems, named trs, which were built upon the PVS libraries for finite sequences and sets. On the one hand, the theory trs is composed of subtheories for dealing with the structure of terms, for replacements of subterms and substitutions and jointly with the theory ars it allows for adequate specifications of elaborate notions of term rewriting systems such as the one of critical pairs. On the other hand, ars specifies basic definitions and notions of abstract reduction systems such as reduction, termination, normal forms, and confluence as well as non basic concepts such as strong normalization.

G. Huet and J.J. Levy (INRIA Rep. 359, 1979) showed that for every strongly sequential orthogonal (i.e., left-linear and non-overlapping) term rewriting system, index reduction strategy is normalizing. Their result is extended to overlapping term rewriting systems. It is shown that index reduction is normalizing for the class of strongly sequential left-linear term rewriting systems in which every critical pair can be joined with root balanced reductions. This class includes all weakly orthogonal left-normal systems, for which a leftmost-outermost reduction strategy is normalizing. >

Given a finite set E of multivariate polynomials, the second author's 1965 algorithm constructs a set E' of polynomials such that E and E' generate the same ideal congruence, but E' has the additional property that the congruence can be decided by "reduction to normal forms w.r.t. E'." The two essential ideas of this algorithm are: the consideration of certain "critical pairs" associated with elements in E and the successive "completion" of E by adjoining the difference of normal forms of critical pairs.

Given a term rewriting system R, a term t is inductive reducible if every ground instance ts of it is reducible. A pair (t, s) of terms is inductive co-reducible if every ground instance (ts, ss) of it for which ts and ss are distinct, is reducible. Inductive (co)-reducibility has been proved to be the fundamental tool for mechanizing inductive proofs, together with Knuth-Bendix completion (Jouannaud and Kounalis [JK, 86 and 89]).In [JK, 86 and 89] an algorithm for testing inductive reducibility is also presented which is tractable in pratical cases, but restricted to left-linear term rewriting systems. The solution of the inductive-(co)-reducibility problem, for the general case, turned out to be surprisingly complicated. Decidability of inductive reducibility for arbitrary term rewriting systems has been first proved by Plaisted [PLA, 85] and next by Kapur, Narendran, and Zhang [KNZ, 87]. However Plaisted's and Kapur, Narendran, and Zhang's algorithms amount to intractable computation, even in very simple cases.We present here a new algorithm for the general case which outperforms Plaisted's and Kapur, Narendran and Zhang's algorithms and even our previous algorithm in case of a left-linear term rewriting system. We then show how to adapt it to check for inductive co-reducibility.KeywordsEquationsTerm rewriting systemsProof by consistencyTest SetsGround terms in normal form

We report our first experience in enhancing automated grading in an undergraduate programming course using formal verification. In our experiment, we deploy a program verifier to check the equivalence between student submissions and reference solutions, alongside the existing, testing-based grading infrastructure. We find that we can use the conservative nature of program equivalence checking to our advantage. We were able to use such equivalence to differentiate student submissions according to their high-level program structure, in particular their recursion pattern, even when their input-output behaviour is identical. Consequently, we achieve (1) higher confidence in correctness of idiomatic solutions but also (2) more thorough assessment of solution landscape that reveals solutions beyond those envisioned by instructors.

Superposition or critical pair computation is one of the key operations in the Knuth-Bendix completion procedure and its extensions. We propose a practical technique which can save computation of some critical pairs where the most general unifiers used to generate these critical pairs are less general than the most general unifiers used to generate other joinable critical pairs. Consequently, there is no need to superpose identical subterms at different positions in a rule more than once and there is also no need to superpose symmetric subterms in a rule more than once. The combination of this technique with other critical pair criteria proposed in the literature is also discussed. The technique has been integrated in the completion procedures for ordinary term rewriting systems as well as term rewriting systems with associative-commutative operators implemented in RRL, Rewrite Rule Laboratory. Performance of the completion procedures with and without this technique is compared on a number of examples.KeywordsTheorem ProveAssociative RingCritical PairCanonical SystemAutomate DeductionThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

On abstract normalisation beyond neededness

This paper generalizes the Huet and Lévy theory of normalization by neededness to an abstract setting. We define Stable Deterministic Residual Structures (SDRS) and Deterministic Family Structures (DFS) by axiomatizing some properties of the residual relation and the family relation on redexes in an Abstract Rewriting System. We present two proofs of the Relative Normalization Theorem, one for SDRSs for regular stable sets, and another for DFSs for all stable sets of desirable ‘normal forms’. We further prove the Relative Optimality Theorem for DFSs. We extend this result to deterministic Computation Structures which are deterministic Event Structures with an extra relation expressing self-essentiality.

Regular Ordinals and Normal Forms

This thesis deals with the design and analysis of distributed systems in which homogeneous, autonomous agents collaborate to achieve a common goal. The class of problems studied includes consensus algorithms in which all agents eventually come to an agreement about a specific action. The thesis proposes a framework, called local-global, for analyzing these systems. A local interaction is an interaction among subsets of agents, while a global interaction is one among all agents in the system. Global interactions, in practice, are rare, yet they are the basis by which correctness of a system is measured. For example, if the problem is to compute the average of a measurement made separately by each agent, and all the agents in the system could exchange values in a single action, then the solution is straightforward: each agent gets the values of all others and computes the average independently. However, if the system consists of a large number of agents with unreliable communication, this scenario is highly unlikely. Thus, the design challenge is to ensure that sequences of local interactions lead, or converge, to the same state as a global interaction. The local-global framework addresses this challenge by describing each local interaction as if were a global one, encompassing all agents within the system. This thesis outlines the concept in detail, using it to design algorithms, prove their correctness, and ultimately develop executable implementations that are reliable. To this end, the tools of formal methods are employed: algorithms are modeled, and mechanically checked, within the PVS theorem prover; programs are also verified using the Spin model checker; and interface specification languages are used to ensure local-global properties are still maintained within Java and C# implementations. The thesis presents example applications of the framework and discusses a class of problems to which the framework can be applied.

An invariant based program is a state transition diagram consisting of nested situations (predicates over program variables) and transitions between situations (predicate transformers). Reasoning about correctness is performed in a local fashion by examining each situation at a time and proving that the situation is satisfied for all possible executions. Since the invariants are in place from the beginning and the verification conditions are easily extracted from the diagram there is no need for complicated proof rules, making invariant diagrams a suitable notation for introducing formal verification to students and programmers. Our preliminary experience from using invariant diagrams in the classroom has prompted the need for a tool to support the method: we introduce here SOCOS, an environment for invariant based programming. SOCOS generates correctness conditions based on weakest precondition semantics, and the user can attempt to automatically discharge these conditions using the Simplify theorem prover; conditions which were not automatically discharged can be proved interactively in the PVS theorem prover.

Frame rule for mutually recursive procedures manipulating pointers

On declarative rewriting for sound and complete union, intersection and negation types

Polymorphic Rewriting Conserves Algebraic Confluence

A random context production has a permitting and forbidding context. A symbol can be rewritten using such a production if all the permitting context symbols and no forbidding context symbol appear in the sentential string. In this paper we limit the effect of forbidding context symbols to be within a certain distance from the symbol to be rewritten. Outside this distance the forbidding context symbols do not influence the rewriting of a symbol. This restriction strictly increases the generating power of the rewriting system. A further result of this paper is a “negative parallel” version of Penttonen's normal form.