Specification and Inference of Trace Refinement Relations

TL;DR

This paper introduces a novel theory and tool for compositional reasoning about program trace similarities and differences using trace-refinement relations and Kleene Algebra with Tests, enabling analysis across program versions.

Contribution

It presents the first formal framework for trace-based refinement relations and a synthesis algorithm implemented in the { t knotical} tool for practical analysis.

Findings

Successfully synthesized trace-refinement relations for 37 benchmarks.

Efficiently analyzed changing fragments of array programs, systems code, and web servers.

Demonstrated the applicability of the approach to real-world software evolution.

Abstract

Modern software is constantly changing. Researchers and practitioners are increasingly aware that verification tools can be impactful if they embrace change through analyses that are compositional and span program versions. Reasoning about similarities and differences between programs goes back to Benton, who introduced state-based refinement relations, which were extended by Yang and others. However, to our knowledge, refinement relations have not been explored for traces. We present a novel theory that allows one to perform compositional reasoning about the similarities/differences between how fragments of two different programs behave over time through the use of what we call trace-refinement relations. We take a reactive view of programs and found Kleene Algebra with Tests (KAT) [Kozen] to be a natural choice to describe traces since it permits algebraic reasoning and has built-in composition. Our theory involves a two-step semantic abstraction from programs to KAT, and then our trace refinement relations correlate behaviors by (i) categorizing program behaviors into trace classes through KAT intersection and (ii) correlating atomic events/conditions across programs with KAT hypotheses. We next describe a synthesis algorithm that iteratively constructs trace-refinement relations between two programs by exploring sub-partitions of their traces, iteratively abstracting them as KAT expressions, discovering relationships through a custom edit-distance algorithm, and applying strategies (i) and (ii) above. We have implemented this algorithm as {\sc knotical}, the first tool capable of synthesizing trace-refinement relations. It built from the ground up in Ocaml, using InterProc and SymKAT. We have demonstrated that useful relations can be efficiently generated across a suite of 37 benchmarks that include changing fragments of array programs, systems code, and web servers.

Figures

Equations

$$\begin{array}[]{c}\forall(r_{2},r_{1},\mathcal{A})\in\mathbb{T}.\;\;k_{2}\cap r_{2}\leq_{\mathcal{A}}k_{1}\cap r_{1}\textrm{ and }\bigcup_{\mathsf{proj}_{1}(\mathbb{T})}\supseteq k_{2}.\end{array}$$

$$\begin{array}[]{ll}k_{1}\stackrel{{\scriptstyle\triangle}}{{=}}&(\textsf{a}_{\texttt{x}\!>\!0}(\textsf{E}_{\texttt{recv}}(\textsf{b}_{\texttt{l}=\textsf{true}}\!\cdot\!\textsf{O}_{\texttt{log}}\;+\;\overline{\textsf{b}_{\texttt{l}=\textsf{true}}}\!\cdot\!1)\!\cdot\!(\textsf{c}_{\texttt{m}\!>\!0}\!\cdot\!\textsf{C}_{\texttt{Rep}}\!\cdot\!\textsf{S}_{\texttt{send}}\\ &(\textsf{b}_{\texttt{l}=\textsf{true}}\!\cdot\!\textsf{L}_{\texttt{log}}\;+\;\overline{\textsf{b}_{\texttt{l}=\textsf{true}}}\!\cdot\!1)\;+\;\overline{\textsf{c}_{\texttt{m}\!>\!0}}\!\cdot\!1)\textsf{X}_{\texttt{x--}}))^{*}\!\cdot\!\overline{\textsf{a}_{\texttt{x}\!>\!0}}\\ k_{2}\stackrel{{\scriptstyle\triangle}}{{=}}&(\textsf{a}_{\texttt{x}\!>\!0}(\textsf{E}_{\texttt{recv}}(\textsf{c}_{\texttt{m}\!>\!0}\!\cdot\!\textsf{K}_{\texttt{check}}\!\cdot\!(\textsf{d}_{\texttt{auth}\!>\!0}\!\cdot\!\textsf{C}_{\texttt{Rep}}\!\cdot\!\textsf{S}_{\texttt{send}}\\ &+\;\overline{\textsf{d}_{\texttt{auth}\!>\!0}}\!\cdot\!1)\;+\;\overline{\textsf{c}_{\texttt{m}\!>\!0}}\!\cdot\!\textsf{O}_{\texttt{log}})\!\cdot\!\textsf{X}_{\texttt{x--}})^{*}\!\cdot\!\overline{\textsf{a}_{\texttt{x}\!>\!0}}\end{array}$$

$$({\text{a}}_{\text{x}>0}({\text{E}}_{\text{recv}}({\text{c}}_{\text{m}>0}\cdot {\text{C}}_{\text{Rep}}\cdot {\text{S}}_{\text{send}}){\text{X}}_{\text{x--}}){)}^{\ast }\overline{{\text{a}}_{\text{x}>0}}$$

$$({\text{a}}_{\text{x}>0}({\text{E}}_{\text{recv}}({\text{c}}_{\text{m}>0}\cdot {\text{K}}_{\text{check}}\cdot {\text{C}}_{\text{Rep}}\cdot {\text{S}}_{\text{send}}){\text{X}}_{\text{x--}}){)}^{\ast }\overline{{\text{a}}_{\text{x}>0}}$$

$$r_2=({\text{a}}_{\text{x}>0}(\text{Any}\cdot \boxed{{\text{c}}_{\text{m}>0}}\cdot \boxed{{\text{d}}_{\text{auth}>0}}){)}^{\ast }\cdot \overline{{\text{a}}_{\text{x}>0}}$$

$$r_1=({\text{a}}_{\text{x}>0}(\text{Any}\cdot \boxed{\overline{{\text{b}}_{\text{l}=\text{true}}}}){)}^{\ast }\cdot \overline{{\text{a}}_{\text{x}>0}},$$

$$\begin{array}[]{ccc}P_{1}=\textsf{A}\!\cdot\!\textsf{b}\!\cdot\!C_{1}\!\cdot\!(\textsf{g}\!\cdot\!\textsf{G}+\textsf{!g}\!\cdot\!1)&\textrm{and}&P_{2}=\textsf{A}\!\cdot\!\textsf{b}\!\cdot\!C_{2}\!\cdot\!(\textsf{g}\!\cdot\!\textsf{G}+\textsf{!g}\!\cdot\!1)\\ \end{array}$$

$$(({\text{b}}_{\text{l}=\text{true}}\cdot \overline{{\text{c}}_{\text{m}>0}}\cdot \text{Any}{)}^{\ast },(\overline{{\text{c}}_{\text{m}>0}}\cdot \text{Any}{)}^{\ast },{\mathcal{A}}_{log})\in \mathbb{T}$$

$$({\text{Any}}^{\ast },({\text{d}}_{\text{auth}>0}\cdot \text{Any}{)}^{\ast },\{{\text{O}}_{\text{log}}=1,{\text{L}}_{\text{log}}=1,{\text{K}}_{\text{check}}=1\})\in \mathbb{T}$$

$$\left\{\begin{array}[]{l}(\textsf{asm}(\textsf{d}_{\texttt{auth}\!>\!0})@C_{2}\!\!:\!\!\ell_{\ref{ln:auth}},\textsf{asm}(\textsf{c}_{\texttt{m}\!>\!0})@C_{1}\!\!:\!\!\ell_{\ref{ln:c1m}}\wedge\textsf{asm}(\textsf{b}_{\texttt{l}=\textsf{true}})@C_{1}\!\!:\!\!\ell_{\ref{ln:c1log}},\\ \;\;\;\{${check}$=\!1,${log}$_{C_{1}}\!=\!1,${log}$_{C_{2}}\!=\!1\}),\\ (\textsf{asm}(\textsf{d}_{\texttt{auth}\!>\!0})@C_{2}\!\!:\!\!\ell_{\ref{ln:auth}},\textsf{asm}(\textsf{c}_{\texttt{m}\!>\!0})@C_{1}\!\!:\!\!\ell_{\ref{ln:c1m}}\wedge\textsf{asm}(\overline{\textsf{b}_{\texttt{l}=\textsf{true}}})@C_{1}\!\!:\!\!\ell_{\ref{ln:c1log}},\\ \;\;\;\{${check}$=\!1,${log}$_{C_{1}}\!=\!1,${log}$_{C_{2}}\!=\!1\}),\\ (\textsf{asm}(\textsf{d}_{\texttt{auth}\!>\!0})@C_{2}\!\!:\!\!\ell_{\ref{ln:auth}},\textsf{asm}(\overline{\textsf{c}_{\texttt{m}\!>\!0}})@C_{1}\!\!:\!\!\ell_{\ref{ln:c1m}}\wedge\textsf{asm}(\overline{\textsf{b}_{\texttt{l}=\textsf{true}}})@C_{1}\!\!:\!\!\ell_{\ref{ln:c1log}},\\ \;\;\;\{${check}$=\!1,${log}$_{C_{1}}\!=\!1,${log}$_{C_{2}}\!=\!1\}),\\ (\textsf{asm}(\overline{\textsf{d}_{\texttt{auth}\!>\!0}})@C_{2}\!\!:\!\!\ell_{\ref{ln:auth}},\textsf{asm}(\textsf{c}_{\texttt{m}\!>\!0})@C_{1}\!\!:\!\!\ell_{\ref{ln:c1m}}\wedge\textsf{asm}(\overline{\textsf{b}_{\texttt{l}=\textsf{true}}})@C_{1}\!\!:\!\!\ell_{\ref{ln:c1log}},\\ \;\;\;\{${check}$=\!1,${log}$_{C_{2}}\!=\!1\}),\\ (\textsf{asm}(\overline{\textsf{d}_{\texttt{auth}\!>\!0}})@C_{2}\!\!:\!\!\ell_{\ref{ln:auth}},\textsf{asm}(\overline{\textsf{c}_{\texttt{m}\!>\!0}})@C_{1}\!\!:\!\!\ell_{\ref{ln:c1m}}\wedge\textsf{asm}(\overline{\textsf{b}_{\texttt{l}=\textsf{true}}})@C_{1}\!\!:\!\!\ell_{\ref{ln:c1log}},\\ \;\;\;\{${check}$=\!1,${log}$_{C_{2}}\!=\!1\})\\ \end{array}\right\}$$

$$\text{KExp}::=p\in \text{P}\mid b\in \text{BExp}\mid k_1\cdot k_2\mid k_1+k_2\mid k^{\ast }\mid 0\mid 1$$

$$\text{for any (l1,l2,A)∈T},l_1\cap k_1{\le }_{\mathcal{A}}{l}_2\cap k_2.$$

$$\text{textsc}Translate(D_{1,i},{\alpha }_i^{\prime }){⪯}_{\mathcal{A}\cup {\mathcal{A}}_i^{\prime }}^{\text{RefRelation}(O_i)}\text{textsc}Translate(D_{2,i},{\alpha }_i^{\prime }),$$

$$\begin{array}[]{rl}\textsc{Translate}(C_{1},\alpha^{\prime})\cap r_{1,1}+\ldots+\textsc{Translate}(C_{1},\alpha^{\prime})\cap r_{1,n}&\equiv_{\mathcal{A}\cup\mathcal{A}^{\prime}}\textsc{Translate}(C_{1},\alpha^{\prime})\\ &\hskip 30.0pt\cap(r_{1,1}+\ldots+r_{1,n})\\ &\equiv_{\mathcal{A}\cup\mathcal{A}^{\prime}}\textsc{Translate}(C_{1},\alpha^{\prime}),\end{array}$$

$$\text{textsc}Translate(D_{1,1},{\alpha }_1^{\prime })+\dots +\text{textsc}Translate(D_{1,n},{\alpha }_n^{\prime }){\equiv }_{\mathcal{A}\cup {\mathcal{A}}^{\prime }}\text{textsc}Translate(C_1,{\alpha }^{\prime }).$$

$$\text{textsc}Translate(D_{2,1},{\alpha }_1^{\prime })+\dots +\text{textsc}Translate(D_{2,n},{\alpha }_n^{\prime }){\equiv }_{\mathcal{A}\cup {\mathcal{A}}^{\prime }}\text{textsc}Translate(C_2,{\alpha }^{\prime }).$$

$$\text{textsc}Translate(C_1,{\alpha }^{\prime }){⪯}_{\mathcal{A}\cup {\mathcal{A}}_1\cup \dots {\mathcal{A}}_n}^{{\mathbb{T}}_1\cup \dots \cup {\mathbb{T}}_n}\text{textsc}Translate(C_2,{\alpha }^{\prime }),$$

Full text

We present a novel theory that allows one to perform compositional reasoning about the similarities/differences between how fragments of two different programs behave over time through the use of what we call trace-refinement relations. We take a reactive view of programs and found Kleene Algebra with Tests (KAT) (Kozen, 1997) to be a natural choice to describe traces since it permits algebraic reasoning and has built-in composition. Our theory involves a two-step semantic abstraction from programs to KAT, and then our trace refinement relations correlate behaviors by (i) categorizing program behaviors into trace classes through KAT intersection and (ii) correlating atomic events/conditions across programs with KAT hypotheses. We next describe a synthesis algorithm that iteratively constructs trace-refinement relations between two programs by exploring sub-partitions of their traces, iteratively abstracting them as KAT expressions, discovering relationships through a custom edit-distance algorithm, and applying strategies (i) and (ii) above. We have implemented this algorithm as Knotical, the first tool capable of synthesizing trace-refinement relations. It built from the ground up in OCaml, using Interproc (int, [n. d.]) and Symkat (sym, [n. d.]). We have demonstrated that useful relations can be efficiently generated across a suite of 37 benchmarks that include changing fragments of array programs, systems code, and web servers.

This work was supported in part by the National Science Foundation (NSF) award #1618542 and the Office of Naval Research (ONR) award #N000141712787.

††conference: ACM SIGPLAN Conference on Programming Languages; January 01–03, 2018; New York, NY, USA††journalyear: 2018††doi: ††copyright: none††doi: 0000001.0000001††ccs: Theory of computation Modal and temporal logics††ccs: Theory of computation Verification by model checking††ccs: Theory of computation Program verification††ccs: Theory of computation Abstract machines

1. Introduction

Modern software changes at a rapid pace. Software engineering practices, e.g.  Agile, advocate a view that software is an evolutionary process, a series of source code edits that lead, slowly but surely, toward an improved system. Meanwhile, as these software systems grow, fragments of code are reused in increasingly many different contexts. To make matters worse, these contexts themselves may be changing, and code written under some assumptions today may be used under different ones tomorrow. With so many moving parts and adoption of formal methods an uphill battle, now more than ever, researchers and practitioners have found compositionality and reasoning across versions (O’Hearn, 2018; Logozzo et al., 2014). to be indispensable.

Changes can be exploited for good purposes: they offer a sort of informal specification, where programmers often view their new code in terms of how it has deviated from the existing code (i.e. a commit or patch), including the removal of bugs, addition of new features, performance improvements, etc. With compositional theories and tools, one can reuse previous analysis results for unchanged code, and combine them with new analyses of only the changing code fragment.

It is therefore a natural question to ask: how does a given program $C_{1}$ compare to $C_{2}$, a modified version of $C_{1}$? If one is merely interested in knowing whether they are strictly equivalent (or whether $C_{2}$ is contained within $C_{1}$), this is a classical notion of concrete program refinement (Morgan, 1994) and includes compiler correctness and translation validation (Pnueli et al., 1998). Intuitively, $C_{1}$ concretely refines $C_{2}$ provided that, when executed from the same initial state, they both reach the same final state. Researchers have developed algorithms and tools (e.g. (Lahiri et al., 2012, 2013; Wood et al., 2017)) to check whether, say, two versions of a function return the same results. Similarly, bisimulation provides equivalence between how programs behave over time, perhaps accounting for different implementations.

Concrete refinement and bisimulation are not typically focused on how the programs differ, but simply whether or not they are equivalent. In his canonical 2004 work (Benton, 2004), Benton weakened classical refinement, allowing one to define equivalence relations over the state space, so that the two programs reach the same output equivalence relation when executed from states in a particular input equivalence relation. Such equivalences allow one to describe what differences over the states one does or does not care about, for example, focusing on important variables or ignoring scratch data. This strategy is compositional because one can correlate the output relation of one code region with the input relation of the next. Benton’s work was later extended by Yang (Yang, 2007) and others (Gyori et al., 2017; Unno et al., 2017).

Benton’s work focuses on state relations. To the best of our knowledge, no prior work has explored the question trace-oriented relations to express similarities/differences between the execution behaviors of $C_{1}$ and $C_{2}$ over time. Examples include whether two programs send/receive messages in the same order, follow the same allocation/release orders, or have certain I/O patterns. Encoding these kinds of properties in state relations with, e.g., history variables seems taxing, yet a trace approach would be appealing because it would be more granular and hopefully lead to more flexibility.

Toward trace refinement relations.

We take a reactive view of programs, treating their execution in terms of events, which can be suitably defined in terms of statements, function calls, I/O, etc. as needed. We considered a few options for characterizing traces. One choice would be a temporal logic such as LTL or CTL, perhaps using the LTL “chop” operator (Barringer et al., 1984) to support composition. We found Kleene Algebra with Tests (KAT) (Kozen, 1997) to be a natural choice for a few reasons. Briefly, KAT is an amalgamation of Kleene Algebra which (like regular expressions) has constructors for union +, concatenation $\cdot$, and star-iteration *, and boolean algebra which has boolean predicates and operations. KAT expressions consist of a combination of event symbols (herein denoted in uppercase: A, B, C) and boolean “test” symbols (herein denoted in lowercase: a, b, c). One can write KAT expressions that mix event symbols with boolean test symbols, e.g., $(\textsf{a}\!\cdot\!\textsf{A})^{*}\!\cdot\!\textsf{C}\!\cdot\!\textsf{b}$. A KAT can be used as a helpful abstraction of simple abstract syntax trees. For example, the KAT expression $(\textsf{b}\!\cdot\!\textsf{C}\;+\;\overline{\textsf{b}}\!\cdot\!\textsf{D})^{*}$ models a program that is a multi-path loop, branching on b. In this way, programs can be abstracted into KAT expressions using a syntactic translation (Kozen, 1997, 2006) or, more generally using semantic translations, as we discuss later in this paper. Also, KAT is appealing because it supports algebraic reasoning, has a natural composition operator, allows hypothesis introduction, and there is existing tool support such as Symkat (Pous, 2015a). For KAT representations of programs, we can define an analog of concrete program refinement, called concrete KAT refinement (see Def. 4.2), but this is not enough to capture programs that have differences.

Contributions.

We present a novel theory of trace-refinement relations, which weaken both the notion of concrete KAT refinement as well as state refinement relations (Benton, 2004). Intuitively, the idea is to reason piece-wise and relate classes of program $C_{2}$ behaviors (traces) to classes of $C_{1}$ behaviors. We identify a class of $C_{2}$ traces by applying a trace restriction and, for that class, we identify an appropriate separate restriction that can be applied to $C_{1}$. We also provide abstractions over individual events so that we can identify which atomic events in $C_{2}$ correspond to which atomic events in $C_{1}$ as well as which atomic events are unimportant. We treat a concrete program $C$ in terms of its traces by abstracting it—via an intermediate abstract program—to a KAT expression, denoted $k_{C}$. A trace-refinement relation $\mathbb{T}$ then characterizes the relationship between $C_{2}$ and $C_{1}$ in terms of their respective trace abstractions $k_{2}$ and $k_{1}$. Specifically, each element of $\mathbb{T}$ is a tuple $(r_{2},r_{1},\mathcal{A})$ embodying a trace class relationship: a restriction $r_{2}$ for $C_{2}$, a restriction $r_{1}$ for $C_{1}$, and atomic event/condition abstractions as a set of KAT hypotheses $\mathcal{A}$. The overall refinement condition is that, for each such triple, KAT inclusion holds over the programs restricted and abstracted trace-wise. Technically, we write ${C_{2}}\preceq^{\mathbb{T}}{C_{1}}{}{}$ to mean:

[TABLE]

Here $\leq_{\mathcal{A}}$ denotes KAT inclusion (up to $\mathcal{A}$), restriction is achieved through intersection, and the additional condition requires that $\mathbb{T}$ accounts for all behaviors of $C_{2}$. The latter requirement is not always enforced, as partial solutions are also useful. Our treatment based on restrictions, if applied to state-based relations, would be akin to taking the pre-relation to be disjunctive and considering each disjunct one at a time. Furthermore, notice there is no particular requirement on the relationship between $r_{2}$ and $r_{1}$ within a tuple, affording flexibility in how to relate the corresponding classes. Finally, we have shown that our trace-refinement relations are composable (Thm. 4.5), permitting an analysis of one pair of program fragments to be reused in many contexts and when the program is further changed.

The second part of our work introduces a novel algorithm that is able to synthesize a trace-refinement relation $\mathbb{T}$, given input programs $C_{1}$ and $C_{2}$, such that ${C_{2}}\preceq^{\mathbb{T}}{C_{1}}{}$. Overall, our search algorithm constructs $(r_{2},r_{1},\mathcal{A})$ triples, by looking for restrictions that can be placed by $r_{2},r_{1}$, on $C_{2},C_{1}$ and relaxing their behavior with new hypotheses $\mathcal{A}$. Each stage of our algorithm is a candidate tuple of trace classes—that may need further restriction—and we proceed as follows. First, we iteratively synthesize a two-step semantic abstraction $\alpha$ from a program $C_{1}$ (and $C_{2}$) to a KAT expression $k_{1}$ (and $k_{2}$). This semantic translation goes beyond the syntactic $C$-to-$k$ translation of Kozen (Kozen, 1997), expressing restrictions (via assume) and accounting for paths becoming infeasible. Second, we check whether $k_{2}$ is included in $k_{1}$ using KAT reasoning, returning a counterexample string if not. Third, we use a custom edit-distance algorithm on such counterexamples to find relationships between cross-program trace classes, with a scoring scheme to correlate program behaviors. Fourth, we employ case-analysis on branching in $C_{1}$ and $C_{2}$, in circumstances where the branching in one program prevents immediate inclusion in the other. This leads us to introduce more restrictions which—unlike (Benton, 2004; Yang, 2007; Gyori et al., 2017; Unno et al., 2017)—are not required to be of the initial state, but rather may appear at program locations anywhere in the program. When we are unable to continue refinement through case-analysis, we introduce KAT hypotheses that either treat unimportant events (e.g. logging) as skip, or else equate similar events. Finally, we construct increasingly restricted trace classes used in subsequent iterations of the algorithm.

The goal of our work is to build foundations for compositional trace-based reasoning. To this end, we generate trace-refinement relations $\mathbb{T}$ to capture the multitude of conditions and ways in which one code region $C_{1}$ can refine another region $C_{2}$, in order to produce results that are reusable. Additionally, synthesized trace refinement relations can also be used by experts. Like a syntactic diffing tool, the relations can guide them to understand how code has changed.

We have implemented our algorithm in a new tool called Knotical, that operates on an input pair of C-like programs and synthesizes trace refinement relations. Knotical is built from the ground up, in OCaml using Interproc (int, [n. d.]) for abstract interpretation, Symkat to generate KAT counter examples (sym, [n. d.]; Pous, 2015a), and our own edit distance algorithm.

We have evaluated our tool on a collection of 37 benchmark examples that we have built (Apx. C). Almost all examples necessitate trace refinement relations that cannot be expressed using concrete refinement or other prior techniques. The examples range from those designed to exercise the various aspects of our approach (restriction, hypotheses, edit distance, etc.), to broader examples including user I/O, array access patterns, and reactive web servers (e.g. thttpd (Poskanzer, [n. d.]) and merecat (Nilsson, [n. d.])). Our evaluation demonstrates that interesting and precise trace refinement relations can be discovered.

Summary.

We make the following contributions:

• •

A theory of trace-refinement relations, going beyond prior state refinement relations. (Sec. 4)

• •

A proof of composition. (Thm. 4.5)

• •

A novel synthesis algorithm that iteratively constructs trace-refinement relations. (Sec. 5)

• •

A proof of soundness. (Thm. 5.1)

• •

The first tool for trace refinement relations. (Sec. 5-7)

• •

A customized edit-distance algorithm for scoring and finding alignments between programs. (Sec. 6)

• •

A collection of benchmarks and experimental validation, demonstrating viability. (Sec. 7)

Related work.

To our knowledge, we are the first to generalize Benton-style refinement (Benton, 2004; Yang, 2007) to trace relationships. Bouajjani *et al. *(Bouajjani et al., 2017) have focused on concurrent loop-free programs. Their notion of refinement is not quite based on “traces” in the sense that we describe herein, but rather on graphs over the reads-from relation and program order. More distantly related are bisimulations, hyper temporal logics (Clarkson et al., 2014) and self-composition (Barthe et al., 2004; Terauchi and Aiken, 2005). (See Sec. 8)

Limitations.

We developed a theory for trace refinement relations and, while KAT has worked well, it has also meant that we were restricted to terminating programs. We leave possibly non-terminating programs to future work. Our implementation was also limited in the number of symbols due to Symkat (sym, [n. d.])’s use of char to represent symbols.

2. Overview

Consider the two programs in Fig. 1, inspired by the Merecat project (Nilsson, [n. d.]) which enhanced the thttpd web server (Poskanzer, [n. d.]) to support SSL connections. We are interested in knowing how the the new program compares to the previous, both of which involve typical web server behavior: alternately receives a request and sends a response. This is illustrated by the two program fragments $C_{1}$ and $C_{2}$. The programs involve some differences, perhaps arising from changes/edits that were made to $C_{1}$. There are still similarities: both programs involve a loop that iterates over x, recving messages and possibly sending responses. On the other hand, $C_{2}$ only performs a log when it recvs an m such that $\texttt{m}\leq 0$, and it additionally performs an authorization check on m. In addition, $C_{1}$ only performs logs when the flag l is enabled.

2.1. Relating the programs’ behavior over time

We take a reactive view of programs, considering not only the programs’ local stack/heap state, but also the programs’ I/O side-effects. For simplicity in this paper we will work with stack variables and events shown as function calls (denoted recv, log, etc.) but our work generalizes to heap structures.

We would like to express similarities in how the programs behave over time, such as alternation between send and recv. We would like a theory to also tolerate the differences between how the programs behave over time, such as the recv/send behavior in $C_{1}$ versus the recv/check/send behavior in $C_{2}$. Intuitively, the theory we develop will need some way of expressing restrictions that can be placed on one program (e.g. auth is always greater than 0 in $C_{2}$) so that its traces are included in the other (e.g. log-free traces of $C_{1}$), as well as to provide abstractions that relate an event in one program (e.g. the send event in $C_{1}$) to an analogous event in the other (e.g. send in $C_{2}$).

Expressing properties of the way a program behaves over time motivates the need for a suitable trace-oriented relational logic (as opposed to state relations (Benton, 2004; Yang, 2007; Gyori et al., 2017; Unno et al., 2017)). As discussed in Sec. 1, we found that Kleene Algebra with Tests (KAT) was a natural choice (Kozen, 1997) for a few reasons, including that the KAT constructors naturally abstract program entities. Our theory involves an abstraction from concrete programs $C_{1},C_{2}$, via abstract programs to a representation as KAT expressions $k_{1},k_{2}$, respectively (Sec. 4.1).

The terms of a KAT expression are event symbols or boolean test symbols. We introduce (uppercase) event symbols for program statements such as “$\textsf{E}_{\texttt{recv}}$” for recv and (lowercase) boolean test symbols for the integer expressions above such as “$\textsf{a}_{\texttt{x}\!>\!0}$” for x>0. (For ease of reading, we use subscripts to indicate which program expressions correspond to the symbol.) Thus, the behaviors of programs $C_{1}$ and $C_{2}$ in Fig. 1 can be represented, respectively, as:

[TABLE]

where “1” is the identity symbol in KAT, akin to skip in programs. Note that composition $\cdot$ binds tighter than union $+$, and we use overline (e.g.  $\overline{\textsf{c}_{\texttt{m}\!>\!0}}$) to indicate negation. The above KAT symbols represent program statements, but we use KAT symbols more generally as semantic entities.

Trace-refinement relations.

With KAT representations of programs, it is straight-forward to define concrete KAT refinement (Def. 4.2 for programs that are equivalent. However, not all behaviors of $C_{1}$ are contained within $C_{2}$ (such as some logging in $C_{1}$) and vice-versa (authorization failures in $C_{2}$) and so KAT refinement does not hold for Fig. 1. Nonetheless, we may still be interested in which behaviors of $C_{1}$ are in $C_{2}$ and how one might correlate events in $C_{1}$ with $C_{2}$. We may want to describe how both programs have a substantially similar recv/send relationship. Imagine that we could somehow focus on the executions of $C_{2}$ in which auth was always greater than 0, somehow focus on the executions of $C_{1}$ that had no log events (when l was always false), and finally on the executions of both programs where they recv valid messages and thus $\texttt{m}>0$. In that case, the programs would have the following more restricted behaviors, represented as the following restricted KAT expressions:

[TABLE]

The above equations are just classes of trace behaviors of $C_{1}$ and $C_{2}$, respectively, with $\leq$ denoting KAT inclusion. If we could now further somehow ignore the $\textsf{K}_{\texttt{check}}$ event, the above KAT expressions are equivalent. (In this case they are syntactically equivalent, but they could also be semantically equivalent.) Finding this correlation takes care of some behaviors of $C_{1}$. Doing this for all behaviors of $C_{1}$ leads us to our trace-oriented notion of refinement relations.

We formalize this kind of reasoning into a weak (as opposed to concrete) and compositional notion of refinement based on what we call trace-refinement relations. We consider one class of traces of $C_{2}$ at a time like we did above in Eqns. 1 and 2. We translate programs into KAT expressions and then reason abstractly about traces of $C_{2}$ by considering its corresponding KAT expression $k_{2}$ and focus on particular behaviors by restricting behaviors—also described as another KAT expression $r_{2}$—with intersection: $k_{2}\cap r_{2}$. For this restricted behavior of $k_{2}$, it is then often helpful to restrict $k_{1}$ (which corresponds to $C_{1}$) with a perhaps rather unrelated $r_{1}$. Then we can ask whether equivalence holds between $k_{2}\cap r_{2}$ and $k_{1}\cap r_{1}$. Returning to the running example, we can consider the class of traces of $C_{2}$ in which auth is always greater than 0 by letting

[TABLE]

where Any is shorthand for the disjunction of all event symbols in the KAT at hand. This restriction allows behaviors of the program where after any event, both $\texttt{m}>0$ and $\texttt{auth}>0$. We can use this restriction to focus on $k_{2}\cap r_{2}$. Similarly we can restrict $C_{1}$ to the classes of traces that do not involve logging by letting

[TABLE]

requiring that $\overline{\textsf{b}_{\texttt{l}=\textsf{true}}}$ holds on every iteration of the loop. With these restrictions in place, we get Eqns 1 and 2 above.

In some cases, we can witness classes of traces in $C_{2}$ that are in $C_{1}$ simply with a pair of restrictions. However, restrictions are not the only way that we relate $k_{2}$ to $k_{1}$. Looking at Eqns 1 and 2, there is still the discrepancy that the $\textsf{K}_{\texttt{check}}$ event occurs in $C_{2}$ but not $C_{1}$. Since we are already focused on a case where auth is always greater than 0, the $\textsf{K}_{\texttt{check}}$ event is not so important. We can ignore such unimportant events by introducing additional hypotheses into the KAT. In this case, we can introduce the hypothesis “$\textsf{K}_{\texttt{check}}=1$,” and we finally have the KAT relationship $(k_{2}\cap r_{2})\equiv_{\{\textsf{K}_{\texttt{check}}=1\}}(k_{1}\cap r_{1})$. Our choice of working with KAT enables us to exploit algebraic reasoning and so we can introduce hypotheses for other purposes too. It is often convenient to let syntactically identical statements between $C_{2}$ and $C_{1}$ use the same KAT symbol. In other cases, we may prefer not to, but we can introduce KAT hypotheses to instead selectively relate statements.

Putting it all together.

As discussed so far, we have only considered one class of $C_{2}$ traces and there are of course many others. Ultimately, we will collect a set $\mathbb{T}=\{(r_{1},r_{2},\mathcal{A}),\allowbreak(r^{\prime}_{1},r^{\prime}_{2},\mathcal{A}^{\prime}),\ldots\}$, each triple considering different cases. Overall, we use the notation ${k_{2}}\preceq^{\mathbb{T}}{k_{1}}{}$ to mean that $(k_{2}\cap r_{2})\leq_{\mathcal{A}}(k_{1}\cap r_{1})$ holds of each triple and that if we union over the first projection of $\mathbb{T}$, we have taken care of every possible behavior of $k_{2}$. Notice that for “weak” completeness we could always add a triple $(1,1,\mathcal{A}^{\top})$ where $\mathcal{A}^{\top}$ maps every single symbol to 1 (skip). The goal is instead to generate useful and precise trace-refinement relations. To this end, our algorithm and implementation favor searching for complex restrictions and resort to hypotheses only when necessary.

To the best of our knowledge, one cannot describe these kinds of trace-based refinement relations in prior works such as Benton (Benton, 2004) and bisimulation (at least not without extraordinary effort to represent trace behavior with complicated ghost variables). Nonetheless, there are many intuitive trace-based properties that one would like to express along the lines of the new program alternately receives and sends messages like the original, the new program additionally performs an authorization check after each receive, and so on.

Remark: Path Sensitivity. KAT has facilities to express many well-known tricks for increasing path sensitivity such as loop unrolling, trace partitioning (Mauborgne and Rival, 2005), control-flow refinement (Gulwani et al., 2009). For lack of space, we omit examples such as alignments between different loop iterations.

2.2. Composition, Contexts, Spanning Versions

So far we have discussed reasoning about a change from $C_{1}$ to $C_{2}$, while the context remains fixed. But what about the context of $C_{1}$? A single fragment $C_{1}$ can be used in many different contexts within a large program. Thus, when $C_{1}$ is changed to $C_{2}$, there is benefit to performing a single analysis that considers all possible contexts, rather than considering how $C_{1}$ and $C_{2}$ relate in each context (O’Hearn, 2018). This approach also allows us to cope with the fact that the context itself may change. Consider, for example, programs:

[TABLE]

In these programs, we need to know how $C_{1}$ and $C_{2}$ relate in a context of boolean symbol b and how they may impact boolean symbol g. If this were the only context we were concerned about, we could focus on search for refinement relations to those that assume b. However, what if the program is then changed to $P_{3}=\textsf{A}\!\cdot\!\textsf{m}\!\cdot\!C_{2}\!\cdot\!(\textsf{g}\!\cdot\!\textsf{G}+\textsf{!g}\!\cdot\!1)$, where b is no longer in the context, but m is? If we are context agnostic in our analysis in our $P_{1}$-vs-$P_{2}$ analysis then we can reuse refinement relations for reasoning about $P_{2}$-vs-$P_{3}$.

Returning to Fig. 1, fragments $C_{1}$ and $C_{2}$ may be used in different contexts. Perhaps in one context it is important that all failed connections are logged and we want to ensure a change from $C_{1}$ to $C_{2}$ preserves this property. In that case we need a refinement relation that does not ignore log events, and assume that the context of $C_{1}$ ensures $\textsf{l}=\textsf{true}$. Formally, we would have the tuple

[TABLE]

This restricts to traces of $C_{1}$ where logging is enabled and all connections fail and restricts traces of $C_{2}$ to those where all connections fail. Moreover, we require a set of hypotheses $\mathcal{A}_{log}$ which does not imply that $\textsf{O}_{\texttt{log}}=1$.

In a different context, other relations would be useful. As noted earlier, this example comes from a change that added SSL support to thttpd (Poskanzer, [n. d.]). Therefore, we may wish to have a refinement relation, specifying that as long as all messages are authenticated in $C_{2}$, then it behaves the same as $C_{1}$. Our theory allows one to express this relationship written, formally as:

[TABLE]

Here, $C_{1}$ is unrestricted, $C_{2}$ is focused only on executions that are authorized, and we use a set of hypotheses that ignores all log events and ignores the check event in $k_{2}$.

It is not hard to see that our formalism can capture other more complicated contexts, such as an outer loop. More broadly, encompasing all of KAT, we have proved that our trace-refinement relations are compositional (Thm. 4.5), allowing us to reason about the overall trace-refinement, by considering pairs of program segments at a time.

2.3. Automation

From $C$ to $k$ and back.

Before we present our main algorithm, we need to translate back and forth between a program $C$ and its corresponding KAT expression $k$. The former lets us learn fine-grained details about the behavior of the program, while the latter lets us perform coarse-grained cross-program comparisons. To get $k$ from $C$, we exploit program semantics to obtain precise KAT expressions, e.g. excluding infeasible paths. Technically, we work with an (iteratively refined) two-step abstraction function $\alpha$ that takes concrete states, via abstract states, to symbols in the KAT boolean subalgebra, using a procedure called $\textsc{Translate}:(C,\alpha)\rightarrow\mathcal{K}$ (see Sec. 4.1). Our abstraction is not a one-way process: our refinement search (discussed below) involves discovering various classes of traces of $k_{1}$, each expressed as a restriction $k_{1}\cap r_{1}$. For example, we may consider traces of $C_{2}$ in which auth in Line 1 is always positive. Our algorithm discovers the restriction $r_{2}$ in Eqn. 3, and uses a subprocedure $\textsc{Restrict}(C_{1},r_{1},C_{2},r_{2},\mathcal{A},\alpha)$ to instrument these restrictions via a source code transformation. We now need to translate this $r_{2}$ back into the program $C_{2}$ so that we can explore more fine-grained behaviors of $C_{2}$ with help from abstract interpretation. This is denoted $\textsc{Restrict}(C_{1},r_{1},C_{2},r_{2},\mathcal{A},\alpha)$ and our implementation represents these restrictions via a source code transformation, using a form of a product program in which we instrument assume statements. As our algorithm continues to search for more fine-grained classes of traces where refinement holds, it may iteratively instrument more assumptions and continue to refine the abstraction $\alpha$ (maintaining a monotonicity constraint).

Overall algorithm:

The above is a depiction of our overall algorithm (Sec. 5) that synthesizes trace-refinement relations by attempting to discover increasingly granular trace classes of $C_{1}$ that are included in trace classes of $C_{2}$. Each such partial solution is a triple $(r_{1},r_{2},\mathcal{A})$ such that ${k_{1}\cap r_{1}}\leq_{\mathcal{A}}{k_{2}\cap r_{2}}$ (Def. 4.4), where $k_{1}$ corresponds to $C_{1}$ and $k_{2}$ to $C_{2}$.

At the high level, each iteration of the algorithm is a recursive call (Synth), where we are exploring a region of the solution space where $C_{1}$ has possibly been restricted, $C_{2}$ has possibly been restricted and a collection of KAT hypotheses $\mathcal{A}$ are in use. Moreover, we have a current abstraction $\alpha$ from programs to $\mathcal{K}$. Each iteration of our algorithm proceeds by calculating the aforementioned KAT abstractions $k_{1}$ and $k_{2}$ of the (possibly already restricted) programs (Translate). Next, we consider whether $k_{1}$ is included in or is equivalent to $k_{2}$, under the current set $\mathcal{A}$ of hypotheses (KATdiff). To check this refinement, we build on the recent work of Pous (Pous, 2015a), using his tool Symkat (sym, [n. d.]). If this refinement holds, then the algorithm returns this triple $(k_{1},k_{2},\mathcal{A})$ as a solution that may be assembled with others into a complete solution by previous calls to Synth. Alternatively, if the inclusion/equivalence does not hold, we employ a sub-procedure (SolveDiff) to decide, based on the counterexamples and the overall KAT expressions, whether to (i) introduce restrictions $(r_{1,i},r_{2,i})$ and/or (ii) introduce hypotheses $\mathcal{A}_{i}$. In Secs. 5 and 6 we discuss how the sub-procedure employs a custom edit distance algorithm for this purpose. Finally, the restrictions $r_{1,i}$ and $r_{2,i}$ are instrumented back into the programs (Restrict), to produce new programs $D_{1,i}$ and $D_{2,i}$ that are considered recursively. We have proved that our algorithm for generating trace-refinement relations is sound (Thm. 5.1). Weak completeness is less interesting because any partial solution can easily be made a complete solution through aggressive use of hypotheses. We note that we do not expect from our algorithm to be able to generate every possible solution. Hence, we are more interested in generating precise and useful trace-refinement relations.

2.4. The Knotical Tool

We have developed a prototype tool Knotical that implements our algorithms and is the first tool capable of synthesizing trace-refinement relations. Our tool is built from the ground up written in OCaml and uses Interproc(int, [n. d.]) for abstract interpretation and Symkat (Pous, 2015a) for symbolically checking KAT expression equalities and inclusion.

Fig. 2 illustrates one of the 75 solutions found by Knotical when run on the example in Fig. 1. The synthesized trace refinement relation $\mathbb{T}$ has five tuples. This output illustrates the restrictions using the notation “$\textsf{asm}(\textsf{d}_{\texttt{auth}\!>\!0})@C_{2}\!\!:\!\!\ell_{\ref{ln:auth}}$” meaning, for example, that we instrument an assume(auth>0) on line 1 of $C_{2}$. Notice that Knotical has considered various case splits, based on these three boolean conditions. It begins with the conditions in the left-hand side ($C_{2}$) and needs to discover at least one solution in $C_{1}$ for each case. When auth>0, Knotical introduces hypotheses to ignore log events in either program and the check event in $C_{2}$. Otherwise the log event does not occur in $C_{2}$ so it needn’t be ignored.

Edit-distance for refinement.

During the algorithm, when considering whether the current $k_{1}$ refines $k_{2}$, Symkat may find that it doesn’t and return a counterexample of a string $w_{1}$ that is in $k_{1}$ but not $k_{2}$ (and $w_{2}$, vice-versa). Returning to the running example, such a pair might be $w_{1}=\textsf{a}_{\texttt{x}\!>\!0}\!\cdot\!\textsf{E}_{\texttt{recv}}\!\cdot\!\overline{\textsf{b}_{\texttt{l}=\textsf{true}}}\!\cdot\!\overline{\textsf{c}_{\texttt{m}\!>\!0}}\!\cdot\!\textsf{X}_{\texttt{x--}}\!\cdot\!\overline{\textsf{a}_{\texttt{x}\!>\!0}}$ and $w_{2}=\textsf{a}_{\texttt{x}\!>\!0}\!\cdot\!\textsf{E}_{\texttt{recv}}\!\cdot\!\overline{\textsf{b}_{\texttt{l}=\textsf{true}}}\!\cdot\!\overline{\textsf{c}_{\texttt{m}\!>\!0}}\!\cdot\!\textsf{O}_{\texttt{log}}\!\cdot\!\textsf{X}_{\texttt{x--}}\!\cdot\!\overline{\textsf{a}_{\texttt{x}\!>\!0}}$. These counterexamples give us information as to how $k_{1}$ and $k_{2}$ diverge. Our algorithm departs from a traditional counterexample-guided approach and instead is able to consider not only the entirety of counterexample strings $w_{1}$ and $w_{2}$, but also the KAT expressions $k_{1}$ and $k_{2}$, in order to find a better correlation between the two. It is easy for a human reader to see that the relationship between $k_{1}$ and $k_{2}$ fits better, when the * expression in $k_{1}$ is correlated with the * expression in $k_{2}$. To this end, we developed a custom edit-distance algorithm (Bille, 2005) (see Sec. 6).

Evaluation.

We created a series of 37 benchmarks for most of which, trace-based refinement relations cannot be expressed in prior formalisms (Sec. 7). On most benchmarks, our tool was able to generate a non-trivial trace-refinement relation in seconds or fractions of a second.

3. Preliminaries

Strings, Sets, Composition, Programs

A string $s$ over an alphabet $\Sigma$ is a sequence $s_{1}\cdot s_{2}\cdots s_{n}$ of symbols $s_{i}\in\Sigma$, for $i\in[1,n]$. Given sets $S_{1},\ldots,S_{n}$, a set $S\subseteq S_{1}\times S_{2}\times\ldots S_{n}$, and an element $s=(s_{1},\ldots,s_{n})\in S$ we denote with $\mathsf{proj}_{i}(s)$ the projection of $s$ to its $i$-th element $s_{i}$ in $S_{i}$. We abuse notation, denoting as $\mathsf{proj}_{i}(S)$ the set $\{s_{i}\in S_{i}\mid s_{i}\in\mathsf{proj}_{i}(s),s\in S\}$.

We assume a set $\mathsf{Prog}$ of (essentially imperative) programs operating on a set $\mathcal{S}$ of states. We assume a distinguished “error state” $\mathsf{fault}\in\mathcal{S}$. A configuration is a pair $\langle{C},{\sigma}\rangle$, where $C$ is a program and $\sigma$ a state; we write $\mathsf{Config}$ for the set of all configurations. We assume a binary relation $\mathord{\leadsto}\subseteq\mathsf{Config}\times\mathcal{S}$ capturing the “big step”, nondeterministic operational semantics of our programs; $\langle{C},{\sigma}\rangle\leadsto\rho$ means that executing program $C$ in initial state $\sigma$ can result in the final state $\rho$.

Kleene Algebra with Tests.

We use KAT (Kozen, 1997) to represent classes of traces within a program. A Kleene Algebra with Tests $\mathcal{K}$ is a two-sorted structure $(\Sigma,\mathcal{B},+,\cdot,{}^{*},\bar{\;},0,1)$, where $(\Sigma,+,\cdot,{}^{*},0,1)$ is a Kleene algebra, $(\mathcal{B},+,\cdot,\bar{\;},0,1)$ is a Boolean algebra, and $(\mathcal{B},+,\cdot,0,1)$ is a sub-algebra of $(\Sigma,+,\cdot,0,1)$. We distinguish between two sets of symbols: set P for primitive actions, and set B for primitive tests. The grammar of boolean test expressions is: $\textsf{BExp}::=b\in\textsf{B}\mid b_{1}\cdot b_{2}\mid b_{1}+b_{2}\mid\bar{b}\mid 0\mid 1$ and we define the grammar KExp of KAT expressions as:

[TABLE]

The free Kleene algebra with tests over $\textsf{P}\cup\textsf{B}$, is obtained by quotienting BExp with the axioms of Boolean algebras, and KExp with the axioms of Kleene Algebra. For $e,f\in\mathcal{K}$, we write $e\leq f$ if $e+f=f$, and all Kleene Algebras with Tests $\mathcal{K}$ we consider here are $*$-continuous, where any elements $a,b,c$ in $\mathcal{K}$, satisfy the axiom $a\cdot b^{*}\cdot c=\sum_{n\in\mathbb{N}}a\cdot b^{n}\cdot c$ ((Kozen, 1990)). By convention we use lower case letters for test symbols and upper case letters for actions. We may also abuse notation, writing program conditions and statements rather than boolean symbols and action symbols (in which case we implicity create symbols for each). For Fig. 1 booleans include $\textsf{B}=\{\textsf{a}_{\texttt{x}\!>\!0},\textsf{b}_{\texttt{l}=\textsf{true}}\}$, actions include $\textsf{P}=\{\textsf{O}_{\texttt{log}},\textsf{E}_{\texttt{recv}}\}$, and $k=...(\textsf{b}_{\texttt{l}=\textsf{true}}\!\cdot\!\textsf{O}_{\texttt{log}}+\overline{\textsf{b}_{\texttt{l}=\textsf{true}}}\!\cdot\!1)...\in\mathcal{K}$.

Definition 3.1 (Intersection).

Given a KAT $\mathcal{K}$ and two of its elements $k_{1}$ and $k_{2}$ we define $k_{1}\cap k_{2}$ to be equal to $l_{1}+\ldots+l_{n}+\ldots$, where $\{l_{i}\}_{i\in\mathbb{N}}$ is the set of all elements $l_{i}$ in $\mathcal{K}$ such that $l_{i}\leq k_{1}$ and $l_{i}\leq k_{2}$.111Notice that for any two KAT expressions $k_{1}+\ldots+k_{n}$ and $l_{1}+\ldots+l_{m}$ over a KAT $\mathcal{K}$, for $n,m\in\mathbb{N}$, there is a finite number of elements $h_{1}+\ldots+h_{r}$, for $r\in\mathbb{N}$ such that $(k_{1}+\ldots+k_{n})\cap(l_{1}+\ldots+l_{m})\equiv h_{1}+\ldots+h_{r}$. Since we never start with a KAT expression as an infinite disjunction in what follows, any time we talk about the intersection of two KAT expressions as a disjunction of KAT elements, we will refer to such a finite disjunction.

For KAT expressions $k_{1},k_{2}$ and $l$, and a set of hypotheses $\mathcal{A}$, we write $l\in k_{1}\setminus_{\mathcal{A}}k_{2}$ if $l\leq_{\mathcal{A}}k_{1}$ and $l\not\leq_{\mathcal{A}}k_{2}$. Similarly, we write $l\in k_{1}\Delta_{\mathcal{A}}k_{2}$ if $l\in k_{1}\setminus_{\mathcal{A}}k_{2}$ or $l\in k_{2}\setminus_{\mathcal{A}}k_{1}$. Finally, for two KATs $\mathcal{K}_{1}$ and $\mathcal{K}_{2}$, we denote with $\mathcal{K}_{1}\cup\mathcal{K}_{2}$ the smallest KAT that contains both $\mathcal{K}_{1}$ and $\mathcal{K}_{2}$. Finally, when we refer to strings we mean KAT strings, which are KAT expressions where only the concatenation operation is used.

Program Refinement.

Program refinement is a classical concept (Morgan, 1994) and can be formulated in different ways, depending on the context. Often, the usual notion of refinement is too concrete because it does not consider the context in which $C_{1}$ and $C_{2}$ are used. Benton (Benton, 2004) introduced a weaker notion of refinement, parameterized by an input relation between the states of the two programs as well as an output relation. We call this an interface, which is an equivalence relation on the set of states $\mathcal{S}$ and defined as follows:

Definition 3.2.

For interfaces $I,O$ and programs $C,C^{\prime}$, we say $C^{\prime}$ refines $C$ w.r.t. $(I,O)$, written ${C^{\prime}}\preceq^{I}_{O}{C}$, if the following two conditions are met, for all states $\sigma,\sigma^{\prime}$ such that $I(\sigma,\sigma^{\prime})$:

1. (1)

if $\langle{C^{\prime}},{\sigma^{\prime}}\rangle\leadsto\mathsf{fault}$, then $\langle{C},{\sigma}\rangle\leadsto\mathsf{fault}$; 2. (2)

if $\langle{C^{\prime}},{\sigma^{\prime}}\rangle\leadsto\rho^{\prime}$, then either there exists $\rho$ such that $\langle{C},{\sigma}\rangle\leadsto\rho$ and $O(\rho,\rho^{\prime})$, or else $\langle{C},{\sigma}\rangle\leadsto\mathsf{fault}$.

We say that $C^{\prime}$ (concretely) refines $C$, written ${C^{\prime}}\preceq{C}$, when ${C^{\prime}}\preceq^{\textsf{id}}_{\textsf{id}}{C}$ where id is the identity relation.222Benton used the notation $\vdash C\stackrel{{\scriptstyle}}{{\thicksim}}C^{\prime}:I\Rightarrow O$ whereas we use notation by James Brotherston (personal communication)

Yang (Yang, 2007) extended Benton’s work to express relational heap properties using a variant of Separation Logic (O’Hearn et al., 2001).

4. KAT Representations and Refinements

In this section we discuss a two-step semantic abstraction (Sec. 4.1), trace refinement and trace-refinement relations (Sec. 4.2), and composition results (Sec. 4.3).

4.1. Abstracting programs into KAT expressions

We describe how to abstract a while-style program $C$ to a KAT expression $k$ over a KAT $\mathcal{K}$. We parameterize such a translation by an abstraction $\alpha$ used for both abstracting concrete states of the program to abstract states, as well as the latter to elements of the boolean subalgebra of $\mathcal{K}$. More concretely, given a program $C$ over a set of states $\mathcal{S}$, we define $\alpha$ to be a tuple $(\mathcal{K},A_{S},\alpha_{S},\alpha_{B})$, where $\mathcal{K}$ is a KAT, $A_{S}$ is a set of abstract states, $\alpha_{S}$ is a mapping from $\mathcal{S}$ to $A_{S}$ corresponding to the program abstraction given by the abstract interpretation, and $\alpha_{B}$ is a mapping from $A_{S}$ to $\mathcal{B}$, the boolean subalgebra of $\mathcal{K}$. Additionally, we require that for any $b\in\mathcal{B}$, there is a set of states $\{a_{1},\ldots,a_{n}\}\in A_{S}$ such that $b\equiv\alpha_{B}(a_{1})+\ldots+\alpha_{B}(a_{n})$. When $\mathcal{K}$ and $A_{S}$ are clear from the context, we write $\alpha=\alpha_{B}\circ\alpha_{S}$.

With such an abstraction $\alpha=(\mathcal{K},A_{S},\alpha_{S},\alpha_{B})$ as a parameter, we say a translation from $C$ to a KAT expression $k\in\mathcal{K}$ is valid (resp. strongly valid), if for any states $\sigma,\rho\in\mathcal{S}$, $\langle{C},{\sigma}\rangle\leadsto\rho$ only if (resp. if and only if) $\alpha_{B}(\alpha_{S}(\sigma))\cdot k\cdot\alpha_{B}(\alpha_{S}(\rho))\not\equiv 0$. We assume a procedure $\textsc{Translate}(C,\alpha)$ that returns $k\in\mathcal{K}$ and the translation from $C$ to $k$ is valid (Sec. 5 for an implementation). Finally, we will (Sec. 5) iteratively construct abstractions and thus need the following notion of refinement over abstractions:

Definition 4.1 (Refining abstractions).

For two abstractions $\alpha=(\mathcal{K},A_{S},\alpha_{S},\alpha_{B})$ and $\alpha^{\prime}=(\mathcal{K}^{\prime},A_{S}^{\prime},\alpha_{S}^{\prime},\alpha_{B}^{\prime})$ over the same set of concrete states $\mathcal{S}$, we say that $\alpha^{\prime}$ refines $\alpha$, and write it as $\alpha^{\prime}\sqsubseteq\alpha$, if $\mathcal{K}$ is a subalgebra of $\mathcal{K}^{\prime}$ and for any state $\sigma\in\mathcal{S}$, $\alpha_{B}^{\prime}(\alpha_{S}^{\prime}(\sigma))\leq\alpha_{B}(\alpha_{S}(\sigma))$.

Let $\alpha_{1}=(\mathcal{K}_{1},A^{1}_{S},\alpha^{1}_{S},\alpha^{1}_{B})$ and $\alpha_{2}=(\mathcal{K}_{2},A^{2}_{S},\alpha^{2}_{S},\alpha^{2}_{B})$ be two abstractions, both refining an abstraction $\alpha$ with Boolean algebra $\mathcal{B}$. By $\alpha^{1}_{S}\times\alpha^{2}_{S}$ we denote the function from $\mathcal{S}$ to $A^{1}_{S}\times A^{2}_{S}$, that maps a state $\sigma\in\mathcal{S}$ to $(\alpha^{1}_{S}(\sigma),\alpha^{2}_{S}(\sigma))$. Further, we define $\alpha^{1}_{B}\cdot\alpha^{2}_{B}$ to be the function from $A^{1}_{S}\times A^{2}_{S}$ to $\mathcal{B}$ that maps a tuple $(a_{1},a_{2})\in A^{1}_{S}\times A^{2}_{S}$ to $\alpha^{1}_{S}(a_{1})\cdot\alpha^{2}_{S}(a_{2})$ in $\mathcal{B}$. The combined abstraction of $\alpha_{1}$ and $\alpha_{2}$, written $\alpha_{1}\sqcup\alpha_{2}$, is defined to be the abstraction $(\mathcal{K}_{1}\cup\mathcal{K}_{2},A^{1}_{S}\times A^{2}_{S},\alpha^{1}_{S}\times\alpha^{2}_{S},\alpha^{1}_{B}\cdot\alpha^{2}_{B})$.

4.2. KAT refinements

With abstractions from programs to KAT expressions in hand, we now first define concrete KAT refinement, and then our notion of trace-refinement relations (Def. 4.4).

Definition 4.2 (Concrete KAT refinement).

Let $k_{1}$ and $k_{2}$ be two KAT expressions over $\mathcal{K}$. We say that $k_{1}$ concretely refines $k_{2}$, and denote it by ${k_{1}}\preceq{k_{2}}$, if for any $b,d\in\mathcal{B}$:

1. (1)

$b\cdot k_{1}\equiv 0$ implies $b\cdot k_{2}\equiv 0$, 2. (2)

$b\cdot k_{1}\cdot d\not\equiv 0$ implies $b\cdot k_{2}\cdot d\not\equiv 0$, or $b\cdot k_{2}\equiv 0$.

The following relates concrete trace refinement, via abstraction, back to concrete program refinement (See Apx. A).

Theorem 4.3.

Let $C_{1}$ and $C_{2}$ be two programs, and let $k_{1}$ and $k_{2}$ be the two KAT expressions obtained from a strongly valid translation of the two programs respectively, under some abstraction $\alpha$. Then it holds that ${C_{1}}\preceq{C_{2}}$ if and only if ${k_{1}}\preceq{k_{2}}$.

We now weaken concrete KAT refinement, presenting trace-refinement relations. Intuitively, the idea is to reason piece-wise, considering classes of traces within $k_{1}$ and, for each, correlating them with a corresponding trace class in $k_{2}$, with the help of KAT hypotheses. Note that, for some element $k$ of a KAT $\mathcal{K}$, we say a set $S=\{s_{1},\ldots,s_{n}\}$ of $\mathcal{K}$ elements partitions $k$, if $k=s_{1}+\ldots+s_{n}$.

Definition 4.4 (Trace Refinement Relations).

Let $\mathcal{K}$ be a KAT, let $\mathfrak{A}$ be a class of hypotheses over $\mathcal{K}$, and let $\mathbb{T}$ be a relation over $\mathcal{K}\times\mathcal{K}\times\mathcal{P}(\mathfrak{A})$. Given two KAT elements $k_{1}$ and $k_{2}$ of $\mathcal{K}$, we say that $k_{1}$ refines $k_{2}$, with respect to $\mathbb{T}$, denoted by ${k_{1}}\preceq^{\mathbb{T}}{k_{2}}{}{}$, if $\mathsf{proj}_{1}(\mathbb{T})\text{ partitions }k_{1}$ and,

[TABLE]

We also consider trace equivalence relations, slightly adapting Def. 4.4 to use equivalence ($\equiv$), rather than inclusion ($\leq$), as well as requiring that both $\mathsf{proj}_{1}(\mathbb{T})$ partitions $k_{1}$ and $\mathsf{proj}_{2}(\mathbb{T})$ partitions $k_{2}$.

As discussed in Sec. 2, intuitively each $(l_{1},l_{2},\mathcal{A})$ triple in a trace-refinement relation $\mathbb{T}$ identifies restrictions on $k_{1}$ and $k_{2}$, as well as KAT hypotheses $\mathcal{A}$ that allow us to align the $k_{1}\cap l_{1}$ trace classes with ones in $k_{2}\cap l_{2}$. In the example from Sec. 2.1, we gave examples of an $l_{1}$ that excluded logging by forcing $\overline{\textsf{b}_{\texttt{l}=\textsf{true}}}$ to hold at each iteration of the loop.

Remark 4.1.

As trace-refinement is a weakening of concrete refinement, it is natural that two KAT expressions $k_{1}$ and $k_{2}$ may be such that $k_{1}$ refines $k_{2}$, but does not concretely refine it. For any two expressions $k_{1}$ and $k_{2}$, the singleton set containing only the tuple $(k_{1},k_{2},\mathcal{A})$, where $\mathcal{A}$ is a set of hypotheses that equates all actions to $1$ and all boolean variables to [math] is a trivial solution to trace-refinement between $k_{1}$ and $k_{2}$.

Finally, we overload the KAT refinement definition to be used on programs themselves, when the abstraction $\alpha$ is clear from the context. Thus, for two programs $C_{1}$ and $C_{2}$, and a trace-refinement relation $\mathbb{T}$, we may write ${C_{1}}\preceq^{\mathbb{T}}{C_{2}}{}{}$ to mean that ${\textsc{Translate}(C_{1},\alpha)}\preceq^{\mathbb{T}}{\textsc{Translate}(C_{2},\alpha)}{}{}$.

Classes of hypotheses.

For this work, we will explore the effect of just a few types of classes of hypotheses. In general, checking equality of KAT expressions under arbitrary additional hypotheses, can be undecidable ((Kozen, 1996)). Because of that, and guided by the limitations imposed by certain libraries we use in our implementation (Symkat), we focus on the following types of hypotheses when $\textsf{A}_{\bf\textsf{}},\textsf{B}_{\bf\textsf{}}\in\textsf{P}$ and $\textsf{a}_{\bf\textsf{}},\textsf{b}_{\bf\textsf{}}\in\textsf{B}$: (i) to ignore certain actions: $\textsf{A}_{\bf\textsf{}}\equiv 1$, (ii) to fix the valuation of certain booleans: $\textsf{b}_{\bf\textsf{}}\equiv 1$ or $\textsf{b}_{\bf\textsf{}}\equiv 0$, (iii) to express commutativity of actions against tests: $\textsf{A}_{\bf\textsf{}}\cdot\textsf{b}_{\bf\textsf{}}\equiv\textsf{b}_{\bf\textsf{}}\cdot\textsf{A}_{\bf\textsf{}}$ (currently not used in our implementation) and (iv) to relate single elements: $\textsf{A}_{\bf\textsf{}}=\textsf{B}_{\bf\textsf{}}$ or $\textsf{a}_{\bf\textsf{}}=\textsf{b}_{\bf\textsf{}}$.

4.3. Composition

Given trace-refinement relations $\mathbb{T}_{1}$ and $\mathbb{T}_{2}$, we define their composition $\mathbb{T}_{1}\odot\mathbb{T}_{2}$ to be the trace-refinement relation $\mathbb{T}=\{(l_{1}\cdot m_{1},l_{2}\cdot m_{2},\mathcal{A}_{1}\cup\mathcal{A}_{2})\mid(l_{1},l_{2},\mathcal{A}_{1})\in\mathbb{T}_{1},(m_{1},m_{2},\mathcal{A}_{2})\in\mathbb{T}_{2}\}$. Similarly, we define disjunction $\mathbb{T}_{1}\oplus\mathbb{T}_{2}$ to be the trace-refinement relation $\mathbb{T}=\{(l_{1}+m_{1},l_{2}+m_{2},\mathcal{A}_{1}\cup\mathcal{A}_{2})\mid(l_{1},l_{2},\mathcal{A}_{1})\in\mathbb{T}_{1},(m_{1},m_{2},\mathcal{A}_{2})\in\mathbb{T}_{2}\}$. Finally, for $\mathbb{T}$, we define $\mathbb{T}^{\star}$ to be $\{(o^{*},p^{*},\mathcal{A})\mid(o,p,\mathcal{A})\in\mathbb{T}\}$.

Thm. 4.5 below allows us to reason about individual fragments of KAT expressions, and combine the analyses into a result that holds overall. We can do so by building trace-refinement relations in a bottom-up fashion, capturing larger and larger fragments of those KAT expressions, guided by their structure. (See Apx. A)

Theorem 4.5.

Suppose $k_{1},k_{2},l_{1}$ and $l_{2}$ are KAT expressions. Let $\mathbb{T}_{k}$ and $\mathbb{T}_{l}$ be trace-refinement relations, such that ${k_{1}}\preceq^{\mathbb{T}_{k}}{k_{2}}$ and ${l_{1}}\preceq^{\mathbb{T}_{l}}{l_{2}}$. Then ${k_{1}\cdot l_{1}}\preceq^{\mathbb{T}_{k}\odot\mathbb{T}_{l}}{k_{2}\cdot l_{2}}$, ${k_{1}+l_{1}}\preceq^{\mathbb{T}_{k}\oplus\mathbb{T}_{l}}{k_{2}+l_{2}}$, ${k_{1}+l_{1}}\preceq^{\mathbb{T}_{k}\cup\mathbb{T}_{l}}{k_{2}+l_{2}}$, and ${k_{1}^{*}}\preceq^{\mathbb{T}_{k}^{\star}}{k_{2}^{*}}$.

As a simple corollary we can always extend a trace-refinement relation corresponding to a pair of KAT expressions, to one corresponding to a pair of KAT expressions obtained from the former by enclosing them into any common context.

Corollary 4.6.

Given any KAT expressions $m,l,k_{1}$ and $k_{2}$, and trace-refinement relation $\mathbb{T}$ such that ${k_{1}}\preceq^{\mathbb{T}}{k_{2}}$, it holds that ${m\cdot k_{1}\cdot l}\preceq^{\mathbb{T}^{\prime}}{m\cdot k_{2}\cdot l}$, where $\mathbb{T}^{\prime}$ is the set $\{(m\cdot r_{1}\cdot l,m\cdot r_{2}\cdot l,\mathcal{A})\mid(r_{1},r_{2},\mathcal{A})\in\mathbb{T}\}$.

Finally, we present a transitivity result, stating how we can extend two trace-refinement relations to achieve it. Let $\mathbb{T}_{1}$ and $\mathbb{T}_{2}$ be two trace-refinement relations, such that for any tuple $(o_{1},p_{1},\mathcal{A}_{1})$ in $\mathbb{T}_{1}$, there is a tuple $(o_{2},p_{2},\mathcal{A}_{2})$ in $\mathbb{T}_{2}$, such that $p_{1}\leq o_{2}$. For such trace-refinement relations, we define their transitive trace-refinement relation to be the one containing the tuples $(o_{1},p_{2},\mathcal{A}_{1}\cup\mathcal{A}_{2})$. We denote such a trace-refinement relation by $\mathbb{T}_{1}\otimes\mathbb{T}_{2}$.

Theorem 4.7.

For any elements $k,l$ and $m$ in a KAT $\mathcal{K}$, and any trace-refinement relations $\mathbb{T}_{1}$, $\mathbb{T}_{2}$, if ${k}\preceq^{\mathbb{T}_{1}}{l}$ and ${l}\preceq^{\mathbb{T}_{2}}{m}$, and $\mathbb{T}_{1}\otimes\mathbb{T}_{2}$ is defined, then ${k}\preceq^{\mathbb{T}_{1}\otimes\mathbb{T}_{2}}{m}$.

5. Automation

Our overall algorithm is given in Fig. 3. The input to our algorithm are programs $C_{1},C_{2}$ provided, for example, in a C-like source format and parsed into ASTs. Our algorithm returns trace-refinement relations for $C_{1},C_{2}$, and is parametric as to whether the relations are for equivalence versus inclusion. Technically, it returns a finite set $O=\{(l_{1}^{1},l_{2}^{1},\mathcal{A}^{1},\alpha^{1}),\ldots\}$ from which the trace refinement relation $\textsf{RefRelation}(O)$ can be constructed by unifying to a common abstraction $\alpha=\alpha^{1}\sqcup\ldots\sqcup\alpha^{n}$.

Our main function Synth uses several sub-components discussed below. At the high level, it begins by using Translate, analyzing $C_{1}$ and using an iteratively constructed abstraction $\alpha$ to obtain the KAT expression $k_{1}$ (similar for $C_{2},k_{2}$), per Sec. 4.1. The algorithm then checks for KAT equivalence or inclusion between $k_{1}$ and $k_{2}$ with KATdiff. If no counterexamples are found, KATdiff returns $k_{1}$ and $k_{2}$, together with the current set of hypotheses $\mathcal{A}$ as a solution. On the other hand, if KATdiff does find counterexamples, they are fed into SolveDiff, which examines them along with the KAT expressions to determine what restrictions and/or hypotheses could be employed to subdivide the search space into trace classes for which we hope further refinements can be discovered. SolveDiff returns this decision, given as a list of $(r_{1},r_{2},\mathcal{A})$ triples. Then Restrict is used to construct increasingly restricted versions of the input programs $C_{1}$ and $C_{2}$ and new abstractions $\alpha^{\prime}$. These are then are considered recursively by Synth.

5.1. Sub-procedures

We now define and discuss the sub-procedures used by Synth. We also discuss the implementation (and limitations) of these subcomponents. As noted, the overall algorithm is parameterized by whether we are looking for solutions to equivalence ($\equiv_{\mathcal{A}}$), or simply to inclusion ($\leq_{\mathcal{A}}$). The functionality of the sub-procedures is largely the same for the two cases.

$\bullet$ ${\textsc{Translate}}(C,\alpha)$: As described in Sec. 4.1, this sub-procedure takes as input a program $C$ and abstraction $\alpha=(\mathcal{K},A_{S},\alpha_{S},\alpha_{B})$, and returns a KAT expression $k$ in $\mathcal{K}$ such that $\langle{C},{\sigma}\rangle\leadsto\rho$ implies that $\alpha_{B}(\alpha_{S}(\sigma))\cdot k\cdot\alpha_{B}(\alpha_{S}(\rho))\not\equiv 0$. In the implementation, Interproc populates the locations of the program with invariants according to abstraction $\alpha$. This is then used in converting the abstract program into a KAT expression $k$ in $\mathcal{K}$ that covers its behavior. Semantic information is exploited where paths of the program are determined to be infeasible. For example, consider the simple instrumented program

asm(d==0); c=d; if (c==0) execB() else execD(); The standard syntactic translation (Kozen, 1997) alone, would produce the expression $\textsf{c}_{\bf\textsf{d==0}}\cdot\textsf{E}_{\bf\textsf{c=d}}\cdot(\textsf{c}_{\bf\textsf{c==0}}\cdot\textsf{B}_{\bf\textsf{execB}}+\overline{\textsf{c}_{\bf\textsf{c==0}}}\cdot\textsf{D}_{\bf\textsf{execD}}).$ In our case, Interproc determines that c==0 is always true under the instrumented asm(d==0) and the program is instead converted to the simpler expression $\textsf{B}_{\bf\textsf{execB}}$.

$\bullet$ ${\textsc{KATdiff}}(k_{1},k_{2},\mathcal{A})$: Given two KAT expressions $k_{1},k_{2}$ and hypotheses $\mathcal{A}$, KATdiff returns cexs, which is a set of KAT expressions $k$ with $k\in k_{1}\setminus_{\mathcal{A}}k_{2}$ and possibly $k\in k_{2}\setminus_{\mathcal{A}}k_{1}$ (depending on whether we seek equivalence or inclusion). We assume this sub-procedure to be sound and complete. If cexs is empty, then the two input KAT expressions $k_{1}$ and $k_{2}$ are such that $k_{1}\leq_{\mathcal{A}}k_{2}$ (or $k_{1}\equiv_{\mathcal{A}}k_{2}$). Our implementation uses Symkat (sym, [n. d.]), which only obtains a singleton set cexs, and is thus either (i) a single string $c$ in $k_{1}\setminus_{\mathcal{A}}k_{2}$ when we seek inclusion or (ii) a pair of strings $(c_{1},c_{2})$, with $c_{1}$ in $k_{1}\setminus_{\mathcal{A}}k_{2}$ and $c_{2}$ in $k_{2}\setminus_{\mathcal{A}}k_{1}$, when we seek equivalence. If $k_{1}=a\cdot M\cdot(b\cdot F+\overline{b}\cdot G)$ and $k_{2}=a\cdot M\cdot\overline{b}\cdot G$, then the string $a\cdot M\cdot b\cdot F$ is included in $k_{1}$ but not in $k_{2}$, and thus in $k_{1}\setminus_{\mathcal{A}}k_{2}$.

$\bullet$ ${\textsc{SolveDiff}}(k_{1},k_{2},\mathcal{A},{\textsf{cexs}})$: This procedure takes KAT expressions $k_{1}$ and $k_{2}$, a set of hypotheses, and the set of counterexamples cexs above. It returns a set $R$ of tuples $(r_{1},r_{2},\mathcal{A}_{r})$, each called a restriction. Restrictions $R$ has the property that $\mathsf{proj}_{1}(R)$ partitions $k_{1}$, ensuring that we have completely covered all traces. Furthermore, in the interest of progress, we also assume that each counterexample in cexs is not a counterexample for $k_{1}\cap r_{1}\setminus_{\mathcal{A}_{r}}k_{2}\cap r_{2}$, or even for $k_{2}\cap r_{2}\setminus_{\mathcal{A}_{r}}k_{1}\cap r_{1}$ depending on whether equivalence is considered instead of inclusion. In our implementation, we apply a customized edit-distance algorithm discussed in Sec. 6, which returns a set of transformations that can be applied to two KAT strings $c_{1}$ and $c_{2}$ to make them equivalent. These transformations are in the form of removing alphabet symbols from the strings at particular locations, or replacing some symbol with another. From these transformations, SolveDiff constructs a list of restrictions to be applied on the input programs of the form $(r_{1},r_{2},\mathcal{A}_{r})$, where $r_{1}$ and $r_{2}$ are KAT expressions, and $\mathcal{A}_{r}$ is a set of hypotheses.

When the edit-distance algorithm asks for the removal of an alphabet symbol from, say, string $c_{1}$, we consider two cases, depending on whether the symbol corresponds to a boolean condition or not. If so, the KAT expression $r_{1}$ corresponding to this transformation is essentially obtained by adding a hypothesis inserting the valuation of the boolean variable, in the given KAT expression $k_{1}$. Since we want these restrictions to cover all behaviors of the input programs, we also consider the negation of that valuation. As such, at least two restrictions are considered, namely $(r_{1},r_{2},\mathcal{A}_{r})$ and $(r_{1}^{\prime},r_{2}^{\prime},\mathcal{A}_{r}^{\prime})$, such that $r_{1}$ and $r_{1}^{\prime}$ cover $k_{1}$. On the other hand, when the removal of an event $\textsf{M}_{\bf\textsf{}}$ is required, a hypothesis of the form $\textsf{M}_{\bf\textsf{}}\equiv 1$ is added to the set of hypotheses.

$\bullet$ $\textsc{Restrict}(C_{1},r_{1},C_{2},r_{2},\mathcal{A},\alpha)$ obtains new programs from previous ones, using restrictions from SolveDiff. Given programs $C_{1},C_{2}$, KAT restrictions $r_{1},r_{2}$, a set of hypotheses $\mathcal{A}$ and current abstraction $\alpha$, this sub-procedure returns a tuple $(D_{1},D_{2},\alpha^{\prime})$, where $D_{1},D_{2}$ are the new programs and $\alpha^{\prime}$ is a new abstraction that refines $\alpha$, such that, for $i\in\{1,2\}$, $\textsc{Translate}(D_{i},\alpha^{\prime})\leq_{\mathcal{A}}\textsc{Translate}(C_{i},\alpha)\cap r_{i}$, but $\textsc{Translate}(D_{i},\alpha^{\prime})\equiv_{\mathcal{A}}\textsc{Translate}(C_{i},\alpha^{\prime})\cap r_{i}$. In other words, the KAT expression obtained from the new program $D_{i}$ under the new refined abstraction $\alpha^{\prime}$, is included in the KAT expression from the original program $C_{i}$ under the old abstraction $\alpha$ using the restriction $r_{i}$, but at the same time, if we used the new abstraction $\alpha^{\prime}$ to translate the program $C_{i}$ under the restriction $r_{i}$, into a KAT expression we would obtain the same as by just translating $D_{i}$ under the new abstraction. Our implementation restricts programs by instrumenting assume statements on appropriate lines of code. For example, for a program $(\textsf{b}_{\texttt{l}=\textsf{true}}\!\cdot\!\textsf{O}_{\texttt{log}}+\overline{\textsf{b}_{\texttt{l}=\textsf{true}}}\!\cdot\!1)^{*}$ we can implement restriction $r=(\textsf{b}_{\texttt{l}=\textsf{true}}\cdot(\textsf{b}_{\texttt{l}=\textsf{true}}\!\cdot\!\textsf{O}_{\texttt{log}}+\overline{\textsf{b}_{\texttt{l}=\textsf{true}}}\!\cdot\!1))^{*}=(\textsf{b}_{\texttt{l}=\textsf{true}}\!\cdot\!\textsf{O}_{\texttt{log}})^{*}$ with an assume(l==true) instrumented immediately inside the body of the corresponding while loop. This can be seen in the output of our tool shown in Fig. 2.

5.2. Formal Guarantees

The key challenge is soundness, even under the sub-procedure assumptions noted above, and the proof is in Apx. A.1..

Theorem 5.1 (Soundness).

For all $C_{1},C_{2}$, and abstractions $\alpha$, let $O=\textsc{Synth}(C_{1},C_{2},\emptyset,\alpha)$, let $\alpha^{\prime}$ be the common abstraction of $O$ and let $k_{1}=\textsc{Translate}(C_{1},\alpha^{\prime})$ and $k_{2}=\textsc{Translate}(C_{2},\alpha^{\prime})$. Then ${k_{1}}\preceq^{\textsf{RefRelation}(O)}{k_{2}}{}$.

Weak completeness is easier because, as per Remark 4.1, trivial solutions can be constructed. So we are more interested in generating increasingly precise solutions. For progress, as long as the sub-procedure SolveDiff returns restrictions that handle the counterexamples returned by KATdiff, then these counterexamples will not be seen again in the recursive steps that follow.

6. Edit-distance on expressions and strings

Our main algorithm depends on SolveDiff to examine a pair of KAT expressions $k_{1},k_{2}$, a set of hypotheses $\mathcal{A}$, as well as counterexamples to their equivalence, and determine appropriate restrictions $r_{1},r_{2}$ and additional hypotheses $\mathcal{A}^{\prime}$ that could be used to further search for trace classes of $k_{1}$ that are contained in $k_{2}$, up to hypotheses $\mathcal{A}\cup\mathcal{A}^{\prime}$. To achieve this, SolveDiff tries to identify the differences between the KAT expressions $k_{1}$ and $k_{2}$, or between their string-based counterexamples, and attempts to find useful restrictions of least impact, to apply to the two input programs. As such, we implemented a sub-procedure Distance, that takes as inputs two KAT strings $c_{1}$ and $c_{2}$, or two KAT expressions $k_{1}$ and $k_{2}$, and returns a list of scored transformations to be applied on the two strings (or KAT expressions) in order to make them equivalent. In our implementation we use the custom edit-distance algorithm only on counterexample strings, and in Apx B.1, we discuss how the global edit-distance for general KAT expressions can help in conjunction with the composition results of Section 4.3. The edit-distance on such KAT expressions has to handle the structure of the expressions, and is naturally more involved than the linear one on strings. (The former is more similar to trees (Bille, 2005).) The idea behind the sub-procedure Distance is similar to edit-distance algorithms in the literature for comparing two strings/trees/graphs (Bille, 2005). These edit-distance algorithms, return a sequence of usually simple single-symbol transformations that are classified as symbol removals, insertions, and replacements, that equate the two input strings when they are applied on them.

We had to customize edit distance for our purposes of cross-program correlation. We thought that inserting a symbol in one of the two strings or KAT expressions, is less natural than removing another one from the other string or expression, and encode such insertions in one string as removals from the other. Therefore we employ just removal and replacement transformations on the two inputs:

• •

$\textsf{Remove}(c,s)$: Returns a new string obtained from $s$ with the symbol $c$ removed,

• •

$\textsf{Replace}(c_{1},c_{2},s)$: Returns a new string obtained from $s$ with the symbol $c_{1}$ replaced with the symbol $c_{2}$.

Note that each copy of each symbol in the string is uniquely labeled, and the transformations above speak about these labeled symbols, making the order in which the transformations are applied irrelevant. Moreover, in our experience, certain transformations have more impact, or are in some way heavier than others. As such, we attempt to score them, and use the score of each individual transformation to ultimately score the whole sequence of transformations. For example, replacing an event symbol $\textsf{M}_{\bf\textsf{}}$ in some string with another symbol $\textsf{N}_{\bf\textsf{}}$, is certainly a transformation that is semantically more involved than simply setting a boolean symbol $\textsf{c}_{\bf\textsf{}}$ to $\mathsf{true}$. The full algorithm for edit-distance can be found in Appendix B of the supplemental material.

Example 6.1.

Consider the two input strings $s_{1}=\textsf{a}_{\bf\textsf{}}\cdot\textsf{A}_{\bf\textsf{}}\cdot\textsf{B}_{\bf\textsf{}}$ and $s_{2}=\textsf{d}_{\bf\textsf{}}\cdot\textsf{e}_{\bf\textsf{}}\cdot\textsf{B}_{\bf\textsf{}}$. Running the procedure Distance on $s_{1}$ and $s_{2}$, will return the pair $(T,S)$, where $T$ is the sequence of transformations $[\mathsf{Replace}(\textsf{a}_{\bf\textsf{}},\textsf{d}_{\bf\textsf{}},s_{1}),\mathsf{Remove}(\textsf{e}_{\bf\textsf{}},s_{2}),\mathsf{Remove}(\textsf{A}_{\bf\textsf{}},s_{1})]$ and the score $S=\mathsf{replace\_scr}+2*\mathsf{remove\_scr}$, where $\mathsf{replace\_scr}$ is the cost of replacing one symbol with another of same type, and $\mathsf{remove\_scr}$ is the cost of removing a symbol from one of the input strings. With this sequence of transformations, both strings become equal to $\textsf{d}_{\bf\textsf{}}\cdot\textsf{B}_{\bf\textsf{}}$.

The sequence of transformations returned by Distance is converted into the one SolveDiff returns, as follows, for $\textsf{A}_{\bf\textsf{}},\textsf{B}_{\bf\textsf{}}$ action symbols and $\textsf{a}_{\bf\textsf{}},\textsf{b}_{\bf\textsf{}}$ boolean symbols.

• •

$\mathsf{Remove(\textsf{A}_{\bf\textsf{}},s)}$: add a new hypothesis $\textsf{A}_{\bf\textsf{}}\equiv 1$

• •

$\mathsf{Remove(\textsf{a}_{\bf\textsf{}},s)}$: perform case analysis and include two tuples of restrictions, resp. corresponding to setting $\textsf{a}_{\bf\textsf{}}$ to $\mathsf{true}$ and setting $\textsf{a}_{\bf\textsf{}}$ to $\mathsf{false}$

• •

$\mathsf{Replace(\textsf{A}_{\bf\textsf{}},\textsf{B}_{\bf\textsf{}},s)}$: add a new hypothesis $\textsf{A}_{\bf\textsf{}}\equiv\textsf{B}_{\bf\textsf{}}$

• •

$\mathsf{Replace(\textsf{a}_{\bf\textsf{}},\textsf{b}_{\bf\textsf{}},s)}$: add a new hypothesis $\textsf{a}_{\bf\textsf{}}\equiv\textsf{b}_{\bf\textsf{}}$

7. Evaluation

Implementation

We have realized our algorithm in a prototype tool called Knotical. Our tool is written in OCaml, using Interproc as an abstract interpreter (int, [n. d.]), and Symkat as a symbolic solver for KAT equalities (Pous, 2015a; sym, [n. d.]). We have described implementation choices made for the tool’s subcomponents in Section 5.1. Knotical generates multiple solutions, internally represented in the form of trees. During the KATdiff and SolveDiff steps of the algorithm, multiple choices can be made and each solution tree corresponds to a particular set of choices. Branching in a solution tree corresponds to the different restrictions applied and their complement, as a result of performing case analysis on a particular condition. Often the solution trees (or subtrees) are partial, in the sense that the different restrictions applied to the programs, when taken together do not cover all behaviors of the input programs. Partial solutions can readily be converted to complete ones (See Remark 4.1)

Benchmarks.

We have evaluated our approach by applying our tool to a collection of 37 new benchmarks. Each benchmark includes two program fragments denoted $C_{1}$ and $C_{2}$. They can be found in Appendix C of the supplemental materials. Broadly speaking, our benchmarks categorized as: (0*.c) – Program pairs that exercise various technical aspects of our algorithm, such as cases where refinement is trivial, concrete refinement holds, refinement can be achieved entirely from case-splits, and where refinement can only be achieved through aggressive introduction of hypotheses. (1*.c) – Program pairs that involve user I/O, system calls, acquire/release, and reactive web servers. (2*.c) – Program pairs that involve tricky patterns, requiring careful alignment between two fragments. ([345]*.c) – These program pairs are more challenging: 3buffer.c and 3syscalls.c model array access patterns with complicated array iterations, and 4ident.c involves a larger pair with identical code. Others model reactive web servers.

Some of the more challenging examples include 5thttpdWr.c and 5thttpdEr.c, each containing a pair of fragments taken from the thttpd (Poskanzer, [n. d.]) and Merecat (Nilsson, [n. d.]) HTTP servers. These two servers are related because Merecat is an extension of thttpd that adds SSL support. These benchmarks contain distillations from the two servers, summarizing how they diverge in handling a request. Merecat, unlike thttpd, performs compression, uses SSL to write responses, and has a keep-alive option so that connections aren’t closed when an error occurs. We have manually decomposed the two programs into two phases: writing a request (5thttpdWr.c) and the subsequent error handling (5thttpdEr.c), demonstrating the compositional nature of our relations.

Results.

We ran Knotical on a MacBook Pro with a 3.1 GHz Intel Core i7 CPU and 16GB RAM, using the OCaml 4.06.1 compiler. Some of the generated trace-refinement relations are shown in Appendix C of the supplemental materials. The table in Figure 4 summarizes these results, including the performance of Knotical. For each benchmark, we have included the lines of code (loc) and number of procedures ($f$s). We also indicate (Dir) whether the benchmark is for refinement $\leq^{\mathbb{T}}$ or for equality $=^{\mathbb{T}}$. For some of the examples, we check only $\leq^{\mathbb{T}}$ because we wanted to ensure the tool was capable of this antisymmetric reasoning. Some of the $\leq^{\mathbb{T}}$ examples were crafted for this purpose.

Next, we report the total time it took in seconds (Time), as well as the number of solutions discovered (Sols). We also report some basic statistics about the solutions generated for each benchmark. We report the number of Tuples in the solution that has the fewest/most (min/max) tuples. Similarly, we report the number of hypotheses (Hypos) in the solution that has the fewest/most (min/max) hypotheses. These statistics help show the quality of the solutions. Intuitively, fewer hypotheses means that the programs are more similar. We also evaluated the quality of the generated trace-refinement relations by inspecting many of them manually.

Discussion.

In most cases, Knotical was able to generate expected solutions quickly, often in fractions of a second. For simpler benchmarks (0*.c), there were often concise solutions with either two tuples (due to a single case-split) or one tuple (due to hypotheses). 0nondet.c is more complicated and both of its solutions had 4 tuples. More complicated benchmarks tended to have solutions with 3 to 7 tuples. The largest number of tuples in a solution was 7 (1sendrecv.c) and the largest number of hypotheses in a solution was 19 (01concloop2.c and 1sendrecv.c). Benchmark 1acqrel.c had a solution with 0 hypotheses because it contains non-terminating loops, which are translated to KAT expressions [math]. Benchmark 0impos.c is expected to have no solutions because its fragments contain two different non-removable events, that cannot be made equivalent with axioms. (Knotical permits users to specify events that cannot be ignored.) Benchmarks 1concloop2.c, 3buffer.c, and 3syscalls.c had hundreds of solutions because they have many complicated conditional branch and loop conditions. Case analysis on the permutations of these conditions leads to many solutions. There is not much correlation between analysis running time (or number of solutions) and lines of code. There is a stronger correlation with code complexity: many events or conditions lead to longer analysis time. 3syscalls.c, e.g., took longer and yielded more solutions. In summary, our algorithm and tool Knotical, promptly generate concise trace-refinement relations.

8. Related Work

To the best of our knowledge, we are the first to define trace-refinement relations in terms of programs’ event behaviors over time, which we call trace-oriented refinement. Prior works (Benton, 2004; Yang, 2007) view refinement in terms of state relations.

Bisimulation.

A bisimilarity relation is over states and expresses that whenever one can perform an action from some state on one system, one can also perform the same action from any bisimilar state on the other system, and reach bisimilar states. While some weakenings of bisimulation have been shown, they don’t capture the types of equivalence discussed here. The very way in which we formulate program equivalences in this paper (expressing program behaviors over time as KAT expressions) is fundamentally different from bisimulation (which relies on step-by-step state relations). Bisimulation is unable to capture that $\textsf{A}\cdot(\textsf{B}+\textsf{C})$ has the same behavior as $\textsf{A}\cdot\textsf{B}+\textsf{A}\cdot\textsf{C}$. It would also be tedious to use bisimulations to express that events commute ($A\cdot B\equiv B\cdot A$) or event inverses ($A\cdot B=1$).

Concrete, state-based semantic differencing.

Other recent works relate a function’s output to its input. Lahiri et al. describe SymDIFF (Lahiri et al., 2012, 2013), defining “differential assertion checking,” which says that from an initial state that was non-failing on $C$, it becomes failing on $C^{\prime}$. Their approach to assertion checking bares some similarity to self-composition (Barthe et al., 2004; Terauchi and Aiken, 2005). Godlin and Strichman (Godlin and Strichman, 2009) offered support for mutual recursion. Wood et al. (Wood et al., 2017) tackle program equivalence in the presence of memory allocation and garbage collection. Unno et al. (Unno et al., 2017) describe a method of verifying relational specifications based on Horn Clause solving. Jackson and Ladd (Jackson and Ladd, 1994) describe an approach based on dependencies between input and output variables, but do not offer formal proofs. Gyori et al. (Gyori et al., 2017) took steps beyond concrete refinement, using equivalence relations, similar to those of Benton, for dataflow-based change impact analysis.

Other works.

Bouajjani et al. (Bouajjani et al., 2017) also eschew state refinement relations in favor of a more abstract relationship between programs. They focus on concurrency questions that arise from reordering program statements and/or re-orderings due to interleaving. The authors don’t work with traces in the sense defined here; rather, their traces are data-flow abstractions, represented as graphs.

There are some analogies between $k$-safety of a single program, and reasoning about two programs. Researchers have explored relational invariants (over multiple executions of a single program) via program transformations that “glue” copies of the program to itself, including self-composition (Barthe et al., 2004; Terauchi and Aiken, 2005), product programs (Barthe et al., 2011), Cartesian Hoare logic (Sousa and Dillig, 2016) and decomposition for $k$-safety (Antonopoulos et al., 2017). Logozzo et al. describe verification modulo versions (Logozzo et al., 2014) and explore how necessary/sufficient environment conditions for a program $C$’s safety can be used to determine whether program $C^{\prime}$ introduced a regression or is “correct relative to $C$”. The work does not involve refinement relations. Composition for (non-relational) temporal logic was explored by Barringer et al. (Barringer et al., 1984), who introduced the “chop” operator. Pous introduced a symbolic approach for determining language equivalence between KAT expressions (Pous, 2015b) (see Sec. 5). Kumazawa and Tamai use edit distance to characterize the difference between counterexamples within a single program (infinite vs lasso traces) (Kumazawa and Tamai, 2011).

9. Conclusion and Future Work

We introduced trace refinement relations, going beyond the state refinement relations (Benton, 2004; Yang, 2007; Gyori et al., 2017; Unno et al., 2017). Our relations express trace-oriented restrictions on a program behavior and case-wise correlate the behaviors of another. We have further provided a novel synthesis algorithm, based on abstract interpretation, KAT solving, restriction, and edit-distance. We have shown with Knotical, the first tool capable of synthesizing trace-refinement relations, that this approach is promising. As discussed in Apx. B.1, we plan to further explore using edit-distance at both global and local levels. Another avenue is to explore how temporal verification can be adapted to trace-refinement relations.

Appendix A Omitted Lemmas and Proofs

Theorem 4.3 (restated). * Let $C_{1}$ and $C_{2}$ be two programs, and let $k_{1}$ and $k_{2}$ be the two KAT expressions obtained from a strongly valid translation of the two programs respectively, under some abstraction $\alpha$. Then it holds that ${C_{1}}\preceq{C_{2}}$ if and only if ${k_{1}}\preceq{k_{2}}$. *

Proof.

For what follows, we write $\alpha$ for $\alpha_{B}\circ\alpha_{S}$. For the only if direction, suppose that ${C_{1}}\preceq{C_{2}}$ and pick any $b,d\in\mathcal{B}$. Suppose first that $b\cdot k_{1}\equiv 0$. Then let $\sigma_{1},\ldots,\sigma_{n}$ be the set of states such that $\alpha(\sigma_{1})+\ldots+\alpha(\sigma_{n})\equiv b$ for $i\leq n$. Then, for all $i\leq n$, $\langle{C_{1}},{\sigma_{i}}\rangle\leadsto\mathsf{fault}$ which implies that $\langle{C_{2}},{\sigma_{i}}\rangle\leadsto\mathsf{fault}$ by assumption that ${C_{1}}\preceq{C_{2}}$. This means that for all $i\leq n$, $\alpha(\sigma_{i})\cdot k_{2}\equiv 0$, and thus $b\cdot k_{2}\equiv\alpha(\sigma_{1})+\ldots+\alpha(\sigma_{n})\cdot k_{2}\equiv 0$.

The second condition states that $b\cdot k_{1}\cdot d\not\equiv 0$ implies $b\cdot k_{2}\cdot d\not\equiv 0$, or $b\cdot k_{2}\equiv 0$. Assume that $b\cdot k_{1}\cdot d\not\equiv 0$. Let $\sigma_{1},\ldots,\sigma_{n}$ be the set of states such that $b=\alpha(\sigma_{1})+\ldots+\alpha(\sigma_{n})$, and let $\rho_{1},\ldots,\rho_{m}$ be the set of states such that $d=\alpha(\rho_{1})+\ldots+\alpha(\rho_{m})$. Therefore, $(\alpha(\sigma_{1})+\ldots+\alpha(\sigma_{n}))\cdot k_{1}\cdot(\alpha(\rho_{1})+\alpha(\rho_{m}))\not\equiv 0$. Let $(\sigma_{i},\rho_{j})$ be all the pairs, such that $\alpha(\sigma_{i})\cdot k_{1}\cdot\alpha(\rho_{j})\not\equiv 0$. It follows by definition that $\langle{C_{1}},{\sigma_{i}}\rangle\leadsto\rho_{j}$. Therefore, either $\langle{C_{2}},{\sigma_{i}}\rangle\leadsto\rho_{j}$ or $\langle{C_{2}},{\sigma_{i}}\rangle\leadsto\mathsf{fault}$ by assumption that ${C_{1}}\preceq{C_{2}}$. It follows that $b\cdot k_{2}\equiv(\alpha(\sigma_{1})+\ldots+\alpha(\sigma_{n}))\cdot k_{2}\equiv 0$ or $b\cdot k_{2}\cdot d\equiv(\alpha(\sigma_{1})+\ldots+\alpha(\sigma_{n}))\cdot k_{2}\cdot(\alpha(\rho_{1})+\ldots+\alpha(\rho_{m}))\not\equiv 0$, as required.

For the if direction, suppose that ${k_{1}}\preceq{k_{2}}$, and let $\sigma,\rho$ be any two states in $\mathcal{S}$. If $\langle{C_{1}},{\sigma}\rangle\leadsto\mathsf{fault}$, then $\alpha(\sigma)\cdot k_{1}\equiv 0$. By the assumption that ${k_{1}}\preceq{k_{2}}$, we have that $\alpha(\sigma)\cdot k_{2}\equiv 0$. Therefore, $\langle{C_{2}},{\sigma}\rangle\leadsto\mathsf{fault}$. On the other hand, if $\langle{C_{1}},{\sigma}\rangle\leadsto\rho$, then $\alpha(\sigma)\cdot k_{1}\cdot\alpha(\rho)\not\equiv 0$. By the assumption that ${k_{1}}\preceq{k_{2}}$, it follows that $\alpha(\sigma)\cdot k_{2}\cdot\alpha(\rho)\not\equiv 0$ or $\alpha(\sigma)\cdot k_{2}\equiv 0$. Therefore, $\langle{C_{2}},{\sigma}\rangle\leadsto\rho$ or $\langle{C_{2}},{\sigma}\rangle\leadsto\mathsf{fault}$, as required. ∎

Lemma A.1.

For any $k,l$ in a KAT $\mathcal{K}$, if $k\leq l$ then $k\cap l=k$.

Proof.

By definition, $k\cap l$ is equal to $m_{1}+\ldots+m_{n}$, where $\{m_{1},\ldots,m_{n}\}$ is the set of all elements $m$ in $\mathcal{K}$ such that $m\leq k$ and $m\leq l$. By assumption, $k$ is equal to $m_{i}$ for some $i\leq n$. Therefore, $k=m_{1}+\ldots+m_{n}$ as required. ∎

Lemma A.2.

Suppose that $k_{1},k_{2}\in\mathcal{K}$ and $\mathcal{A}$ a set of hypotheses such that $k_{1}\leq_{\mathcal{A}}k_{2}$. Then for any $\mathcal{A}^{\prime}$ with $\mathcal{A}\subseteq\mathcal{A}^{\prime}$, $k_{1}\leq_{\mathcal{A}^{\prime}}k_{2}$.

Lemma A.3.

Let $k_{1},k_{2},l_{1}$ and $l_{2}$ be elements of a KAT $\mathcal{K}$. If $k_{1}\leq l_{1}$ and $k_{2}\leq l_{2}$, then $k_{1}\cdot k_{2}\leq l_{1}\cdot l_{2}$ and $k_{1}+k_{2}\leq l_{1}+l_{2}$.

Proof.

Firstly notice that $k_{1}+l_{1}=l_{1}$ and $k_{2}+l_{2}=l_{2}$. For the first inequality, we want to show that $k_{1}\cdot k_{2}+l_{1}\cdot l_{2}=l_{1}\cdot l_{2}$. Using the aforementioned equalities, $k_{1}\cdot k_{2}+l_{1}\cdot l_{2}=k_{1}\cdot k_{2}+(k_{1}+l_{1})\cdot(k_{2}+l_{2})=k_{1}\cdot k_{2}+k_{1}\cdot k_{2}+k_{1}\cdot l_{2}+l_{1}\cdot k_{2}+l_{1}\cdot l_{2}=k_{1}\cdot k_{2}+k_{1}\cdot l_{2}+l_{1}\cdot k_{2}+l_{1}\cdot l_{2}=(k_{1}+l_{1})\cdot(k_{2}+l_{2})=l_{1}\cdot l_{2}$ as required. For the second inequality, we have that $k_{1}+k_{2}+l_{1}+l_{2}=(k_{1}+l_{1})+(k_{2}+l_{2})=l_{1}+l_{2}$ as needed.

∎

Lemma A.4.

Let $k_{1},k_{2}\in\mathcal{K}$. It holds that $k_{1}\leq k_{2}$ if and only if for all $m\in\mathcal{K}$, $m\leq k_{1}$ implies $m\leq k_{2}$.

Proof.

For the if direction, suppose that for all $m\in\mathcal{K}$, $m\leq k_{1}$ implies $m\leq k_{2}$. Then in particular, for $m=k_{1}$, $k_{1}\leq k_{1}$ implies that $k_{1}\leq k_{2}$.

For the only if direction, suppose that $k_{1}\leq k_{2}$, and suppose for contradiction that there is $m\in\mathcal{K}$ such that $m\leq k_{1}$ but $m\not\leq k_{2}$. Then $m+k_{1}=k_{1}$, but $m+k_{2}\neq k_{2}$. From the assumption that $k_{1}\leq k_{2}$, it follows that $k_{1}+k_{2}=k_{2}$. Thus $k_{1}+m+k_{2}=k_{2}$, which implies that $m+k_{2}=k_{2}$. It follows that $m\leq k_{2}$, which is a contradiction. ∎

Lemma A.5.

Let $k,l,o,p$ be elements of some KAT $\mathcal{K}$, and let $o\leq k$ and $p\leq l$. Then $(k\cdot l)\cap(o\cdot p)\leq(k\cap o)\cdot(l\cap p)$ and $(k+l)\cap(o+p)\leq(k\cap o)+(l\cap p)$.

Proof.

We consider the first inequality first, namely, $(k\cdot l)\cap(o\cdot p)\leq(k\cap o)\cdot(l\cap p)$. By definition of intersection, we have that $(k\cdot l)\cap(o\cdot p)\leq o\cdot p$ and $(k+l)\cap(o+p)\leq o+p$. Since $o\leq k$ and $p\leq l$, by Lemma A.1, we have that $k\cap o=o$ and $l\cap p=p$. Therefore $(k\cdot l)\cap(o\cdot p)\leq(k\cap o)\cdot(l\cap p)$ and $(k+l)\cap(o+p)\leq(k\cap o)+(l\cap p)$ as required. ∎

Lemma A.6.

Let $k,l,o,p$ be elements of some KAT $\mathcal{K}$. Then $(k\cap o)\cdot(l\cap p)\leq(k\cdot l)\cap(o\cdot p)$ and $(k\cap o)+(l\cap p)\leq(k+l)\cap(o+p)$.

Proof.

Consider the expressions $(k\cap o)$ and $(l\cap p)$. By definiton, $k\cap o=x_{1}+\ldots+x_{M}$, where $\{x_{1},\ldots,x_{M}\}$ is the set of all elements $x$ in $\mathcal{K}$ such that $x\leq k$ and $x\leq o$. Similarly, $(l\cap p)=y_{1}+\ldots+y_{N}$ where $\{y_{1},\ldots,y_{N}\}$ is the set of all $y$ in $\mathcal{K}$ such that $y\leq l$ and $y\leq p$. Therefore, by Lemma A.3, for any $x$ in the first set and any $y$ in the second set, $x+y\leq k+l$, $x+y\leq o+p$, $x\cdot y\leq k\cdot l$ and $x\cdot y\leq o\cdot p$.

For the first inequality, namely, $(k\cap o)\cdot(l\cap p)\leq(k\cdot l)\cap(o\cdot p)$, notice that $(k\cap o)\cdot(l\cap p)$ is equal to $(x_{1}+\ldots+x_{M})\cdot(y_{1}+\ldots+y_{M})=(x_{1}\cdot y_{1})+(x_{1}\cdot y_{2})+\ldots+(x_{i}\cdot y_{j})+\ldots+(x_{M}\cdot y_{M})$. Therefore, $(k\cap o)\cdot(l\cap p)\leq k\cdot l$ and $(k\cap o)\cdot(l\cap p)\leq o\cdot p$, and thus $(k\cap o)\cdot(l\cap p)\leq(k\cdot l)\cap(o\cdot p)$, as required. Similarly, for the second inequality, notice that $(k\cap o)+(l\cap p)$ is equal to $(x_{1}+\ldots+x_{M})+(y_{1}+\ldots+y_{M})=(x_{1}+y_{1})+(x_{1}+y_{2})+\ldots+(x_{i}+y_{j})+\ldots+(x_{M}+y_{M})$. Therefore, $(k\cap o)+(l\cap p)\leq k+l$ and $(k\cap o)+(l\cap p)\leq o+p$, and thus $(k\cap o)+(l\cap p)\leq(k+l)\cap(o+p)$. ∎

Lemma A.7.

Let $k$ and $o$ be elements of some KAT $\mathcal{K}$, and let $o\leq k$. Then $k^{*}\cap o^{*}\leq(k\cap o)^{*}$.

Proof.

It suffices to show that for all $n,m\in\mathbb{N}$, $k^{n}\cap o^{m}\leq(k\cap p)^{*}$. Let $m$ be any element of $\mathcal{K}$, such that $m\leq k^{n}$ and $m\leq o^{m}$. Then, since $o\leq k$, by Lemma A.1 it holds that $o=k\cap o$, and therefore, $m\leq o^{m}$ implies that $m\leq(k\cap o)^{m}$, and thus $m\leq(k\cap o)^{*}$. Since $m$ was chosen arbitrarily among the elements $x$ in $\mathcal{K}$ for which $x\leq k^{n}\cap o^{m}$, by Lemma A.4, the result follows. ∎

Lemma A.8.

Let $k$ and $o$ be elements of some KAT $\mathcal{K}$. Then $(k\cap o)^{*}\leq k^{*}\cap o^{*}$.

Proof.

Let $M={m_{1},\ldots,m_{n}}$ be the set of all elements $m$, such that $m\leq k$ and $m\leq o$. Therefore, $(k\cap o)^{*}=(m_{1}+\ldots+m_{n})^{*}$, for $m_{i}\in M$. It suffices to show that for all $u\in\mathbb{N}$, $(m_{1}+\ldots+m_{n})^{u}\leq k^{*}\cap o^{*}$. In particular, it is enough to show that $u\in\mathbb{N}$, $(m_{1}+\ldots+m_{n})^{u}\leq k^{u}\cap o^{u}$. The latter is equal to $z_{1}+\ldots+z_{s}$, for $z_{i}\leq k^{u}$ and $z_{i}\leq o^{u}$. Notice that for any element $x\leq(m_{1}+\ldots+m_{n})^{u}$, there is a function $f:[u]\rightarrow[n]$, such that $x\leq m_{f(1)}\cdot m_{f(1)}\cdots m_{f(u)}$. Since for all $j\leq u$, $m_{f(j)}\leq k$ and $m_{f(j)}\leq o$, it follows that $m_{f(1)}\cdot m_{f(1)}\cdots m_{f(u)}\leq k^{u}$ and $m_{f(1)}\cdot m_{f(1)}\cdots m_{f(u)}\leq o^{u}$. Hence, $m_{f(1)}\cdot m_{f(1)}\cdots m_{f(u)}\leq k^{u}\cap o^{u}$. Since $x$ was chosen arbitrarily, the result follows by Lemma A.4. ∎

Theorem A.9.

Suppose $k_{1},k_{2},l_{1}$ and $l_{2}$ are KAT expressions. Let $\mathbb{T}_{k}$ and $\mathbb{T}_{l}$ be trace-refinement relations, such that ${k_{1}}\preceq^{\mathbb{T}_{k}}{k_{2}}$ and ${l_{1}}\preceq^{\mathbb{T}_{l}}{l_{2}}$. Then ${k_{1}\cdot l_{1}}\preceq^{\mathbb{T}_{k}\odot\mathbb{T}_{l}}{k_{2}\cdot l_{2}}$.

Proof.

We want to show that for any tuple $(x,y,\mathcal{D})\in\mathbb{T}_{k}\odot\mathbb{T}_{l}$, $(k_{1}\cdot k_{2})\cap x\leq_{\mathcal{D}}(l_{1}\cdot l_{2})\cap y$. Choose such an arbitrary tuple $(x,y,\mathcal{D})\in\mathbb{T}_{k}\odot\mathbb{T}_{l}$, and let $(o,q,\mathcal{A})\in\mathbb{T}_{k}$ and $(p,r,\mathcal{B})\in\mathbb{T}_{l}$ be the tuples that produced $(x,y,\mathcal{D})$. In other words, $x=o\cdot p$, $y=q\cdot r$ and $\mathcal{D}=\mathcal{A}\cup\mathcal{B}$.

Since $\mathsf{proj}_{1}(\mathbb{T}_{k})$ partitions $k_{1}$ and $\mathsf{proj}_{1}(\mathbb{T}_{l})$ partitions $l_{1}$, we have that for any $o\in\mathsf{proj}_{1}(\mathbb{T}_{k})$ and $p\in\mathsf{proj}_{1}(\mathbb{T}_{l})$, $o\leq k$ and $p\leq l$, and thus by Lemma A.5, we have that $(k_{1}\cdot l_{1})\cap(o\cdot p)\leq(k_{1}\cap o)\cdot(l_{1}\cap p)$. By assumption, $k_{1}\cap o\leq_{\mathcal{A}}k_{2}\cap q$ and $l_{1}\cap p\leq_{\mathcal{B}}l_{2}\cap r$. Since $\mathcal{D}=\mathcal{A}\cup\mathcal{B}$, by Lemma A.2, we have that $k_{1}\cap o\leq_{\mathcal{D}}k_{2}\cap q$ and $l_{1}\cap p\leq_{\mathcal{D}}l_{2}\cap r$. Therefore, by Lemma A.3, we have that $(k_{1}\cap o)\cdot(l_{1}\cap p)\leq_{\mathcal{D}}(k_{2}\cap q)\cdot(l_{2}\cap r)$. By Lemma A.6, we have that $(k_{2}\cap q)\cdot(l_{2}\cap r)\leq_{\mathcal{D}}(k_{2}\cdot l_{2})\cap(q\cdot r)$, and hence $(k_{1}\cdot l_{1})\cap(o\cdot p)\leq_{\mathcal{D}}(k_{2}\cdot l_{2})\cap(q\cdot r)$ as required. ∎

Theorem A.10.

Suppose $k_{1},k_{2},l_{1}$ and $l_{2}$ are KAT expressions. Let $\mathbb{T}_{k}$ and $\mathbb{T}_{l}$ be trace-refinement relations, such that ${k_{1}}\preceq^{\mathbb{T}_{k}}{k_{2}}$ and ${l_{1}}\preceq^{\mathbb{T}_{l}}{l_{2}}$. Then ${k_{1}+l_{1}}\preceq^{\mathbb{T}_{k}\oplus\mathbb{T}_{l}}{k_{2}+l_{2}}$.

Proof.

We want to show that for any tuple $(x,y,\mathcal{D})\in\mathbb{T}_{k}\oplus\mathbb{T}_{l}$, $(k_{1}+k_{2})\cap x\leq_{\mathcal{D}}(l_{1}+l_{2})\cap y$. Choose such an arbitrary tuple $(x,y,\mathcal{D})\in\mathbb{T}_{k}\oplus\mathbb{T}_{l}$, and let $(o,q,\mathcal{A})\in\mathbb{T}_{k}$ and $(p,r,\mathcal{B})\in\mathbb{T}_{l}$ be the tuples that produced $(x,y,\mathcal{D})$. In other words, $x=o+p$, $y=q+r$ and $\mathcal{D}=\mathcal{A}\cup\mathcal{B}$.

Since $\mathsf{proj}_{1}(\mathbb{T}_{k})$ partitions $k_{1}$ and $\mathsf{proj}_{1}(\mathbb{T}_{l})$ partitions $l_{1}$, we have that for any $o\in\mathsf{proj}_{1}(\mathbb{T}_{k})$ and $p\in\mathsf{proj}_{1}(\mathbb{T}_{l})$, $o\leq k$ and $p\leq l$, and thus by Lemma A.5, we have that $(k_{1}+l_{1})\cap(o+p)\leq(k_{1}\cap o)+(l_{1}\cap p)$. By assumption, $k_{1}\cap o\leq_{\mathcal{A}}k_{2}\cap q$ and $l_{1}\cap p\leq_{\mathcal{B}}l_{2}\cap r$. Since $\mathcal{D}=\mathcal{A}\cup\mathcal{B}$, by Lemma A.2, we have that $k_{1}\cap o\leq_{\mathcal{D}}k_{2}\cap q$ and $l_{1}\cap p\leq_{\mathcal{D}}l_{2}\cap r$. Therefore, by Lemma A.3, we have that $(k_{1}\cap o)+(l_{1}\cap p)\leq_{\mathcal{D}}(k_{2}\cap q)+(l_{2}\cap r)$. By Lemma A.6, we have that $(k_{2}\cap q)+(l_{2}\cap r)\leq_{\mathcal{D}}(k_{2}+l_{2})\cap(q+r)$, and hence $(k_{1}+l_{1})\cap(o+p)\leq_{\mathcal{D}}(k_{2}+l_{2})\cap(q+r)$ as required. ∎

Theorem A.11.

Suppose $k_{1},k_{2},l_{1}$ and $l_{2}$ are KAT expressions. Let $\mathbb{T}_{k}$ and $\mathbb{T}_{l}$ be trace-refinement relations, such that ${k_{1}}\preceq^{\mathbb{T}_{k}}{k_{2}}$ and ${l_{1}}\preceq^{\mathbb{T}_{l}}{l_{2}}$. Then ${k_{1}+l_{1}}\preceq^{\mathbb{T}_{k}\cup\mathbb{T}_{l}}{k_{2}+l_{2}}$.

Proof.

Let $(x,y,\mathcal{D})$ be any tuple in $\mathbb{T}_{k}\cup\mathbb{T}_{l}$. Then $(x,y,\mathcal{D})\in\mathbb{T}_{k}$ or $(x,y,\mathcal{D})\in\mathbb{T}_{l}$. Since ${k_{1}}\preceq^{\mathbb{T}_{k}}{k_{2}}$ and ${l_{1}}\preceq^{\mathbb{T}_{l}}{l_{2}}$, it follows by definition that $k_{1}\cap x\leq_{\mathcal{D}}k_{2}\cap y$ and $l_{1}\cap x\leq_{\mathcal{D}}l_{2}\cap y$. Notice that if either $(x,y,\mathcal{D})\notin\mathbb{T}_{k}$ or $(x,y,\mathcal{D})\notin\mathbb{T}_{l}$, then, repsecitevly, either $k_{1}\cap x\equiv 0$ or $l_{1}\cap x\equiv 0$, and thus the above inequalities hold. Hence, by Lemmas A.5 and A.6, $(k_{1}+l_{1})\cap x\leq_{\mathcal{D}}(k_{2}+l_{2}\cap y$ as required. ∎

Theorem A.12.

Given any KAT expressions $k$ and $l$, and trace-refinement relation $\mathbb{T}$ such that ${k}\preceq^{\mathbb{T}}{l}$, it holds that ${k^{*}}\preceq^{\mathbb{T}^{\star}}{l^{*}}$.

Proof.

We want to show that for any tuple $(x,y,\mathcal{D})\in\mathbb{T}^{\star}$, $k^{*}\cap x\leq_{\mathcal{D}}l^{*}\cap y$. Choose such an arbitrary tuple $(x,y,\mathcal{D})\in\mathbb{T}^{\star}$, and let $(o,q,\mathcal{A})\in\mathbb{T}$ be the tuple that produced $(x,y,\mathcal{D})$. In other words, $x=o^{*}$, $y=q^{*}$ and $\mathcal{D}=\mathcal{A}$.

Since $\mathsf{proj}_{1}(\mathbb{T})$ partitions $k_{1}$, we have that for any $o\in\mathsf{proj}_{1}(\mathbb{T})$, $o\leq k$. By Lemma A.7 and the latter inequality, it follows that $k^{*}\cap o^{*}\leq_{\mathcal{A}}(k\cap o)^{*}$. Then, by the assumption that ${k}\preceq^{\mathbb{T}}{l}$, we have that $k\cap o\leq_{\mathcal{A}}l\cap q$, and thus $(k\cap o)^{*}\leq_{\mathcal{A}}(l\cap q)^{*}$. Furthermore, by Lemma A.8, we have that $(l\cap q)^{*}\leq_{\mathcal{A}}l^{*}\cap q^{*}$. Together, these inequalities give us that $k^{*}\cap o^{*}\leq_{\mathcal{A}}l^{*}\cap q^{*}$, as required. ∎

Theorem 4.5 (restated). * Suppose $k_{1},k_{2},l_{1}$ and $l_{2}$ are KAT expressions. Let $\mathbb{T}_{k}$ and $\mathbb{T}_{l}$ be trace-refinement relations, such that ${k_{1}}\preceq^{\mathbb{T}_{k}}{k_{2}}$ and ${l_{1}}\preceq^{\mathbb{T}_{l}}{l_{2}}$. Then*

• •

${k_{1}\cdot l_{1}}\preceq^{\mathbb{T}_{k}\odot\mathbb{T}_{l}}{k_{2}\cdot l_{2}}$,

• •

${k_{1}+l_{1}}\preceq^{\mathbb{T}_{k}\oplus\mathbb{T}_{l}}{k_{2}+l_{2}}$,

• •

${k_{1}+l_{1}}\preceq^{\mathbb{T}_{k}\cup\mathbb{T}_{l}}{k_{2}+l_{2}}$, and

• •

${k_{1}^{*}}\preceq^{\mathbb{T}_{k}^{\star}}{k_{2}^{*}}$.

Proof.

It follows immediatelly from Theorems A.9, A.10, A.11 and A.12. ∎

Corollary 4.6 (restated). * Given any KAT expressions $m,l,k_{1}$ and $k_{2}$, and trace-refinement relation $\mathbb{T}$ such that ${k_{1}}\preceq^{\mathbb{T}}{k_{2}}$, it holds that ${m\cdot k_{1}\cdot l}\preceq^{\mathbb{T}^{\prime}}{m\cdot k_{2}\cdot l}$, where $\mathbb{T}^{\prime}$ is the set $\{(m\cdot r_{1}\cdot l,m\cdot r_{2}\cdot l,\mathcal{A})\mid(r_{1},r_{2},\mathcal{A})\in\mathbb{T}\}$. *

Proof.

The result follows from Theorem 4.5, by noticing that ${m}\preceq^{\mathbb{T}_{m}}{m}$ and ${l}\preceq^{\mathbb{T}_{l}}{l}$, where $\mathbb{T}_{m}$ and $\mathbb{T}_{l}$ are the sets $\{(m,m,\emptyset)\}$ and $\{(l,l,\emptyset)\}$ respectively. ∎

Theorem 4.7 (restated). * For any elements $k,l$ and $m$ in a KAT $\mathcal{K}$, and any trace-refinement relations $\mathbb{T}_{1}$, $\mathbb{T}_{2}$, if ${k}\preceq^{\mathbb{T}_{1}}{l}$ and ${l}\preceq^{\mathbb{T}_{2}}{m}$, and $\mathbb{T}_{1}\otimes\mathbb{T}_{2}$ is defined, then ${k}\preceq^{\mathbb{T}_{1}\otimes\mathbb{T}_{2}}{m}$. *

Proof.

We want to show that for any $(o,p,\mathcal{A})\in\mathbb{T}_{1}\otimes\mathbb{T}_{2}$, $k\cap o\leq_{\mathcal{A}}l\cap p$. Let $(o,r_{1},\mathcal{A}_{1})\in\mathbb{T}_{1}$ and $(r_{2},p,\mathcal{A}_{2})\in\mathbb{T}_{2}$, be the two tuples that produced the tuple $(o,p,\mathcal{A})$ in their transitive trace-refinement relation. In other words, $r_{1}\leq r_{2}$ and $\mathcal{A}=\mathcal{A}_{1}\cup\mathcal{A}_{2}$. By assumption, we have that $k\cap o\leq_{\mathcal{A}_{1}}l\cap r_{1}$. Since $r_{1}\leq r_{2}$, $l\cap r_{1}\leq l\cap r_{2}$. Therefore, $k\cap o\leq_{\mathcal{A}_{1}}l\cap r_{2}$. Again by assumption, we have that $l\cap r_{2}\leq_{\mathcal{A}_{2}}m\cap p$. By Lemma A.2, we have that $k\cap o\leq_{\mathcal{A}}l\cap r_{2}$ and $l\cap r_{2}\leq_{\mathcal{A}}m\cap p$. Thus $k\cap o\leq_{\mathcal{A}}m\cap p$ as required. ∎

A.1. Automation

Theorem 5.1 (restated). * (Soundness). For all $C_{1},C_{2}$, and abstractions $\alpha$, let $O=\textsc{Synth}(C_{1},C_{2},\emptyset,\alpha)$, let $\alpha^{\prime}$ be the common abstraction of $O$ and let $k_{1}=\textsc{Translate}(C_{1},\alpha^{\prime})$ and $k_{2}=\textsc{Translate}(C_{2},\alpha^{\prime})$. Then ${k_{1}}\preceq^{\textsf{RefRelation}(O)}{k_{2}}{}$. *

Proof.

Let $\mathcal{K}$ be a KAT. For a set of hypotheses $\mathcal{A}$ over $\mathcal{K}$, two KAT expressions $k_{1}$ and $k_{2}$ and a trace-refinement relation $\mathbb{T}$, we write ${k_{1}}\preceq^{\mathbb{T}}_{\mathcal{A}}{k_{2}}$ to denote that $k_{1}$ refines $k_{2}$ with respect to $\mathbb{T}$ by augmenting the set of hypotheses with $\mathcal{A}$. We proceed by induction on the number of recursive calls to show that for any abstraction $\alpha=(\mathcal{K},A_{S},\alpha_{S},\alpha_{B})$, and any two programs $C_{1}$ and $C_{2}$, if $\mathbb{T}=\textsf{RefRelation}(\textsc{Synth}(C_{1},C_{2},\mathcal{A},\alpha))$, then ${\textsc{Translate}(C_{1},\alpha)}\preceq^{\mathbb{T}}_{\mathcal{A}}{\textsc{Translate}(C_{1},\alpha)}$. Since the algorithm is initialised with $\mathcal{A}$ being the empty set, the trace-refinement relation $\mathbb{T}$ returned will be such that ${k_{1}}\preceq^{\mathbb{T}}{k_{2}}$.

For the base case, suppose that the algorithm returns without any recursive calls. Then, for $k_{1}=\textsc{Translate}(C_{1},\alpha)$ and $k_{2}=\textsc{Translate}(C_{2},\alpha)$, the procedure $\textsc{KATdiff}(k_{1},k_{2},\mathcal{A})$ returns no counterexamples. By assumption, this means that $k_{1}\leq_{\mathcal{A}}k_{2}$, which implies that ${k_{1}}\preceq^{\mathbb{T}}_{\mathcal{A}}{k_{2}}$, for $\mathbb{T}=\{(k_{1},k_{2},\mathcal{A},\alpha)\}$.

For the inductive case, suppose that $\textsc{KATdiff}(k_{1},k_{2},\mathcal{A})$ returns a set of counterexamples $c=\{c_{1},\ldots,c_{m}\}$. By assumption, the subprocedure SolveDiff, given $k_{1},k_{2},c$ and $\mathcal{A}$ as input, returns a set $R$ of restrictions, say of size $n\in\mathbb{N}$, such that $\mathsf{proj}_{1}(R)$ partitions $k_{1}$. Let $(r_{1},r_{2},\mathcal{A}^{\prime})$ be a tuple in $R$, and let $(D_{1},D_{2},\alpha^{\prime})$ be the output of $\textsc{Restrict}(C_{1},r_{1},C_{2},r_{2},\mathcal{A}\cup\mathcal{A}^{\prime},\alpha)$. By assumption, $\textsc{Translate}(D_{1},\alpha^{\prime})\equiv_{\mathcal{A}\cup\mathcal{A}^{\prime}}\textsc{Translate}(C_{1},\alpha^{\prime})\cap r_{1}$, and the same holds for $D_{2},C_{2}$ and $r_{2}$. By the inductive hypothesis, if $O$ is the output of $\textsc{Synth}(D_{1},D_{2},\mathcal{A}\cup\mathcal{A}^{\prime},\alpha^{\prime})$, then ${\textsc{Translate}(D_{1},\alpha^{\prime})}\preceq^{\textsf{RefRelation}(O)}_{\mathcal{A}\cup\mathcal{A}^{\prime}}{\textsc{Translate}(D_{2},\alpha^{\prime})}$.

For $i\leq n$, let $(r_{1,i},r_{2,i},\mathcal{A}_{i})$ be the tuples in $R$ returned by the procedure SolveDiff. For each $i\leq n$, let $(D_{1,i},D_{2,i},\alpha^{\prime}_{i})$ be the result of $\textsc{Restrict}(C_{1},r_{1,i},C_{2},r_{2,i},\mathcal{A}\cup\mathcal{A}_{i},\alpha)$. Finally, let $O_{i}$ be the output of $\textsc{Synth}(D_{1,i},D_{2,i},\mathcal{A}\cup\mathcal{A}_{i})$ and $\mathbb{T}_{i}^{\prime}$ be equal to $\textsf{RefRelation}(O_{i})$. In other words, for each $i\leq n$, let $\mathbb{T}_{i}^{\prime}$ be the set $\{(k,l,\mathcal{A})\mid(k,l,\mathcal{A},\alpha^{\prime}_{i})\in O_{i}\}$, where $\alpha^{\prime}_{i}$ is the common abstraction of $O_{i}$. Define $\beta$ to be the abstraction $\bigsqcup_{i\leq n}\alpha^{\prime}_{i}$, and let $\mathbb{T}_{i}$ be obtained from $\mathbb{T}_{i}^{\prime}$ by having all KAT expressions be over the common abstraction $\beta$. Then define $O$ to be equal to $O_{1}\cup\ldots\cup O_{n}$. Notice that the flatmap operator in the algorithm, simply returns $O$ from all the $O_{i}$, and notice that $\mathbb{T}_{1}\cup\ldots\cup\mathbb{T}_{n}=\textsf{RefRelation}(O_{1}\cup\ldots\cup O_{n})$. By the argument above, we have that for all $i\leq n$,

[TABLE]

and $\textsc{Translate}(D_{1,i},\alpha^{\prime}_{i})\equiv_{\mathcal{A}\cup\mathcal{A}^{\prime}}\textsc{Translate}(C_{1},\alpha^{\prime})\cap r_{1,i}$. Notice that since $\mathsf{proj}_{1}(R)$ partitions $k_{1}$,

[TABLE]

and therefore

[TABLE]

By a similar argument,

[TABLE]

Therefore, by Theorem A.11 and equations (5), (6) and (7),

[TABLE]

where, as was argued earlier, $\mathbb{T}_{1}\cup\ldots\cup\mathbb{T}_{n}=\textsf{RefRelation}(O_{1}\cup\ldots\cup O_{n})=\textsf{RefRelation}(O)$. ∎

Appendix B Edit Distance Algorithm

The algorithm, shown in Figure 5, traverses recursively the two iputs one symbol at a time, with the option of staying stationary on one of them at each iteration, and assigns a score on the association between the symbols at hand. For this, 4 different types of scores (in the form of rationals), are calcualted for any two strings, and are added to the total score at each iteration, depending on the action that is chosen. All possible cases are considered by the algorithm, and the association that leads to the smallest global score is finally chosen. The 4 different types of scores are as follows.

• •

remove_scr: Used when a symbol is removed from one of the two strings.

• •

replace_scr: Used when a symbol is replaced with another symbol in one of the two strings.

• •

match_scr: Used when a symbol in one string is matched with a symbol of the same type (boolean or event) in the other string.

• •

penalty_scr: Used when a matching such as the one above is chosen, but where the matching is between symbols of different type.

The values for remove_scr and replace_scr are usually 1, whereas the penalty_scr is higher that them, and correlated with the length of the input strings. The value of match_scr on the other hand is negative, and used to counter-balance the effect of penalty_scr. In the algorithm shown above, $\mathsf{RemoveAll(s_{2})}$, for a string $s_{2}=a_{1}\cdots a_{n}$, is shorthand for the sequence:

$[\mathsf{Remove(a_{1},s_{2}),\ldots,Remove(a_{n},s_{2})}]$.

B.1. Global KAT expression edit-distance

We have implemented a custom edit-distance algorithm that accepts general KAT expressions as inputs, instead of merely KAT strings. The edit-distance on such KAT expressions has to handle the structure of the expressions, and is naturally more involved than the linear one on strings. (The former is more similar to trees (Bille, 2005).) For example, the algorithm will attempt and match a subexpression under a star operation in one expression with a similar subexpression under a star operation in the other. In our experiments, using this distance algorithm on the whole KAT expressions, instead of the counterexamples to their equivalence or inclusion, would most of the time remove and replace many symbols. Our implementation mostly does not use this facility. However, searching for edit distance globally on the KAT expressions can be exploited in the beginning of the algorithm, in order to find natural alignments between two large programs, split them into subcomponents, apply the Synth algorithm on each pair of such subcomponents, and finally use Theorem 4.5 to combine the individual results into a solution that works over the whole programs. Our use of global KAT edit distance does not require further theoretical development and we plan to use our implementation of these ideas in future work.

Appendix C Benchmarks and Full Results of Knotical

C.1. Example synthesized solution for benchmark 00arith.c

\dirtree

.1 solution. .2 AComplete. .3 \left\{\begin{array}[]{l}Axioms:\{E=1,b=!c\}\\ k_{1}=(a_{5}\!\cdot\!(b_{8}\!\cdot\!()=foo();+\neg b_{8}\!\cdot\!()=bar();))*\!\cdot\!\neg a_{5}\\ k_{2}=()=foo();\!\cdot\!(a_{12}\!\cdot\!(c_{19}\!\cdot\!()=bar();+\neg c_{19}\!\cdot\!()=foo();))*\!\cdot\!\neg a_{12}\end{array}\right..

C.2. Example synthesized solution for benchmark 00complete.c

\dirtree

.1 solution. .2 (Complete), cond: $n>0$. .3 \left\{\begin{array}[]{l}Cond:a_{10}\\ k_{1}=()=evA();\\ k_{2}=(a_{10}\!\cdot\!()=evB();+\neg a_{10}\!\cdot\!()=evC();)\end{array}\right.. .4 AComplete. .5 \left\{\begin{array}[]{l}Axioms:\{E=V\}\\ k_{1}=()=evA();\\ k_{2}=1\!\cdot\!()=evB();\end{array}\right.. .3 \left\{\begin{array}[]{l}Cond:\neg a_{10}\\ k_{1}=()=evA();\\ k_{2}=(a_{10}\!\cdot\!()=evB();+\neg a_{10}\!\cdot\!()=evC();)\end{array}\right.. .4 AComplete. .5 \left\{\begin{array}[]{l}Axioms:\{E=A\}\\ k_{1}=()=evA();\\ k_{2}=1\!\cdot\!()=evC();\end{array}\right..

C.3. Example synthesized solution for benchmark 00complete1.c

\dirtree

.1 solution. .2 AComplete. .3 \left\{\begin{array}[]{l}Axioms:\{!a=!b,V=D,E=A\}\\ k_{1}=(a_{7}\!\cdot\!()=evA();+\neg a_{7}\!\cdot\!()=evB();)\\ k_{2}=(b_{13}\!\cdot\!()=evC();+\neg b_{13}\!\cdot\!()=evD();)\end{array}\right..

C.4. Example synthesized solution for benchmark 00false.c

\dirtree

.1 solution. .2 AComplete. .3 \left\{\begin{array}[]{l}Axioms:\{V=1\}\\ k_{1}=1\\ k_{2}=()=eventA();\end{array}\right..

C.5. Example synthesized solution for benchmark 00if.c

\dirtree

.1 solution. .2 AComplete. .3 \left\{\begin{array}[]{l}Axioms:\{V=1,B=1\}\\ k_{1}=a=nondet();\!\cdot\!(a_{7}\!\cdot\!()=send();\!\cdot\!()=recv();+\neg a_{7}\!\cdot\!1)\\ k_{2}=a=nondet();\!\cdot\!(a_{12}\!\cdot\!()=send();+\neg a_{12}\!\cdot\!1)\!\cdot\!()=recv();\end{array}\right..

C.6. Example synthesized solution for benchmark 00ifarecv.c

\dirtree

.1 solution. .2 AComplete. .3 \left\{\begin{array}[]{l}Axioms:\{N=1,D=1\}\\ k_{1}=()=init();\!\cdot\!a=recv();\!\cdot\!(a_{6}\!\cdot\!()=send();+\neg a_{6}\!\cdot\!1)\\ k_{2}=()=init();\!\cdot\!a=recv();\!\cdot\!()=send();\end{array}\right..

C.7. Example synthesized solution for benchmark 00impos.c

No solutions.

C.8. Example synthesized solution for benchmark 00medstrai.c

\dirtree

.1 solution. .2 (Partial), cond: $N>0$. .3 \left\{\begin{array}[]{l}Cond:\neg b_{14}\\ k_{1}=(b_{14}\!\cdot\!()=m1();\!\cdot\!()=m2();+\neg b_{14}\!\cdot\!1)\!\cdot\!()=m4();\!\cdot\!()=m5();\!\cdot\!(a_{9}\!\cdot\!()=m11();\!\cdot\!()=m12();+\neg a_{9}\!\cdot\!1)\!\cdot\!()=m14();\!\cdot\!()=m15();\\ k_{2}=()=m1();\!\cdot\!()=m2();\!\cdot\!()=m4();\!\cdot\!()=m5();\!\cdot\!()=m11();\!\cdot\!()=m12();\!\cdot\!()=m14();\!\cdot\!()=m15();\end{array}\right.. .4 (Partial), cond: $N<0$. .5 \left\{\begin{array}[]{l}Cond:a_{9}\\ k_{1}=1\!\cdot\!1\!\cdot\!()=m4();\!\cdot\!()=m5();\!\cdot\!(a_{9}\!\cdot\!()=m11();\!\cdot\!()=m12();+\neg a_{9}\!\cdot\!1)\!\cdot\!()=m14();\!\cdot\!()=m15();\\ k_{2}=()=m1();\!\cdot\!()=m2();\!\cdot\!()=m4();\!\cdot\!()=m5();\!\cdot\!()=m11();\!\cdot\!()=m12();\!\cdot\!()=m14();\!\cdot\!()=m15();\end{array}\right.. .6 AComplete. .7 \left\{\begin{array}[]{l}Axioms:\{L=1,P=1\}\\ k_{1}=1\!\cdot\!1\!\cdot\!()=m4();\!\cdot\!()=m5();\!\cdot\!1\!\cdot\!()=m11();\!\cdot\!()=m12();\!\cdot\!()=m14();\!\cdot\!()=m15();\\ k_{2}=()=m1();\!\cdot\!()=m2();\!\cdot\!()=m4();\!\cdot\!()=m5();\!\cdot\!()=m11();\!\cdot\!()=m12();\!\cdot\!()=m14();\!\cdot\!()=m15();\end{array}\right..

Remaining 1 solutions ommitted for brevity.

C.9. Example synthesized solution for benchmark 00needax.c

\dirtree

.1 solution. .2 AComplete. .3 \left\{\begin{array}[]{l}Axioms:\{V=E\}\\ k_{1}=(a_{7}\!\cdot\!()=evA();+\neg a_{7}\!\cdot\!()=evB();)\\ k_{2}=()=evA();\end{array}\right..

C.10. Example synthesized solution for benchmark 00nohyp.c

\dirtree

.1 solution. .2 AComplete. .3 \left\{\begin{array}[]{l}Axioms:\{D=1,!a=b\}\\ k_{1}=(a_{7}\!\cdot\!()=evA();+\neg a_{7}\!\cdot\!()=evB();)\\ k_{2}=t=nondet();\!\cdot\!(b_{12}\!\cdot\!()=evB();+\neg b_{12}\!\cdot\!()=evA();)\end{array}\right..

C.11. Example synthesized solution for benchmark 00noloop.c

\dirtree

.1 solution. .2 (Partial), cond: $count<=4$. .3 \left\{\begin{array}[]{l}Cond:\neg a_{9}\\ k_{1}=1\!\cdot\!(a_{5}\!\cdot\!0)*\!\cdot\!\neg a_{5}\\ k_{2}=(a_{9}\!\cdot\!()=evA();\!\cdot\!count=count+1;)*\!\cdot\!\neg a_{9}\end{array}\right.. .4 AComplete. .5 \left\{\begin{array}[]{l}Axioms:\{\}\\ k_{1}=1\!\cdot\!(a_{5}\!\cdot\!0)*\!\cdot\!\neg a_{5}\\ k_{2}=1\!\cdot\!(a_{9}\!\cdot\!0)*\!\cdot\!\neg a_{9}\end{array}\right..

C.12. Example synthesized solution for benchmark 00nondet.c

\dirtree

.1 solution. .2 (Complete), cond: $a>0$. .3 \left\{\begin{array}[]{l}Cond:d_{15}\\ k_{1}=i=nondet();\!\cdot\!j=nondet();\!\cdot\!(c_{11}\!\cdot\!(d_{15}\!\cdot\!()=B();+\neg d_{15}\!\cdot\!()=C();)\!\cdot\!i=nondet();)*\!\cdot\!\neg c_{11}\!\cdot\!()=D();\\ \;\;\;\!\cdot\!(a_{5}\!\cdot\!(b_{9}\!\cdot\!()=G();+\neg b_{9}\!\cdot\!()=H();)\!\cdot\!j=nondet();)*\!\cdot\!\neg a_{5}\\ k_{2}=i=nondet();\!\cdot\!j=nondet();\!\cdot\!(c_{29}\!\cdot\!(f_{33}\!\cdot\!()=B();+\neg f_{33}\!\cdot\!()=C();)\!\cdot\!i=nondet();)*\!\cdot\!\neg c_{29}\!\cdot\!()=D();\\ \;\;\;\!\cdot\!(a_{23}\!\cdot\!(e_{27}\!\cdot\!()=G();+\neg e_{27}\!\cdot\!()=H();)\!\cdot\!j=nondet();)*\!\cdot\!\neg a_{23}\end{array}\right.. .4 AComplete. .5 \left\{\begin{array}[]{l}Axioms:\{b=e,B=C\}\\ k_{1}=i=nondet();\!\cdot\!j=nondet();\!\cdot\!(c_{11}\!\cdot\!1\!\cdot\!()=B();\!\cdot\!i=nondet();)*\!\cdot\!\neg c_{11}\!\cdot\!()=D();\\ \;\;\;\!\cdot\!(a_{5}\!\cdot\!(b_{9}\!\cdot\!()=G();+\neg b_{9}\!\cdot\!()=H();)\!\cdot\!j=nondet();)*\!\cdot\!\neg a_{5}\\ k_{2}=i=nondet();\!\cdot\!j=nondet();\!\cdot\!(c_{29}\!\cdot\!(f_{33}\!\cdot\!()=B();+\neg f_{33}\!\cdot\!()=C();)\!\cdot\!i=nondet();)*\!\cdot\!\neg c_{29}\!\cdot\!()=D();\\ \;\;\;\!\cdot\!(a_{23}\!\cdot\!(e_{27}\!\cdot\!()=G();+\neg e_{27}\!\cdot\!()=H();)\!\cdot\!j=nondet();)*\!\cdot\!\neg a_{23}\end{array}\right.. .3 \left\{\begin{array}[]{l}Cond:\neg d_{15}\\ k_{1}=i=nondet();\!\cdot\!j=nondet();\!\cdot\!(c_{11}\!\cdot\!(d_{15}\!\cdot\!()=B();+\neg d_{15}\!\cdot\!()=C();)\!\cdot\!i=nondet();)*\!\cdot\!\neg c_{11}\!\cdot\!()=D();\\ \;\;\;\!\cdot\!(a_{5}\!\cdot\!(b_{9}\!\cdot\!()=G();+\neg b_{9}\!\cdot\!()=H();)\!\cdot\!j=nondet();)*\!\cdot\!\neg a_{5}\\ k_{2}=i=nondet();\!\cdot\!j=nondet();\!\cdot\!(c_{29}\!\cdot\!(f_{33}\!\cdot\!()=B();+\neg f_{33}\!\cdot\!()=C();)\!\cdot\!i=nondet();)*\!\cdot\!\neg c_{29}\!\cdot\!()=D();\\ \;\;\;\!\cdot\!(a_{23}\!\cdot\!(e_{27}\!\cdot\!()=G();+\neg e_{27}\!\cdot\!()=H();)\!\cdot\!j=nondet();)*\!\cdot\!\neg a_{23}\end{array}\right.. .4 AComplete. .5 \left\{\begin{array}[]{l}Axioms:\{b=e,C=B\}\\ k_{1}=i=nondet();\!\cdot\!j=nondet();\!\cdot\!(c_{11}\!\cdot\!1\!\cdot\!()=C();\!\cdot\!i=nondet();)*\!\cdot\!\neg c_{11}\!\cdot\!()=D();\\ \;\;\;\!\cdot\!(a_{5}\!\cdot\!(b_{9}\!\cdot\!()=G();+\neg b_{9}\!\cdot\!()=H();)\!\cdot\!j=nondet();)*\!\cdot\!\neg a_{5}\\ k_{2}=i=nondet();\!\cdot\!j=nondet();\!\cdot\!(c_{29}\!\cdot\!(f_{33}\!\cdot\!()=B();+\neg f_{33}\!\cdot\!()=C();)\!\cdot\!i=nondet();)*\!\cdot\!\neg c_{29}\!\cdot\!()=D();\\ \;\;\;\!\cdot\!(a_{23}\!\cdot\!(e_{27}\!\cdot\!()=G();+\neg e_{27}\!\cdot\!()=H();)\!\cdot\!j=nondet();)*\!\cdot\!\neg a_{23}\end{array}\right..

C.13. Example synthesized solution for benchmark 00pos.c

\dirtree

.1 solution. .2 (Partial), cond: $x>0$. .3 \left\{\begin{array}[]{l}Cond:a_{7}\\ k_{1}=(a_{7}\!\cdot\!()=evA();+\neg a_{7}\!\cdot\!()=evB();)\\ k_{2}=()=evA();\end{array}\right.. .4 AComplete. .5 \left\{\begin{array}[]{l}Axioms:\{\}\\ k_{1}=1\!\cdot\!()=evA();\\ k_{2}=()=evA();\end{array}\right..

C.14. Example synthesized solution for benchmark 00rename.c

\dirtree

.1 solution. .2 AComplete. .3 \left\{\begin{array}[]{l}Axioms:\{a=b\}\\ k_{1}=(a_{7}\!\cdot\!()=foo();+\neg a_{7}\!\cdot\!()=bar();)\\ k_{2}=(b_{13}\!\cdot\!()=foo();+\neg b_{13}\!\cdot\!()=bar();)\end{array}\right..

C.15. Example synthesized solution for benchmark 00rename1.c

\dirtree

.1 solution. .2 AComplete. .3 \left\{\begin{array}[]{l}Axioms:\{a=!b\}\\ k_{1}=(a_{7}\!\cdot\!()=foo();+\neg a_{7}\!\cdot\!()=bar();)\\ k_{2}=(b_{13}\!\cdot\!()=bar();+\neg b_{13}\!\cdot\!()=foo();)\end{array}\right..

C.16. Example synthesized solution for benchmark 00sanity.c

\dirtree

.1 solution. .2 AComplete. .3 \left\{\begin{array}[]{l}Axioms:\{\}\\ k_{1}=()=foo();\!\cdot\!()=bar();\\ k_{2}=()=foo();\!\cdot\!()=bar();\end{array}\right..

C.17. Example synthesized solution for benchmark 00sanity1.c

\dirtree

.1 solution. .2 AComplete. .3 \left\{\begin{array}[]{l}Axioms:\{O=B\}\\ k_{1}=()=foo();\!\cdot\!()=bar();\\ k_{2}=()=bar();\!\cdot\!()=foo();\end{array}\right..

C.18. Example synthesized solution for benchmark 00smstrai.c

\dirtree

.1 solution. .2 (Partial), cond: $N>0$. .3 \left\{\begin{array}[]{l}Cond:b_{10}\\ k_{1}=(b_{10}\!\cdot\!()=m1();+\neg b_{10}\!\cdot\!1)\!\cdot\!()=m4();\!\cdot\!(a_{7}\!\cdot\!()=m11();+\neg a_{7}\!\cdot\!1)\!\cdot\!()=m14();\\ k_{2}=()=m1();\!\cdot\!()=m4();\!\cdot\!()=m11();\!\cdot\!()=m14();\end{array}\right.. .4 AComplete. .5 \left\{\begin{array}[]{l}Axioms:\{G=1\}\\ k_{1}=1\!\cdot\!()=m1();\!\cdot\!()=m4();\!\cdot\!1\!\cdot\!()=m14();\\ k_{2}=()=m1();\!\cdot\!()=m4();\!\cdot\!()=m11();\!\cdot\!()=m14();\end{array}\right..

Remaining 3 solutions ommitted for brevity.

C.19. Example synthesized solution for benchmark 01acqrel.c

\dirtree

.1 solution. .2 AComplete. .3 \left\{\begin{array}[]{l}Axioms:\{\}\\ k_{1}=A=0;\!\cdot\!R=0;\!\cdot\!0\!\cdot\!0\\ k_{2}=AA=0;\!\cdot\!RR=0;\!\cdot\!(a_{8}\!\cdot\!AA=1;\!\cdot\!AA=0;\!\cdot\!(a_{11}\!\cdot\!n=n-1;)*\!\cdot\!\neg a_{11}\!\cdot\!RR=1;\!\cdot\!RR=0;)*\!\cdot\!\neg a_{8}\!\cdot\!0\end{array}\right..

C.20. Example synthesized solution for benchmark 01asendrecv.c

\dirtree

.1 solution. .2 (Partial), cond: $b>0$. .3 \left\{\begin{array}[]{l}Cond:b_{11}\\ k_{1}=(a_{7}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!1\!\cdot\!(b_{11}\!\cdot\!n=constructReply();\!\cdot\!()=send(n);\\ \;\;\;\!\cdot\!1+\neg b_{11}\!\cdot\!1)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{7}\\ k_{2}=(a_{19}\!\cdot\!b=recv();\!\cdot\!(b_{26}\!\cdot\!auth=check(b);\!\cdot\!(c_{23}\!\cdot\!n=constructReply();\!\cdot\!()=sendA(n);\\ \;\;\;+\neg c_{23}\!\cdot\!1)+\neg b_{26}\!\cdot\!()=log(b);)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{19}\end{array}\right.. .4 (Partial), cond: $b>0$. .5 \left\{\begin{array}[]{l}Cond:b_{26}\\ k_{1}=(a_{7}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!1\!\cdot\!1\!\cdot\!n=constructReply();\!\cdot\!()=send(n);\\ \;\;\;\!\cdot\!1\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{7}\\ k_{2}=(a_{19}\!\cdot\!b=recv();\!\cdot\!(b_{26}\!\cdot\!auth=check(b);\!\cdot\!(c_{23}\!\cdot\!n=constructReply();\!\cdot\!()=sendA(n);\\ \;\;\;+\neg c_{23}\!\cdot\!1)+\neg b_{26}\!\cdot\!()=log(b);)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{19}\end{array}\right.. .6 (Partial), cond: $auth>0$. .7 \left\{\begin{array}[]{l}Cond:c_{23}\\ k_{1}=(a_{7}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!1\!\cdot\!1\!\cdot\!n=constructReply();\!\cdot\!()=send(n);\\ \;\;\;\!\cdot\!1\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{7}\\ k_{2}=(a_{19}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!auth=check(b);\!\cdot\!(c_{23}\!\cdot\!n=constructReply();\!\cdot\!()=sendA(n);\\ \;\;\;+\neg c_{23}\!\cdot\!1)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{19}\end{array}\right.. .8 AComplete. .9 \left\{\begin{array}[]{l}Axioms:\{I=1,J=1,M=1,P=1\}\\ k_{1}=(a_{7}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!1\!\cdot\!1\!\cdot\!n=constructReply();\!\cdot\!()=send(n);\\ \;\;\;\!\cdot\!1\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{7}\\ k_{2}=(a_{19}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!auth=check(b);\!\cdot\!1\!\cdot\!n=constructReply();\!\cdot\!()=sendA(n);\\ \;\;\;\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{19}\end{array}\right.. .3 \left\{\begin{array}[]{l}Cond:\neg b_{11}\\ k_{1}=(a_{7}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!1\!\cdot\!(b_{11}\!\cdot\!n=constructReply();\!\cdot\!()=send(n);\\ \;\;\;\!\cdot\!1+\neg b_{11}\!\cdot\!1)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{7}\\ k_{2}=(a_{19}\!\cdot\!b=recv();\!\cdot\!(b_{26}\!\cdot\!auth=check(b);\!\cdot\!(c_{23}\!\cdot\!n=constructReply();\!\cdot\!()=sendA(n);\\ \;\;\;+\neg c_{23}\!\cdot\!1)+\neg b_{26}\!\cdot\!()=log(b);)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{19}\end{array}\right.. .4 (Partial), cond: $auth>0$. .5 \left\{\begin{array}[]{l}Cond:c_{23}\\ k_{1}=(a_{7}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!1\!\cdot\!1\!\cdot\!1\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{7}\\ k_{2}=(a_{19}\!\cdot\!b=recv();\!\cdot\!(b_{26}\!\cdot\!auth=check(b);\!\cdot\!(c_{23}\!\cdot\!n=constructReply();\!\cdot\!()=sendA(n);\\ \;\;\;+\neg c_{23}\!\cdot\!1)+\neg b_{26}\!\cdot\!()=log(b);)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{19}\end{array}\right.. .6 (Partial), cond: $b>0$. .7 \left\{\begin{array}[]{l}Cond:\neg b_{26}\\ k_{1}=(a_{7}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!1\!\cdot\!1\!\cdot\!1\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{7}\\ k_{2}=(a_{19}\!\cdot\!b=recv();\!\cdot\!(b_{26}\!\cdot\!auth=check(b);\!\cdot\!1\!\cdot\!n=constructReply();\!\cdot\!()=sendA(n);\\ \;\;\;+\neg b_{26}\!\cdot\!()=log(b);)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{19}\end{array}\right.. .8 AComplete. .9 \left\{\begin{array}[]{l}Axioms:\{I=1,J=1\}\\ k_{1}=(a_{7}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!1\!\cdot\!1\!\cdot\!1\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{7}\\ k_{2}=(a_{19}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!()=log(b);\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{19}\end{array}\right.. .5 \left\{\begin{array}[]{l}Cond:\neg c_{23}\\ k_{1}=(a_{7}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!1\!\cdot\!1\!\cdot\!1\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{7}\\ k_{2}=(a_{19}\!\cdot\!b=recv();\!\cdot\!(b_{26}\!\cdot\!auth=check(b);\!\cdot\!(c_{23}\!\cdot\!n=constructReply();\!\cdot\!()=sendA(n);\\ \;\;\;+\neg c_{23}\!\cdot\!1)+\neg b_{26}\!\cdot\!()=log(b);)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{19}\end{array}\right.. .6 AComplete. .7 \left\{\begin{array}[]{l}Axioms:\{I=1,J=1\}\\ k_{1}=(a_{7}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!1\!\cdot\!1\!\cdot\!1\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{7}\\ k_{2}=(a_{19}\!\cdot\!b=recv();\!\cdot\!(b_{26}\!\cdot\!auth=check(b);\!\cdot\!1\!\cdot\!1+\neg b_{26}\!\cdot\!()=log(b);)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{19}\end{array}\right..

Remaining 37 solutions ommitted for brevity.

C.21. Example synthesized solution for benchmark 01assume.c

\dirtree

.1 solution. .2 (Complete), cond: $count<=4$. .3 \left\{\begin{array}[]{l}Cond:a_{5}\\ k_{1}=count=nondet();\!\cdot\!(a_{5}\!\cdot\!()=printf(count);\\ \;\;\;\!\cdot\!count=count+1;)*\!\cdot\!\neg a_{5}\\ k_{2}=count=nondet();\!\cdot\!1\!\cdot\!((a_{11}\wedge b_{12})\!\cdot\!()=printf(count);\\ \;\;\;\!\cdot\!count=count+1;)*\!\cdot\!\neg a_{11}\end{array}\right.. .4 (Complete), cond: $number>=0$. .5 \left\{\begin{array}[]{l}Cond:b_{12}\\ k_{1}=count=nondet();\!\cdot\!1\!\cdot\!(a_{5}\!\cdot\!()=printf(count);\\ \;\;\;\!\cdot\!count=count+1;)*\!\cdot\!\neg a_{5}\\ k_{2}=count=nondet();\!\cdot\!1\!\cdot\!((a_{11}\wedge b_{12})\!\cdot\!()=printf(count);\\ \;\;\;\!\cdot\!count=count+1;)*\!\cdot\!\neg a_{11}\end{array}\right.. .6 AComplete. .7 \left\{\begin{array}[]{l}Axioms:\{D=1,E=1,I=1,T=1,U=1\}\\ k_{1}=count=nondet();\!\cdot\!1\!\cdot\!(a_{5}\!\cdot\!()=printf(count);\\ \;\;\;\!\cdot\!count=count+1;)*\!\cdot\!\neg a_{5}\\ k_{2}=count=nondet();\!\cdot\!1\!\cdot\!1\!\cdot\!((a_{11}\wedge b_{12})\!\cdot\!()=printf(count);\\ \;\;\;\!\cdot\!count=count+1;)*\!\cdot\!\neg a_{11}\end{array}\right.. .3 \left\{\begin{array}[]{l}Cond:\neg a_{5}\\ k_{1}=count=nondet();\!\cdot\!(a_{5}\!\cdot\!()=printf(count);\\ \;\;\;\!\cdot\!count=count+1;)*\!\cdot\!\neg a_{5}\\ k_{2}=count=nondet();\!\cdot\!1\!\cdot\!((a_{11}\wedge b_{12})\!\cdot\!()=printf(count);\\ \;\;\;\!\cdot\!count=count+1;)*\!\cdot\!\neg a_{11}\end{array}\right.. .4 AComplete. .5 \left\{\begin{array}[]{l}Axioms:\{D=1,E=1\}\\ k_{1}=count=nondet();\!\cdot\!1\!\cdot\!(a_{5}\!\cdot\!0)*\!\cdot\!\neg a_{5}\\ k_{2}=count=nondet();\!\cdot\!1\!\cdot\!((a_{11}\wedge b_{12})\!\cdot\!()=printf(count);\\ \;\;\;\!\cdot\!count=count+1;)*\!\cdot\!\neg a_{11}\end{array}\right..

Remaining 42 solutions ommitted for brevity.

C.22. Example synthesized solution for benchmark 01concloop.c

\dirtree

.1 solution. .2 (Partial), cond: $number>=0$. .3 \left\{\begin{array}[]{l}Cond:b_{12}\\ k_{1}=count=1;\!\cdot\!(a_{5}\!\cdot\!()=evA(count);\!\cdot\!count=count+1;)*\!\cdot\!\neg a_{5}\\ k_{2}=count=1;\!\cdot\!number=nondet();\!\cdot\!((a_{11}\wedge b_{12})\!\cdot\!()=evA(count);\!\cdot\!count=count+1;)*\!\cdot\!(\neg a_{11}\vee\neg b_{12})\end{array}\right.. .4 (Partial), cond: $count<=4$. .5 \left\{\begin{array}[]{l}Cond:\neg a_{5}\\ k_{1}=count=1;\!\cdot\!(a_{5}\!\cdot\!()=evA(count);\!\cdot\!count=count+1;)*\!\cdot\!\neg a_{5}\\ k_{2}=count=1;\!\cdot\!number=nondet();\!\cdot\!1\!\cdot\!((a_{11}\wedge b_{12})\!\cdot\!()=evA(count);\!\cdot\!count=count+1;)*\!\cdot\!\neg a_{11}\end{array}\right.. .6 (Partial), cond: $count<=4$. .7 \left\{\begin{array}[]{l}Cond:\neg a_{11}\\ k_{1}=count=1;\!\cdot\!0\!\cdot\!0\\ k_{2}=count=1;\!\cdot\!number=nondet();\!\cdot\!1\!\cdot\!((a_{11}\wedge b_{12})\!\cdot\!()=evA(count);\!\cdot\!count=count+1;)*\!\cdot\!\neg a_{11}\end{array}\right.. .8 AComplete. .9 \left\{\begin{array}[]{l}Axioms:\{D=1,U=1,T=1\}\\ k_{1}=count=1;\!\cdot\!0\!\cdot\!0\\ k_{2}=count=1;\!\cdot\!number=nondet();\!\cdot\!1\!\cdot\!0\!\cdot\!0\end{array}\right..

Remaining 12 solutions ommitted for brevity.

C.23. Example synthesized solution for benchmark 01concloop2.c

\dirtree

.1 solution. .2 AComplete. .3 \left\{\begin{array}[]{l}Axioms:\{D=1,I=1,E=1,G=1,T=1,U=1\}\\ k_{1}=count=1;\!\cdot\!(a_{4}\!\cdot\!()=printf(count);\\ \;\;\;\!\cdot\!count=count+1;)*\!\cdot\!\neg a_{4}\\ k_{2}=count=1;\!\cdot\!number=nondet();\!\cdot\!()=printf(count);\\ \;\;\;\!\cdot\!fv_{1}=2;\!\cdot\!number=scanf(fv_{1});\!\cdot\!((b_{11}\wedge a_{12})\!\cdot\!count=count+1;)*\!\cdot\!(\neg b_{11}\vee\neg a_{12})\end{array}\right..

Remaining 238 solutions ommitted for brevity.

C.24. Example synthesized solution for benchmark 01concloop3.c

\dirtree

.1 solution. .2 (Partial), cond: $number>=0$. .3 \left\{\begin{array}[]{l}Cond:b_{12}\\ k_{1}=(a_{5}\!\cdot\!()=evA();\!\cdot\!count=count+1;)*\!\cdot\!\neg a_{5}\\ k_{2}=((a_{11}\wedge b_{12})\!\cdot\!()=evA();\!\cdot\!count=count+1;)*\!\cdot\!(\neg a_{11}\vee\neg b_{12})\end{array}\right.. .4 (Complete), cond: $count<=4$. .5 \left\{\begin{array}[]{l}Cond:a_{11}\\ k_{1}=(a_{5}\!\cdot\!()=evA();\!\cdot\!count=count+1;)*\!\cdot\!\neg a_{5}\\ k_{2}=1\!\cdot\!((a_{11}\wedge b_{12})\!\cdot\!()=evA();\!\cdot\!count=count+1;)*\!\cdot\!\neg a_{11}\end{array}\right.. .6 AComplete. .7 \left\{\begin{array}[]{l}Axioms:\{V=1,U=1,D=1,T=1\}\\ k_{1}=(a_{5}\!\cdot\!()=evA();\!\cdot\!count=count+1;)*\!\cdot\!\neg a_{5}\\ k_{2}=1\!\cdot\!1\!\cdot\!((a_{11}\wedge b_{12})\!\cdot\!()=evA();\!\cdot\!count=count+1;)*\!\cdot\!\neg a_{11}\end{array}\right.. .5 \left\{\begin{array}[]{l}Cond:\neg a_{11}\\ k_{1}=(a_{5}\!\cdot\!()=evA();\!\cdot\!count=count+1;)*\!\cdot\!\neg a_{5}\\ k_{2}=1\!\cdot\!((a_{11}\wedge b_{12})\!\cdot\!()=evA();\!\cdot\!count=count+1;)*\!\cdot\!\neg a_{11}\end{array}\right.. .6 AComplete. .7 \left\{\begin{array}[]{l}Axioms:\{V=1,U=1\}\\ k_{1}=(a_{5}\!\cdot\!()=evA();\!\cdot\!count=count+1;)*\!\cdot\!\neg a_{5}\\ k_{2}=1\!\cdot\!1\!\cdot\!((a_{11}\wedge b_{12})\!\cdot\!0)*\!\cdot\!\neg a_{11}\end{array}\right..

Remaining 125 solutions ommitted for brevity.

C.25. Example synthesized solution for benchmark 01linarith.c

\dirtree

.1 solution. .2 AComplete. .3 \left\{\begin{array}[]{l}Axioms:\{G=1,J=1,T=1,S=I\}\\ k_{1}=c=nondet();\!\cdot\!servers=4;\!\cdot\!resp=0;\!\cdot\!curr\_serv=servers;\!\cdot\!tmp=nondet();\!\cdot\!(a_{5}\!\cdot\!1\!\cdot\!c=c-1;\!\cdot\!()=shutdown();\\ \;\;\;\!\cdot\!curr\_serv=curr\_serv-1;\!\cdot\!resp=resp+1;\!\cdot\!tmp=nondet();)*\!\cdot\!\neg a_{5}\\ k_{2}=c=nondet();\!\cdot\!servers=4;\!\cdot\!resp=0;\!\cdot\!curr\_serv=servers;\!\cdot\!tmp=nondet();\!\cdot\!(a_{17}\!\cdot\!1\!\cdot\!()=pingall();\\ \;\;\;\!\cdot\!curr\_serv=curr\_serv-1;\!\cdot\!c=c-1;\!\cdot\!resp=resp+1;\!\cdot\!()=shutdown();\\ \;\;\;\!\cdot\!tmp=nondet();)*\!\cdot\!\neg a_{17}\end{array}\right..

Remaining 10 solutions ommitted for brevity.

C.26. Example synthesized solution for benchmark 01loopevent.c

\dirtree

.1 solution. .2 (Partial), cond: $a>5$. .3 \left\{\begin{array}[]{l}Cond:\neg c_{16}\\ k_{1}=((a_{5}\vee b_{6})\!\cdot\!()=eventA();\!\cdot\!i=i+1;\!\cdot\!j=j+1;)*\!\cdot\!(\neg a_{5}\wedge\neg b_{6})\\ k_{2}=((a_{13}\vee b_{14})\!\cdot\!a=i+j;\!\cdot\!()=eventA();\!\cdot\!i=i+1;\!\cdot\!j=j+1;\!\cdot\!(c_{16}\!\cdot\!()=eventA();+\neg c_{16}\!\cdot\!1))*\!\cdot\!(\neg a_{13}\wedge\neg b_{14})\end{array}\right.. .4 AComplete. .5 \left\{\begin{array}[]{l}Axioms:\{D=1\}\\ k_{1}=((a_{5}\vee b_{6})\!\cdot\!()=eventA();\!\cdot\!i=i+1;\!\cdot\!j=j+1;)*\!\cdot\!(\neg a_{5}\wedge\neg b_{6})\\ k_{2}=((a_{13}\vee b_{14})\!\cdot\!a=i+j;\!\cdot\!()=eventA();\!\cdot\!i=i+1;\!\cdot\!j=j+1;\!\cdot\!1\!\cdot\!1)*\!\cdot\!(\neg a_{13}\wedge\neg b_{14})\end{array}\right..

Remaining 65 solutions ommitted for brevity.

C.27. Example synthesized solution for benchmark 01loopprint.c

\dirtree

.1 solution. .2 (Complete), cond: $a>5$. .3 \left\{\begin{array}[]{l}Cond:c_{17}\\ k_{1}=((a_{5}\vee b_{6})\!\cdot\!()=printf(i,j);\\ \;\;\;\!\cdot\!i=i+1;\!\cdot\!j=j+1;)*\!\cdot\!(\neg a_{5}\wedge\neg b_{6})\\ k_{2}=((a_{13}\vee b_{14})\!\cdot\!a=i+j;\!\cdot\!()=printf(i,j);\\ \;\;\;\!\cdot\!i=i+1;\!\cdot\!j=j+1;\!\cdot\!(c_{17}\!\cdot\!fv_{1}=0;\!\cdot\!()=printf(a,fv_{1});+\neg c_{17}\!\cdot\!1))*\!\cdot\!(\neg a_{13}\wedge\neg b_{14})\end{array}\right.. .4 AComplete. .5 \left\{\begin{array}[]{l}Axioms:\{D=1,E=1,G=1\}\\ k_{1}=((a_{5}\vee b_{6})\!\cdot\!()=printf(i,j);\\ \;\;\;\!\cdot\!i=i+1;\!\cdot\!j=j+1;)*\!\cdot\!(\neg a_{5}\wedge\neg b_{6})\\ k_{2}=((a_{13}\vee b_{14})\!\cdot\!a=i+j;\!\cdot\!()=printf(i,j);\\ \;\;\;\!\cdot\!i=i+1;\!\cdot\!j=j+1;\!\cdot\!1\!\cdot\!fv_{1}=0;\!\cdot\!()=printf(a,fv_{1});)*\!\cdot\!(\neg a_{13}\wedge\neg b_{14})\end{array}\right.. .3 \left\{\begin{array}[]{l}Cond:\neg c_{17}\\ k_{1}=((a_{5}\vee b_{6})\!\cdot\!()=printf(i,j);\\ \;\;\;\!\cdot\!i=i+1;\!\cdot\!j=j+1;)*\!\cdot\!(\neg a_{5}\wedge\neg b_{6})\\ k_{2}=((a_{13}\vee b_{14})\!\cdot\!a=i+j;\!\cdot\!()=printf(i,j);\\ \;\;\;\!\cdot\!i=i+1;\!\cdot\!j=j+1;\!\cdot\!(c_{17}\!\cdot\!fv_{1}=0;\!\cdot\!()=printf(a,fv_{1});+\neg c_{17}\!\cdot\!1))*\!\cdot\!(\neg a_{13}\wedge\neg b_{14})\end{array}\right.. .4 AComplete. .5 \left\{\begin{array}[]{l}Axioms:\{D=1\}\\ k_{1}=((a_{5}\vee b_{6})\!\cdot\!()=printf(i,j);\\ \;\;\;\!\cdot\!i=i+1;\!\cdot\!j=j+1;)*\!\cdot\!(\neg a_{5}\wedge\neg b_{6})\\ k_{2}=((a_{13}\vee b_{14})\!\cdot\!a=i+j;\!\cdot\!()=printf(i,j);\\ \;\;\;\!\cdot\!i=i+1;\!\cdot\!j=j+1;\!\cdot\!1\!\cdot\!1)*\!\cdot\!(\neg a_{13}\wedge\neg b_{14})\end{array}\right..

Remaining 10 solutions ommitted for brevity.

C.28. Example synthesized solution for benchmark 01sendrecv.c

\dirtree

.1 solution. .2 (Partial), cond: $c>0$. .3 \left\{\begin{array}[]{l}Cond:d_{30}\\ k_{1}=(a_{8}\!\cdot\!b=recv();\!\cdot\!(c_{15}\!\cdot\!auth=check(b);\!\cdot\!(b_{12}\!\cdot\!n=constructReply();\!\cdot\!()=send(n);\\ \;\;\;+\neg b_{12}\!\cdot\!1)+\neg c_{15}\!\cdot\!()=log(b);)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{8}\\ k_{2}=(a_{22}\!\cdot\!b=recv();\!\cdot\!(d_{30}\!\cdot\!()=log(b);+\neg d_{30}\!\cdot\!1)\!\cdot\!(c_{28}\!\cdot\!n=constructReply();\!\cdot\!()=send(n);\\ \;\;\;\!\cdot\!(d_{25}\!\cdot\!()=log(n);+\neg d_{25}\!\cdot\!1)+\neg c_{28}\!\cdot\!1)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{22}\end{array}\right.. .4 (Partial), cond: $b>0$. .5 \left\{\begin{array}[]{l}Cond:c_{28}\\ k_{1}=(a_{8}\!\cdot\!b=recv();\!\cdot\!(c_{15}\!\cdot\!auth=check(b);\!\cdot\!(b_{12}\!\cdot\!n=constructReply();\!\cdot\!()=send(n);\\ \;\;\;+\neg b_{12}\!\cdot\!1)+\neg c_{15}\!\cdot\!()=log(b);)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{8}\\ k_{2}=(a_{22}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!()=log(b);\!\cdot\!(c_{28}\!\cdot\!n=constructReply();\!\cdot\!()=send(n);\\ \;\;\;\!\cdot\!()=log(n);+\neg c_{28}\!\cdot\!1)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{22}\end{array}\right.. .6 (Partial), cond: $b>0$. .7 \left\{\begin{array}[]{l}Cond:c_{15}\\ k_{1}=(a_{8}\!\cdot\!b=recv();\!\cdot\!(c_{15}\!\cdot\!auth=check(b);\!\cdot\!(b_{12}\!\cdot\!n=constructReply();\!\cdot\!()=send(n);\\ \;\;\;+\neg b_{12}\!\cdot\!1)+\neg c_{15}\!\cdot\!()=log(b);)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{8}\\ k_{2}=(a_{22}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!()=log(b);\!\cdot\!1\!\cdot\!n=constructReply();\!\cdot\!()=send(n);\\ \;\;\;\!\cdot\!()=log(n);\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{22}\end{array}\right.. .8 (Partial), cond: $auth>0$. .9 \left\{\begin{array}[]{l}Cond:b_{12}\\ k_{1}=(a_{8}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!auth=check(b);\!\cdot\!(b_{12}\!\cdot\!n=constructReply();\!\cdot\!()=send(n);\\ \;\;\;+\neg b_{12}\!\cdot\!1)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{8}\\ k_{2}=(a_{22}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!()=log(b);\!\cdot\!1\!\cdot\!n=constructReply();\!\cdot\!()=send(n);\\ \;\;\;\!\cdot\!()=log(n);\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{22}\end{array}\right.. .10 AComplete. .11 \left\{\begin{array}[]{l}Axioms:\{I=1,J=1,K=1,M=1\}\\ k_{1}=(a_{8}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!auth=check(b);\!\cdot\!1\!\cdot\!n=constructReply();\!\cdot\!()=send(n);\\ \;\;\;\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{8}\\ k_{2}=(a_{22}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!()=log(b);\!\cdot\!1\!\cdot\!n=constructReply();\!\cdot\!()=send(n);\\ \;\;\;\!\cdot\!()=log(n);\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{22}\end{array}\right.. .5 \left\{\begin{array}[]{l}Cond:\neg c_{28}\\ k_{1}=(a_{8}\!\cdot\!b=recv();\!\cdot\!(c_{15}\!\cdot\!auth=check(b);\!\cdot\!(b_{12}\!\cdot\!n=constructReply();\!\cdot\!()=send(n);\\ \;\;\;+\neg b_{12}\!\cdot\!1)+\neg c_{15}\!\cdot\!()=log(b);)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{8}\\ k_{2}=(a_{22}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!()=log(b);\!\cdot\!(c_{28}\!\cdot\!n=constructReply();\!\cdot\!()=send(n);\\ \;\;\;\!\cdot\!()=log(n);+\neg c_{28}\!\cdot\!1)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{22}\end{array}\right.. .6 (Partial), cond: $b>0$. .7 \left\{\begin{array}[]{l}Cond:c_{15}\\ k_{1}=(a_{8}\!\cdot\!b=recv();\!\cdot\!(c_{15}\!\cdot\!auth=check(b);\!\cdot\!(b_{12}\!\cdot\!n=constructReply();\!\cdot\!()=send(n);\\ \;\;\;+\neg b_{12}\!\cdot\!1)+\neg c_{15}\!\cdot\!()=log(b);)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{8}\\ k_{2}=(a_{22}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!()=log(b);\!\cdot\!1\!\cdot\!1\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{22}\end{array}\right.. .8 (Partial), cond: $auth>0$. .9 \left\{\begin{array}[]{l}Cond:\neg b_{12}\\ k_{1}=(a_{8}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!auth=check(b);\!\cdot\!(b_{12}\!\cdot\!n=constructReply();\!\cdot\!()=send(n);\\ \;\;\;+\neg b_{12}\!\cdot\!1)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{8}\\ k_{2}=(a_{22}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!()=log(b);\!\cdot\!1\!\cdot\!1\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{22}\end{array}\right.. .10 AComplete. .11 \left\{\begin{array}[]{l}Axioms:\{I=1,J=1,K=1\}\\ k_{1}=(a_{8}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!auth=check(b);\!\cdot\!1\!\cdot\!1\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{8}\\ k_{2}=(a_{22}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!()=log(b);\!\cdot\!1\!\cdot\!1\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{22}\end{array}\right.. .7 \left\{\begin{array}[]{l}Cond:\neg c_{15}\\ k_{1}=(a_{8}\!\cdot\!b=recv();\!\cdot\!(c_{15}\!\cdot\!auth=check(b);\!\cdot\!(b_{12}\!\cdot\!n=constructReply();\!\cdot\!()=send(n);\\ \;\;\;+\neg b_{12}\!\cdot\!1)+\neg c_{15}\!\cdot\!()=log(b);)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{8}\\ k_{2}=(a_{22}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!()=log(b);\!\cdot\!1\!\cdot\!1\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{22}\end{array}\right.. .8 AComplete. .9 \left\{\begin{array}[]{l}Axioms:\{I=1,J=1,K=1\}\\ k_{1}=(a_{8}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!()=log(b);\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{8}\\ k_{2}=(a_{22}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!()=log(b);\!\cdot\!1\!\cdot\!1\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{22}\end{array}\right.. .3 \left\{\begin{array}[]{l}Cond:\neg d_{30}\\ k_{1}=(a_{8}\!\cdot\!b=recv();\!\cdot\!(c_{15}\!\cdot\!auth=check(b);\!\cdot\!(b_{12}\!\cdot\!n=constructReply();\!\cdot\!()=send(n);\\ \;\;\;+\neg b_{12}\!\cdot\!1)+\neg c_{15}\!\cdot\!()=log(b);)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{8}\\ k_{2}=(a_{22}\!\cdot\!b=recv();\!\cdot\!(d_{30}\!\cdot\!()=log(b);+\neg d_{30}\!\cdot\!1)\!\cdot\!(c_{28}\!\cdot\!n=constructReply();\!\cdot\!()=send(n);\\ \;\;\;\!\cdot\!(d_{25}\!\cdot\!()=log(n);+\neg d_{25}\!\cdot\!1)+\neg c_{28}\!\cdot\!1)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{22}\end{array}\right.. .4 (Partial), cond: $b>0$. .5 \left\{\begin{array}[]{l}Cond:\neg c_{28}\\ k_{1}=(a_{8}\!\cdot\!b=recv();\!\cdot\!(c_{15}\!\cdot\!auth=check(b);\!\cdot\!(b_{12}\!\cdot\!n=constructReply();\!\cdot\!()=send(n);\\ \;\;\;+\neg b_{12}\!\cdot\!1)+\neg c_{15}\!\cdot\!()=log(b);)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{8}\\ k_{2}=(a_{22}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!1\!\cdot\!(c_{28}\!\cdot\!n=constructReply();\!\cdot\!()=send(n);\\ \;\;\;\!\cdot\!1+\neg c_{28}\!\cdot\!1)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{22}\end{array}\right.. .6 (Partial), cond: $b>0$. .7 \left\{\begin{array}[]{l}Cond:c_{15}\\ k_{1}=(a_{8}\!\cdot\!b=recv();\!\cdot\!(c_{15}\!\cdot\!auth=check(b);\!\cdot\!(b_{12}\!\cdot\!n=constructReply();\!\cdot\!()=send(n);\\ \;\;\;+\neg b_{12}\!\cdot\!1)+\neg c_{15}\!\cdot\!()=log(b);)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{8}\\ k_{2}=(a_{22}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!1\!\cdot\!1\!\cdot\!1\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{22}\end{array}\right.. .8 (Partial), cond: $auth>0$. .9 \left\{\begin{array}[]{l}Cond:\neg b_{12}\\ k_{1}=(a_{8}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!auth=check(b);\!\cdot\!(b_{12}\!\cdot\!n=constructReply();\!\cdot\!()=send(n);\\ \;\;\;+\neg b_{12}\!\cdot\!1)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{8}\\ k_{2}=(a_{22}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!1\!\cdot\!1\!\cdot\!1\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{22}\end{array}\right.. .10 AComplete. .11 \left\{\begin{array}[]{l}Axioms:\{I=1,K=1\}\\ k_{1}=(a_{8}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!auth=check(b);\!\cdot\!1\!\cdot\!1\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{8}\\ k_{2}=(a_{22}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!1\!\cdot\!1\!\cdot\!1\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{22}\end{array}\right.. .7 \left\{\begin{array}[]{l}Cond:\neg c_{15}\\ k_{1}=(a_{8}\!\cdot\!b=recv();\!\cdot\!(c_{15}\!\cdot\!auth=check(b);\!\cdot\!(b_{12}\!\cdot\!n=constructReply();\!\cdot\!()=send(n);\\ \;\;\;+\neg b_{12}\!\cdot\!1)+\neg c_{15}\!\cdot\!()=log(b);)\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{8}\\ k_{2}=(a_{22}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!1\!\cdot\!1\!\cdot\!1\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{22}\end{array}\right.. .8 AComplete. .9 \left\{\begin{array}[]{l}Axioms:\{I=1,K=1\}\\ k_{1}=(a_{8}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!()=log(b);\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{8}\\ k_{2}=(a_{22}\!\cdot\!b=recv();\!\cdot\!1\!\cdot\!1\!\cdot\!1\!\cdot\!1\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{22}\end{array}\right..

Remaining 73 solutions ommitted for brevity.

C.29. Example synthesized solution for benchmark 01toggle.c

\dirtree

.1 solution. .2 AComplete. .3 \left\{\begin{array}[]{l}Axioms:\{b=!c\}\\ k_{1}=i=0;\!\cdot\!(a_{5}\!\cdot\!n=nondet();\!\cdot\!(b_{9}\!\cdot\!t=1;+\neg b_{9}\!\cdot\!t=0;)\!\cdot\!i=i+1;)*\!\cdot\!\neg a_{5}\\ k_{2}=i=0;\!\cdot\!(a_{14}\!\cdot\!n=nondet();\!\cdot\!(c_{18}\!\cdot\!t=0;+\neg c_{18}\!\cdot\!t=1;)\!\cdot\!i=i+1;)*\!\cdot\!\neg a_{14}\end{array}\right..

C.30. Example synthesized solution for benchmark 02altern.c

\dirtree

.1 solution. .2 AComplete. .3 \left\{\begin{array}[]{l}Axioms:\{T=1,B=1\}\\ k_{1}=(a_{5}\!\cdot\!x=x-1;\!\cdot\!()=eventA();\!\cdot\!()=eventB();)*\!\cdot\!\neg a_{5}\\ k_{2}=(a_{11}\!\cdot\!x=x-1;\!\cdot\!()=eventB();\!\cdot\!()=eventA();)*\!\cdot\!\neg a_{11}\end{array}\right..

C.31. Example synthesized solution for benchmark 02cdown.c

\dirtree

.1 solution. .2 AComplete. .3 \left\{\begin{array}[]{l}Axioms:\{X=A\}\\ k_{1}=()=eventA();\!\cdot\!(a_{7}\!\cdot\!x=x-1;)*\!\cdot\!\neg a_{7}\!\cdot\!()=eventB();\!\cdot\!()=eventA();\\ k_{2}=()=eventA();\!\cdot\!(a_{14}\!\cdot\!x=x-2;)*\!\cdot\!\neg a_{14}\!\cdot\!()=eventB();\!\cdot\!()=eventA();\end{array}\right..

C.32. Example synthesized solution for benchmark 02foil.c

\dirtree

.1 solution. .2 AComplete. .3 \left\{\begin{array}[]{l}Axioms:\{E=V\}\\ k_{1}=()=eventA();\!\cdot\!()=eventB();\!\cdot\!()=eventB();\\ k_{2}=()=eventA();\!\cdot\!()=eventA();\!\cdot\!()=eventB();\end{array}\right..

C.33. Example synthesized solution for benchmark 03buffer.c

\dirtree

.1 solution. .2 (Partial), cond: $brk<1$. .3 \left\{\begin{array}[]{l}Cond:a_{6}\\ k_{1}=fv_{1}=1024;\!\cdot\!buffer=array\_alloc(fv_{1});\!\cdot\!i=0;\!\cdot\!brk=0;\!\cdot\!(a_{6}\!\cdot\!c=getchar();\\ \;\;\;\!\cdot\!(c_{12}\!\cdot\!brk=1;+\neg c_{12}\!\cdot\!(b_{11}\!\cdot\!brk=1;+\neg b_{11}\!\cdot\!()=array\_write(buffer,i,c);\!\cdot\!i=i+1;)))*\!\cdot\!\neg a_{6}\\ k_{2}=fv_{2}=1024;\!\cdot\!buffer=array\_alloc(fv_{2});\!\cdot\!i=0;\!\cdot\!brk=0;\!\cdot\!(a_{19}\!\cdot\!c=getchar();\\ \;\;\;\!\cdot\!(c_{24}\!\cdot\!brk=1;+\neg c_{24}\!\cdot\!(b_{23}\!\cdot\!brk=1;+\neg b_{23}\!\cdot\!brk=1;)))*\!\cdot\!\neg a_{19}\end{array}\right.. .4 AComplete. .5 \left\{\begin{array}[]{l}Axioms:\{M=1,N=1,Y=L,W=1,O=1,P=1\}\\ k_{1}=fv_{1}=1024;\!\cdot\!buffer=array\_alloc(fv_{1});\!\cdot\!i=0;\!\cdot\!brk=0;\!\cdot\!1\!\cdot\!(a_{6}\!\cdot\!c=getchar();\\ \;\;\;\!\cdot\!(c_{12}\!\cdot\!brk=1;+\neg c_{12}\!\cdot\!(b_{11}\!\cdot\!brk=1;+\neg b_{11}\!\cdot\!()=array\_write(buffer,i,c);\!\cdot\!i=i+1;)))*\!\cdot\!\neg a_{6}\\ k_{2}=fv_{2}=1024;\!\cdot\!buffer=array\_alloc(fv_{2});\!\cdot\!i=0;\!\cdot\!brk=0;\!\cdot\!(a_{19}\!\cdot\!c=getchar();\\ \;\;\;\!\cdot\!(c_{24}\!\cdot\!brk=1;+\neg c_{24}\!\cdot\!(b_{23}\!\cdot\!brk=1;+\neg b_{23}\!\cdot\!brk=1;)))*\!\cdot\!\neg a_{19}\end{array}\right.. .3 \left\{\begin{array}[]{l}Cond:\neg a_{6}\\ k_{1}=fv_{1}=1024;\!\cdot\!buffer=array\_alloc(fv_{1});\!\cdot\!i=0;\!\cdot\!brk=0;\!\cdot\!(a_{6}\!\cdot\!c=getchar();\\ \;\;\;\!\cdot\!(c_{12}\!\cdot\!brk=1;+\neg c_{12}\!\cdot\!(b_{11}\!\cdot\!brk=1;+\neg b_{11}\!\cdot\!()=array\_write(buffer,i,c);\!\cdot\!i=i+1;)))*\!\cdot\!\neg a_{6}\\ k_{2}=fv_{2}=1024;\!\cdot\!buffer=array\_alloc(fv_{2});\!\cdot\!i=0;\!\cdot\!brk=0;\!\cdot\!(a_{19}\!\cdot\!c=getchar();\\ \;\;\;\!\cdot\!(c_{24}\!\cdot\!brk=1;+\neg c_{24}\!\cdot\!(b_{23}\!\cdot\!brk=1;+\neg b_{23}\!\cdot\!brk=1;)))*\!\cdot\!\neg a_{19}\end{array}\right.. .4 (Partial), cond: $brk<1$. .5 \left\{\begin{array}[]{l}Cond:\neg a_{19}\\ k_{1}=fv_{1}=1024;\!\cdot\!buffer=array\_alloc(fv_{1});\!\cdot\!i=0;\!\cdot\!brk=0;\!\cdot\!0\!\cdot\!0\\ k_{2}=fv_{2}=1024;\!\cdot\!buffer=array\_alloc(fv_{2});\!\cdot\!i=0;\!\cdot\!brk=0;\!\cdot\!(a_{19}\!\cdot\!c=getchar();\\ \;\;\;\!\cdot\!(c_{24}\!\cdot\!brk=1;+\neg c_{24}\!\cdot\!(b_{23}\!\cdot\!brk=1;+\neg b_{23}\!\cdot\!brk=1;)))*\!\cdot\!\neg a_{19}\end{array}\right.. .6 AComplete. .7 \left\{\begin{array}[]{l}Axioms:\{M=1,N=1,Y=L,W=1,O=1\}\\ k_{1}=fv_{1}=1024;\!\cdot\!buffer=array\_alloc(fv_{1});\!\cdot\!i=0;\!\cdot\!brk=0;\!\cdot\!0\!\cdot\!0\\ k_{2}=fv_{2}=1024;\!\cdot\!buffer=array\_alloc(fv_{2});\!\cdot\!i=0;\!\cdot\!brk=0;\!\cdot\!0\!\cdot\!0\end{array}\right..

Remaining 190 solutions ommitted for brevity.

C.34. Example synthesized solution for benchmark 03syscalls.c

\dirtree

.1 solution. .2 (Complete), cond: $x==0$. .3 \left\{\begin{array}[]{l}Cond:b_{28}\\ k_{1}=fv_{1}=1000;\!\cdot\!c=array\_alloc(fv_{1});\!\cdot\!(b_{15}\!\cdot\!fv_{2}=1;\!\cdot\!()=show(fv_{2});+\neg b_{15}\!\cdot\!1)\!\cdot\!b=getchar();\\ \;\;\;\!\cdot\!(a_{9}\!\cdot\!()=array\_write(c,b);\!\cdot\!b=b-1;)*\!\cdot\!\neg a_{9}\!\cdot\!r=array\_read(c);\\ k_{2}=a=nondet();\!\cdot\!c=array\_alloc(a);\!\cdot\!(b_{28}\!\cdot\!fv_{3}=2;\!\cdot\!()=show(fv_{3});+\neg b_{28}\!\cdot\!1)\!\cdot\!b=getchar();\\ \;\;\;\!\cdot\!((a_{21}\wedge c_{22})\!\cdot\!()=array\_write(c,b);\!\cdot\!b=b-1;)*\!\cdot\!(\neg a_{21}\vee\neg c_{22})\!\cdot\!r=array\_read(c);\end{array}\right.. .4 AComplete. .5 \left\{\begin{array}[]{l}Axioms:\{K=1,L=T,M=1,P=1,W=1,!a=!c,Q=1,U=1\}\\ k_{1}=fv_{1}=1000;\!\cdot\!c=array\_alloc(fv_{1});\!\cdot\!(b_{15}\!\cdot\!fv_{2}=1;\!\cdot\!()=show(fv_{2});+\neg b_{15}\!\cdot\!1)\!\cdot\!b=getchar();\\ \;\;\;\!\cdot\!(a_{9}\!\cdot\!()=array\_write(c,b);\!\cdot\!b=b-1;)*\!\cdot\!\neg a_{9}\!\cdot\!r=array\_read(c);\\ k_{2}=a=nondet();\!\cdot\!c=array\_alloc(a);\!\cdot\!1\!\cdot\!(b_{28}\!\cdot\!fv_{3}=2;\!\cdot\!()=show(fv_{3});+\neg b_{28}\!\cdot\!1)\!\cdot\!b=getchar();\\ \;\;\;\!\cdot\!((a_{21}\wedge c_{22})\!\cdot\!()=array\_write(c,b);\!\cdot\!b=b-1;)*\!\cdot\!(\neg a_{21}\vee\neg c_{22})\!\cdot\!r=array\_read(c);\end{array}\right.. .3 \left\{\begin{array}[]{l}Cond:\neg b_{28}\\ k_{1}=fv_{1}=1000;\!\cdot\!c=array\_alloc(fv_{1});\!\cdot\!(b_{15}\!\cdot\!fv_{2}=1;\!\cdot\!()=show(fv_{2});+\neg b_{15}\!\cdot\!1)\!\cdot\!b=getchar();\\ \;\;\;\!\cdot\!(a_{9}\!\cdot\!()=array\_write(c,b);\!\cdot\!b=b-1;)*\!\cdot\!\neg a_{9}\!\cdot\!r=array\_read(c);\\ k_{2}=a=nondet();\!\cdot\!c=array\_alloc(a);\!\cdot\!(b_{28}\!\cdot\!fv_{3}=2;\!\cdot\!()=show(fv_{3});+\neg b_{28}\!\cdot\!1)\!\cdot\!b=getchar();\\ \;\;\;\!\cdot\!((a_{21}\wedge c_{22})\!\cdot\!()=array\_write(c,b);\!\cdot\!b=b-1;)*\!\cdot\!(\neg a_{21}\vee\neg c_{22})\!\cdot\!r=array\_read(c);\end{array}\right.. .4 AComplete. .5 \left\{\begin{array}[]{l}Axioms:\{K=1,L=T,M=1,P=1,W=1,!a=!c,Q=1,U=1\}\\ k_{1}=fv_{1}=1000;\!\cdot\!c=array\_alloc(fv_{1});\!\cdot\!(b_{15}\!\cdot\!fv_{2}=1;\!\cdot\!()=show(fv_{2});+\neg b_{15}\!\cdot\!1)\!\cdot\!b=getchar();\\ \;\;\;\!\cdot\!(a_{9}\!\cdot\!()=array\_write(c,b);\!\cdot\!b=b-1;)*\!\cdot\!\neg a_{9}\!\cdot\!r=array\_read(c);\\ k_{2}=a=nondet();\!\cdot\!c=array\_alloc(a);\!\cdot\!1\!\cdot\!(b_{28}\!\cdot\!fv_{3}=2;\!\cdot\!()=show(fv_{3});+\neg b_{28}\!\cdot\!1)\!\cdot\!b=getchar();\\ \;\;\;\!\cdot\!((a_{21}\wedge c_{22})\!\cdot\!()=array\_write(c,b);\!\cdot\!b=b-1;)*\!\cdot\!(\neg a_{21}\vee\neg c_{22})\!\cdot\!r=array\_read(c);\end{array}\right..

Remaining 154 solutions ommitted for brevity.

C.35. Example synthesized solution for benchmark 04ident.c

\dirtree

.1 solution. .2 AComplete. .3 \left\{\begin{array}[]{l}Axioms:\{J=1,K=1,E=B\}\\ k_{1}=err=copyin(uap\_alen,len);\!\cdot\!(b_{17}\!\cdot\!()=fdrop(fp,p);+\neg b_{17}\!\cdot\!1)\!\cdot\!(c_{15}\!\cdot\!len=sa\_len;+\neg c_{15}\!\cdot\!1)\!\cdot\!\\ \;\;\;err=copyout(sa,uap\_asa,len);\!\cdot\!(b_{12}\!\cdot\!(a_{11}\!\cdot\!fv_{1}=42;\!\cdot\!()=free(sa,fv_{1});+\neg a_{11}\!\cdot\!1)\!\cdot\!()=fdrop(fp,p);+\neg b_{12}\!\cdot\!1)\!\cdot\!\\ \;\;\;err=copyout(len,uap\_alen,sizeof\_len);\\ k_{2}=err=copyin(uap\_alen,len);\!\cdot\!(b_{32}\!\cdot\!()=fdrop(fp,p);+\neg b_{32}\!\cdot\!1)\!\cdot\!(c_{30}\!\cdot\!len=sa\_len;+\neg c_{30}\!\cdot\!1)\!\cdot\!\\ \;\;\;err=copyout(sa,uap\_asa,len);\!\cdot\!(b_{27}\!\cdot\!(a_{26}\!\cdot\!fv_{2}=42;\!\cdot\!()=free(sa,fv_{2});+\neg a_{26}\!\cdot\!1)\!\cdot\!()=fdrop(fp,p);+\neg b_{27}\!\cdot\!1)\!\cdot\!\\ \;\;\;err=copyout(len,uap\_alen,sizeof\_len);\end{array}\right..

Remaining 4 solutions ommitted for brevity.

C.36. Example synthesized solution for benchmark 05thttpdEr.c

\dirtree

.1 solution. .2 (Complete), cond: $keepalive<=0$. .3 \left\{\begin{array}[]{l}Cond:a_{6}\\ k_{1}=(b_{8}\!\cdot\!(a_{6}\!\cdot\!()=shutdown();\\ \;\;\;+\neg a_{6}\!\cdot\!1)+\neg b_{8}\!\cdot\!()=update\_stats();)\\ k_{2}=(b_{18}\!\cdot\!()=clear\_connection();\!\cdot\!()=shutdown();\\ \;\;\;+\neg b_{18}\!\cdot\!()=update\_stats();)\end{array}\right.. .4 AComplete. .5 \left\{\begin{array}[]{l}Axioms:\{I=1\}\\ k_{1}=(b_{8}\!\cdot\!1\!\cdot\!()=shutdown();\\ \;\;\;+\neg b_{8}\!\cdot\!()=update\_stats();)\\ k_{2}=(b_{18}\!\cdot\!()=clear\_connection();\!\cdot\!()=shutdown();\\ \;\;\;+\neg b_{18}\!\cdot\!()=update\_stats();)\end{array}\right.. .3 \left\{\begin{array}[]{l}Cond:\neg a_{6}\\ k_{1}=(b_{8}\!\cdot\!(a_{6}\!\cdot\!()=shutdown();\\ \;\;\;+\neg a_{6}\!\cdot\!1)+\neg b_{8}\!\cdot\!()=update\_stats();)\\ k_{2}=(b_{18}\!\cdot\!()=clear\_connection();\!\cdot\!()=shutdown();\\ \;\;\;+\neg b_{18}\!\cdot\!()=update\_stats();)\end{array}\right.. .4 (Complete), cond: $err>0$. .5 \left\{\begin{array}[]{l}Cond:\neg b_{18}\\ k_{1}=(b_{8}\!\cdot\!1\!\cdot\!1+\neg b_{8}\!\cdot\!()=update\_stats();)\\ k_{2}=(b_{18}\!\cdot\!()=clear\_connection();\!\cdot\!()=shutdown();\\ \;\;\;+\neg b_{18}\!\cdot\!()=update\_stats();)\end{array}\right.. .6 (Complete), cond: $err>0$. .7 \left\{\begin{array}[]{l}Cond:\neg b_{8}\\ k_{1}=(b_{8}\!\cdot\!1\!\cdot\!1+\neg b_{8}\!\cdot\!()=update\_stats();)\\ k_{2}=1\!\cdot\!()=update\_stats();\end{array}\right.. .8 AComplete. .9 \left\{\begin{array}[]{l}Axioms:\{I=1\}\\ k_{1}=1\!\cdot\!()=update\_stats();\\ k_{2}=1\!\cdot\!()=update\_stats();\end{array}\right..

Remaining 3 solutions ommitted for brevity.

C.37. Example synthesized solution for benchmark 05thttpdWr.c

\dirtree

.1 solution. .2 (Partial), cond: $compress>0$. .3 \left\{\begin{array}[]{l}Cond:a_{12}\\ k_{1}=(a_{12}\!\cdot\!()=compress();\!\cdot\!()=write\_headers();\\ \;\;\;\!\cdot\!()=httpd\_ssl\_write();+\neg a_{12}\!\cdot\!()=write\_headers();\\ \;\;\;\!\cdot\!()=httpd\_ssl\_write();)\!\cdot\!err=write(out);\\ k_{2}=t=nondet();\!\cdot\!(b_{21}\!\cdot\!()=write\_headers();\\ \;\;\;+\neg b_{21}\!\cdot\!1)\!\cdot\!err=write(out);\end{array}\right.. .4 (Partial), cond: $t>0$. .5 \left\{\begin{array}[]{l}Cond:b_{21}\\ k_{1}=1\!\cdot\!()=compress();\!\cdot\!()=write\_headers();\\ \;\;\;\!\cdot\!()=httpd\_ssl\_write();\!\cdot\!err=write(out);\\ k_{2}=t=nondet();\!\cdot\!(b_{21}\!\cdot\!()=write\_headers();\\ \;\;\;+\neg b_{21}\!\cdot\!1)\!\cdot\!err=write(out);\end{array}\right.. .6 AComplete. .7 \left\{\begin{array}[]{l}Axioms:\{K=1,M=1,P=1\}\\ k_{1}=1\!\cdot\!()=compress();\!\cdot\!()=write\_headers();\\ \;\;\;\!\cdot\!()=httpd\_ssl\_write();\!\cdot\!err=write(out);\\ k_{2}=t=nondet();\!\cdot\!1\!\cdot\!()=write\_headers();\\ \;\;\;\!\cdot\!err=write(out);\end{array}\right.. .3 \left\{\begin{array}[]{l}Cond:\neg a_{12}\\ k_{1}=(a_{12}\!\cdot\!()=compress();\!\cdot\!()=write\_headers();\\ \;\;\;\!\cdot\!()=httpd\_ssl\_write();+\neg a_{12}\!\cdot\!()=write\_headers();\\ \;\;\;\!\cdot\!()=httpd\_ssl\_write();)\!\cdot\!err=write(out);\\ k_{2}=t=nondet();\!\cdot\!(b_{21}\!\cdot\!()=write\_headers();\\ \;\;\;+\neg b_{21}\!\cdot\!1)\!\cdot\!err=write(out);\end{array}\right.. .4 (Partial), cond: $t>0$. .5 \left\{\begin{array}[]{l}Cond:b_{21}\\ k_{1}=1\!\cdot\!()=write\_headers();\\ \;\;\;\!\cdot\!()=httpd\_ssl\_write();\!\cdot\!err=write(out);\\ k_{2}=t=nondet();\!\cdot\!(b_{21}\!\cdot\!()=write\_headers();\\ \;\;\;+\neg b_{21}\!\cdot\!1)\!\cdot\!err=write(out);\end{array}\right.. .6 AComplete. .7 \left\{\begin{array}[]{l}Axioms:\{K=1,P=1\}\\ k_{1}=1\!\cdot\!()=write\_headers();\\ \;\;\;\!\cdot\!()=httpd\_ssl\_write();\!\cdot\!err=write(out);\\ k_{2}=t=nondet();\!\cdot\!1\!\cdot\!()=write\_headers();\\ \;\;\;\!\cdot\!err=write(out);\end{array}\right..

Remaining 60 solutions ommitted for brevity.