Technical Report: Using Loop Scopes with for-Loops

TL;DR

This paper extends the concept of loop scopes from while-loops to for-loops and introduces sound loop unrolling rules, enabling more straightforward semi-automated proofs without program transformation.

Contribution

It presents a novel extension of loop scopes to for-loops and provides sound unrolling rules that treat for-loops as first-class citizens, simplifying proof processes.

Findings

Extended loop scopes to for-loops

Developed sound unrolling rules for loops

Facilitated easier semi-automated proofs

Abstract

Loop scopes have been shown to be a helpful tool in creating sound loop invariant rules which do not require program transformation of the loop body. Here we extend this idea from while-loops to for-loops and also present sound loop unrolling rules for while- and for-loops, which require neither program transformation of the loop body, nor the use of nested modalities. This approach allows for-loops to be treated as first-class citizens -- rather than the usual approach of transforming for-loops into while-loops -- which makes semi-automated proofs easier to follow for the user, who may need to provide help in order to finish the proof.

Equations

$$\begin{array}[]{@{}l@{}}\mbox{\small{$\mathsf{loopInvariantWhile}$}}\\ \quad\genfrac{}{}{}{0}{\begin{array}[]{l}\Gamma\Longrightarrow\{\mathcal{U}\}\mathit{Inv},\Delta\\ \Gamma,\{\mathcal{U}^{\prime}\}\mathit{Inv}\Longrightarrow\{\mathcal{U}^{\prime}~{}||~{}\text{x}\mathrel{:=}\text{TRUE}\}}{\\ \qquad\qquad\qquad\quad[\text{$\pi$ $\circlearrowright_{\text{x}}$ if ($nse$) $l_{1}:\ldots l_{n}:$ \hbox{{\char 123\relax}} p x = false; \hbox{{\char 125\relax}} $\circlearrowleft$ $\omega$}]\\ \hfill((\text{x}\doteq\text{TRUE}\rightarrow\phi)\ \&\ (\text{x}\doteq\text{FALSE}\rightarrow\mathit{Inv})),\Delta\end{array}}{\begin{array}[]{l}\Gamma\Longrightarrow\{\mathcal{U}\}[\text{$\pi$ $l_{1}:\ldots l_{n}:$ while ($nse$) p $\omega$}]\phi,\Delta\end{array}}\end{array}$$

$$\begin{array}[]{@{}l@{}}\mbox{\small{$\mathsf{emptyIndexedLoopScope}$}}\\ \quad\genfrac{}{}{}{0}{\begin{array}[]{l}\Gamma\Longrightarrow\{\mathcal{U}\}$($\operatorname{if}~{}(\text{x}\doteq\mathit{TRUE})~{}\operatorname{then}~{}([\text{$\pi$ $\omega$}]\varphi)~{}\operatorname{else}~{}([]{\varphi})$)$,\Delta\end{array}}{\begin{array}[]{l}\Gamma\Longrightarrow\{\mathcal{U}\}[\text{$\pi$ $\circlearrowright_{\text{x}}$ $\circlearrowleft$ $\omega$}]\varphi,\Delta\end{array}}\end{array}$$

$$\{\text{b}\doteq \text{TRUE}\}[\text{↻x if (b) { b = false; x = false; } if (!x) { p } ↺}]\varphi$$

$$\{\text{b}\doteq \text{TRUE}\}[\text{↻x if (b) { b = false; continue; } if (!x) { p } ↺}]\varphi$$

$$\{\text{b}\doteq \text{FALSE}||\text{x}\doteq \text{FALSE}\}[\text{if (!x) { p }}]\varphi$$

$$\{\text{b}\doteq \text{FALSE}\}[\text{↻x continue; if (!x) { p } ↺}]\varphi$$

$$\mbox{\small{$\mathsf{continueIndexedLoopScope}$}}\ \genfrac{}{}{}{0}{\begin{array}[]{l}\Gamma\Longrightarrow\{\mathcal{U}\}[\text{$\pi$ $\circlearrowright_{\text{x}}$ x = false; p $\circlearrowleft$ $\omega$}]\varphi,\Delta\end{array}}{\begin{array}[]{l}\Gamma\Longrightarrow\{\mathcal{U}\}[\text{$\pi$ $\circlearrowright_{\text{x}}$ continue; p $\circlearrowleft$ $\omega$}]\varphi,\Delta\end{array}}$$

$$\begin{array}[]{@{}l@{}}\mbox{\small{$\mathsf{pullOutLoopInitializer}$}}\\ \quad\genfrac{}{}{}{0}{\begin{array}[]{l}\Gamma\Longrightarrow\{\mathcal{U}\}[\text{$\pi$ \hbox{{\char 123\relax}} $init^{\prime}$ $l_{1}:\ldots l_{n}:$ for (; $guard$; $upd$) p \hbox{{\char 125\relax}} $\omega$}]\phi,\Delta\end{array}}{\begin{array}[]{l}\Gamma\Longrightarrow\{\mathcal{U}\}[\text{$\pi$ $l_{1}:\ldots l_{n}:$ for ($init$; $guard$; $upd$) p $\omega$}]\phi,\Delta\end{array}}\end{array}$$

$$\displaystyle\begin{array}[]{@{}l@{}}\mbox{\small{$\mathsf{loopInvariantFor}$}}\\ \quad\genfrac{}{}{}{0}{\begin{array}[]{l}\Gamma\Longrightarrow\{\mathcal{U}\}\mathit{Inv},\Delta\\ \Gamma,\{\mathcal{U}^{\prime}\}\mathit{Inv}\Longrightarrow\{\mathcal{U}^{\prime}~{}||~{}\text{x}\mathrel{:=}\text{TRUE}\}\\ \qquad\qquad\qquad\quad[\text{$\pi$ $\circlearrowright_{\text{x}}$ if ($guard^{\prime}$) $l_{1}:\ldots l_{n}:$ \hbox{{\char 123\relax}} p x = false; \hbox{{\char 125\relax}}}}{\\ \hfill\text{if (!x) \hbox{{\char 123\relax}} x = true; $upd^{\prime}$ x = false; \hbox{{\char 125\relax}} $\circlearrowleft$ $\omega$}]\\ \hfill((\text{x}\doteq\text{TRUE}\rightarrow\phi)\ \&\ (\text{x}\doteq\text{FALSE}\rightarrow\mathit{Inv})),\Delta\end{array}}{\begin{array}[]{l}\Gamma\Longrightarrow\{\mathcal{U}\}[\text{$\pi$ $l_{1}:\ldots l_{n}:$ for (; $guard$; $upd$) p $\omega$}]\phi,\Delta\end{array}}\end{array}$$

$$\begin{array}[]{@{}l@{}}\mbox{\small{$\mathsf{unwindWhileLoop}$}}\\ \quad\genfrac{}{}{}{0}{\begin{array}[]{l}\Gamma\Longrightarrow\{\mathcal{U}~{}||~{}\text{x}\mathrel{:=}\text{TRUE}~{}||~{}\text{cont}\mathrel{:=}\text{FALSE}\}}{\\ \qquad\quad[\text{$\pi$ $\circlearrowright_{\text{x}}$ if ($nse$) $l_{1}:\ldots l_{n}:$ \hbox{{\char 123\relax}} p x = false; \hbox{{\char 125\relax}}}\\ \qquad\qquad\qquad\,\text{if (!x) \hbox{{\char 123\relax}} x = true; cont = true; \hbox{{\char 125\relax}} $\circlearrowleft$}\\ \qquad\qquad\ \text{if (cont) $l_{1}:\ldots l_{n}:$ while ($nse$) p $\omega$}]{\phi},\Delta\end{array}}{\begin{array}[]{l}\Gamma\Longrightarrow\{\mathcal{U}\}[\text{$\pi$ $l_{1}:\ldots l_{n}:$ while ($nse$) p $\omega$}]\phi,\Delta\end{array}}\end{array}$$

$$\begin{array}[]{@{}l@{}}\mbox{\small{$\mathsf{unwindForLoop}$}}\\ \quad\genfrac{}{}{}{0}{\begin{array}[]{l}\Gamma\Longrightarrow\{\mathcal{U}~{}||~{}\text{x}\mathrel{:=}\text{TRUE}~{}||~{}\text{cont}\mathrel{:=}\text{FALSE}\}}{\\ \qquad\quad[\text{$\pi$ $\circlearrowright_{\text{x}}$ if ($guard^{\prime}$) $l_{1}:\ldots l_{n}:$ \hbox{{\char 123\relax}} p x = false; \hbox{{\char 125\relax}}}\\ \qquad\qquad\qquad\,\text{if (!x) \hbox{{\char 123\relax}} x = true; $upd^{\prime}$ cont = true; \hbox{{\char 125\relax}} $\circlearrowleft$}\\ \qquad\qquad\ \text{if (cont) $l_{1}:\ldots l_{n}:$ for (; $guard$; $upd$) p $\omega$}]{\phi},\Delta\end{array}}{\begin{array}[]{l}\Gamma\Longrightarrow\{\mathcal{U}\}[\text{$\pi$ $l_{1}:\ldots l_{n}:$ for (; $guard$; $upd$) p $\omega$}]\phi,\Delta\end{array}}\end{array}$$

Full text

1 Introduction

Loop scopes were introduced in [3]. These allow a sound loop invariant rule (which does not require program transformation of the loop body) for programs with non-standard control-flow. In [2] it was shown that an implementation of this new loop invariant rule in KeY [1] also decreases proof size when compared to the existing rule.

The loop invariant rule using loop scopes was proposed only for while loops. Here we briefly sketch how loop invariant rules for for loops using loop scopes can be introduced to avoid program transformation of the loop bodies.

2 Implementation of Loop Scope Rules in KeY

When the rules for loop scopes were imlemented in KeY some changes were made. Among others the implemented loop invariant rule for while loops using loop scopes is as follows:

[TABLE]

In the context of the loop invariant rule these changes to the loop scope rules do not impact the semantics. However, now continuing a loop normally only implicitly sets the loop scope index variable to false, rather than explicitly calling continue.

Another change is that the definition of the rule for the empty loop scope in KeY no longer matches the original rule of [2], where the index was set to true. Now, the index is initialized to true by the loop invariant rule, and the rule processing the empty loop scope checks for its value to decide how to continue:

[TABLE]

In order to keep the semantics equivalent for normal loop continuation and explicit loop continuation via continue statement inside a loop scope, we consider the following formulas111The implemented loop invariant rule for while loops cannot result in these formulas.:

[TABLE]

Simplifying these formulas leads to:

[TABLE]

Simplifying (3) further leads to the formula $\{\text{b}\doteq\text{FALSE}~{}||~{}\text{x}\doteq\text{FALSE}\}[\text{p}]\phi$. As we want the semantics to be equivalent, simplifying (4) needs to result in the same formula. The easiest solution is to ensure that simplifying (4) leads to (3), by replacing the original rule in [3] with the following:

[TABLE]

The difference is that in the original rule the program fragment p is thrown away, while here it is kept (the context is also not deleted, which works well because of the described change to emptyIndexedLoopScope). This has no influence whatsoever on the existing loop invariant rule, which would only ever lead to applications of the $\mathsf{continueIndexedLoopScope}$ rule with an empty p (since the body is contained in a block, and the remainder of a block is discarded by the $\mathsf{blockContinue}$ rule). However, it allows us to treat for-loops. In fact, the example formulas (1) and (2) use loop scopes to model the following two programs222As will be shown later, this is not quite accurate, as p is an expression list inside the programs, but a program fragment in the formulas. While an expression list is not a program fragment, it can easily be converted into one.:

[TABLE]

3 Loop Invariant Rules using Loop Scopes

In order to prove that the loop invariant of a for loop initially holds, we must first reach the “initial” entry point of the loop. This is the point after full execution of the loop initializer. We therefore introduce the following rule to pull out the loop initializer of a for loop, where $init^{\prime}$ is a statement list equivalent to the loop initializer $init$:

[TABLE]

The following loop invariant rule can then be applied to for loops without loop initializers, where $upd^{\prime}$ is a statement list equivalent to the expression list $upd$, and $guard^{\prime}$ is an expression equivalent to $guard$ (true, if $guard$ is empty):

[TABLE]

Execution of $upd^{\prime}$ must be wrapped ({ x = true; $upd^{\prime}$ x = false; }) to ensure that an exception thrown in $upd^{\prime}$ causes x to be set to true as required.

4 Loop Unwinding Rules using Loop Scopes

Using this new idea we can also create a loop unwinding rule for while loops which does not require nested modalities as the rule in [3] does:

[TABLE]

The idea here is to execute one loop iteration within a loop scope with a continuation that tracks that the loop should be continued and then exits the loop scope. Based on the value of the tracking variable we then either re-enter the loop or continue with the rest of the program.

We can also introduce a loop unwinding rule for the for loop:

[TABLE]

It is important that $upd^{\prime}$ is executed after setting x to true and before setting cont to true, to ensure that an exception thrown in $upd^{\prime}$ leaves x set to true while cont remains false.