Reductions for Automated Hypersafety Verification

TL;DR

This paper introduces an automated verification method for hypersafety properties, using reductions to simplify the proof process by analyzing a representative set of program runs, demonstrated with the tool Weaver.

Contribution

It presents a novel reduction-based approach for hypersafety verification and an algorithm that combines reduction search with proof generation in a counterexample-guided loop.

Findings

Weaver effectively verifies diverse hypersafety properties.

The reduction approach simplifies complex hypersafety proofs.

The method is applicable to various classes of input programs.

Abstract

We propose an automated verification technique for hypersafety properties, which express sets of valid interrelations between multiple finite runs of a program. The key observation is that constructing a proof for a small representative set of the runs of the product program (i.e. the product of the several copies of the program by itself), called a reduction, is sufficient to formally prove the hypersafety property about the program. We propose an algorithm based on a counterexample-guided refinement loop that simultaneously searches for a reduction and a proof of the correctness for the reduction. We demonstrate that our tool Weaver is very effective in verifying a diverse array of hypersafety properties for a diverse class of input programs.

Tables

Table 1. Table 1. Experimental results averages for benchmark groups.

Benchmark Group	Group Count	Proof Size	Number of Refinement Rounds	Proof Construction Time	Proof Checking Time	Total Time
Looping programs of (SousaD16, ) 2-safety properties	5	63	12	46.69s	0.1s	47.03s
Looping programs of (SousaD16, ) 3-safety properties	8	155	22	475.78s	11.79s	448.36s
Loop-free programs of (SousaD16, )	27	5	2	0.13s	0.0004s	0.15s
Our sequential benchmarks	13	30	9	14.27s	2.5s	17.94s
Our parallel benchmarks	7	31	8	17.95	0.56s	18.63s

Table 2. Table 2. The detailed results of the winning algorithm performed on our benchmarks. TO = total-order, P = partition, N = naive, BPE(?n) = bounded-progress-ensuring (with n 𝑛 n counterexamples from left (L), middle (M), or round-robin (RR)).

Benchmark	Property	Algorithm	Proof Size	Refinement Rounds	Proof Construction Time	Proof Checking Time	Total Time
Our Sequential Benchmarks
ArrayEq	Symm	BPE(RR)	17	10	1.17s	0.16s	1.38s
ArrayEq	Trans	BPE(M5)	97	15	156.17s	30.71s	201.2s
Mult	Dist	BPE(M1)	21	11	1.34s	1.32s	2.94s
Mult	Dist (Flipped)	BPE(L1)	27	12	2.54s	1.38s	4s
Security	Sec	BPE(RR)	12	6	0.41s	0.052s	0.49s
Unroll2	Equiv	BPE(RR)	21	9	1.42s	0.017s	1.48s
Unroll3	Equiv	BPE(RR)	25	9	1.99s	0.02s	2.06s
Unroll4	Equiv	BPE(L1)	31	11	3.31s	0.05s	3.43s
Unroll5	Equiv	BPE(L1)	36	12	4.87s	0.06s	5.01s
UnrollCond2	Equiv	BPE(RR)	22	7	0.85s	0.01s	0.88s
UnrollCond3	Equiv	BPE(RR)	30	9	2.28s	0.02s	2.35s
UnrollCond4	Equiv	BPE(L1)	38	9	4.7s	0.02s	4.8s
UnrollCond5	Equiv	BPE(L1)	45	10	7.06s	0.02s	7.18s
Our Parallel Benchmarks
Barrier	Det	BPE(RR)	21	6	4.05s	1.98s	6.1s
Lamport	Equiv	BPE(RR)	28	8	3.24s	0.44s	3.77s
ParallelSum1	Equiv	BPE(M5)	32	7	6.01s	0.19s	6.45s
ParallelSum1	Det	BPE(RR)	37	13	10.38s	0.22s	10.72s
ParallelSum2	Det	BPE(RR)	86	15	101.89s	1.07s	103.23s
SimpleInc	Equiv	BPE(M1)	7	2	0.05s	0.0008s	0.06s
Spaghetti	Det	BPE(RR)	4	2	0.03s	0.02s	0.05s
Stress Tests
Exp1x3	Det	BPE(L1)	10	5	0.13s	0.005s	0.15s
Exp2x3	Det	BPE(L1)	17	8	0.88s	3.03s	3.95s
Exp2x4	Det	BPE(RR)	18	8	1.11s	4.23s	5.39s
Exp2x6	Det	BPE(RR)	19	8	1.32s	8.26s	9.65s
Exp2x9	Det	BPE(RR)	19	8	1.34s	19.19s	20.61s
Exp3x3	Det	BPE(L5)	26	11	3.77s	1672.05s	1676.61s

Table 3. Table 3. The detailed results of the winning algorithm performed on benchmarks from ( SousaD16, ) . TO = total-order, P = partition, N = naive, BPE(?n) = bounded-progress-ensuring (with n 𝑛 n counterexamples from left (L), middle (M), or round-robin (RR))

Benchmark	Property	Algorithm	Proof Size	Refinement Rounds	Proof Construction Time	Proof Checking Time	Total Time
ArrayInt	CompSubst	BPE(RR)	146	20	517.33s	5.22	523.82
ArrayInt	CompSymm	BPE(RR)	29	8	6.21s	0.02s	6.36s
ArrayInt	CompTrans	BPE(RR)	148	21	390.15s	2.27s	393.66s
Chromosome	CompSubst	BPE(L1)	136	18	211.34s	11.39s	223.58s
Chromosome	CompSymm	BPE(RR)	99	16	61.68s	0.15s	62.2s
Chromosome	CompTrans	BPE(L1)	179	23	274s	16.56s	291.22s
Collitem	CompSubst	BPE(M1)	5	2	0.5s	0.0004s	0.55s
Collitem	CompSymm	BPE(M1)	4	2	0.09s	0.0003s	0.12s
Collitem	CompTrans	BPE(M1)	5	2	0.21s	0.0003s	0.24s
Container	CompSubst	BPE(M1)	5	2	0.39s	0.0004s	0.43s
Container	CompSymm	BPE(M1)	4	2	0.09s	0.001s	0.12s
Container	CompTrans	BPE(M1)	5	2	0.22s	0.0005s	0.25s
ExpTerm	CompSubst	BPE(L1)	5	2	0.16s	0.0005s	0.18s
ExpTerm	CompSymm	BPE(M1)	4	2	0.07s	0.0003s	0.08s
ExpTerm	CompTrans	BPE(M1)	4	2	0.08s	0.0003s	0.09s
FileItem	CompSubst	BPE(RR)	5	2	0.14s	0.0004s	0.16s
FileItem	CompSymm	BPE(RR)	4	2	0.07s	0.0003s	0.08s
FileItem	CompTrans	BPE(L1)	5	2	0.12s	0.0004s	0.13s
Match	CompSubst	BPE(RR)	5	2	0.11s	0.0004s	0.12s
Match	CompSymm	BPE(M1)	4	2	0.06s	0.0005s	0.07s
Match	CompTrans	BPE(RR)	5	2	0.07s	0.0004s	0.08s
NameComparator	CompSubst	BPE(L1)	75	14	70.41s	0.37s	71.03s
NameComparator	CompSymm	BPE(L1)	49	9	15.5s	0.026s	15.66s
NameComparator	CompTrans	BPE(L1)	114	18	114.88s	3.56s	118.84s
Node	CompSubst	BPE(L1)	5	2	0.27s	0.0004s	0.3s
Node	CompSymm	BPE(L1)	4	2	0.06s	0.0002s	0.08s
Node	CompTrans	BPE(RR)	5	2	0.1s	0.0004s	0.11s
NzbFile	CompSubst	BPE(RR)	298	33	2026.73s	28.51s	2056.9s
NzbFile	CompSymm	BPE(RR)	111	19	144.96s	0.27s	145.72s
NzbFile	CompTrans	BPE(RR)	219	29	751.71s	43.97s	796.54s
SimplStr	CompSubst	BPE(RR)	5	2	0.12s	0.0003s	0.13s
SimplStr	CompSymm	BPE(L1)	4	2	0.03s	0.0002s	0.04s
SimplStr	CompTrans	BPE(RR)	5	2	0.07s	0.0003s	0.07s
Sponsored	CompSubst	BPE(RR)	5	2	0.07s	0.0003s	0.08s
Sponsored	CompSymm	BPE(M1)	4	2	0.03s	0.0002s	0.03s
Sponsored	CompTrans	BPE(M1)	5	2	0.03s	0.0003s	0.04s
Time	CompSubst	BPE(M1)	5	2	0.17s	0.0005s	0.19s
Time	CompSymm	BPE(M1)	4	2	0.03s	0.0005s	0.04s
Time	CompTrans	BPE(M1)	5	2	0.07s	0.0004s	0.08s
Word	CompSubst	BPE(RR)	103	18	179.29s	2.59s	182.28s
Word	CompSymm	BPE(RR)	26	8	5.14s	0.017s	5.22s
Word	CompTrans	BPE(RR)	129	22	221.94s	3.48s	225.78s

Table 4. Table 4. The detailed results of the last round of proof checking for all benchmarks, with and without the antichain optimization. The value of the Threads column is the number of threads in the encoded program. Benchmarks whose proofs take less than 0.01 seconds to check are omitted.

Benchmark	Property	Threads	Proof Size	Optimized Time	Unoptimized Time
Our Sequential Benchmarks
ArrayEq	Symm	2	17	0.03s	0.13s
ArrayEq	Trans	3	97	5.99s	75.53s
Mult	Dist	3	21	0.42s	5.21s
Mult	Dist (Flipped)	3	27	0.33s	3.11s
Security	Sec	2	12	0.01s	0.06s
Unroll2	Equiv	2	21	0.003s	0.007s
Unroll3	Equiv	2	25	0.005s	0.01s
Unroll4	Equiv	2	31	0.01s	0.05s
Unroll5	Equiv	2	36	0.01s	0.05s
UnrollCond2	Equiv	2	22	0.002s	0.003s
UnrollCond3	Equiv	2	30	0.003s	0.005s
UnrollCond4	Equiv	2	38	0.007s	0.02s
UnrollCond5	Equiv	2	45	0.006s	0.01s
Our Parallel Benchmarks
Barrier	Det	4	21	0.47s	11.46s
Lamport	Equiv	3	28	0.09s	0.36s
ParallelSum1	Equiv	3	32	0.09s	1.10s
ParallelSum1	Det	4	37	0.12s	1.17s
ParallelSum2	Det	4	86	0.1s	1.21s
SimpleInc	Equiv	3	7	0.0004s	0.001s
Spaghetti	Det	4	4	0.004s	2.28s
Stress Tests
Exp1x3	Det	2	10	0.002s	0.005s
Exp2x3	Det	4	17	1.15s	27.2s
Exp2x4	Det	4	18	1.33s	36.009s
Exp2x6	Det	4	19	2.34s	80.98s
Exp2x9	Det	4	19	5.045s	222.45s
Exp3x3	Det	6	26	910.03s	T/O
Benchmarks from (SousaD16, )
ArrayInt	CompSubst	3	146	0.54s	2.47s
ArrayInt	CompSymm	2	29	0.004s	0.005s
ArrayInt	CompTrans	3	148	0.13s	0.71s
Chromosome	CompSubst	3	136	2.81s	32.63s
Chromosome	CompSymm	2	99	0.02s	0.02s
Chromosome	CompTrans	3	179	3.25s	24.55s
NameComparator	CompSubst	3	75	0.02s	0.31s
NameComparator	CompSymm	2	49	0.004s	0.009s
NameComparator	CompTrans	3	114	0.22s	1.79s
NzbFile	CompSubst	3	298	6.25s	34.38s
NzbFile	CompSymm	2	111	0.041s	0.082s
NzbFile	CompTrans	3	219	9.39s	50.74s
Word	CompSubst	3	103	0.42s	2.11s
Word	CompSymm	2	26	0.005s	0.007s
Word	CompTrans	3	129	0.39s	2.038s

Equations

$$\exists \Pi \subseteq \mathcal{A}.P\subseteq \mathcal{L}(\Pi )$$

$$\exists P^{\prime }⪯P,\Pi \subseteq \mathcal{A}.P^{\prime }\subseteq \mathcal{L}(\Pi )$$

$$\exists P^{\prime }\in \mathcal{R}.P^{\prime }\subseteq \mathcal{L}(\Pi )$$

$${\Delta }_{\cap }=\{((q_1,q_2),B,\lambda a.({\sigma }_1(a),{\sigma }_2(a)))\mid (q_1,B,{\sigma }_1)\in {\Delta }_1\wedge (q_2,B,{\sigma }_2)\in {\Delta }_2\}$$

$${\Delta }_{\mathcal{P}(L)}=\{(q,B,\lambda a.\delta (q,a))\mid B⟹q\in F\}$$

$$(a,b)\in [[P]]$$

$$⟺\exists x\in [P^{\prime }{]}_D.(a,b)\in [[x]]$$

$$⟺\exists x.\exists y\in P^{\prime }.x{\sim }_{D}y\wedge (a,b)\in [[x]]$$

$$⟺\exists x.\exists y\in P^{\prime }.x{\sim }_{D}y\wedge (a,b)\in [[y]]$$

$$⟺\exists y\in P^{\prime }.(a,b)\in [[y]]$$

$$⟺(a,b)\in [[P^{\prime }]]$$

$${\mathrm{sleep}}_R(ϵ)$$

$${\mathrm{sleep}}_R(xa)$$

$$x\in {\mathrm{ignore}}_R$$

$$a\in {\mathrm{sleep}}_R(x)$$

$$[P\setminus {\mathrm{ignore}}_R{]}_D$$

$$=P\cap [\overline{{\mathrm{ignore}}_R}{]}_D$$

$$=P\cap {\Sigma }^{\ast }$$

$$=P$$

$${\mathrm{ignore}}_R=\{x_{1}a{x}_{2}b{x}_3\mid (a,b)\in R(x_1)\wedge (\forall c\in a{x}_2.(c,b)\notin D)\}$$

$$xay{<}_{R}xbz⟺(b,a)\in R(x)\wedge |y|=|z|$$

$${\Delta }_D=\{((q,\iota ,S),q\in F\wedge \neg \iota ,\lambda a.(\delta (q,a),\iota \vee a\in S,(S\cup R(a))\setminus D(a))\mid R\in \mathcal{L}in(\Sigma )\}$$

$$\forall (q,B,\sigma )\in \Delta .\exists a.\sigma (a)\in \mathrm{inactive}(M)$$

$$F_M(X)=\{q\mid \forall (q,B,\sigma )\in \Delta .\exists a.\sigma (a)\in X\}.$$

$$\max (\mathrm{inactive}(M))=$$

$$=$$

$$F_{M_{P\Pi }}(X)$$

$$=$$

$$M_{P\Pi }$$

$${\Delta }_{\cap }$$

$${\Delta }_{\mathcal{P}(\mathcal{L}(\Pi ))}$$

$${\Delta }_D$$

$$\forall R\in \mathcal{L}in(R).\exists a.((q_P^{\prime },\top ,(S\cup R(a))\setminus D(a)),{\delta }_{\Pi }(q_{\Pi },a))\in X$$

$$S\subseteq S^{\prime }⟹((q_P,\perp ,S),q_{\Pi }){⊑}_{P\Pi }((q_P,\perp ,S^{\prime }),q_{\Pi })$$

$$F_{M_{P\Pi }}(X)$$

$$=$$

$$M_{P\Pi }$$

$${\Delta }_{\cap }$$

$${\Delta }_{\mathcal{P}(\mathcal{L}(\Pi ))}$$

$${\Delta }_D$$

$$\mathbb{B}$$

Full text

1. Introduction

A hypersafety property describes the set of valid interrelations between multiple finite runs of a program. A $k$-safety property (ClarksonS08, ) is a program safety property whose violation is witnessed by at least $k$ finite runs of a program. Determinism is an example of such a property: non-determinism can only be witnessed by two runs of the program on the same input which produce two different outputs. This makes determinism an instance of a 2-safety property.

The vast majority of existing program verification methodologies are geared towards verifying standard (1-)safety properties. This paper proposes an approach to automatically reduce verification of $k$-safety to verification of 1-safety, and hence a way to leverage existing safety verification techniques for hypersafety verification. The most straightforward way to do this is via self-composition (BartheDR11, ), where verification is performed on $k$ memory-disjoint copies of the program, sequentially composed one after another. Unfortunately, the proofs in these cases are often very verbose, since the full functionality of each copy has to be captured by the proof. Moreover, when it comes to automated verification, the invariants required to verify such programs are often well beyond the capabilities of modern solvers (TerauchiA05, ) even for very simple programs and properties.

The more practical approach, which is typically used in manual or automated proofs of such properties, is to compose $k$ memory-disjoint copies of the program in parallel (instead of in sequence), and then verify some reduced program obtained by removing redundant traces from the program formed in the previous step. This parallel product program can have many such reductions. For example, the program formed from sequential self-composition is one such reduction of the parallel product program. Therefore, care must be taken to choose a “good” reduction that admits a simple proof. Many existing approaches limit themselves to a narrow class of reductions, such as the one where each copy of the program executes in lockstep (BartheCK11, ; EilersMH18, ; SousaD16, ), or define a general class of reductions, but do not provide algorithms with guarantees of covering the entire class (BartheCK13, ; SousaD16, ).

We propose a solution that combines the search for a safety proof with the search for an appropriate reduction, in a counterexample-based refinement loop. Instead of settling on a single reduction in advance, we try to verify the entire (possibly infinite) set of reductions simultaneously and terminate as soon as some reduction is successfully verified. If the proof is not currently strong enough to cover at least one of the represented program reductions, then an appropriate set of counterexamples are generated that guarantee progress towards a proof.

Our solution is language-theoretic. We propose a way to represent sets of reductions using infinite tree automata. The standard safety proofs are also represented using the same automata, which have the desired closure properties. This allows us to check if a candidate proof is in fact a proof for one of the represented program reductions, with reasonable efficiency.

Our approach is not uniquely applicable to hypersafety properties of sequential programs. Our proposed set of reductions naturally work well for concurrent programs, and can be viewed in the spirit of reduction-based methods such as those proposed in (ElmasQT09, ; PopeeaRW14, ). This makes our approach particularly appealing when it comes to verification of hypersafety properties of concurrent programs, for example, proving that a concurrent program is deterministic. The parallel composition for hypersafety verification mentioned above and the parallel composition of threads inside the multi-threaded program are treated in a uniform way by our proof construction and checking algorithms. In summary:

• •

We present a counterexample-guided refinement loop that simultaneously searches for a proof and a program reduction in Section 7. This refinement loop relies on an efficient algorithm for proof checking based on the antichain method of (WulfDHR06, ), and strong theoretical progress guarantees.

• •

We propose an automata-based approach to representing a class of program reductions for k-safety verification. In Section 5 we describe the precise class of automata we use and show how their use leads to an effective proof checking algorithm incorporated in our refinement loop.

• •

We demonstrate the efficacy of our approach in proving hypersafety properties of sequential and concurrent benchmarks in Section 8.

2. Illustrative Example

We use a simple program Mult, that computes the product of two non-negative integers, to illustrate the challenges of verifying hypersafety properties and the type of proof that our approach targets. Consider the multiplication program in Figure 1(i), and assume we want to prove that it is distributive over addition.

In Figure 1 (ii), the parallel composition of Mult with two copies of itself is illustrated. The product program is formed for the purpose of proving distributivity, which can be encoded through the postcondition $x_{1}=x_{2}+x_{3}$. Since $a$, $b$, and $c$ are not modified in the program, the same variables are used across all copies. One way to prove Mult is distributive is to come up with an inductive invariant $\phi_{ijk}$ for each location in the product program, represented by a triple of program locations $(\ell_{i},\ell_{j},\ell_{k})$, such that $\mathit{true}\implies\phi_{111}$ and $\phi_{666}\implies x_{1}=x_{2}+x_{3}$. The main difficulty lies in finding assignments for locations such as $\phi_{611}$ that are points in the execution of the program where one thread has finished executing and the next one is starting. For example, at $(\ell_{6},\ell_{1},\ell_{1})$ we need the assignment $\phi_{611}\leftarrow x_{1}=(a+b)*c$ which is non-linear. However, the program given in Figure 1(ii) can be verified with simpler (linear) reasoning.

The program on the right is a semantically equivalent reduction of the full composition of Figure 1(ii). Consider the program $P$ = (Copy 1 $||$ (Copy 2; Copy 3)). The program on the right is equivalent to a lockstep execution of the two parallel components of $P$. The validity of this reduction is derived from the fact that the statements in each thread are independent of the statements in the other. That is, reordering the statements of different threads in an execution leads to an equivalent execution. It is easy to see that $x_{1}=x_{2}+x_{3}$ is an invariant of both while loops in the reduced program, and therefore, linear reasoning is sufficient to prove the postcondition for this program. Conceptually, this reduction (and its soundness proof) together with the proof of correctness for the reduced program constitute a proof that the original program Mult is distributive. Our proposed approach can come up with reductions like this and their corresponding proofs fully automatically. Note that a lockstep reduction of the program in Figure 1(ii) would not yield a solution for this problem and therefore the discovery of the right reduction is an integral part of the solution.

3. Programs and Proofs

A non-deterministic finite automaton (NFA) is a tuple $A=(Q,\Sigma,\delta,q_{0},F)$ where $Q$ is a finite set of states, $\Sigma$ is a finite alphabet, $\delta\subseteq Q\times\Sigma\times Q$ is the transition relation, $q_{0}\in Q$ is the initial state, and $F\subseteq Q$ is the set of final states. A deterministic finite automaton (DFA) is an NFA whose transition relation is a function $\delta:Q\times\Sigma\to Q$. The language of an NFA or DFA $A$ is denoted $\mathcal{L}(A)$, which is defined in the standard way (Hopcroft:2006, ).

3.1. Program Traces

$\mathcal{S}t$ denotes the (possibly infinite) set of program states. For example, a program with two integer variables has $\mathcal{S}t=\mathbb{Z}\times\mathbb{Z}$. $\mathcal{A}\subseteq\mathcal{S}t$ is a (possibly infinite) set of assertions on program states. $\Sigma$ denotes a finite alphabet of program statements. We refer to a finite string of statements as a (program) trace. For each statement $a\in\Sigma$ we associate a semantics $\llbracket a\rrbracket\subseteq\mathcal{S}t\times\mathcal{S}t$ and extend $\llbracket-\rrbracket$ to traces via (relation) composition. A trace $x\in\Sigma^{*}$ is said to be infeasible if $\llbracket x\rrbracket(\mathcal{S}t)=\emptyset$, where $\llbracket x\rrbracket(\mathcal{S}t)$ denotes the image of $\llbracket x\rrbracket$ under $\mathcal{S}t$.

To abstract away from a particular program syntax, we define a program as a regular language of traces. The semantics of a program $P$ is simply the union of the semantics of its traces $\llbracket P\rrbracket=\bigcup_{x\in P}\llbracket x\rrbracket$. Concretely, one may obtain programs as languages by interpreting their edge-labelled control-flow graphs as DFAs: each vertex in the control flow graph is a state, and each edge in the control flow graph is a transition. The control flow graph entry location is the initial state of the DFA and all its exit locations are final states.

3.2. Safety

There are many equivalent notions of program safety; we use non-reachability. A program $P$ is safe if all traces of $P$ are infeasible, i.e. $\llbracket P\rrbracket(\mathcal{S}t)=\emptyset$. Standard partial correctness specifications are then represented via a simple encoding. Given a precondition $\phi$ and a postcondition $\psi$, the validity of the Hoare-triple $\{\phi\}P\{\psi\}$ is equivalent to the safety of $[\phi]\cdot P\cdot[\neg\psi]$, where $[]$ is a standard assume statement (or the singleton set containing it), and $\cdot$ is language concatenation.

Example 3.1.

We use determinism as an example of how $k$-safety can be encoded in the framework defined thus far. If $P$ is a program then determinism of $P$ is equivalent to safety of $[\phi]\cdot(P_{1}\shuffle P_{2})\cdot[\neg\phi]$ where $P_{1}$ and $P_{2}$ are copies of $P$ operating on disjoint variables, $\shuffle$ is a shuffle product of two languages, and $[\phi]$ is an assume statement asserting that the variables in each copy of $P$ are equal.

A proof is a finite set of assertions $\Pi\subseteq\mathcal{A}$ that includes $\mathit{true}$ and $\mathit{false}$. Each $\Pi$ gives rise to an NFA $\Pi_{NFA}=(\Pi,\mathcal{S}t,\delta_{\Pi},\mathit{true},\{\mathit{false}\})$ where $\delta_{\Pi}(\phi_{pre},a)=\{\phi_{post}\mid\llbracket a\rrbracket(\phi_{pre})\subseteq\phi_{post}\}$. We abbreviate $\mathcal{L}(\Pi_{NFA})$ as $\mathcal{L}(\Pi)$. Intuitively, $\mathcal{L}(\Pi)$ consists of all traces that can be proven infeasible using only assertions in $\Pi$. Thus the following proof rule is sound (FarzanKP13, ; FarzanKP15, ; HeizmannHP09, ):

[TABLE]

When $P\subseteq\mathcal{L}(\Pi)$, we say that $\Pi$ is a proof for $P$. A proof does not uniquely belong to any particular program; a single $\Pi$ may prove many programs correct.

4. Reductions

The set of assertions used for a proof is usually determined by a particular language of assertions, and a safe program may not have a (safety) proof in that particular language. Yet, a subset of the program traces may have a proof in that assertion language. If it can be proven that the subset of program runs that have a safety proof are a faithful representation of all program behaviours (with respect to a given property), then the program is correct. This motivates the notion of program reductions.

Definition 4.1 (semantic reduction).

If for programs $P$ and $P^{\prime}$, $P^{\prime}$ is safe implies that $P$ is safe, then $P^{\prime}$ is a semantic reduction of $P$ (written $P^{\prime}\preceq P$).

The definition immediately gives rise to the following proof rule for proving program safety:

[TABLE]

This generic proof rule is not automatable since, given a proof $\Pi$, verifying the existence of the appropriate reduction is undecidable. Observe that a program is safe if and only if $\emptyset$ is a valid reduction of the program. This means that discovering a semantic reduction and proving safety are mutually reducible to each other. To have decidable premises for the proof rule, we need to formulate an easier (than proving safety) problem in discovering a reduction. One way to achieve this is by restricting the set of reductions under consideration from all reductions (given in Definition 4.1) to a proper subset which more amenable to algorithmic checking. Fixing a set $\mathcal{R}$ of (semantic) reductions, we will have the rule:

[TABLE]

Proposition 4.2.

The proof rule SafeRed2 is sound.

Proof.

By the left precondition, there exists some $P^{\prime}\in\mathcal{R}$ such that $P^{\prime}\subseteq\mathcal{L}(\Pi)$, which implies $\llbracket P^{\prime}\rrbracket=\emptyset$. By the right precondition, $\llbracket P\rrbracket=\llbracket P^{\prime}\rrbracket$, and therefore $P$ is safe. ∎

The core contribution of this paper is that it provides an algorithmic solution inspired by the above proof rule. To achieve this, two subproblems are solved: (1) Given a set $\mathcal{R}$ of reductions of a program $P$ and a candidate proof $\Pi$, can we check if there exists a reduction $P^{\prime}\in\mathcal{R}$ which is covered by the proof $\Pi$? In section 5, we propose a new semantic interpretation of an existing notion of infinite tree automata that gives rise to an algorithmic check for this step. (2) Given a program $P$, is there a general sound set of reductions $\mathcal{R}$ that be effectively represented to accommodate step (1)? In section 6, we propose a construction of an effective set of reductions, representable by our infinite tree automata, using inspirations from known partial order reduction techniques (Godefroid96, ).

5. Proof Checking

Given a set of reductions $\mathcal{R}$ of a program $P$, and a candidate proof $\Pi$, we want to check if there exists a reduction $P^{\prime}\in\mathcal{R}$ which is covered by $\Pi$. We call this proof checking. We use tree automata to represent certain classes of languages (i.e sets of sets of strings), and then use operations on these automata for the purpose of proof checking.

The set $\Sigma^{*}$ can be represented as an infinite tree. Each $x\in\Sigma^{*}$ defines a path to a unique node in the tree: the root node is located at the empty string $\epsilon$, and for all $a\in\Sigma$, the node located at $xa$ is a child of the node located at $x$. Each node is then identified by the string labeling the path leading to it. A language $L\subseteq\Sigma^{*}$ (equivalently, $L:\Sigma^{*}\to\mathbb{B}$) can consequently be represented as an infinite tree where the node at each $x$ is labelled with a boolean value $B\equiv(x\in L)$. An example is given in Figure 2. It follows that a set of languages is a set of infinite trees, which can be represented using automata over infinite trees. Looping Tree Automata (LTAs) are a subclass of Büchi Tree Automata where all states are accept states (BaaderT01, ). The class of Looping Tree Automata is closed under intersection and union, and checking emptiness of LTAs is decidable. Unlike Büchi Tree Automata, emptiness can be decided in linear time (BaaderT01, ).

Definition 5.1.

A Looping Tree Automaton (LTA) over $|\Sigma|$-ary, $\mathbb{B}$-labelled trees is a tuple $M=(Q,\Delta,q_{0})$ where $Q$ is a finite set of states, $\Delta\subseteq Q\times\mathbb{B}\times(\Sigma\to Q)$ is the transition relation, and $q_{0}$ is the initial state.

Intuitively, an LTA $M=(Q,\Delta,q_{0})$ performs a parallel and depth-first traversal of an infinite tree $L$ while maintaining some local state. Execution begins at the root $\epsilon$ from state $q_{0}$ and non-deterministically picks a transition $(q_{0},B,\sigma)\in\Delta$ such that $B$ matches the label at the root of the tree (i.e. $B=(\epsilon\in L)$). If no such transition exists, the tree is rejected. Otherwise, $M$ recursively works on each child $a$ from state $q^{\prime}=\sigma(a)$ in parallel. This process continues infinitely, and $L$ is accepted if and only if $L$ is never rejected.

Formally, $M$’s execution over a tree $L$ is characterized by a run $\delta^{*}:\Sigma^{*}\to Q$ where $\delta^{*}(\epsilon)=q_{0}$ and $(\delta^{*}(x),x\in L,\lambda a\ldotp\delta^{*}(xa))\in\Delta$ for all $x\in\Sigma^{*}$. The set of languages accepted by $M$ is then defined as \mathcal{L}(M)=\{L\mid\exists\delta^{*}\ldotp\text{\delta^{*}$is a run of$M$on$L}\}.

Theorem 5.2.

Given an LTA $M$ and a regular language $L$, it is decidable whether $\exists P\in\mathcal{L}(M)\ldotp P\subseteq L$.

Proof.

The proposition $\exists P\in\mathcal{L}(M)\ldotp P\subseteq L$ is equivalent to the proposition $\mathcal{L}(M)\cap{\mathcal{P}(L)}=\emptyset$. LTA languages are closed under intersection (Lemma 5.3), ${\mathcal{P}(L)}$ is recognized by an LTA (Lemma 5.4), and LTA emptiness is decidable (BaaderT01, ), so $\mathcal{L}(M)\cap{\mathcal{P}(L)}=\emptyset$ (and therefore $\exists P\in\mathcal{L}(M)\ldotp P\subseteq L$) is decidable. ∎

Lemma 5.3.

The set of languages accepted by an LTA is closed under intersection.

Proof.

The standard construction for Büchi tree automata intersection also works for LTAs. There is a simpler construction specifically for LTAs, which we include here.

Let $M_{1}=(Q_{1},\Delta_{1},q_{01})$ and $M_{2}=(Q_{2},\Delta_{2},q_{02})$ be LTAs. Define $M_{\cap}=(Q_{1}\times Q_{2},\Delta_{\cap},(q_{01},q_{02}))$, where

[TABLE]

Then $\mathcal{L}(M_{\cap})=\mathcal{L}(M_{1})\cap\mathcal{L}(M_{2})$.

This proof has been mechanically checked. ∎

Lemma 5.4.

If $L$ is a regular language, then ${\mathcal{P}(L)}$ is recognized by an LTA.

Proof.

Since $L$ is a regular language, there exists a DFA $A=(Q,\Sigma,\delta,q_{0},F)$ such that $\mathcal{L}(A)=L$. Define $M_{\mathcal{P}(L)}=(Q,\Delta_{\mathcal{P}(L)},q_{0})$ where

[TABLE]

Then $\mathcal{L}(M_{\mathcal{P}(L)})={\mathcal{P}(L)}$.

This proof has been mechanically checked. ∎

Counterexamples.

Theorem 5.2 effectively states that proof checking is decidable. For automated verification, beyond checking the validity of a proof, we require counterexamples to fuel the development of the proof when the proof does not check. Note that in the simple case of the proof rule Safe, when $P\not\subseteq\mathcal{L}(\Pi)$ there exists a counterexample trace $x\in P$ such that $x\notin\mathcal{L}(\Pi)$.

With our proof rule SafeRed2, things get a bit more complicated. First, note that unlike the classic case (Safe), where a failed proof check coincides with the non-emptiness of an intersection check (i.e. $P\cap\overline{\mathcal{L}(\Pi)}\not=\emptyset$), in our case, a failed proof check coincides with the emptiness of an intersection check (i.e. $\mathcal{R}\cap{\mathcal{P}(\mathcal{L}(\Pi))}=\emptyset$). The sets $\mathcal{R}$ and ${\mathcal{P}(\mathcal{L}(\Pi))}$ are both sets of languages. What does the witness to the emptiness of the intersection look like? Each language member of $\mathcal{R}$ contains at least one string that does not belong to any of the subsets of our proof language. One can collect all such witness strings to guarantee progress across the board in the next round. However, since LTAs can represent an infinite set of languages, one must take care not end up with an infinite set of counterexamples following this strategy. Fortunately, this will not be the case.

Theorem 5.5.

Let $M$ be an LTA and let $L$ be a regular language such that $P\not\subseteq L$ for all $P\in\mathcal{L}(M)$. There exists a finite set of counterexamples $C$ such that, for all $P\in\mathcal{L}(M)$, there exists some $x\in C$ such that $x\in P$ and $x\notin L$.

Proof.

Assume $M=(Q_{M},\Delta_{M},q_{0M})$ and let $A=(Q_{A},\Sigma,\delta_{A},q_{0A},F_{A})$ be an automaton that accepts $L$.

Assume $P\not\subseteq L$ for all $P\in\mathcal{L}(M)$. Then $\mathcal{L}(M)\cap{\mathcal{P}(L)}=\emptyset$, so the root node of any automaton accepting $\mathcal{L}(M)\cap{\mathcal{P}(L)}$ is inactive (BaaderT01, ). The set of inactive states is the smallest set satisfying

$\forall(q,B,\sigma)\in\Delta\ldotp\exists a\ldotp\sigma(a)\in\mathrm{inactive}(M)$

$q\in\mathrm{inactive}(M)$

If we instantiate this rule for $M_{\cap}$ (from Lemma 5.3) and $M_{\mathcal{P}(L)}$ (from Lemma 5.4), we get

$\forall(q_{M},B,\sigma)\in\Delta_{M}\ldotp(B\implies q_{A}\in F_{A})\implies\exists a\ldotp(\sigma(a),\delta_{A}(q_{A},a))\in\mathrm{inactive}(M_{\cap})$

$(q_{M},q_{A})\in\mathrm{inactive}(M_{\cap})$

A proof of inactivity is essentially a finite tree where every node is labelled by a pair of states $(q_{M},q_{A})$ (the root node labelled by $(q_{0M},q_{0A})$) and contains an outgoing edge labelled by some $a\in\Sigma$ for every transition. We define our counterexample set $C$ as the set of all strings labelling the path from the root node to any leaf node in this tree. Such a set is clearly finite, so it remains to show that every $P\in\mathcal{L}(M)$ contains some element of $C$ that is not in $L$.

Fix some $P\in\mathcal{L}(M)$ and let $\delta^{*}:\Sigma^{*}\to Q_{M}$ be the corresponding accepting run. Since the every node in the tree described above contains an outgoing edge for every transition, there must exist a sequence of nodes through the tree labelled by a sequence of states $(q_{0M},q_{0A})...(q_{nM},q_{nA})$ and string $a=a_{1}...a_{n}\in C$ such that $\delta^{*}(a_{1}...a_{i})=q_{iM}$ for all $0\leq i\leq n$. The state $(q_{nM},q_{nA})$ must have no outgoing transitions or else it would not label a leaf node. However, both $q_{nM}$ and $q_{nA}$ must have outgoing transitions in their own respective automata: $q_{nM}$ is part of an accepting run, and every state in $M_{\subseteq}$ has an outgoing transition by definition. Thus, $(q_{nM},B,\sigma)\in\Delta_{M}$ implies $B=\top$ and $q_{nA}\notin F_{A}$, and therefore $a\in P$ and $a\notin L$.

This proof has been mechanically checked. ∎

This theorem justifies our choice of using LTAs instead of more expressive formalisms such as Büchi Tree Automata. For example, the Büchi Tree Automaton that accepts the language $\{\{x\}\mid x\in\Sigma^{*}\}$ would give rise to an infinite number of counterexamples with respect to the empty proof (i.e. $\Pi=\emptyset$). The finiteness of the counterexample set presents an alternate proof that LTAs are strictly less expressive than Büchi Tree Automata (VardiW94, ).

6. Sleep Set Reductions

We have established so far that (1) a set of assertions gives rise to a regular language proof, and (2) given a regular language proof and a set of program reductions recognizable by an LTA, we can check the program (reductions) against the proof. The last piece of the puzzle is to show that a useful class of program reductions can be expressed using LTAs.

Recall our example from Section 2. The reduction we obtain is sound because, for every trace in the full parallel-composition program, an equivalent trace exists in the reduced program. By equivalent, we mean that one trace can be obtained from the other by swapping independent statements. Such an equivalence is the essence of the theory of Mazurkiewicz traces (DiekertM97, ).

We fix a reflexive symmetric dependence relation $D\subseteq\Sigma\times\Sigma$. For all $a,b\in\Sigma$, we say that $a$ and $b$ are dependent if $(a,b)\in D$, and say they are independent otherwise. We define $\sim_{D}$ as the smallest congruence satisfying $xaby\sim_{D}xbay$ for all $x,y\in\Sigma^{*}$ and independent $a,b\in\Sigma$. The closure of a language $L\subseteq\Sigma^{*}$ with respect to $\sim_{D}$ is denoted $[L]_{D}$. A language $L$ is $\sim_{D}$-closed if $L=[L]_{D}$. It is worthwhile to note that all input programs considered in this paper correspond to regular languages that are $\sim_{D}$-closed.

An equivalence class of $\sim_{D}$ is typically called a (Mazurkiewicz) trace. We avoid using this terminology as it conflicts with our definition of traces as strings of statements in Section 3.1. We assume $D$ is sound, i.e. $\llbracket ab\rrbracket=\llbracket ba\rrbracket$ for all independent $a,b\in\Sigma$.

Definition 6.1 ($D$-reduction).

A program $P^{\prime}$ is a $D$-reduction of a program $P$, that is $P^{\prime}\preceq_{D}P$, if $[P^{\prime}]_{D}=P$.

Note that the equivalence relation on programs induced by $\sim_{D}$ is a refinement of the semantic equivalence relation used in Definition 4.1.

Lemma 6.2.

If $P^{\prime}\preceq_{D}P$ then $P^{\prime}\preceq P$.

Proof.

Since $D$ is sound, then $x\sim_{D}y$ implies $\llbracket x\rrbracket=\llbracket y\rrbracket$ for all $x,y\in\Sigma^{*}$. Then

[TABLE]

for all $a,b\in\mathcal{S}t$, so $\llbracket P^{\prime}\rrbracket=\llbracket P\rrbracket$ and therefore $P^{\prime}\preceq P$. ∎

Ideally, we would like to define an LTA that accepts all $D$-reductions of a program $P$, but unfortunately this is not possible in general.

Proposition 6.3 (corollary of Theorem 67 of (DiekertM97, )).

For arbitrary regular languages $L_{1},L_{2}\in\Sigma^{*}$ and relation $D$, the proposition $\exists L\preceq_{D}L_{1}\ldotp L\subseteq L_{2}$ is undecidable.

Proof.

Assume that we can decide whether $\exists L\preceq_{D}L_{1}\ldotp L\subseteq L_{2}$. Then we can decide whether $[L^{\prime}]_{D}=\Sigma^{*}$ for any regular language $L^{\prime}\subseteq\Sigma^{*}$ (by instantiating $L_{1}=\Sigma^{*}$ and $L_{2}=L^{\prime}$), which is known to be generally undecidable (DiekertM97, ). ∎

The proposition is decidable only when $\overline{D}$ is transitive, which does not hold for a semantically correct notion of independence for a parallel program encoding a $k$-safety property, since statements from the same thread are dependent and statements from different program copies are independent. Therefore, we have:

Proposition 6.4.

Assume $P$ is a $\sim_{D}$-closed program and $\Pi$ is a proof. The proposition $\exists P^{\prime}\preceq_{D}P\ldotp P^{\prime}\subseteq\mathcal{L}(\Pi)$ is undecidable.

In order to have a decidable premise for proof rule SafeRed2 then, we present an approximation of the set of $D$-reductions, inspired by sleep sets (Godefroid96, ). The idea is to construct an LTA that recognizes a class of $D$-reductions of an input program $P$, whose language is assumed to be $\sim_{D}$-closed. This automaton intuitively makes non-deterministic choices about what program traces to prune in favour of other $\sim_{D}$-equivalent program traces for a given reduction. Different non-deterministic choices lead to different $D$-reductions.

Consider two statements $a,b\in\Sigma$ where $(a,b)\not\in D$. Let $x,y\in\Sigma^{*}$ and consider two program runs $xaby$ and $xbay$. We know $\llbracket xbay\rrbracket=\llbracket xaby\rrbracket$. If the automaton makes a non-deterministic choice that the successors of $xa$ have been explored, then the successors of $xba$ need not be explored (can be pruned away) as illustrated in Figure 3. Now assume $(a,c)\in D$, for some $c\in\Sigma$. When the node $xbc$ is being explored, we can no longer safely ignore $a$-transitions, since the equality $\llbracket xbcay\rrbracket=\llbracket xabcy\rrbracket$ is not guaranteed. Therefore, the $a$ successor of $xbc$ has to be explored. The nondeterministic choice of what child node to explore is modelled by a choice of order in which we explore each node’s children. Different orders yield different reductions. Reductions are therefore characterized as an assignment $R:\Sigma^{*}\to\mathcal{L}in(\Sigma)$ from nodes to linear orderings on $\Sigma$, where $(a,b)\in R(x)$ means we explore child $xa$ after child $xb$.

Given $R:\Sigma^{*}\to\mathcal{L}in(\Sigma)$, the sleep set $\mathrm{sleep}_{R}(x)\subseteq\Sigma$ at node $x\in\Sigma^{*}$ defines the set of transitions that can be ignored at $x$:

[TABLE]

Intuitively, (1) no transition can be ignored at the root node, since nothing has been explored yet, and (2) at node $x$, the sleep set of $xa$ is obtained by adding the transitions we explored before $a$ ($R(x)(a)$) and then removing the ones that conflict with $a$ (i.e. are related to $a$ by $D$).

Next, we make precise which nodes are ignored. The set of ignored nodes is the smallest set $\mathrm{ignore}_{R}:\Sigma^{*}\to\mathbb{B}$ such that

[TABLE]

Intuitively, a node $xa$ is ignored if (1) any of its ancestors is ignored ($\mathrm{ignore}_{R}(x)$), or (2) $a$ is one of the ignored transitions at node $x$ ($a\in\mathrm{sleep}_{R}(x)$).

Finally, we obtain an actual reduction of a program $P$ from a characterization of a reduction $R$ by removing the ignored nodes from $P$, i.e. $P\setminus\mathrm{ignore}_{R}$.

Lemma 6.5.

For all $R:\Sigma^{*}\to\mathcal{L}in(\Sigma)$, if $P$ is a $\sim_{D}$-closed program then $P\setminus\mathrm{ignore}_{R}$ is a $D$-reduction of $P$.

Proof.

If $[\overline{\mathrm{ignore}_{R}}]_{D}=\Sigma^{*}$, then

[TABLE]

so it is sufficient to show $[\overline{\mathrm{ignore}_{R}}]_{D}=\Sigma^{*}$. More specifically, it is sufficient to show that for all $x\in\mathrm{ignore}_{R}$ there exists some $y\notin\mathrm{ignore}_{R}$ such that $x\sim_{D}y$.

First, observe that

[TABLE]

Second, define the following ordering on traces

[TABLE]

The $|y|=|z|$ condition enforces that only strings of the same length are related. Since each $R(x)$ is a linear order on a finite set, it follows that $<_{R}$ is well-founded.

Assume $x\in\mathrm{ignore}_{R}$. We proceed by well-founded induction on $x$ using $<_{R}$. By the above observation, we have $x=x_{1}ax_{2}bx_{3}$ for some $x_{1},x_{2},x_{3}\in\Sigma$ and $(a,b)\in R(x_{1})$ such that $(c,b)\notin D$ for all $c\in ax_{2}$. Define $y=x_{1}bax_{2}x_{3}$. Thus $x\sim_{D}y$ and $y<_{R}x$. If $y\notin\mathrm{ignore}_{R}$, then we are done. Otherwise, we have $y\in\mathrm{ignore}_{R}$ and $y<_{R}x$, and so induction completes the proof.

This proof has been mechanically checked. ∎

We define the set of all such reductions as $\mathrm{reduce}_{D}(P)=\{P\setminus\mathrm{ignore}_{R}\mid R:\Sigma^{*}\to\mathcal{L}in(\Sigma)\}$.

Theorem 6.6.

For any regular language $P$, $\mathrm{reduce}_{D}(P)$ is accepted by an LTA.

Proof.

Since $P$ is regular, there exists a DFA $A=(Q,\Sigma,\delta,q_{0},F)$ such that $\mathcal{L}(A)=P$. Define $M_{D}=(Q\times\mathbb{B}\times{\mathcal{P}(\Sigma)},\Delta_{D},(q_{0},\bot,\emptyset))$ where

[TABLE]

The values of $\mathrm{sleep}_{R}(x)$ and $x\in\mathrm{ignore}_{R}$ can be computed by a simple left-to-right traversal of the input string $x$. Intuitively, $M$ simulates this computation for a nondeterministically chosen $R:\Sigma^{*}\to\mathcal{L}in(\Sigma)$. Partial computations of $\mathrm{sleep}_{R}$ ($\mathrm{ignore}_{R}$) are stored in the ${\mathcal{P}(\Sigma)}$ ($\mathbb{B}$) part of the state. Thus $\mathcal{L}(M_{D})=\mathrm{reduce}_{D}(P)$.

This proof has been mechanically checked. ∎

Interestingly, every reduction in $\mathrm{reduce}_{D}(P)$ is optimal in the sense that each reduction contains at most one representative of each equivalence class of $\sim_{D}$.

Theorem 6.7.

Fix some $P\subseteq\Sigma^{*}$ and $R:\Sigma^{*}\to\mathcal{L}in(\Sigma)$. For all $(x,y)\in P\setminus\mathrm{ignore}_{R}$, if $x\sim_{D}y$ then $x=y$.

Proof.

It is sufficient to show that $\overline{\mathrm{ignore}_{R}}$ contains at most one representative of each equivalence class of $\sim_{D}$, i.e. for all $x,y\notin\mathrm{ignore}_{R}$, if $x\sim_{D}y$ then $x=y$.

Assume $x,y\notin\mathrm{ignore}_{R}$ and $x\sim_{D}y$. For a contradiction, assume $x\neq y$. Then $x$ and $y$ must differ at some character, so $x=x_{1}ax_{2}$ and $y=x_{1}bx_{3}$ for $x_{i}\in\Sigma^{*}$ and $a\neq b$. Assume (by symmetry) that $(a,b)\in R$. We have $x\sim_{D}y$, so $b$ must appear somewhere in $x_{2}$ after a run of elements independent of $b$, i.e. $x=x_{1}ax_{21}bx_{22}$ where $(b,c)\in D$ for every $c\in x_{21}$. However, this implies $b\in\mathrm{sleep}_{R}(x_{1}ax_{21})$, which implies $x_{1}ax_{21}b\in\mathrm{ignore}_{R}$, and therefore $x\in\mathrm{ignore}_{R}$, which is a contradiction.

This proof has been mechanically checked. ∎

7. Algorithms

Figure 4 illustrates the outline of our verification algorithm. It is a counterexample-guided abstraction refinement loop in the style of (FarzanKP13, ; FarzanKP15, ; HeizmannHP09, ). The key difference is that instead of checking whether some proof $\Pi$ is a proof for the program $P$, it checks if there exists a reduction of the program $P$ that $\Pi$ proves correct.

The algorithm relies on an oracle Interpolate that, given a finite set of program traces $C$, returns a proof $\Pi^{\prime}$, if one exists, such that $C\subseteq\mathcal{L}(\Pi^{\prime})$. In our tool, we use Craig interpolation to implement the oracle Interpolate. In general, since program traces are the simplest form of sequential programs (loop and branch free), any automated program prover that can handle proving them may be used.

The results presented in Sections 5 and 6 give rise to the proof checking sub routine of the algorithm in Figure 4 (i.e. the light grey test). Given a program DFA $A_{P}=(Q_{P},\Sigma,\delta_{P},q_{P0},F_{P})$ and a proof DFA $A_{\Pi}=(Q_{\Pi},\Sigma,\delta_{\Pi},q_{\Pi 0},F_{\Pi})$ (obtained by determinizing the proof NFA $\Pi_{NFA}$), we can decide $\exists P^{\prime}\in\mathrm{reduce}_{D}(\mathcal{L}(A_{P}))\ldotp P^{\prime}\subseteq\mathcal{L}(A_{\Pi})$ by constructing an LTA $M_{P\Pi}$ for $\mathrm{reduce}_{D}(\mathcal{L}(A_{P}))\cap{\mathcal{P}(\mathcal{L}(A_{\Pi}))}$ and checking emptiness (Theorem 5.2).

7.1. Progress

The algorithm corresponding to Figure 4 satisfies a weak progress theorem: none of the counterexamples from a round of the algorithm will ever appear in a future counterexample set. This, however, is not strong enough to guarantee termination. Alternatively, one can think of the algorithm’s progress as follows. In each round new assertions are discovered through the oracle Interpolate, and one can optimistically hope that one can finally converge on an existing target proof $\Pi^{*}$. The success of this algorithm depends on two factors: (1) the counterexamples used by the algorithm belong to $\mathcal{L}(\Pi^{*})$ and (2) the proof that Interpolate discovers for these counterexamples coincide with $\Pi^{*}$. The latter is a typical known wild card in software model checking, which cannot be guaranteed; there is plenty of empirical evidence, however, that procedures based on Craig Interpolation do well in approximating it. The former is a new problem for our refinement loop.

In a standard algorithm in the style of (FarzanKP13, ; FarzanKP15, ; HeizmannHP09, ), the verification proof rule dictates that every program trace must be in $\mathcal{L}(\Pi^{*})$. In our setting, we only require a subset (corresponding to some reduction) to be in $\mathcal{L}(\Pi^{*})$. This means one cannot simply rely on program traces as appropriate counterexamples. Theorem 5.5 presents a solution to this problem. It ensures that we always feed Interpolate some counterexample from $\Pi^{*}$ and therefore guarantee progress.

Theorem 7.1 (Strong Progress).

Assume a proof $\Pi^{*}$ exists for some reduction $P^{*}\in\mathcal{R}$ and Interpolate always returns some subset of $\Pi^{*}$ for traces in $\mathcal{L}(\Pi^{*})$. Then the algorithm will terminate in at most $|\Pi^{*}|$ iterations.

Proof.

It is sufficient to show that we learn at least one new assertion in $\Pi^{*}$ every iteration. Assume we have received a counterexample set $C$ such that, for all $P^{\prime}\in\mathcal{R}$, there exists some $x\in C$ such that $x\in P^{\prime}$ and $x\notin\mathcal{L}(\Pi)$ (Theorem 5.5 ensures $C$ exists). Let $x^{*}\in C$ be the counterexample for $P^{*}$. Then Interpolate$(x)$ will return new assertions $\Pi^{\prime}\subseteq\Pi^{*}$ satisfying $x^{*}\in\mathcal{L}(\Pi^{\prime})$. If $\Pi^{\prime}\subseteq\Pi$ then $x^{*}$ would not have been returned as a counterexample, so there must exist some $\phi\in\Pi^{\prime}$ (and therefore $\phi\in\Pi^{*}$) such that $\phi\notin\Pi$. ∎

Theorem 7.1 ensures that the algorithm will never get into an infinite loop due to a bad choice of counterexamples. The condition on Interpolate ensures that divergence does not occur due to the wrong choice of assertions by Interpolate and without it any standard interpolation-based software model checking algorithm may diverge. The assumption that there exists a proof for a reduction of the program in the fixed set $\mathcal{R}$ ensures that the proof checking procedure can verify the target proof $\Pi^{*}$ once it is reached. Note that, in general, a proof may exist for a reduction of the program which is not in $\mathcal{R}$. Therefore, the algorithm is not complete with respect to all reductions, since checking the premises of SafeRed1 is undecidable as discussed in Section 4.

7.2. Faster Proof Checking through Antichains

The state set of $M_{P\Pi}$, the intersection of program and proof LTAs, has size $|Q_{P}\times\mathbb{B}\times\mathcal{P}(\Sigma)\times Q_{\Pi}|$, which is exponential in $|\Sigma|$. Therefore, even a linear emptiness test for this LTA can be computationally expensive. Antichains have been previously used (WulfDHR06, ) to optimize certain operations over NFAs that also suffer from exponential blowups, such as deciding universality and inclusion tests. The main idea is that these operations involve computing downwards-closed and upwards-closed sets according to an appropriate subsumption relation, which can be represented compactly as antichains. We employ similar techniques to propose a new emptiness check algorithm.

Antichains.

The set of maximal elements of a set $X$ with respect to some ordering relation $\sqsubseteq$ is denoted $\operatorname{max}(X)$. The downwards-closure of a set $X$ with respect to $\sqsubseteq$ is denoted ${\lfloor X\rfloor}$. An antichain is a set $X$ where no element of $X$ is related (by $\sqsubseteq$) to another. The maximal elements $\operatorname{max}(X)$ of a finite set $X$ is an antichain. If $X$ is downwards-closed then ${\lfloor\operatorname{max}(X)\rfloor}=X$.

The emptiness check algorithm for LTAs from (BaaderT01, ) computes the set of inactive states (i.e. states which generate an empty language) and checks if the initial state is inactive. The set of inactive states of an LTA $M=(Q,\Delta,q_{0})$ is defined as the smallest set $\mathrm{inactive}(M)$ satisfying

[TABLE]

Alternatively, one can view $\mathrm{inactive}(M)$ as the least fixed-point of a monotone (with respect to $\subseteq$) function $F_{M}:{\mathcal{P}(Q)}\to{\mathcal{P}(Q)}$ where

[TABLE]

Therefore, $\mathrm{inactive}(M)$ can be computed using a standard fixpoint algorithm.

If $\mathrm{inactive}(M)$ is downwards-closed with respect to some subsumption relation $(\sqsubseteq)\subseteq Q\times Q$, then we need not represent all of $\mathrm{inactive}(M)$. The antichain $\max(\mathrm{inactive}(M))$ of maximal elements of $\mathrm{inactive}(M)$ (with respect to $\sqsubseteq$) would be sufficient to represent the entirety of $\mathrm{inactive}(M)$, and can be exponentially smaller than $\mathrm{inactive}(M)$, depending on the choice of relation $\sqsubseteq$.

A trivial way to compute $\max(\mathrm{inactive}(M))$ is to first compute $\mathrm{inactive}(M)$ and then find the maximal elements of the result, but this involves doing strictly more work than the baseline algorithm. However, observe that if $F_{M}$ also preserves downwards-closedness with respect to $\sqsubseteq$, then

[TABLE]

That is, $\max(\mathrm{inactive}(M))$ is the least fixed-point of a function $F^{\max}_{M}:{\mathcal{P}(Q)}\to{\mathcal{P}(Q)}$ defined as $F^{\max}_{M}(X)=\max(F_{M}({\lfloor X\rfloor}))$. We can calculate $\max(\mathrm{inactive}(M))$ efficiently if we can calculate $F^{\max}_{M}(X)$ efficiently, which is true in the special case of the intersection automaton for the languages of our proof ${\mathcal{P}(\mathcal{L}(\Pi))}$ and our program $\mathrm{reduce}_{D}(P)$, which we refer to as $M_{P\Pi}$.

We are most interested in the state space of $M_{P\Pi}$, which is $Q_{P\Pi}=(Q_{P}\times\mathbb{B}\times{\mathcal{P}(\Sigma)})\times Q_{\Pi}$. Observe that states whose $\mathbb{B}$ part is $\top$ are always active:

Lemma 7.2.

$((q_{P},\top,S),q_{\Pi})\notin\mathrm{inactive}(M_{P\Pi})$* for all $q_{P}\in Q_{P}$, $q_{\Pi}\in Q_{\Pi}$, and $S\subseteq\Sigma$.*

Proof.

Let $A_{P}=(Q_{P},\Sigma,\delta_{P},q_{0P},F_{P})$ and $A_{\Pi}=(Q_{\Pi},\Sigma,\delta_{\Pi},q_{0\Pi},F_{\Pi})$ be automata recognizing $P$ and $\mathcal{L}(\Pi)$, respectively. Then

[TABLE]

Note that if $\iota=\top$ then the body of the set comprehension simplifies to

[TABLE]

In other words, a state where $\iota=\top$ always has a transition to another state with $\iota=\top$. Therefore such states cannot be inactive.

This proof has been mechanically checked. ∎

The state space can then be assumed to be $Q_{P\Pi}=(Q_{P}\times\{\bot\}\times{\mathcal{P}(\Sigma)})\times Q_{\Pi}$ for the purposes of checking inactivity. The subsumption relation defined as the smallest relation $\sqsubseteq_{P\Pi}$ satisfying

[TABLE]

for all $q_{P}\in Q_{P}$, $q_{\Pi}\in Q_{\Pi}$, and $S,S^{\prime}\subseteq\Sigma$, is a suitable one since:

Lemma 7.3.

$F_{M_{P\Pi}}$* preserves downwards-closedness with respect to $\sqsubseteq_{P\Pi}$.*

Proof.

Let $A_{P}=(Q_{P},\Sigma,\delta_{P},q_{0P},F_{P})$ and $A_{\Pi}=(Q_{\Pi},\Sigma,\delta_{\Pi},q_{0\Pi},F_{\Pi})$ be automata recognizing $P$ and $\mathcal{L}(\Pi)$, respectively. Then

[TABLE]

where

[TABLE]

Recall the subsumption relation $\sqsubseteq_{P\Pi}$:

[TABLE]

Assume $X\subseteq(Q_{P}\times\{\bot\}\times{\mathcal{P}(\Sigma)})\times Q_{\Pi}$ is downwards-closed with respect to $\sqsubseteq_{P\Pi}$. For any $S,S^{\prime}\subseteq\Sigma$ such that $S\subseteq S^{\prime}$, we have

[TABLE]

for all $R\in\mathcal{L}in(\Sigma)$, so $F_{P\Pi}(X)$ is also downwards-closed with respect to $\sqsubseteq_{P\Pi}$.

This proof has been mechanically checked. ∎

The function $F^{\max}_{M_{P\Pi}}$ is a function over relations

[TABLE]

but in our case it is more convenient to view it as a function over functions

[TABLE]

Through some algebraic manipulation and some simple observations, we can define $F^{\max}_{M_{P\Pi}}$ functionally as follows.

Lemma 7.4.

For all $q_{P}\in Q_{P}$, $q_{\Pi}\in Q_{\Pi}$, and $X:Q_{P}\times\{\bot\}\times Q_{\Pi}\to{\mathcal{P}({\mathcal{P}(\Sigma)})}$,

[TABLE]

where

[TABLE]

[TABLE]

Proof.

From the proof of Lemma 7.3 we have

[TABLE]

where

[TABLE]

Since ${\mathcal{P}((Q_{\Pi}\times\{\bot\}\times{\mathcal{P}(\Sigma)})\times Q_{P})}\simeq Q_{\Pi}\times\{\bot\}\times Q_{P}\to{\mathcal{P}({\mathcal{P}(\Sigma)})}$ we can reformulate $F_{M_{P\Pi}}$ as a function

[TABLE]

and therefore

[TABLE]

The first case is already in the form we want, so we focus on the second case:

[TABLE]

This proof has been mechanically checked. ∎

Formulating $F^{\max}_{M_{P\Pi}}$ as a higher-order function allows us to calculate $\max(\mathrm{inactive}(M_{P\Pi}))$ using efficient fixpoint algorithms like the one in (Pottier_lazyleast, ). Algorithm 1 outlines our proof checking routine. $\textsc{Fix}:((A\to B)\to(A\to B))\to(A\to B)$ is a procedure that computes the least fixpoint of its input. The algorithm simply computes the fixpoint of the function $F^{\max}_{M_{P\Pi}}$ as defined in Lemma 7.4, which is a compact representation of $\mathrm{inactive}(M_{P\Pi})$ and checks if the start state of $M_{P\Pi}$ is in it.

Complexity.

Antichain methods do not generally improve worst case time complexity, as the size of the largest antichain in ${\mathcal{P}(\Sigma)}$ is exponential in $|\Sigma|$. Therefore, our fixpoint algorithm can perform up to $|Q_{P}||Q_{\Pi}|2^{|\Sigma|}$ iterations in the worst case. At each iteration of the fixpoint algorithm, $F^{\max}(X)(q_{P},\bot,q_{\Pi})$ must be recalculated for each $q_{P}\in Q_{P}$ and $q_{\Pi}\in Q_{\Pi}$, where $X:Q_{P}\times\bot\times Q_{\Pi}\to{\mathcal{P}({\mathcal{P}(\Sigma)})}$ is the current assignment calculated by the fixpoint algorithm.

To analyze the complexity of $F^{\max}$, first, note that antichain meet ($\sqcap$) and join ($\sqcup$) can be computed in $\mathcal{O}((n_{1}n_{2})^{2})$ and $\mathcal{O}(n_{1}n_{2})$ time, respectively, where $n_{1}$ and $n_{2}$ are the cardinalities of the left and right arguments, respectively. The complexities of iterated antichain meet ($\bigsqcap$) and join ($\bigsqcup$) over a set of $n$ elements with cardinality at most $m$ are therefore

[TABLE]

and

[TABLE]

respectively.

The inner join of $F^{\max}$ is over at most $k=|\Sigma||Q_{P}||Q_{\Pi}|2^{|\Sigma|}$ antichains of size $\leq 1$, and is therefore computed in $\mathcal{O}(k^{2})$ and computes an antichain with size $k$. The outer meet is over $|\Sigma|!$ antichains produced by the inner join, and thus has complexity $\mathcal{O}(k^{2|\Sigma|!})$. Therefore $F^{\max}$ can be computed in $\mathcal{O}(k^{2|\Sigma|!}k^{2})=\mathcal{O}(k^{2|\Sigma|!+2})$. This brings the total complexity of our fixpoint algorithm to $\mathcal{O}(|Q_{P}|^{2}|Q_{\Pi}|^{2}2^{|\Sigma|}k^{2|\Sigma|!+2})$. Since $|\Sigma|$ is typically linear in the program size, we simplify this to $\mathcal{O}(|P||\Pi|(|P|^{2}|\Pi|2^{|P|})^{2|P|!+3})$, where $|P|$ is the program size and $|\Pi|$ is the proof size.

Counterexamples.

Theorem 5.5 states that a finite set of counterexamples exists whenever $\exists P^{\prime}\in\mathrm{reduce}_{D}(P)\ldotp P^{\prime}\subseteq\mathcal{L}(\Pi)$ does not hold. The proof of emptiness for an LTA, formed using rule Inactive above, is a finite tree. Each edge in the tree is labelled by an element of $\Sigma$ (obtained from the existential in the rule) and the paths through this tree form the counterexample set. To compute this set, then, it suffices to remember enough information during the computation of $\mathrm{inactive}(M)$ to reconstruct the proof tree. Every time a state $q$ is determined to be inactive, we must also record the witness $a\in\Sigma$ for each transition $(q,B,\sigma)\in\Delta$ such that $\sigma(a)\in\mathrm{inactive}(M)$.

In an antichain-based algorithm, once we determine a state $q$ to be inactive, we simultaneously determine everything it subsumes (i.e. $\sqsubseteq q$) to be inactive as well. If we record unique witnesses for each and every state that $q$ subsumes, then the space complexity of our antichain algorithm will be the same as the unoptimized version. The following lemma states that it is sufficient to record witnesses only for $q$ and discard witnesses for states that $q$ subsumes.

Lemma 7.5.

Fix some states $q,q^{\prime}$ such that $q^{\prime}\sqsubseteq_{P\Pi}q$. A witness used to prove $q$ is inactive can also be used to prove $q^{\prime}$ is inactive.

Proof.

From the proof of Lemma 7.3 we have

[TABLE]

where

[TABLE]

Thus, if we have states $q^{\prime}=((q_{P},\bot,S^{\prime}),q_{\Pi})$ and $q=((q_{P},\bot,S),q_{\Pi})$ with $S\subseteq S^{\prime}$ such that $q^{\prime}\in\mathrm{inactive}(M_{P\Pi})$ (and therefore $q\in\mathrm{inactive}(M_{P\Pi})$), our witness for $q^{\prime}$ is a function $f:\mathcal{L}in(R)\to\Sigma$ such that

[TABLE]

We must show

[TABLE]

which is indeed the case since $f(R)\notin S^{\prime}\implies f(R)\notin S$ and $(S\cup R(a))\setminus D(a)\subseteq(S^{\prime}\cup R(a))\setminus D(a)$. ∎

Note that this means that the antichain algorithm soundly returns potentially fewer counterexamples than the original one.

7.3. Partition Optimization

The LTA construction for $\mathrm{reduce}_{D}(P)$ involves a nondeterministic choice of linear order at each state. Since $|\mathcal{L}in(\Sigma)|$ has size $|\Sigma|!$, each state in the automaton would have a large number of transitions. As an optimization, our algorithm selects ordering relations out of $\mathcal{P}art(\Sigma)$ (instead of $\mathcal{L}in(\Sigma)$), defined as $\mathcal{P}art(\Sigma)=\{\Sigma_{1}\times\Sigma_{2}\mid\Sigma_{1}\uplus\Sigma_{2}=\Sigma\}$ where $\uplus$ is disjoint union. This leads to a sound algorithm which is not complete with respect to sleep set reductions and trades the factorial complexity of computing $\mathcal{L}in(\Sigma)$ for an exponential one.

8. Experiments

8.1. Implementation

To evaluate our approach, we have implemented our algorithm in a tool called Weaver written in Haskell. Weaver accepts a program written in a simple imperative language as input, where the property is already encoded in the program in the form of assume statements, and attempts to prove the program correct. The dependence relation for each input program is computed using a heuristic that ensures $\sim_{D}$-closedness. It is based on the fact that the shuffle product (i.e. parallel composition) of two $\sim_{D}$-closed languages is $\sim_{D}$-closed.

Weaver employs two verification algorithms: (1) The total order algorithm presented in Algorithm 1, and (2) the variation with the partition optimization discussed in Section 7.3. It also implements multiple counterexample generation algorithms: (1) Naive: selects the first counterexample in the difference of the program and proof language. (2) Progress-Ensuring: selects a set of counterexamples satisfying Theorem 5.5. (3) Bounded Progress-Ensuring: selects a limited subset of the set computed by the progress-ensuring algorithm. We experimented with multiple strategies for the selection of the limited subset:

• •

RR: selects a lockstep trace of the program. In other words, it selects a single counterexample by choosing successive statements from each thread in a round robin fashion, e.g. the first statement is from thread 1, the second statement is from thread 2, and so on.

• •

Ln: selects the $n$ leftmost counterexamples from the tree of counterexamples. When $n=1$, this counterexample strategy effectively chooses sequential composition traces of the program.

• •

Mn: selects the $n$ middlemost counterexamples from the tree of counterexamples. The middlemost counterexamples do not always contain lockstep counterexamples, so this strategy is distinct from the RR strategy.

Fixing a counterexample strategy does not mean committing to a particular reduction. For example, it is possible for assertions learned from a sequential composition trace to generalize to lockstep traces. In some of our benchmarks, we found that our algorithm converged using the L1 strategy, despite the fact that no full proof exists for the sequential composition reduction.

Our experimentation demonstrated that in all cases, the bounded progress ensuring algorithm (an instance of the partition algorithm) is the fastest of all options. Therefore, all our reports in this section are using this instance of the algorithm.

For the larger benchmarks, we use a simple sound optimization to reduce the proof size. We declare the basic blocks of code as atomic, so that internal assertions need not be generated for them as part of the proof. This optimization is incomplete with respect to sleep set reductions. Weaver and all our benchmarks can be found at github.com/weaver-verifier/weaver.

8.2. Benchmarks

We use a set of sequential benchmarks from (SousaD16, ) and include additional sequential benchmarks that involve more interesting reductions in their proofs. We also have a set of parallel benchmarks, which are beyond the scope of previous hypersafety verification techniques. We use these benchmarks to demonstrate that our technique/tool can seamlessly handle concurrency. These involve proving concurrency specific hypersafety properties such as determinism and equivalence of parallel and sequential implementations of algorithms. Finally, since the proof checking algorithm is the core contribution of this paper, we have a contrived set of instances to stress test our proof checking algorithm. These involve proving determinism of simple parallel-disjoint programs with various numbers of threads and statements per thread. These benchmarks have been designed to cause a combinatorial explosion for the proof checker and counterexample generation routines. The set of hypersafety properties used in all our experimental results are depicted in Figure 5.

Benchmarks from (SousaD16, ).

Each example implements a comparator function that returns a negative number if the first argument is less than the second, a positive number if the first argument is greater than the second, and zero if they are equal. We check that each comparator satisfies CompSubst, CompTrans, and CompSymm.

Our Sequential Benchmarks.

We verify the Mult example given in Section 2 satisfies Dist (i.e. $\textsc{Mult}(a+b,c)=\textsc{Mult}(a,c)+\textsc{Mult}(b,c)$). Since Mult iterates on its first argument only, we also verify that the property holds when its arguments are flipped (i.e. $\textsc{Mult}(c,a+b)=\textsc{Mult}(c,a)+\textsc{Mult}(c,b)$). We also verify that an array equality procedure ArrayEq satisfies symmetry and transitivity, and include a simple information flow security example. Lastly, we include examples of loop unrolling: each UnrollN example involves a loop iterating a multiple of N times, and each UnrollCondN example unrolls a loop N times, with cleanup code for extra iterations.

Our Parallel Benchmarks.

We use the following parallel benchmarks:

• •

The Barrier example checks that a simple loop-free barrier computation is deterministic.

• •

The Lamport example verifies the correctness of a locking algorithm by checking whether executing a non-atomic operation in two threads within the confines of the lock is equivalent to executing the operation twice sequentially. The lock is implemented using Lamport’s bakery algorithm.

• •

The ParallelSum examples implement parallel summation over a queue. The ParallelSum1 example has two threads atomically sum into a shared variable, while each thread in the ParallelSum2 example sums into a local variable. We verify that they are deterministic. We also verify that ParallelSum1 is equivalent to a single-threaded version of the same program.

• •

The SimpleInc example verifies that atomically incrementing an integer in two different threads is equivalent to non-atomically incrementing it twice in a single thread. The Spaghetti example verifies the determinism of a program that performs an arbitrary computation before setting its output to a fixed value.

• •

The ExpNxM benchmarks verify that a program computing an exponential term is deterministic. Each program is replicated over N threads, and each thread contains M statements.

8.3. Evaluation

Detailed results of our experiments are included in Appendix A. Table 1 includes a summary in the form of averages, and here, we discuss our top findings.

Proof construction time refers to the time spent to construct $\mathcal{L}(\Pi)$ from a given set of assertions $\Pi$ and excludes the time to produce proofs for the counterexamples in a given round. Proof checking time is the time spent to check if the current proof candidate is strong enough for a reduction of the program. In the fastest instances (total time around $0.01$ seconds), roughly equal time is spent in proof checking and proof construction. In the slowest instances, the total time is almost entirely spent in proof construction. In contrast, in our stress tests (designed to stress the proof checking algorithm) the majority of the time is spent in proof checking. The time spent in proving counterexamples correct is negligible in all instances. Proof sizes vary from 4 assertions to 298 for the most complicated instance. Verification times are correlated with the final proof size; larger proofs tend to cause longer verification times.

Numbers of refinement rounds vary from 2 for the simplest to 33 for the most complicated instance. A small number of refinement rounds (e.g. 2) implies a fast verification time. But, for the higher number of rounds, a strong positive correlation between the number of rounds and verification time does not exist.

The bounded progress ensuring algorithm achieves its best time, in most cases, by taking 1 counterexample at each refinement round. There are two exceptions which respectively require 5 counterexamples from the left (the parallel sum) and middle (transitivity of integer array comparator) per refinement round for the best overall verification time. The former is negligible because the 1 counterexample variation produces a runtime within 12% of this optimal answer. The latter is significant, since other instances take substantially more time to verify.

In the vast majority of the cases, choosing a counterexample from the left or the middle makes a negligible difference in the verification time. The exceptions are the hardest sequential instance and the hardest parallel one. In these two cases, a left choice leads to a timeout while the middle one succeeds.

To gauge the effect of the counterexample selection strategy on the overall performance of our approach, we used all three counterexample selection modes on all our benchmarks: RR, L$n$, and M$n$ , for $n\in\{1,5,10\}$. In most cases, the fastest configuration is 1-2x faster than the next fastest. For the more complicated benchmarks, the difference is much larger; for example, Weaver converges 13x faster using the RR compared to M$1$ counterexample mode for the substitutivity of the integer array comparator.

Our conclusion is that in the cases that the proof is complicated and can grow large, the choice of counterexamples can have a big impact on verification time. One can simply run a few instantiations of the algorithm with different counterexample choices in parallel and wait for the best one to return.

For our parallel programs benchmarks (other than our stress tests), the tool spends the majority of its time in proof construction. Therefore, we designed specific (unusual) parallel programs to stress test the proof checker. Stress test benchmarks are trivial tests of determinism of disjoint parallel programs, which can be proven correct easily by using the atomic block optimization. However, we force the tool to do the unnecessary hard work. These instances simulate the worst case theoretical complexity where the proof checking time and number of counterexamples grow exponentially with the number of threads and the sizes of the threads. In the largest instance, more than 99% of the total verification time is spent in proof checking. Averages are not very informative for these instances, and therefore are not included in Table 1.

Finally, Weaver is only slow for verifying 3-safety properties of large looping benchmarks from (SousaD16, ). Note that unlike the approach in (SousaD16, ), which starts from a default lockstep reduction (that is incidentally sufficient to prove these instances), we do not assume any reduction and consider them all. The extra time is therefore expected when the product programs become quite large.

Antichains. To measure the effectiveness of our antichain optimization, we compare the times for proof checking of the final (correct) proof for all our benchmarks with and without the antichain optimization. We discard the cases where the proof checking time is under 0.01s without optimization as the times are too small to be statistically relevant. The antichain-based algorithm outperforms the unoptimized one in all these instances. Of the remaining (27 benchamrks), the minimum speedup is a factor of 2, and the maximum is a factor of 44 (not considering the one instance that times out without the optimization). The average speedup is 12, and larger speedups (on average) are observed for the parallel benchmarks compared to the sequential ones.

9. Related Work

The notion of a $k$-safety hyperproperty was introduced in (ClarksonS08, ) without consideration for automatic program verification. The approach of reducing $k$-safety to 1-safety by self-composition is introduced in (BartheDR11, ). While theoretically complete, self-composition is not practical as discussed in Section 1. Product programs generalize the self-composition approach and have been used in verifying translation validation (PnueliSS98, ), non-interference (GoguenM82a, ; SabelfeldM03, ), and program optimization (SousaDVDG14, ). A product of two programs $P_{1}$ and $P_{2}$ is semantically equivalent to $P_{1}\cdot P_{2}$ (sequential composition), but is made easier to verify by allowing parts of each program to be interleaved. The product programs proposed in (BartheCK11, ) allow lockstep interleaving exclusively, but only when the control structures of $P_{1}$ and $P_{2}$ match. This restriction is lifted in (BartheCK13, ) to allow some non-lockstep interleavings. However, the given construction rules are non-deterministic, and the choice of product program is left to the user or a heuristic.

Relational program logics (Benton04, ; Yang07, ) extend traditional program logics to allow reasoning about relational program properties, however automation is usually not addressed. Automatic construction of product programs is discussed in (EilersMH18, ) with the goal of supporting procedure specifications and modular reasoning, but is also restricted to lockstep interleavings. Our approach does not support procedure calls but is fully automated and permits non-lockstep interleavings.

The key feature of our approached is the automation of the discovery of an appropriate program reduction and a proof combined. In this case, the only other method that compares is the one based on Cartesian Hoare Logic (CHL) proposed in (SousaD16, ) along with an algorithm for automatic verification based on CHL. Their proposed algorithm implicitly constructs a product program, using a heuristic that favours lockstep executions as much as possible, and then prioritizes certain rules of the logic over the rest. The heuristic nature of the search for the proof means that no characterization of the search space can be given, and no guarantees about whether an appropriate product program will be found. In contrast, we have a formal characterization of the set of explored product programs in this paper. Moreover, CHL was not designed to deal with concurrency.

Lipton (Lipton75, ) first proposed reduction as a way to simplify reasoning about concurrent programs. His ideas have been employed in a semi-automatic setting in (ElmasQT09, ). Partial-order reduction (POR) is a class of techniques that reduces the state space of search by removing redundant paths. POR techniques are concerned with finding a single (preferably minimal) reduction of the input program. In contrast, we use the same underlying ideas to explore many program reductions simultaenously. The class of reductions described in Section 6 is based on the sleep set technique of Godefroid (Godefroid96, ). Other techniques exist (Godefroid96, ; AbdullaAJS17, ) that are used in conjunction with sleep sets to achieve minimality in a normal POR setting. In our setting, reductions generated by sleep sets are already optimal (Theorem 6.7). However, employing these additional POR techniques may propose ways of optimizing our proof checking algorithm by producing a smaller reduction LTA.

Appendix A Results

Benchmarks were run on a Proliant DL980 G7 with eight eight-core Intel X6550 processors (64 cores, 64 threads) and 256G of RAM, running 64-bit Ubuntu.