Reducing Total Correctness to Partial Correctness by a Transformation of the Language Semantics

TL;DR

This paper presents a language-parametric method to automatically reduce total correctness verification to partial correctness verification using rewrite theories, demonstrated with a prototype implementation on the RMT tool.

Contribution

It introduces a novel, language-parametric transformation that simplifies total correctness proofs by leveraging partial correctness, applicable to semantics given as rewrite theories.

Findings

Prototype implementation on RMT tool successfully verified several examples.

The approach effectively reduces total correctness to partial correctness.

Demonstrates practical applicability of the transformation in real-world scenarios.

Abstract

We give a language-parametric solution to the problem of total correctness, by automatically reducing it to the problem of partial correctness, under the assumption that an expression whose value decreases with each program step in a well-founded order is provided. Our approach assumes that the programming language semantics is given as a rewrite theory. We implement a prototype on top of the RMT tool and we show that it works in practice on a number of examples.

Equations

$$\begin{array}[]{llr}\mathit{Id}::=&{\tt x}\mid{\tt y}\mid{\tt z}\mid\ldots&\textit{identifiers (program variables)}\\ \mathit{Int}::=&0,1,-1,\ldots&\textit{integers}\\ \mathit{Bool}::=&\mathit{True}\mid\mathit{False}&\textit{booleans}\\ \mathit{AE}::=&\mathit{Int}\mid\mathit{Id}\mid\mathit{AE}+\mathit{AE}\mid\ldots&\textit{arithmetic expressions}\\ \mathit{BE}::=&\mathit{Bool}\mid\mathit{AE}=\mathit{AE}\mid\mathit{AE}<\mathit{AE}\mid\mbox{$\mathit{not}$ $\mathit{BE}$}\mid\ldots&\textit{boolean expressions}\\ \mathit{Stmt}::=&\mathit{skip}&\textit{empty statement}\\ &\mid\mbox{$\mathit{Stmt}$; $\mathit{Stmt}$}&\textit{sequence of statements}\\ &\mid\mbox{$\mathit{Id}$ := $\mathit{AE}$}&\textit{assignment}\\ &\mid\mbox{while $\mathit{BE}$ do $\mathit{Stmt}$}&\textit{while loop}\\ &\mid\mbox{if $\mathit{BE}$ then $\mathit{Stmt}$ else $\mathit{Stmt}$}&\textit{conditional statement}\\ \end{array}$$

$$\begin{array}[]{lclr}\langle(v:=i)\rightsquigarrow l\;|\;\mathit{env}\rangle&\Rightarrow&\langle l\;|\;\mathit{update}(v,i,\mathit{env})\rangle&\mbox{ and }\\ \langle\mbox{(if $b$ then $s_{\_}1$ else $s_{\_}2$)}\rightsquigarrow l\;|\;\mathit{env}\rangle&\Rightarrow&\langle s_{\_}1\rightsquigarrow l\;|\;\mathit{env}\rangle\mbox{ if $b=\mathit{True}$},&\end{array}$$

$$S⊢l\wedge {\varphi }_{\_}l{\Rightarrow }^{\forall }\exists \tilde{x}.(r\wedge {\varphi }_{\_}r),$$

$$\begin{array}[]{l}S\vdash\langle\textit{SUM}\;|\;\mathit{env}_{\_}1\rangle\land\mathit{lookup}({\tt m},\mathit{env}_{\_}1)=z\land z\geq 0\Rightarrow^{\forall}\\ \qquad\exists\mathit{env}_{\_}2.(\langle\mathit{skip}\;|\;\mathit{env}_{\_}2\rangle\land\mathit{lookup}({\tt s},\mathit{env}_{\_}2)=z(z+1)/2),\end{array}$$

$$\begin{array}[]{l}S\vdash\langle\textit{SUM}\;|\;\mathit{env}_{\_}1\rangle\land\mathit{lookup}({\tt m},\mathit{env}_{\_}1)=z\Rightarrow^{\forall}\\ \qquad\exists\mathit{env}_{\_}2.(\langle\mathit{skip}\;|\;\mathit{env}_{\_}2\rangle\land\mathit{lookup}({\tt s},\mathit{env}_{\_}2)=z(z+1)/2)\end{array}$$

$$\begin{array}[]{lclr}(\langle(v:=i)\rightsquigarrow l\;|\;\mathit{env}\rangle,n)&\Rightarrow&(\langle l\;|\;\mathit{update}(v,i,\mathit{env})\rangle,n-1)&\mbox{ and }\\ (\langle\mbox{(if $b$ then $s_{\_}1$ else $s_{\_}2$)}\rightsquigarrow l\;|\;\mathit{env}\rangle,n)&\Rightarrow&(\langle s_{\_}1\rightsquigarrow l\;|\;\mathit{env}\rangle,n-1)\mbox{ if $b=\mathit{True}$}.&\end{array}$$

$$\begin{array}[]{l}\theta(S)\vdash(\langle\textit{SUM}\;|\;\mathit{env}_{\_}1\rangle,200|z|+200)\land\mathit{lookup}({\tt m},\mathit{env}_{\_}1)=z\land z\geq 0\Rightarrow^{\forall}\\ \qquad\exists g,\mathit{env}_{\_}2.((\langle\mathit{skip}\;|\;\mathit{env}_{\_}2\rangle,g)\land\mathit{lookup}({\tt s},\mathit{env}_{\_}2)=z(z+1)/2),\end{array}$$

$$\begin{array}[]{l}\theta(S)\vdash(\langle\textit{SUM}\;|\;\mathit{env}_{\_}1\rangle,B)\land\mathit{lookup}({\tt m},\mathit{env}_{\_}1)=z\Rightarrow^{\forall}\\ \qquad\exists g,\mathit{env}_{\_}2.((\langle\mathit{skip}\;|\;\mathit{env}_{\_}2\rangle,g)\land\mathit{lookup}({\tt s},\mathit{env}_{\_}2)=z(z+1)/2),\end{array}$$

$$\begin{array}[]{l}\langle\llbracket\mathit{seq}(\mathit{assign(s,\overline{\mbox{$0$}})},\\ \phantom{\langle\llbracket\mathit{seq}(}\mathit{while}(not(eq(\overline{0},[m])),\mathit{seq}(\mathit{assign}(s,\mathit{plus}([s],[m])),\\ \phantom{\langle\llbracket\mathit{seq}(\mathit{while}(not(eq(\overline{0},[m])),\mathit{seq}(}\mathit{assign}(m,\mathit{plus}([m],\overline{-1})))))\rrbracket\rightsquigarrow\mathit{Nil}\;|\;\epsilon\rangle.\end{array}$$

$$⟨[[while(C,skip)]]⇝Nil|ϵ⟩\text{mbox},whereC\in {Var}_{\_}BE.$$

$$\begin{array}[]{c}\langle\llbracket\mathit{while}(\llceil\underline{\mathit{True}}\rrceil,\mathit{skip})\rrbracket\rightsquigarrow\mathit{Nil}\;|\;\epsilon\rangle\Rightarrow^{\mathcal{T}}_{S}\\ \langle\llbracket\mathit{ite}(\llceil\underline{\mathit{True}}\rrceil,\mathit{seq}(\mathit{skip},\mathit{while}(\llceil\underline{\mathit{True}}\rrceil,\mathit{skip})),\mathit{skip})\rrbracket\rightsquigarrow T\;|\;\epsilon\rangle\Rightarrow^{\mathcal{T}}_{S}\cdots\\ \langle\llbracket\mathit{while}(\llceil\underline{\mathit{True}}\rrceil,\mathit{skip})\rrbracket\rightsquigarrow\mathit{Nil}\;|\;\epsilon\rangle\Rightarrow^{\mathcal{T}}_{S}\cdots\end{array}$$

$$\theta (S)\models \theta (\phi ,s){\Rightarrow }^{\forall }\exists M.\theta ({\phi }^{\prime },M),$$

$$\begin{array}[]{l}\theta(S)\vdash(\langle\textit{SUM}\;|\;\mathit{env}_{\_}1\rangle,200|z|+200)\land\mathit{lookup}(m,\mathit{env}_{\_}1)=z\land z\geq 0\Rightarrow^{\forall}\\ \qquad\exists M,\mathit{env}_{\_}2.((\langle\mathit{skip}\;|\;\mathit{env}_{\_}2\rangle,M)\land\mathit{lookup}(s,\mathit{env}_{\_}2)=z(z+1)/2),\end{array}$$

$$\frac{\text{vbox}\models \phi \to \underset{\_}{\bigvee }{\phi }_{\_}l{\Rightarrow }^{\exists }{\phi }_{\_}r\in S\exists FreeVars({\phi }_{\_}l){\phi }_{\_}l\models \exists c(\phi [c/\square ]\wedge {\phi }_{\_}l[c/\square ])\wedge {\phi }_{\_}r\to {\phi }^{\prime }\text{ for all }{\phi }_{\_}l{\Rightarrow }^{\exists }{\phi }_{\_}r\in S\text{vbox}\models \exists c(\phi [c/\square ]\wedge {\phi }_{\_}l[c/\square ])\wedge {\phi }_{\_}r\to {\phi }^{\prime }\text{ for all }{\phi }_{\_}l{\Rightarrow }^{\exists }{\phi }_{\_}r\in S\text{vbox}}{\text{vbox}\text{vbox}\mathcal{S},\mathcal{A}{⊢}_{\_}\mathcal{C}\phi {\Rightarrow }^{\forall }{\phi }^{\prime }}$$

$$\theta (S)⊢([0,n],n){\Rightarrow }^{\forall }{\phi }_{\_}R,$$

Full text

1 Introduction

The line of work on reachability logic (see [23, 21, 22, 15, 16]) proposes language-parametric verification tools for programs. We continue this line of work by introducing a language-parametric total correctness checker. Our checker works by reducing the problem of total correctness to the problem of partial correctness by a transformation of the semantics of the programming language.

A program is partially correct if its output satisfies the postcondition for all inputs on which it terminates. A program is totally correct if it terminates on all inputs and its output satisfies the postcondition. Therefore, total correctness is usually proven by splitting the problem into two parts: first establish partial correctness by using various Hoare-like logics (e.g., [8, 16]), and then establish termination using a specialized termination prover (e.g., [18, 2]).

More rarely, logics that can directly prove total correctness (e.g., [26, 20]) are used. However, recent work in automated termination proving (e.g., [6, 4, 14, 7, 13]) shows that it is beneficial to use information obtained by proving properties of a program (e.g., invariants) in the termination argument. Most formal verification tools $V$ take a (possibly annotated) program $P$ as input and return $V(P)$, which is yes if the verification is successful and no if there is a counterexample; additionally, because such problems are typically undecidable, the verifier could return unknown or it could loop indefinitely. In this setting, if the programming language of $P$ changes (e.g., when a new language standard is published), the verifier $V$ needs to be upgraded as well and also proved sound – which may not be trivial. Another downside of this approach is that the same verification techniques need to be implemented and proved sound for all languages of interest.

In our line of work (see [23, 21, 22, 15, 16]), we propose to build language-parametric verifiers $V$: in this parametric setting, $V$ takes as input both the (possibly annotated) program $P$ and the operational semantics $S$ of the programming language of $P$. Then $V(S,P)$ returns yes, no or unknown (or loops indefinitely), depending on the particular property that it checks of the program $P$ in the operational semantics $S$. The advantage of this approach is that the verifier is proved sound once and can then be used for various programming languages.

Reachability logic, which is a sound and relatively complete proof system for partial correctness, was introduced in [15]. For a verifier $V$ that implements this logic, $V(S,P)$ checks whether the (annotated) program $P$ is partially correct, when interpreted using the operational semantics $S$. In the present article, we propose to construct a language-parametric verifier $V_{\_}t(S,P)$ that checks total correctness of the program $P$ in the operational semantics $S$. Our approach works by applying a transformation on $S$ and the program $P$. We develop and prove the soundness of a transformation function $\theta$ such that $V_{\_}t(S,P)=V(\theta(S),\theta(P)).$ This means that total correctness of the program $P$ in the semantics $S$ is the same as partial correctness of the program $\theta(P)$ in the semantics $\theta(S)$ and therefore the existing partial correctness verifier can be used in conjunction with the transformation $\theta$ to obtain a total correctness prover for any language.

Our approach assumes that the operational semantics $S$ of the language in question is given as a rewrite theory with rules of the form

$l\Rightarrow r\mbox{ if }b$,

where $l$ and $r$ are two terms representing program configurations and $b$ is a boolean constraint. For our running example, we use a simple imperative language that we call IMP (see, e.g., [27]), whose abstract syntax is presented in Figure 1. IMP configurations are pairs $\langle c_{\_}1\rightsquigarrow c_{\_}2\rightsquigarrow\cdots\rightsquigarrow c_{\_}n\rightsquigarrow\mathit{Nil}\;|\;\mathit{env}\rangle$ where $c_{\_}1,c_{\_}2,\ldots,c_{\_}n$ is a list of expressions or statements that are to be evaluated/executed in order and $\mathit{env}$ is a map from program identifiers (program variables) to integers. The notation $\mathit{Nil}$ stands for the empty list. The semantics of IMP consists of rewrite rules like

[TABLE]

which define the meaning of all language operators. The two rules above illustrate parts of the semantics of the assignment statement and of the if-then-else statement, respectively. The full details on the syntax and semantics of IMP are formally given in Section 2. However, we note that it is possible to faithfully model a variety of languages in this manner, as shown in [25]. Given a language semantics $S$ as a parameter, reachability logic (defined in [15]) can prove sequents of the form

[TABLE]

where $l$ and $r$ are configuration terms and $\phi_{\_}l,\phi_{\_}r$ are constraints. The intuitive meaning of a sequent is that any instance of the configuration $l$ satisfying constraint $\phi_{\_}l$ either diverges (does not terminate) or it reaches (along any path, hence the $\forall$) in a finite number of steps an instance of the configuration $r$ satisfying constraint $\phi_{\_}r$ and agreeing with $l$ on all variables except $\tilde{x}$. The full syntax and semantics of the sequents are presented formally in Section 2. Note that such sequents subsume the notion of partial correctness. For example, the partial correctness of the SUM program

s := 0 while not (m = 0) do s := s + m; m := m - 1

is represented by the following partial correctness sequent

[TABLE]

which is derivable using reachability logic. The sequent states that if we run the SUM program in a configuration where the environment $\mathit{env}_{\_}1$ maps the program identifier ${\tt m}$ to a positive integer $z$, then the program eventually reaches a configuration where there is nothing left to execute (hence the $\mathit{skip}$) and where the identifier ${\tt s}$ is mapped to the sum of the first $z$ positive naturals. The sequent

[TABLE]

is also derivable (note that the constraint $z\geq 0$ does not appear anymore). The sequent is valid when interpreted in a partial correctness sense, since the program loops forever when $z<0$. We propose a language transformation that builds an artificial semantics $\theta(S)$ from the semantics $S$ by adding to the configuration a parameter that decreases with each rewrite step. The formal expression that is used for the parameter is a program variant (i.e., an expression whose value decreases with each program step). For example, the previously illustrated rewrite rules for the assignment statement and respectively for the conditional statement become:

[TABLE]

In the new semantics, $\theta(S)$, all programs terminate, since the variant is in a well-founded order and therefore it cannot decrease indefinitely. Therefore, in order to prove total correctness of a program $P$ in $S$, it is sufficient to prove partial correctness of $(P,B)$ in $\theta(S)$, where $B$ is a sufficiently large bound. For our running example, we can establish that

[TABLE]

which implies by our soundness theorem that SUM is totally correct, under the precondition that the program variable ${\tt m}$ starts with a nonnegative value. We have chosen the upper bound $200|n|+200$, since it is sufficiently large to allow for the program to finish. The variable $g$ captures the number of execution steps remaining from the initial $200|n|+200$ steps. The sequent above can be proven automatically (by relying on an invariant-like annotation for the while loop) in our implementation. However, by our soundness theorem, there is no bound $B$ such that

[TABLE]

meaning that it is impossible to prove the total correctness of the program SUM if there is no precondition for the initial value of the program variable ${\tt m}$.

In contrast with some other automated termination provers (discussed in Section 4), our method requires to provide the upper bound on the number of steps manually. In the example above, we picked $200|n|+200$ because, intuitively, the program has a linear-time complexity. The constant $200$ should be large enough to allow the program to terminate.

The advantage and novelty of our method is that it is language-parametric (the semantics of the language is given as an input to our reduction). The main technical difficulties are to find a sound but general enough transformation $\theta$ (given in Definition 3.3) and the right statement of the soundness theorem (Theorem 3.1).

Contributions.

We propose a language-parametric method of proving total correctness; 2. 2.

Our approach works by reducing total correctness to partial correctness using a language transformation and therefore it can also be seen as an argument for semantics-parametric program verifiers; 3. 3.

We implement the reduction in the RMT [11] tool and we use it to prove several interesting examples.

Organization.

In Section 2, we briefly introduce our notations for many-sorted algebras and we recall matching logic and reachability logic, which are the formalisms that we use to define and reason about the operational semantics of languages. In Section 3, we present our transformation, which reduces total correctness to partial correctness, we prove its soundness and we present the main difficulties. Section 4 discusses related work and Section 5 concludes the paper, including possible directions for future work.

2 Preliminaries: Proving Partial Correctness using Reachability

Logic

This section fixes notations for many-sorted algebra and recalls matching logic and reachability logic.

We denote by ${S}^{*}$ the set of ordered tuples, possibly empty, with elements in $S$; we say that a set $T$ is $S$-indexed if $T=\left\{T_{\_}s\;|\;s\in S\right\}$ is a collection of sets, each one corresponding to a different item in $S$. For ease of notation, we sometimes write $x\in T$ instead of $x\in T_{\_}s$ when $s$ is clear from context. A many-sorted signature $\Sigma$ is an ordered pair $\Sigma=(S,F)$, where $S$ is the set of sorts, and $F=\left\{F_{\_}{w,s}\;|\;w\in{S}^{*},s\in S\right\}$ is the $({S}^{*}\times S)$-indexed set of function symbols. If $f\in F_{\_}{w,s}$, we say that $f$ is a function symbol of arity $(w,s)$. If $w=(s_{\_}1,\ldots,s_{\_}n)$, we sometimes write $f:s_{\_}1,\ldots,s_{\_}n\rightarrow s$ instead of $f\in F_{\_}{w,s}$, which indicates that the function symbol $f$ has arguments of sorts $s_{\_}1,\ldots,s_{\_}n$ and a result of sort $s$ ($f\in F_{\_}{w,s}$).

A $\Sigma$-algebra is a pair $\mathcal{A}=(A,I_{\_}A)$, where $A=\left\{A_{\_}s\;|\;s\in S\right\}$ is an $S$-indexed set called the carrier set of $\mathcal{A}$ and $I_{\_}A(f)$ is a function, $I_{\_}A(f):A_{\_}{s_{\_}1}\times\ldots\times A_{\_}{s_{\_}n}\rightarrow A_{\_}{s}$, for all $f\in F_{\_}{(s_{\_}1,\ldots,s_{\_}n),s}$. That is, the interpretation map $I_{\_}A$ assigns to each function symbol in $F$ a function of the appropriate arity. For convenience, we sometimes refer to the algebra $\mathcal{A}$ as a set, in which case we mean its carrier set $A$. We assume as usual that $A_{\_}s\not=\emptyset$ for any $s\in S$. Given an $S$-indexed set of symbols $\mathit{Var}$, we denote by $\mathit{Term}_{\_}{\Sigma,s}(\mathit{Var})$ the set of terms of sort $s$ built with function symbols in $\Sigma$ and variables in $\mathit{Var}$ and by $\mathit{Term}_{\_}{\Sigma}(\mathit{Var})$ the $S$-indexed set of all terms with variables in $\mathit{Var}$. Given a $\Sigma$-algebra $\mathcal{A}$ with carrier set $A=\left\{A_{\_}s\;|\;s\in S\right\}$, a valuation $\rho:\bigcup_{\_}{s\in S}\mathit{Var}_{\_}s\rightarrow\bigcup_{\_}{s\in S}A_{\_}s$ is a function that assigns to each variable an element in $A$ of the appropriate sort. Valuations extend homomorphically to terms as usual. We now recall matching logic, as introduced in [15]. Fix an algebraic signature $\Sigma=(S,F)$ with a distinguished sort $\mathit{Cfg}\in S$ called the sort of configurations, an $S$-indexed set of variables $\mathit{Var}$ and a $\Sigma$-algebra $\mathcal{T}$ with carrier set $T$. $T$ is called the configuration model. The elements of the algebra $\mathcal{T}$ of sort $\mathit{Cfg}$, denoted by $\mathcal{T}_{\_}{\mathit{Cfg}}$, are called configurations. Matching logic is a logic of program configurations.

Example 2.1**.**

We consider a running example where the elements of $\mathcal{T}$ of sort $\mathit{Cfg}$ are programs, running in an environment, written in a simple imperative language that we call IMP. We work in the signature $(S,\Sigma)$, where $S=\{\mathit{Int},\mathit{Bool},\mathit{AE},\mathit{BE},\mathit{Id},\mathit{Stmt},\mathit{Stack},\mathit{Env},\mathit{Cfg},\mathit{Code}\}$ and where the function symbols in $\Sigma$ are presented in Figure 2. The first set of symbols is used to represent the syntax of IMP programs. The second set of symbols is required to represent configurations, which consist of a stack of code to be executed/evaluated, and an environment mapping identifiers to integers. The third set of symbols represents mathematical operations. The last set consists of several auxiliary symbols, which are necessary to specify the rules of the operational semantics. For brevity, not all operators are presented; there are additional operations for less-than, boolean connectives, etc. The sorts $\mathit{Int}$ and $\mathit{Bool}$ are interpreted by mathematical integers and booleans, respectively. The sorts $\mathit{AE}$, $\mathit{BE}$ and $\mathit{Stmt}$ are the sorts for arithmetic expressions, boolean expressions and statements, respectively. The sort $\mathit{Id}$ is for program identifiers (program variables). There are injections $\llfloor\cdot\rrfloor$, $\llceil\cdot\rrceil$ and $\llbracket\cdot\rrbracket$ from $\mathit{AE}$, $\mathit{BE}$ and $\mathit{Stmt}$, respectively, into the sort $\mathit{Code}$. Therefore $\mathit{Code}$ refers to either arithmetic or boolean expressions, or statements. $\mathit{Env}$ is the sort of maps from $\mathit{Id}$s to $\mathit{Int}$egers. The sort $\mathit{Stack}$ refers to a stack of $\mathit{Code}$s that should be evaluated/executed in order, starting with the top of the stack. Configurations (of sort $\mathit{Cfg}$) consist of a $\mathit{Stack}$ and of an environment of sort $\mathit{Env}$. The symbols in the signature $\Sigma$ are presented in Figure 2. It includes all function symbols needed to represent the initial configuration, but also helper symbols that occur during program execution.

Example 2.2**.**

The SUM program introduced earlier, placed in an initial configuration with the empty environment, $\epsilon$, is represented by the following term of sort $\mathit{Cfg}$:

[TABLE]

The rest of this section recalls definitions from [15].

Definition 2.1**.**

A matching logic formula (or pattern), is a first-order logic (FOL) formula that additionally allows terms in $\mathit{Term}_{\_}{\Sigma,\mathit{Cfg}}(\mathit{Var})$, called basic patterns, as atomic formulae. We recall that by $\mathit{Term}_{\_}{\Sigma,\mathit{Cfg}}(\mathit{Var})$ we denote the terms of sort $\mathit{Cfg}$ in the $\Sigma$-algebra of terms. We say that a pattern is structureless if it contains no basic patterns. More formally, a matching logic formula is defined as follows:

if $\pi\in\mathit{Term}_{\_}{\Sigma,\mathit{Cfg}}(\mathit{Var})$, then $\pi$ is a formula; 2. 2.

if $w=(s_{\_}1,\ldots,s_{\_}n)$, $t_{\_}i\in\mathit{Term}_{\_}{\Sigma,s_{\_}i}(\mathit{Var})$ for all $i\in\left\{1,\ldots,n\right\}$ and $P\in F_{\_}{w,\mathit{Bool}}$, then $P(t_{\_}1,\ldots,t_{\_}n)$ is a formula; 3. 3.

if $\varphi_{\_}1$ and $\varphi_{\_}2$ are formulae, then $\varphi_{\_}1\wedge\varphi_{\_}2$ and $\varphi_{\_}1\vee\varphi_{\_}2$ are formulae; 4. 4.

if $\varphi$ is a formula, then $\neg\varphi$ is a formula; 5. 5.

if $\varphi$ is a formula and $x\in\mathit{Var}$, then $\exists x\varphi$ and $\forall x\varphi$ are formulae.

By $\mathcal{P}_{\_}{\mathcal{T}}$ we denote the set of all patterns over an algebra $\mathcal{T}$.

Definition 2.2**.**

For a fixed algebra $\mathcal{T}=(A,I)$, we define satisfaction $(\gamma,\rho)\models\varphi$ over configurations $\gamma\in\mathcal{T}_{\_}{\mathit{Cfg}}$, valuations $\rho:\mathit{Var}\rightarrow\mathcal{T}$ and patterns $\varphi$ as follows:

$(\gamma,\rho)\models$ $P(t_{\_}1,t_{\_}2,\ldots,t_{\_}n)$ if and only if $(I(P))(\rho(t_{\_}1),\rho(t_{\_}2),\ldots,\rho(t_{\_}n))=\top$; 2. 2.

$(\gamma,\rho)\models\pi$ iff $\gamma=\rho(\pi)$ where $\pi\in\mathit{Term}_{\_}{\Sigma,\mathit{Cfg}}(\mathit{Var})$; 3. 3.

$(\gamma,\rho)\models(\varphi_{\_}1\wedge\varphi_{\_}2)$ iff $(\gamma,\rho)\models\varphi_{\_}1$ and $(\gamma,\rho)\models\varphi_{\_}2$; 4. 4.

$(\gamma,\rho)\models(\varphi_{\_}1\vee\varphi_{\_}2)$ iff $(\gamma,\rho)\models\varphi_{\_}1$ or $(\gamma,\rho)\models\varphi_{\_}2$; 5. 5.

$(\gamma,\rho)\models\neg\varphi$ iff $(\gamma,\rho)\;\not\models\;\varphi$; 6. 6.

$(\gamma,\rho)\models\exists X\varphi$ iff $(\gamma,\rho^{\prime})\models\varphi$ for some $\rho^{\prime}:\mathit{Var}\rightarrow\mathcal{T}$ with $\rho^{\prime}(y)=\rho(y)$ for all $y\in Var\backslash\{X\}$; 7. 7.

$(\gamma,\rho)\models\forall X\varphi$ iff $(\gamma,\rho)\;\not\models\;\exists X(\neg\varphi)$.

We write $\models\varphi$ when $(\gamma,\rho)\models\varphi$ for all $\gamma\in\mathcal{T}_{\_}{\mathit{Cfg}}$ and all $\rho:\mathit{Var}\rightarrow\mathcal{T}$.

We now recall all-path reachability logic (as presented in [15]).

Definition 2.3**.**

A (one-path) reachability rule is an ordered pair of patterns $(\varphi,\varphi^{\prime})$ (which can have free variables). We write this pair as $\varphi\Rightarrow^{\exists}\varphi^{\prime}$. We say that rule $\varphi\Rightarrow^{\exists}\varphi^{\prime}$ is weakly well-defined iff for any $\gamma\in\mathcal{T}_{\_}{\mathit{Cfg}}$ and $\rho:\mathit{Var}\rightarrow\mathcal{T}$ with $(\gamma,\rho)\models\varphi$, there exists $\gamma^{\prime}\in\mathcal{T}_{\_}{\mathit{Cfg}}$ such that $(\gamma^{\prime},\rho)\models\varphi^{\prime}$.

Definition 2.4**.**

A reachability system is a set of reachability rules. A reachability system $S$ is weakly well-defined iff each rule is weakly well-defined. $S$ induces a transition system $(\mathcal{T},\Rightarrow^{\mathcal{T}}_{\_}S)$ on the configuration model: $\gamma\Rightarrow^{\mathcal{T}}_{\_}S\gamma^{\prime}$ for $\gamma,\gamma^{\prime}\in\mathcal{T}_{\_}{\mathit{Cfg}}$ iff there is some rule $\varphi\Rightarrow^{\exists}\varphi^{\prime}\in S$ and some valuation $\rho:\mathit{Var}\rightarrow\mathcal{T}$ such that $(\gamma,\rho)\models\varphi$ and $(\gamma^{\prime},\rho)\models\varphi^{\prime}$. We write $\Rightarrow$ instead of $\Rightarrow^{\mathcal{T}}_{\_}S$ when it is clear from context that we are referring to a particular transition system.

Example 2.3**.**

We consider a fixed $\Sigma$-algebra $\mathcal{T}$ having the following properties: $\mathcal{T}_{\_}{\mathit{Int}}=\mathbb{Z}$, $\mathcal{T}_{\_}{\mathit{Bool}}=\{\mathit{True},\mathit{False}\}$, $\mathcal{T}_{\_}{\mathit{Id}}=\{x,y,z\ldots\}$, $\mathcal{T}_{\_}{a+b}=a+b$ for all $a,b\in\mathbb{Z}$, $\mathcal{T}_{\_}{lookup(X,update(X,I,\mathit{env}))}=I$ for all $X\in\mathcal{T}_{\_}{\mathit{Id}},I\in\mathbb{Z}$, $\mathit{env}\in\mathcal{T}_{\_}{\mathit{Env}}$, $\mathcal{T}_{\_}{\mathit{lookup}(Y,update(X,I,\mathit{env}))}=\mathcal{T}_{\_}{\mathit{lookup}(Y,\mathit{env})}$ for all $Y\in\mathcal{T}_{\_}{\mathit{Id}}\setminus\{X\},I\in\mathbb{Z}$, $\mathit{env}\in\mathcal{T}_{\_}{\mathit{Env}}$, $\mathcal{T}_{\_}{\mathit{lookup}(X,\epsilon)}=0$ for all $X\in\mathcal{T}_{\_}{\mathit{Id}}$, $\mathcal{T}_{\_}{\mathit{isInt}(x)}=\mathit{True}$ iff $x=\overline{y}$, for some $y\in\mathbb{Z}$ and $\mathcal{T}_{\_}{\mathit{isBool}(x)}=\mathit{True}$ iff $x=\underline{y}$, for some $y\in\mathcal{T}_{\_}{\mathit{Bool}}$. The weakly well-defined system $S$ defining the operational semantics of IMP is presented in Figure 3. For brevity, some rules that are similar to existing rules are missing (e.g., the rules for $\mathit{eq}$ are similar to those for $\mathit{plus}$). We discuss the first four rules, which define the assignment operator and the lookup. The first rule schedules the expression on the rhs of an assignment to be evaluated, if it is not already an integer. Once the expression is evaluated to an integer (using the other rules), the second rule places the result back into the assignment operator. Once the rhs is an integer, the third rule updates the environment appropriately. The fourth rule evaluates a variable by looking it up in the environment. The reachability system $S$ generates the transition relation $\Rightarrow^{\mathcal{T}}_{\_}S$ on the model $\mathcal{T}$. Note that reachability rules of the form $l\land\phi\Rightarrow^{\exists}r$ (with $l\land\phi$ and $r$ being matching logic formulae) subsume the rewrite rules of the form $l\Rightarrow r\mbox{ if }\varphi$ used in the introduction.

Definition 2.5**.**

A $\Rightarrow^{\mathcal{T}}_{\_}S$-execution is a sequence $\gamma_{\_}0\Rightarrow^{\mathcal{T}}_{\_}S\gamma_{\_}1\Rightarrow^{\mathcal{T}}_{\_}S\cdots$, potentially infinite, where $\gamma_{\_}0,\gamma_{\_}1,\ldots\in\mathcal{T}_{\_}{\mathit{Cfg}}$. If a $\Rightarrow^{\mathcal{T}}_{\_}S$-execution is finite, we call it a $\Rightarrow^{\mathcal{T}}_{\_}S$-path. We say that such a path is complete iff it is not a strict prefix of any other $\Rightarrow^{\mathcal{T}}_{\_}S$-path (i.e., the last element is irreducible).

The following is an example of a complete $\Rightarrow^{\mathcal{T}}_{S}$-path:

$\langle\llbracket\mathit{seq}(\mathit{skip},\mathit{skip})\rrbracket\rightsquigarrow\mathit{Nil}\;|\;\epsilon\rangle\Rightarrow\langle\llbracket\mathit{skip}\rrbracket\rightsquigarrow\llbracket\mathit{skip}\rrbracket\rightsquigarrow\mathit{Nil}\;|\;\epsilon\rangle\Rightarrow\langle\llbracket\mathit{skip}\rrbracket\rightsquigarrow\mathit{Nil}\;|\;\epsilon\rangle\Rightarrow\langle\mathit{Nil}\;|\;\epsilon\rangle$.

Definition 2.6** (Partial Correctness).**

An all-path reachability rule is a pair $\varphi\Rightarrow^{\forall}\varphi^{\prime}$. We say that $\varphi\Rightarrow^{\forall}\varphi^{\prime}$ is satisfied by $S$, denoted by $S\models\varphi\Rightarrow^{\forall}\varphi^{\prime}$, iff for all complete $\Rightarrow^{\mathcal{T}}_{S}$-paths $\tau$ starting with $\gamma\in\mathcal{T}_{\_}{\mathit{Cfg}}$ and for all $\rho:\mathit{Var}\rightarrow\mathcal{T}$ such that $(\gamma,\rho)\models\varphi$, there exists some $\gamma^{\prime}\in\tau$ such that $(\gamma^{\prime},\rho)\models\varphi^{\prime}$.

The definition above generalizes typical partial correctness of Hoare tuples of the form $\{\varphi\}\mathit{P}\{\varphi^{\prime}\}$, as the reachability formula $\mathit{P}\land\varphi\Rightarrow^{\forall}\langle\mathit{skip}\;|\;\mathit{env}\rangle\land\varphi^{\prime}$ can be used instead. See [15] for a more detailed discussion. Reachability logic has a sound and relatively complete proof system, which derives sequents of the form $S\vdash\varphi\Rightarrow^{\forall}\varphi^{\prime}$ if and only if $S\models\varphi\Rightarrow^{\forall}\varphi^{\prime}$ holds. The results in the present paper do not depend on the proof system, and therefore the proof system is presented in Appendix A.

3 The Reduction of Total Correctness to Partial Correctness

We now present a transformation that reduces total correctness to the problem of partial correctness. We first define what it means for a pattern to terminate.

Definition 3.1** (Termination of a Pattern).**

We say that a pattern $\varphi$ terminates in $S$ if for all $\gamma\in\mathcal{T}_{\_}{\mathit{Cfg}}$ and all $\rho:\mathit{Var}\rightarrow\mathcal{T}$ such that $(\gamma,\rho)\models\varphi$, all executions $\gamma\Rightarrow\gamma_{\_}1\Rightarrow\gamma_{\_}2\Rightarrow\cdots$ from $\gamma$ in $(\mathcal{T},\Rightarrow^{\mathcal{T}}_{\_}{S})$ are finite.

Example 3.1**.**

The following pattern does not terminate in $S$:

[TABLE]

Its nontermination is witnessed by the following execution:

[TABLE]

The next definition is at the core of our proof. It is the total-correctness counterpart to Definition 2.6.

Definition 3.2** (Total Correctness).**

We say that an all-path reachability rule $\varphi\Rightarrow^{\forall}\varphi^{\prime}$ is totally satisfied by $S$, denoted by $S\models_{\_}t\varphi\Rightarrow^{\forall}\varphi^{\prime}$, iff for all complete or diverging $\Rightarrow^{\mathcal{T}}_{S}$-executions $\tau$ starting with $\gamma\in\mathcal{T}_{\_}{\mathit{Cfg}}$ and for all $\rho:\mathit{Var}\rightarrow\mathcal{T}$ such that $(\gamma,\rho)\models\varphi$, there exists some $\gamma^{\prime}\in\tau$ such that $(\gamma^{\prime},\rho)\models\varphi^{\prime}$.

We now discuss how the definition above generalizes the usual definition for total correctness found in the literature.

A Hoare tuple $\{\phi\}P\{\phi^{\prime}\}$ is valid in the sense of total correctness if the precondition $\phi$ entails

the termination of the program $P$, and also 2. 2.

that the postcondition $\phi^{\prime}$ holds after the program $P$ terminates.

Our definition of $S\models_{\_}t\varphi\Rightarrow^{\forall}\varphi^{\prime}$ states that any execution starting from $\varphi$, terminating or not, reaches at some point $\varphi^{\prime}$. If we choose $\varphi^{\prime}$ to be a configuration that is known to terminate (e.g., for the case of IMP, $\langle\mathit{skip}\rightsquigarrow\mathit{Nil}\;|\;\ldots\rangle$), then it follows that $\varphi$ must terminate along all paths. Otherwise, any nonterminating path starting with $\varphi$ would meet $\varphi^{\prime}$, which terminates, leading to a contradiction.

In particular, the total correctness of the Hoare tuple $\{\phi\}P\{\phi^{\prime}\}$ is encoded by $S\models_{\_}tP\land\phi\Rightarrow^{\forall}\langle\mathit{skip}\rightsquigarrow\mathit{Nil}\;|\;\mathit{env}\rangle\land\phi^{\prime}$. In addition to encoding total correctness Hoare tuples, our definition of total correctness is strictly more general, since it guarantees that $\varphi^{\prime}$ is reached in a finite number of steps from $\varphi$, even if $\varphi$ does not terminate.

We now present our transformation $\theta$, which helps reduce total correctness guarantees of the form $S\models_{\_}t\varphi\Rightarrow^{\forall}\varphi^{\prime}$ to partial correctness sequents of the form $\theta(S)\vdash\theta(\varphi,s)\Rightarrow^{\forall}\exists M.\theta(\varphi^{\prime},M)$, where $\theta$ transforms its arguments as explained in Theorem 3.1 below.

Definition 3.3** **(Reduction From Total Correctness to Partial

Correctness).

We define several homonymous maps $\theta$ that encode our transformation for reducing total correctness to partial correctness. By $\mathcal{S}_{\_}{\Sigma}$ we denote the class of all algebraic signatures, by $\mathcal{S}$ the class of all sorts and by $\mathcal{U}$ the class of all algebras with distinguished sets of configurations.

Transforming signatures ($\theta:(\mathcal{S}_{\_}{\Sigma}\times\mathcal{S})\rightarrow(\mathcal{S}_{\_}{\Sigma}\times\mathcal{S})$)

Let $\Sigma=(S,F)$ be an algebraic signature and $\mathit{Cfg}\in S$. We define $\theta(\Sigma,\mathit{Cfg})=(\Sigma^{\prime},\mathit{Cfg}^{\prime}),$ where $\Sigma^{\prime}=(S\cup\mathit{Nat}\cup\mathit{Cfg}^{\prime},\allowbreak F\cup\left\{F_{\_}{(),\mathit{Nat}},F_{\_}{(\mathit{Cfg},\mathit{Nat}),\mathit{Cfg}^{\prime}},\allowbreak F_{\_}{(\mathit{Nat},\mathit{Nat}),\mathit{Nat}}\right\})$ and where $F_{\_}{(),\mathit{Nat}}=\left\{0,1,2,\ldots,\right\},\allowbreak F_{\_}{(\mathit{Cfg},\mathit{Nat}),\mathit{Cfg}^{\prime}}=\left\{(\>,)\right\},\allowbreak F_{\_}{(\mathit{Nat},\mathit{Nat}),\mathit{Nat}}=\left\{+,-,\times,/\right\}.$

Intuitively, $\theta$ adds a sort for the set of naturals and changes the configuration sort such that new configurations consist of old configurations, plus a natural number. The natural intuitively represents a program variant that is added to the configuration, i.e. the maximum number of steps the program can take before ending its execution. In addition to the standard operations $+,-,\times,/$, we may also consider other operations like $|\cdot|:\mathit{Int}\to\mathit{Nat}$ (absolute value) that operate on $\mathit{Nat}$ and other existing sorts. Alternatively, we could consider any well-founded set instead of the set of naturals; however, naturals make the presentation easier to follow. 2. 2.

Transforming algebras ($\theta:\mathcal{U}\rightarrow\mathcal{U}$)

Let $\mathcal{A}=(A,I_{\_}A)$ be a $\Sigma$-algebra, where $\mathit{Cfg}$ is the distinguished sort of configurations and assume $\theta(\Sigma,\mathit{Cfg})=(\Sigma^{\prime},\mathit{Cfg}^{\prime})$. Then $\theta(\mathcal{A})=(A^{\prime},I^{\prime}_{\_}A)$ is a $\Sigma^{\prime}$-algebra with a distinguished sort $\mathit{Cfg}^{\prime}$ defined as follows:

1. (a)

$A\subseteq A^{\prime}$; 2. (b)

$\mathbb{N}=A^{\prime}_{\_}{\mathit{Nat}}\in A^{\prime}$; 3. (c)

$I^{\prime}_{\_}A$ is an extension of $I_{\_}A$ such that $\mathcal{T}(n)=n_{\_}{\mathbb{N}}$, $\mathcal{T}(a\delta b)=\mathcal{T}(a\delta_{\_}{\mathbb{N}}b)$ for $\delta\in\left\{+,-,\times,/\right\}$; 4. (d)

$\mathcal{T}(\mathit{Cfg}^{\prime})=\mathcal{T}(\mathit{Cfg})\times\mathbb{N}$.

Intuitively, each $\Sigma$-algebra with a distinguished sort $\mathit{Cfg}$ of configurations is transformed into a $\Sigma$-algebra with a distinguished sort $\mathit{Cfg}^{\prime}$. The sort $\mathit{Cfg}^{\prime}$ is interpreted as pairs of old configurations and naturals. 3. 3.

Transforming patterns (matching logic formulae) ($\theta:(\mathcal{P}_{\_}{\mathcal{T}}\times\mathit{Term}_{\_}{\Sigma,\mathit{Nat}}(\mathit{Var}))\rightarrow\mathcal{P}_{\_}{\mathcal{\theta(T)}}$)

Consider a $\Sigma$-algebra $\mathcal{T}$. Let $\varphi$ be a pattern over $\mathcal{T}$ and $n\in\mathit{Term}_{\_}{\Sigma,\mathit{Nat}}(\mathit{Var})$ ($n$ is a term of sort $\mathit{Nat}$). We define $\theta$ as follows:

1. (a)

if $\varphi$ is structureless, then $\theta(\varphi,n)=\varphi$; 2. (b)

if $\varphi$ is a basic pattern, then $\theta(\varphi,n)=(\varphi,n)$ (note that this is the interesting case, as in the other cases the transformation $\theta$ simply applies homomorphically); 3. (c)

if $\varphi=(\varphi_{\_}1\>\delta\>\varphi_{\_}2)$ and $\varphi$ is not structureless, then $\theta(\varphi,n)=\theta(\varphi_{\_}1,n)\>\delta\>\theta(\varphi_{\_}2,n)$, for $\delta\in\left\{\vee,\wedge\right\}$; 4. (d)

if $\varphi=\delta X(\varphi^{\prime})$ and $\varphi$ is not structureless, then $\theta(\varphi,n)=\delta X\theta(\varphi^{\prime},n)$, for $\delta\in\left\{\exists,\forall\right\}$; 5. (e)

if $\varphi=\neg\varphi^{\prime}$ and $\varphi$ is not structureless, then $\theta(\varphi,n)=\neg\theta(\varphi^{\prime},n)$.

Intuitively, $\theta$ transforms each old basic pattern into a new basic pattern by adding the natural $n$ and “propagates” this change for all basic patterns contained in the given pattern. 4. 4.

Transforming one-path reachability rules ($\theta:(\mathcal{P}_{\_}{\mathcal{T}}\times\mathcal{P}_{\_}{\mathcal{T}})\rightarrow(\mathcal{P}_{\_}{\mathcal{\theta(T)}}\times\mathcal{P}_{\_}{\mathcal{\theta(T)}})$)

Let $\varphi\Rightarrow^{\exists}\varphi^{\prime}$ be a reachability rule. Then $\theta(\varphi\Rightarrow^{\exists}\varphi^{\prime})=\theta(\varphi,n)\Rightarrow^{\exists}\theta(\varphi^{\prime},n-1)$, where $n$ is a fresh variable of sort $\mathit{Nat}$. The transformation forces each rule to decrease the program variant (by $1$). 5. 5.

Transforming language semantics ($\theta:2^{(\mathcal{P}_{\_}{\mathcal{T}}\times\mathcal{P}_{\_}{\mathcal{T}})}\rightarrow 2^{(\mathcal{P}_{\_}{\mathcal{\theta(T)}}\times\mathcal{P}_{\_}{\mathcal{\theta(T)}})}$)

We define the transformation by $\theta(S)=\left\{\theta(\varphi\Rightarrow^{\exists}\varphi^{\prime})\;|\;(\varphi\Rightarrow^{\exists}\varphi^{\prime})\in S\right\}.$ Each one-path reachability rule is transformed independently.

We now reduce the problem of total correctness to partial correctness. This is achieved by the following property of the transformation $\theta$ defined previously:

Theorem 3.1**.**

If there exists some term $s\in\mathit{Term}_{\_}{\Sigma,\mathit{Nat}}(\mathit{Var})$ of sort $\mathit{Nat}$ such that

[TABLE]

where $M\in\mathit{Var}_{\_}\mathit{Nat}$, then $S\models_{\_}t\varphi\Rightarrow^{\forall}\varphi^{\prime}.$

Proof.

Suppose there exist some valuation $\rho:\mathit{Var}\rightarrow\mathcal{\theta(T)}$, some configuration $\gamma\in\mathcal{T}_{\_}{\mathit{Cfg}}$ with the property $(\gamma,\rho)\models\varphi$ and a complete or diverging $\Rightarrow^{\mathcal{T}}_{S}$-execution $\tau=\gamma\Rightarrow^{\mathcal{T}}_{S}\gamma_{\_}1\Rightarrow^{\mathcal{T}}_{S}\cdots$ such that there is no $\gamma^{\prime}$ in $\tau$ for which $(\gamma^{\prime},\rho)\models\varphi^{\prime}$. Let $n=\rho(s)$. As $\theta(S)\models\theta(\varphi,s)\Rightarrow^{\forall}\exists M.\theta(\varphi^{\prime},M)$, we have, by definition, that for all complete $\Rightarrow^{\mathcal{\theta(T)}}_{\theta(S)}$-paths $\tau^{\theta}=(\gamma^{\theta},n)\Rightarrow^{\mathcal{\theta(T)}}_{\theta(S)}(\gamma_{\_}1^{\theta},n-1)\Rightarrow^{\mathcal{\theta(T)}}_{\theta(S)}\cdots\Rightarrow^{\mathcal{\theta(T)}}_{\theta(S)}(\gamma_{\_}k^{\theta},n-k)$ such that $((\gamma^{\theta},n),\rho)\models\theta(\varphi,s)$, there exists some $(\gamma_{\_}p^{\theta},n-p)$ in $\tau^{\theta}$ such that $((\gamma_{\_}p^{\theta},n-p),\rho)\models\exists M.\theta(\varphi^{\prime},M)$.

We distinguish two cases. First, suppose $\tau$ is complete and has at most $n$ steps. Consider the path $\tau^{\theta}=(\gamma,n)\Rightarrow^{\mathcal{\theta(T)}}_{\theta(S)}(\gamma_{\_}1,n-1)\Rightarrow^{\mathcal{\theta(T)}}_{\theta(S)}\cdots\Rightarrow^{\mathcal{\theta(T)}}_{\theta(S)}(\gamma_{\_}k,n-k)$. It is easy to see that since $\tau$ has at most $n$ steps, $\tau^{\theta}$ is indeed a valid $\Rightarrow^{\mathcal{\theta(T)}}_{\theta(S)}$-path. Moreover, since $\tau$ is complete, it is easy to see that $\tau^{\theta}$ is also complete. It follows that there exists some $(\gamma_{\_}p,n-p)$ in $\tau^{\theta}$ such that $((\gamma_{\_}p,n-p),\rho)\models\exists M.\theta(\varphi^{\prime},M)$. By the definition of satisfaction, this statement implies that $(\gamma_{\_}p,\rho)\models\varphi^{\prime}$ and we have obtained a contradiction.

For the second case, we have that $\tau$ has more than $n$ steps. Consider the prefix of $\tau$ of $n$ steps: $\tau^{\prime}=\gamma\Rightarrow^{\mathcal{T}}_{S}\gamma_{\_}1\Rightarrow^{\mathcal{T}}_{S}\cdots\Rightarrow^{\mathcal{T}}_{S}\gamma_{\_}n$. Consider the $\Rightarrow^{\mathcal{\theta(T)}}_{\theta(S)}$-path $\tau^{\prime\prime}=(\gamma,n)\Rightarrow^{\mathcal{\theta(T)}}_{\theta(S)}(\gamma_{\_}1,n-1)\Rightarrow^{\mathcal{\theta(T)}}_{\theta(S)}\cdots\Rightarrow^{\mathcal{\theta(T)}}_{\theta(S)}(\gamma_{\_}n,0)$. Note that $\tau^{\prime\prime}$ is indeed a valid path in $\theta(S)$ and additionally $((\gamma,n),\rho)\models\theta(\varphi,s)$. Moreover, $\tau^{\prime\prime}$ is complete since $(\gamma_{\_}n,0)$ cannot advance in $\Rightarrow^{\mathcal{\theta(T)}}_{\theta(S)}$.

This means that $((\gamma_{\_}p,n-p),\rho)\models\exists M.\theta(\varphi^{\prime},M)$ for some value $p$. It is easy to see from the definition of satisfaction that this last statement implies $(\gamma_{\_}p,\rho)\models\varphi^{\prime}$. Since $\theta(\gamma_{\_}p,0)$ is in $\tau^{\prime\prime}$, then $\gamma_{\_}p$ is in $\tau^{\prime}$, which obviously implies that $\gamma_{\_}p$ is in $\tau$ as well. Therefore, there exists $\gamma_{\_}p$ in $\tau$ for which $(\gamma_{\_}p,\rho)\models\varphi^{\prime}$.

We have arrived at a contradiction in both cases, from which we draw the conclusion that for all complete or diverging $\Rightarrow^{\mathcal{T}}_{S}$-paths $\tau$ starting with $\gamma\in\mathcal{T}_{\_}{\mathit{Cfg}}$ such that $(\gamma,\rho)\models\varphi$, there exists some $\gamma^{\prime}$ in $\tau$ such that $(\gamma^{\prime},\rho)\models\varphi^{\prime}$. By definition, this means that $S\models(\varphi\Rightarrow^{\forall}_{\_}t\varphi^{\prime})$, which is what we had to prove. ∎

Corollary 3.1**.**

If there exists $s\in\mathit{Term}_{\_}{\Sigma,\mathit{Nat}}(\mathit{Var})$ of sort $\mathit{Nat}$ such that $\theta(S)\models\theta(\varphi,s)\Rightarrow^{\forall}\exists M.\theta(\varphi^{\prime},M)$, where $M\in\mathit{Var}_{\_}\mathit{Nat}$, then:

$S\models\varphi\Rightarrow^{\forall}\varphi^{\prime}$; 2. 2.

If $\varphi^{\prime}$ terminates in $S$, then $\varphi$ also terminates in $S$.

The converse of the corollary above, stating that if a partial correctness guarantee holds and $\varphi$ terminates then the total correctness guarantee holds as well, in the cases of finitely-branching transition systems (this is an immediate consequence of König’s lemma). Given the program SUM in our running example and the semantics $S$ of IMP, the following sequent can be derived:

[TABLE]

which proves the total correctness of SUM. A fully worked out example of a proof of total correctness is given in Appendix B.

4 Related Work

We critically rely on previous work on language-parametric partial program correctness, as developed in [15]. Starting with the operational semantics of the language of the program for which we prove total correctness, we transform it into an (artificial) language whose configurations consist of the configurations of the initial language, plus a variant. This construction is automated. Given a program and a program variant, its total correctness in the original language reduces to showing partial correctness in the new language. Language transformations have been used before, for example to develop language-parametric symbolic execution engines [19] or language-parametric partial equivalence checkers [10].

In general, the research community treats the subject of termination orthogonally to the subject of partial correctness. There are several automated approaches to proving (and certifying) termination (e.g., [18, 3, 12, 2]), but these are typically only concerned with termination, and not correctness. Therefore, to establish total correctness we generally first establish partial correctness by using various Hoare-like logics (e.g., [8, 16]), and then termination using a specialized termination prover (e.g., [18, 2]).

Logics that prove total correctness directly (e.g., [26, 20]) are used more rarely. This is despite the fact that relatively recent work in automated termination proving (e.g., [6, 4, 14, 7, 13]) shows that it is beneficial to use information obtained by proving a program (e.g., invariants) in the termination argument: in [6], a cooperation graph is used to enable the cooperation between a safety prover and the rank synthesis tool, in [4], a variance analysis is introduced that is parametric in an invariance analysis and Ramsey-based termination arguments are improved with lexicographic ordering in [14].

5 Conclusion and Future Work

We have developed a language semantics transformation that can be used to prove total correctness of programs. The method can be used for any programming language whose operational semantics is given by a set of reachability rules. This is not a restriction, as any programming language [25] can be faithfully encoded as such. Moreover, our definition of total correctness (Definition 3.2) generalizes the usual definition of total correctness, as it can also be used to reason about nonterminating programs that are guaranteed to reach a desired configuration (which could be nonterminating) in a finite number of steps. We have implemented our approach in the RMT tool [11, 9]. Instructions on obtaining RMT are available at at http://profs.info.uaic.ro/~stefan.ciobaca/wpte2018, along with several examples for total correctness (including our running example). Our examples show that our approach works in practice, but in future work we must also benchmark realistic languages with reachability logic semantics such as C (see [17]) or Java (see [5]). A limitation of our approach is that the number of steps has to be computable upfront. This means that we cannot handle programs that nondeterministically choose a value and loop for that number of steps. Another limitation is that the upper bound is not found automatically (even in simple cases), it has to be provided by the user.

There remain many exciting open questions for future work. The main question is proving our reduction to be complete. We will also study how our notion of total correctness corresponds to the well-known notions of may-convergence and must-convergence in the literature on process algebra (e.g.,in [24]). Another open question is whether our generalization of the notion of total correctness has any practical advantages over the usual definition. In our present approach, the program variant must be a natural number, but an important question is to analyze whether other well-founded orders could be needed as well. Another open question is compositionality: instead of providing a program-wide variant, would it be possible to have a more modular approach? Finally, can we combine our method with existing state of the art automated termination provers like [7, 13] to obtain the benefits of both?

Acknowledgement

This work is funded by the Ministry of Research and Innovation within Program 1 – Development of the national RD system, Subprogram 1.2 – Institutional Performance – RDI excellence funding projects, Contract no.34PFE/19.10.2018.

Appendix A Proof System for Partial Correctness

We recall in Figure 4 the proof system for the problem of partial correctness from [15].

Matching logic formulae can be translated into FOL formulae such that matching logic satisfaction reduces to FOL satisfaction in the model of configurations $\mathcal{T}$. This allows conventional theorem provers to be used for matching logic reasoning. One of the proof rules of reachability logic depends on this translation.

Definition A.1**.**

Let $\square$ be a fresh variable of sort $\mathit{Cfg}$. For a pattern $\varphi$, let $\varphi^{\square}$ be the FOL formula formed from $\varphi$ by replacing basic patterns $\pi\in\mathit{Term}_{\_}{\Sigma,\mathit{Cfg}}(\mathit{Var})$ with equalities $\square=\pi$. If $\rho:\mathit{Var}\rightarrow\mathcal{T}$ and $\gamma\in\mathcal{T}_{\_}{\mathit{Cfg}}$ then let the valuation $\rho^{\gamma}:\mathit{Var}\cup\left\{\square\right\}$ be such that $\rho^{\gamma}(x)=\rho(x)$ for all $x\in\mathit{Var}$ and $\rho^{\gamma}(\square)=\gamma$.

We have that

$(\gamma,\rho)\models\varphi\iff\rho^{\gamma}\models\varphi^{\square}$.

We use $\varphi[c/\square]$ to denote the FOL formula resulting from eliminating $\square$ from $\varphi$ and replacing it with a $\mathit{Cfg}$ variable $c$.

The proof system was shown in [15] to be sound (and also relatively complete) for the problem of partial correctness. Note that, this provides no guarantees for configurations that do not terminate.

Appendix B A Complete Example

In this section, we present in full details a very simple example of how the reduction presented above work. We consider a very simple “language” with configurations of the form $[s,i]$ (where $s$ and $i$ are naturals) that add to $s$ the first $i$ positive naturals.

Let $\Sigma=(\left\{\mathit{Cfg},\mathit{Nat},\mathit{Bool}\right\},F)$, where:

• $\bullet$

$F_{\_}{(),\mathit{Nat}}=\left\{0,1,2\ldots\right\}$

• $\bullet$

$F_{\_}{(),\mathit{Bool}}=\left\{\mathit{True},\mathit{False}\right\}$

• $\bullet$

$F_{\_}{(\mathit{Nat},\mathit{Nat}),\mathit{Nat}}=\left\{+,-,/,*\right\}$

• $\bullet$

$F_{\_}{(\mathit{Nat},\mathit{Nat}),\mathit{Bool}}=\left\{<,>,\leq,\geq,=\right\}$

• $\bullet$

$F_{\_}{(\mathit{Nat},\mathit{Nat}),\mathit{Cfg}}=\left\{[,]\right\}$

We consider a $\Sigma$-algebra $\mathcal{T}$ with the expected interpretation for common symbols and a system of reachability rules $S$ consisting of a single rule:

$[s,i]\wedge(i>0)\Rightarrow[s+i,i-1]$, where $s,i\in\mathit{Var}_{\_}{\mathit{Nat}}$.

The algebra $\theta(\mathcal{T})$ contains a sort $\mathit{Cfg}^{\prime}$ and, by definition, $\theta(S)$ consists of the following rule:

$([s,i],n)\wedge(i>0)\Rightarrow([s+i,i-1],n-1)$, where $s,i,n\in\mathit{Var}_{\_}{\mathit{Nat}}$.

For ease of readability let $\mathit{SUM}(x,y)=y*(y+1)/2-(x-1)*x/2$ by notation. Let $\varphi_{\_}L=([\mathit{SUM}(n^{\prime}+1,n),n^{\prime}],n^{\prime})\wedge n^{\prime}\geq 0$ and $\varphi_{\_}R=\exists m([\mathit{SUM}(1,n),0],m)$, where $n^{\prime},n,m\in\mathit{Var}_{\_}{\mathit{Nat}}$. Let us now prove that

[TABLE]

which establishes not only that $[0,n]$ computes the sum from $1$ to $n$ (by the soundness of reachability logic), but also that it terminates within $n$ steps (by Theorem 3.1):

14. $\theta(S),{\left\{\exists n^{\prime}\varphi_{\_}L\Rightarrow^{\forall}\varphi_{\_}R\right\}}\vdash\exists n^{\prime}\varphi_{\_}L\Rightarrow^{\forall}\varphi_{\_}R$ by Axiom

15. $\theta(S),{\left\{\exists n^{\prime}\varphi_{\_}L\Rightarrow^{\forall}\varphi_{\_}R\right\}}\vdash([\mathit{SUM}(n^{\prime},n),n^{\prime}-1],n^{\prime}-1)\wedge(n^{\prime}-1)\geq 0\Rightarrow^{\forall}\varphi_{\_}R$

by Consequence from 14

12. $\theta(S)\vdash_{\_}{\left\{\exists n^{\prime}\varphi_{\_}L\Rightarrow^{\forall}\varphi_{\_}R\right\}}([\mathit{SUM}(n^{\prime}+1,n),n^{\prime}],n^{\prime})\wedge n^{\prime}>0\Rightarrow^{\forall}$

$\qquad([\mathit{SUM}(n^{\prime},n),n^{\prime}-1],n^{\prime}-1)\wedge(n^{\prime}-1)\geq 0$ by Step

11. $\theta(S)\vdash_{\_}{\left\{\exists n^{\prime}\varphi_{\_}L\Rightarrow^{\forall}\varphi_{\_}R\right\}}([\mathit{SUM}(n^{\prime}+1,n),n^{\prime}],n^{\prime})\wedge n^{\prime}>0\Rightarrow^{\forall}\varphi_{\_}R$

by Transitivity from 12 and 13

10. $\theta(S)\vdash_{\_}{\left\{\exists n^{\prime}\varphi_{\_}L\Rightarrow^{\forall}\varphi_{\_}R\right\}}([\mathit{SUM}(1,n),0],0)\Rightarrow^{\forall}([\mathit{SUM}(1,n),0],0)$

by Reflexivity

9. $\theta(S)\vdash_{\_}{\left\{\exists n^{\prime}\varphi_{\_}L\Rightarrow^{\forall}\varphi_{\_}R\right\}}([\mathit{SUM}(1,n),0],0)\Rightarrow^{\forall}\varphi_{\_}R$ by Consequence from 10

10. $\theta(S)\vdash_{\_}{\left\{\exists n^{\prime}\varphi_{\_}L\Rightarrow^{\forall}\varphi_{\_}R\right\}}\exists n^{\prime}(([\mathit{SUM}(n^{\prime}+1,n),n^{\prime}],n^{\prime})\wedge n^{\prime}>0)\Rightarrow^{\forall}\varphi_{\_}R$

by Abstraction from 11

7. $\theta(S)\vdash_{\_}{\left\{\exists n^{\prime}\varphi_{\_}L\Rightarrow^{\forall}\varphi_{\_}R\right\}}\exists(n^{\prime}([\mathit{SUM}(n^{\prime}+1,n),n^{\prime}],n^{\prime})\wedge n^{\prime}=0)\Rightarrow^{\forall}\varphi_{\_}R$

by Consequence from 9

6. $\theta(S)\vdash_{\_}{\left\{\exists n^{\prime}\varphi_{\_}L\Rightarrow^{\forall}\varphi_{\_}R\right\}}\exists n^{\prime}(([\mathit{SUM}(n^{\prime}+1,n),n^{\prime}],n^{\prime})\wedge n^{\prime}>0)\vee$

$\exists n^{\prime}(([\mathit{SUM}(n^{\prime}+1,n),n^{\prime}],n^{\prime})\wedge n^{\prime}=0)\Rightarrow^{\forall}\varphi_{\_}R$ by Case analysis from 7, 8

5. $\theta(S)\vdash_{\_}{\left\{\exists n^{\prime}\varphi_{\_}L\Rightarrow^{\forall}\varphi_{\_}R\right\}}\exists n^{\prime}\varphi_{\_}L\Rightarrow^{\forall}\varphi_{\_}R$ by Consequence from 6

6. $\theta(S)\vdash([0,n],n)\Rightarrow^{\forall}([0,n],n)$ by Reflexivity

7. $\theta(S)\vdash\exists n^{\prime}\varphi_{\_}L\Rightarrow^{\forall}\varphi_{\_}R$ by Circularity from 5

8. $\theta(S)\vdash([0,n],n)\Rightarrow^{\forall}\exists n^{\prime}\varphi_{\_}L$ by Consequence from 4

9. $\theta(S)\vdash([0,n],n)\Rightarrow^{\forall}\varphi_{\_}R$ by Transitivity from 2 and 3

Our approach also works on the programming language IMP described above. We have shown, for example, that the following program is (unsurprisingly) totally correct (when ${\tt m}$ starts up with a nonnegative number):

s := 0 while not (m = 0) do s := s + m; m := m - 1

The main idea in proving the program above totally correct is the same as in the fully developed example above, but the formal proof is a lot longer.