Unification in Matching Logic

Abstract

Matching Logic is a framework for specifying programming language semantics and reasoning about programs. Its formulas are called patterns and are built with variables, symbols, connectives and quantifiers. A pattern is a combination of structural components (term patterns), which must be matched, and constraints (predicate patterns), which must be satisfied. Dealing with more than one structural component in a pattern could be cumbersome because it involves multiple matching operations. A source for getting patterns with many structural components is the conjunction of patterns. Here, we propose a method that uses a syntactic unification algorithm to transform conjunctions of structural patterns into equivalent patterns having only one structural component and some additional constraints. We prove the soundness of our approach, we discuss why the approach is not complete and we provide sound strategies to generate certificates for the equivalences, validated using Coq.

Proof-Carrying Parameters in Certified Symbolic Execution: The Case Study of Antiunification

“…DOMAIN). For the sake of presentation, this axiom does not include the case of the mutual recursive sorts 3 .…”

“…To compute the symbolic successors of a pattern, say t ∧ φ , with respect to a rule, say t 1 ∧ φ 1 ⇒ t 2 ∧ φ 2 , we need to unify the patterns t ∧ φ and t 1 ∧ φ 1 . Because unification can be expressed as a conjunction in ML [2,20], we can say that only the states matched by (t ∧ φ ) ∧ (t 1 ∧ φ 1 ) ≡ (t ∧ t 1 ) ∧ (φ ∧ φ 1 ) transit to states matched by t 2 ∧ φ 2 . Expressing unification as a conjunction (t ∧ t 1 ) is a nice feature of ML, but, in practice, unification algorithms are still needed to compute the general unifying substitution since it is used in symbolic successor patterns.…”

“…In [20], the author shows that unification in ML can be represented as a conjunction of ML patterns. A first step into generating proof objects for unification was done in [2]. We proposed a method to normalise conjunctions of patterns t 1 ∧ t 2 .…”

“…The K implementation works with patterns in normal form t ∧ φ , which are more efficient: matching/unification algorithms are executed only once on normalised patterns, rather than multiple times on patterns having multiple structural components (e.g., t 1 ∧t 2 ). In [2], we use the syntactic unification algorithm [16] to (1) find an equivalent normal form t ∧φ for conjunctions t 1 ∧t 2 , and (2) to generate proof objects for the equivalence between t ∧ φ and t 1 ∧ t 2 . The unification algorithm provides the needed parameters (e.g., unifying substitutions) for proof generation.…”

“…Contributions. A lesson that we learned from [2] and [6] is that the algorithms implemented in various components of K can be used to compute the parameters needed to generate proof objects. In this paper we address the problem of generating proof objects for antiunification, which is used, e.g., in symbolic execution and verification.…”