Matching logic explained

Abstract

Matching logic was recently proposed as a unifying logic for specifying and reasoning about static structure and dynamic behavior of programs. In matching logic, patterns and specifications are used to uniformly represent mathematical domains (such as numbers and Boolean values), datatypes, and transition systems, whose properties can be reasoned about using one fixed matching logic proof system. In this paper we give a tutorial of matching logic. We use a suite of examples to explain the basic concepts of matching logic and show how to capture many important mathematical domains, datatypes, and transition systems using patterns and specifications. We put emphasis on the general principles of induction and coinduction in matching logic and show how to do inductive and coinductive reasoning about datatypes and codatatypes. To encourage the future tools development for matching logic, we propose and use throughout the paper a human-readable formal syntax to write specifications in a modular and compact way.

Introduction

Matching logic is a unifying logic for specifying and reasoning about static structure and dynamic behavior of programs. It was recently proposed in [1] and further developed in [2], [3]. There exist several equivalent variants of matching logic. In this paper we consider the functional variant, which has a minimal presentation among the others. We refer to this variant as matching logic throughout the paper, abbreviating it as ML.

The key concept of ML is its patterns. Patterns are ML formulas, which are built from variables, constant symbols, a binary application construct, standard FOL constructs ⊥, →, ∃, and a least fixpoint construct μ. In terms of semantics, patterns are interpreted as the sets of elements that match them, which gives ML a pattern matching semantics. For example, $\mathbb{0}$ is a pattern matched by the natural number 0; $\mathbb{1}$ is a pattern matched by 1; $\mathbb{0}\vee \mathbb{1}$ is then a disjunctive¹ pattern matched by 0 and 1, or, to put it another way, an element a matches $\mathbb{0}\vee \mathbb{1}$ iff a matches $\mathbb{0}$ or a matches $\mathbb{1}$. Complex patterns can be built this way to match elements that are of particular structure, have certain dynamic behavior, or satisfy certain logic constraints. We discuss various examples in Sections 3 to 9.

We can use patterns to constrain models, by enforcing the models to match a set of given patterns, called axioms. This set of axioms yields a specification, also called a logical theory. In this paper we will define a variety of specifications, some of them capturing relevant mathematical domains, others datatypes, and others capturing transition systems. We will also show how to build a complex specification in a modular way by importing existing specifications. To present ML specifications rigorously and compactly, we propose a specification syntax in Section 3 that allows us to write specifications in a compact and human-readable way. All ML specifications presented in this paper are written using this syntax.

Our main technical contribution is a collection of complete ML specifications of important datatypes and data structures (including parameterized types, function types, and dependent types), a basic process algebra and its dynamic reduction relation, and the higher-order reasoning about functors and monads in category theory. For each specification, we derive several nontrivial properties using the matching logic proof system; some of these properties require inductive/coinductive reasoning, also supported by ML.

We organize the rest of the paper as follows:

• In Section 2 we define the syntax and semantics of ML.

• In Section 3 we introduce the specification syntax and define the specifications of several important mathematical instruments such as equality, membership, sorts, and functions.

• In Section 4 we explain how patterns are interpreted in ML models.

• In Section 5 we review the Hilbert-style proof system of ML and its soundness theorem.

• In Section 6 we discuss the general principle of induction and coinduction in ML and compare it with the classical principle of (co)induction in complete lattices.

• In Section 7 we give specifications for examples of main data types used in programming languages: simple datatypes (booleans and naturals), parametric types (product, sum, functions, lists, and streams), dependent types (vectors, dependent product, and dependent sum). For each example we present and prove illustrative (co)inductive properties.

• In Section 8 we define a basic process algebra in ML.

• In Section 9 we use ML for higher-order reasoning in category theory and define functors, monads, and comonads as ML specifications.

• In Section 10 we conclude the paper.