Cooperation between Automatic and Interactive Software Veriﬁers

. The veriﬁcation community develops two kinds of veriﬁcation tools: automatic veriﬁers and interactive veriﬁers. There are many such veriﬁers available, and there is steady progress in research. However, cooperation between the two kinds of veriﬁers was not yet addressed in a modular way. Yet, it is imperative for the community to leverage all possibilities, because our society heavily depends on software systems that work correctly. This paper contributes tools and a modular design to address the open problem of insuﬃcient support for cooperation between veriﬁcation tools. We identify invariants as information that needs to be exchanged in cooperation, and we support translation between two ‘containers’ for invariants: program annotations and correctness witnesses. Using our new building blocks, invariants computed by automatic veri-ﬁers can be given to interactive veriﬁers as annotations in the program, and annotations from the user or interactive veriﬁer can be given to automatic veriﬁers, in order to help the approaches mutually to solve the veriﬁcation problem. The modular framework, and the design choice to work with readily-available components in oﬀ-the-shelf manner, opens up many opportunities to combine new tools from existing components. Our experiments on a large set of programs show that our constructions work, that is, we constructed tool combinations that can solve veriﬁcation tasks that the veriﬁers could not solve before.


Introduction
Software verification becomes more and more important, and large IT companies are investing into this technology [5,25,29].There was a lot of progress in the past two decades and many software-verification tools exist [7,8,15,34,42].But there are also obstacles that hinder the application of new technology in practice [3,35].The verification tools can roughly be divided into two different flavors: automatic verifiers, which are more suited for automatic settings such as continuous-integration checks, and interactive verifiers, which can be fed with proof hints to solve verification tasks.These different tools have different strengths and often one verifier alone is not able to prove the correctness.Yet, the potential from cooperation between different kinds of verifiers is a largely unused technology, although it is expected to significantly improve the state of the art.
In this paper, we contribute ideas to bridge the gap between automatic and interactive verifiers by introducing cooperation between tools of both kinds.As a starting point, we identify invariants as the objects that we need to exchange.Then we investigate which interfaces are supported by different verification tools.As a result, we choose verification witnesses [12] and annotations [6] as containers for the invariants.We implement various transformers for exchanging invariants between the different interfaces.This results in a modular composition framework that is based on off-the-shelf components (in binary format).We can use existing components because we base our work on existing interfaces (witnesses and annotations).
Automatic verifiers, such as Cbmc [28], CPAchecker [18], Goblint [49], Korn [32], PeSCo [48], Symbiotic [26], Ultimate Automizer [39], and VeriAbs [1] (alphabetic order, just to name a few, for a larger list we refer to a competition report [8]), usually take as input a program and a specification (a.k.a.verification task) and compute invariants, in order to prove correctness.The above-mentioned verifiers can save the computed invariants into a standard witness file for later use (e.g., for result validation).
Interactive verifiers, such as Dafny [46], Frama-C [30], KeY [2], KIV [33], and VeriFast [43] (alphabetic order, just to name a few, for a larger list we refer to a competition report [34]), usually take as input a program with an inlined specification (contracts, asserts), and during the verification process, the verification engineer can interact with the verifier by providing invariants and other information as annotations in the program.
The automatic verifiers use a standardized exchange format for verification witnesses [12], and thus, we can easily plug-in all of them.The interactive verifiers come each with their own annotation language.We decided to consider only ACSL [6], which is supported by Frama-C [30], as a starting point for our study, because it is well documented.In practice, many of these annotation languages are similar, so our results apply to other annotation languages as well.
Contributions.This paper contributes the following in order to enable new verification technology: Related Work.In the following we discuss the most related existing approaches.
Transform Programs.This is not the first work to convert the semantics of witness validation into a program.Some existing approaches [14] focus on violation witnesses, while we solely focus on correctness witnesses.Most similar in this regard is MetaVal [21].The main difference is that we preserve the program structure while MetaVal does an automaton product between the control-flow automaton (CFA) of the program and witness automaton, and turns the result back into a C program, which will result in a different syntactic structure.
Interact via Conditions.The approach conditional model checking [16] also achieves cooperation between verifiers, but is limited to automatic verifiers that support the condition format and the verifier that comes second uses the condition to restrict the part of the state space that is explored.Our framework supports more tools via the usage of standardized exchange formats, also considers interactive verifiers, and the second verifier still performs a full proof.Another approach that builds on conditions is alternating conditional analysis [36,37].Here, the witness format is also used as standardized exchange format and multiple verifiers are supported.However, the focus is on violation witnesses whereas we are focussing on correctness witnesses.Instead of removing parts of the state space, we actually extend the property that needs to be checked, such that it is (potentially) easier to be proven.The same holds if we compare our component Witness2Assert to reducer-based conditional model checking [17].While both approaches encode the important information into the original program, we actually would need to assume the invariants instead of asserting them in order to act as a reducer.Conditions are also used to improve testing [19,27,31].
Store and Exchange Proofs.Another parallel can be drawn to proof-carrying code [44,45,47], where the proof of correctness is stored alongside the program.We do the same here in cases where the added annotations actually suffice for a full proof by Frama-C, but we also have the possibility to generate partial proofs.Correctness witnesses are used to store intermediate results and to validate results [11].Proofs are also stored in the area of theorem provers [38] (https://www.isa-afp.org/)and SAT solvers [40,41].

Preliminaries
For our framework that enables cooperation between automatic and interactive verifiers we need to take into account the interfaces that each of them provide, i.e., how the information important for the verification process is communicated.For automatic verifiers there exists a common exchange format [12] in which verifiers export the program invariants they found.For interactive verifiers, we look at ACSL [6], the specification language that is e.g.used by Frama-C.In the following, we will quickly introduce these formats and the general verification problem we are looking at using a small example program that is depicted in Fig. 1.
For the rest of the paper, we will focus on reachability properties, though our approach can also be extended to work for other properties as well. 1 The crucial part of verifying reachability properties is to find the right loop invariants.In the example program this would be the fact that x==y always holds before each loop iteration.Please note that while this invariant is also present in the assertion in line 11, for more complicated programs it is generally not the case that we can find the invariants written in the code.Also, since there might be more than one loop in a program, a verifier might only partially succeed and therefore only be able to provide invariants for some of these loops, or only invariants that are not yet strong enough to prove the program correct.This is why cooperation by exchange of these discovered invariants can potentially lead to better results.

Verification Witnesses
In case an automatic verifier can prove our example program correct, information like a discovered invariant is normally made available as shown in Fig. 3a    <node i d=" q1 "> 3 <d a t a key=" i n v a r i a n t ">( y == x )</ data> 4 <d a t a key=" i n v a r i a n t .s c o p e ">main</data> 5 </node> 6 <e d g e s o u r c e=" q0 " t a r g e t=" q1 "> 7 <d a t a key=" enterLoopHead ">t r u e </data> 8 <d a t a key=" s t a r t l i n e ">6</data> 9 <d a t a key=" e n d l i n e ">6</data> 10 <d a t a key=" s t a r t o f f s e t ">157</data>   the standard witness exchange format (described in [12], maintained at https: //github.com/sosy-lab/sv-witnesses)as correctness witness.There are also violation witnesses in case a violation has been found, but since we are mainly interested in the invariants, we will focus on correctness witnesses and omit the prefix "correctness" for the rest of the paper.
Such a witness contains a graph representation of an observer automaton.Invariants can be given for nodes if they always hold when the witness automaton is in the corresponding state.The semantics of the witness is given by constructing the product of the witness automaton and the CFA of the program.This might lead to edge cases where the exact semantics depends on how the tool interpreting the witness constructs a CFA from the program, but in practice a witness can be written such that it is mostly robust against those differences.For further details on the semantics of the witness automata we refer the reader the existing literature [12].
There are currently some restrictions on the contents of an invariant: An invariant has to be a valid C expression that can be evaluated to an int at the current scope in the program.It may contain conjunctions and disjunctions but no function calls.

ACSL
Interactive verifiers rely on the user to provide the (non-trivial) invariants for the proof.An example can bee seen in Fig. 2, where the loop invariant has been added as ACSL annotation in line 5.Only when this information is externally provided (usually by the user), an interactive verifier like Frama-C is able to prove that the assertion in line 11 can never be violated.
Loop annotations are only one of many kinds of annotation in ACSL.For example we can see a function contract in line 1 and an assertion in line 8.These annotations usually represent specifications which the implementation should adhere to, but they can also be seen as invariants, since they should hold for every possible program execution.
The basic building blocks of ACSL annotations are logic expressions that represent the concrete properties of the specification, e.g., a + b > 0 or x && y == z.Logic expressions can be subdivided into terms and predicates, which behave similarly as terms and formulas in first-order logic.Basically, logic expressions that evaluate to a boolean value are predicates, while all other logic expressions are terms.The above example a + b > 0 is therefore a predicate, while a + b is a term.We currently support only logic expressions that can also be expressed as C expressions, as they may not be used in a witness otherwise.Finding ways to represent more ACSL features is a topic of ongoing research.
ACSL also features different types of annotations.In this paper we will only present translations for the most common type of annotations, namely function contracts, and the simplest type, namely assertions.Our implementation also supports statement contracts and loop annotations.
All types of ACSL annotations when placed in a C source file must be given in comments starting with an @ sign, i.e., must be in the form //@ annotation or /*@ annotation */.ACSL assertions can be placed anywhere in a program where a statement would be allowed, start with the keyword assert and contain a predicate that needs to hold at the location where the assertion is placed.

A Component Framework for Cooperative Verification
The framework we developed consists of three core components that allow us to improve interaction between the existing tools.Witness2ACSL acts as transformer that converts a program and a correctness witness given as witness automaton where invariants are annotated to certain nodes, into a program with ACSL annotations.ACSL2Witness takes a program that contains ACSL annotations, encodes them as invariants into a witness automaton and produces a correctness witness in the standardized GraphML format.Witness2Assert is mostly identical to Witness2ACSL.The main difference is that instead of adding assertions as ACSL annotations to the program, it actually encodes the semantics of the annotations directly into the program such that automatic verifiers will understand them as additional properties to prove.(e) Interactive Verifier from Automatic Verifier Fig. 4: Graphical visualization of the developed components to improve cooperation; we use the notation introduced in previous work [24]: p represents a program, φ b a behavior specification, ω a witness, and r a verification result On the one hand, this component enables us to check the validity of the ACSL annotations for which ACSL2Witness generated a witness, with tools that do not understand the annotation language ACSL.On the other hand, this component is also useful on its own, since it allows us to validate correctness witnesses and give witness producers a better feedback on how their invariants are interpreted and whether they are useful (validator developers can inspect the produced program).
These three components now enable us to achieve cooperation in many different ways.We can utilize a proposed component framework [24] to visualize this as shown in Fig. 4. The use case shown in Fig. 4a is to use Frama-C as a correctness witness validator.This is interesting because it can further reduce the technology bias (the currently available validators are based on automatic verifiers [4,11,13,21], test execution [14], and interpretation [50]).By using Witness2Assert instead of Witness2ACSL as shown in Fig. 4b we can also configure new correctness witness validators that are based on automatic verifiers, similar to what metaval [21] does, only with a different transformer.Figure 4c illustrates the use of Witness2ACSL (or similarly for Witness2Assert) to inspect the information from the witness as annotations in the program code.
The compositional framework makes it possible to leverage existing correctness witness validators and turn them into interactive verifiers that can understand ACSL, as shown in Fig. 4d.Since we also have the possibility now to construct a validator from an automatic verifier (Fig. 4b) we can turn automatic verifiers into interactive ones as depicted in Fig. 4e.While automatic verifiers can already make use of assertions that are manually added to the program, this now also allows us to use other types of high-level annotations like function contracts without having to change the original program.

Witness2ACSL
To create an ACSL annotated program from the source code and a correctness witness, we first need to extract location invariants from the witness, i.e., invariants that always hold at a certain program location (with program locations we refer to the nodes of the CFA here).We can represent location invariants as a tuple (l, φ) consisting of a program location l and an invariant φ.In general there is no one-to-one mapping between the invariants in the witness and this set of location invariants, since there might be multiple states with different invariants in the witness automaton that are paired with the same program location in the product with the CFA of the program.For extracting the set of location invariants, we calculate this product and then take the disjunctions of all invariants that might hold at each respective location.

ACSL2Witness
In order to convert the ACSL annotations present in a given program, we transform each annotation into a set of ACSL predicates that capture the semantics of those annotations and use the predicates as invariants in a witness.This mode of operation is based on two observations: Firstly, for a given ACSL annotation it is usually possible to find a number of ACSL assertions that are semantically equivalent to that annotation.For example, a loop invariant can be replaced by asserting that the invariant holds at the loop entry, i.e., before each loop iteration.Secontly, most ACSL assertions are logically equivalent to a valid invariant and can therefore be used in a witness.As mentioned in Sect.2.2, we currently only support those predicates which can be converted into C expressions, which is a limitation of the witness format and might be lifted in future versions of the format.

Witness2Assert
This component is very similar to Witness2ACSL.The main difference is that instead of generating ACSL annotations we generate actual C code that encodes the invariants as assertions (i.e., additional reachability properties).This translation is sound since assertions added this way do not hide violations, i.e., every feasible trace that violates the original reachability property in the program before the modification will either still exist or have a corresponding trace that violates the additional reachability properties of the modified program.It is worth mentioning that this is an improvement compared to existing transformations like the one used in MetaVal [21], where the program is resynthesized from the reachability graph and the soundness can therefore easily be broken by a bug in MetaVal's transformation process.
We implemented the components mentioned in Sect. 3 in the software-verification framework CPAchecker.In our evaluation, we attempt to answer the following research questions: • RQ 1: Can we construct interactive verifiers from automatic verifiers, and can they be useful in terms of effectiveness? • RQ 2: Can we improve the results of, or partially automate, interactive verifiers by annotating invariants that were computed by automatic verifiers?• RQ 3: Can we construct result validators from interactive verifiers?• RQ 4: Are verifiers ready for cooperation, that is, do they produce invariants that help other verifiers to increase their effectiveness?

Experimental Setup
Our benchmarks are executed on machines running Ubuntu 20.04.Each of these machines has an Intel E5-1230 processor with 4 cores, 8 processing units, and 33 GB of RAM.For reliable measurements we use BenchExec [20].For the automatic verifiers, we use the available tools that participated in the ReachSafety category of the 2022 competition on software verification (SV-COMP) in their submission version2 .Frama-C will be executed via Frama-C-SV [22], a wrapper that enables Frama-C to understand reachability property and special functions used in SV-COMP.Unless otherwise noted we will use the EVA plugin of Frama-C.We limit each execution to 900 s of CPU time, 15 GB of RAM, and 8 processing units, which is identical to the resource limitations used in SV-COMP.

Benchmark Set with Useful Witnesses
In order to provide meaningful results, we need to assemble an appropriate benchmark set consisting of witnesses that indeed contain useful information, i.e., information that potentially improves the results of another tool.As a starting point, we consider correctness witnesses from the final runs of SV-COMP 2022 [8,10].This means that for one verification task we might get multiple correctness witnesses (from different participating verifiers), while for others we might even get none because no verifier was able to come up with a proof.We select the witnesses for tasks in the subcategory ReachSafety-Loops, because this subcategory is focussed on verifying programs with challenging loop invariants.This selection leaves us with 6242 correctness witnesses (without knowing which of those actually contain useful information).
For each of the selected witnesses we converted the contained invariants into both ACSL annotations (for verification with Frama-C) and assertions (for verification with automatic verifiers from SV-COMP 2022).Here we can immediately drop those witnesses that do not result in any annotations being generated, which results in 1931 witnesses belonging to 640 different verification tasks.
Table 1: Impact of cooperation: in each row, a 'consuming' verifier is fed with information from witnesses of our benchmark set; 'Baseline' reports the number of programs that the verifier proved correct without any help; 'Improved via coop.' reports the number of programs that the verifier can prove in addition, if the information from the witness is provided We then run each verifier for each program where annotations have been generated, once with the original, unmodified program, and n times with the transformed program for each of the n witnesses.This allows us determine whether any improvement was achieved, by looking at the differences between verification of the unmodified program versus verification of a program that has been enhanced by information generated from some potentially different tool.Using this process, we further reduce our benchmark set of witnesses to those that are useful for at least one of the verifiers and thus enable cooperation.This leads to the final set of 434 witnesses that evidently contain information that enables cooperation between verifiers.These witnesses correspond to 230 different programs from the SV-Benchmarks repository (https://github.com/sosy-lab/sv-benchmarks).We made this benchmark set available to the community in a supplementary artifact of this paper [23].

RQ 1.
For the first research question, we need to show that we can construct interactive verifiers from automatic verifiers, and that they can be useful in terms of effectiveness.By "interactive verifier", we mean a verifier that can verify more programs correct if we feed it with invariants, for example, by annotating the input program with ACSL annotations.Using our building blocks from Sect. 3, an interactive verifier can be composed as illustrated in Fig. 4e (that is, configurations of the form ACSL2Witness|Witness2Assert|Verifier). For a meaningful evaluation we need a large number of annotated programs, which we would be able to get if we converted the witnesses from SV-COMP using Witness2ACSL in advance.But since the first component ACSL2Witness in Fig. 4e essentially does the inverse operation, we can generalize and directly consider witnesses as input, as illustrated in Fig. 4b (that is, configurations of the form Witness2Assert|Verifier).
Now we look at the results in Table 1: The first row reports that cooperation improves the verifier 2ls in 179 cases, that is, there are 179 witnesses that contain information that helps 2ls to prove a program that it could not prove without the information.In other words, for 179 witnesses, we ran Witness2Assert to transform the original program to one in which the invariants from the witness were written as assertions, and 2ls was then able to verify the program.Since there are often several witnesses for the same program, 2ls verified in total 111 unique programs that it was not able to verify without the annotated invariants as assertion.
In sum, the table reports that many programs that could not be proved by verifiers when ran on the unmodified program, could be proved when the verifier was given the program with invariants.Since we were able to show the effect using generated witnesses, it is clear that manually provided invariants will also help the automatic verifiers to prove the program.We will continue this argument in Sect.4.4.

RQ 2.
For the second research question, we need to show that our new design can improve the results of interactive verifiers by annotating invariants that were computed by automatic verifiers.Using our building blocks from Sect. 3, we assemble a construction as illustrated in Fig. 4a (i.e., configurations of the form Witness2ACSL|Verifier). We take a program and a witness and transform the program to a new program that contains the invariants from the witness as ACSL annotations.
Let us consider the last row in Table 1: Frama-C is able to prove 20 programs correct using invariants from 31 witnesses.Those 31 witnesses were computed by automatic verifiers, and thus, we can conclude that our new design enables using results of automatic verifiers to help the verification process of an interactive verifier.RQ 3.For the third research question, we need to show that we can construct result validators from interactive verifiers and that they can effectively complement existing validators.A results validator is a tool that takes as input a verification task, a verdict, and a witness, and confirms or rejects the result.In essence, due to the modular components, the answer to this research question can be given by the same setup as for RQ 2: If the interactive verifier (Frama-C) was able to prove the program correct, then it also has proved that the invariants provided by the witnesses were correct, and thus, the witness should be confirmed.
Table 2: Proof of cooperation: for each 'producing' verifier, we report the number of correctness witnesses that help another verifier to prove a program which it otherwise could not; we also list the number of cases where this cooperation was observed (some witnesses improve the results of multiple verifiers); we omit producers without improved results New validators that are based on a different technology are a welcome complement because this reduces the technology bias and increases trust.Also, the proof goals for annotated programs might be interesting for verification engineers to look at, even or especially when the validation does not succeed completely.RQ 4. For the fourth research question, we report on the status of cooperationreadiness of verifiers.In other words, the question is if the verifiers produce invariants that help other verifiers to increase their effectiveness.

Producing verifier Useful witnesses Cases of cooperation
In Table 2 we list how many useful witnesses each verifier contributed to our benchmark set of useful witnesses.The results show that there are several verifiers that produce significant amounts of witnesses that contain invariants that help to improve results of other verifiers.

Case Study on Interactive Verification with Manual Annotations
So far, we tested our approach using information from only the SV-COMP witnesses.For constructing interactive verifiers, we would also like to evaluate whether our approach is useful if the information is provided by an actual human in the form of ACSL annotations.
ACSL Benchmark Set.To achieve this, we need a benchmark set with tasks that contain sufficient ACSL annotations and also adhere to the conventions of SV-COMP.Since to our knowledge such a benchmark set does not exist yet, we decided to manually annotate assertions and loop invariants to the tasks from the SV-Benchmarks collection ourselves.While annotating all of the benchmark tasks is out of scope, we managed to add ACSL annotations to 125 tasks from the ReachSafety-Loops subcategory.This subcategory is particularly relevant, since Table 3: Case study with 125 correct verification tasks where sufficient, inductive loop invariants are manually annotated to the program; we either input these to Frama-C or automatically transform the annotations into witnesses and try to validate these witnesses using CPAchecker's k -induction validator (with k fixed to 1); the listed numbers correspond to the number of successful proofs in each of the sub-folders; we also list the number of successful proofs if no invariants are provided to the tools it contains a selection of programs with interesting loop invariants.The loop invariants we added are sufficient to proof the tasks correct in a pen-and-paper, Hoare-style proof.Our benchmark set with manually added ACSL annotations is available in the artifact for this paper [23]. 3onstruction of an Interactive Verifier.With our ACSL benchmark set, we can now convert a witness validator into an interactive verifier as depicted in Fig. 4d.For the validator we use CPAchecker, which can validate witnesses by using the invariants for a proof by k -induction.By fixing the unrolling bound of the k -induction to k = 1, this will essentially attempt to prove the program correct via 1-induction over the provided loop invariants.If we do not fix the unrolling bound, the k-induction validation would also essentially perform bounded model checking, so we would not know whether a proof succeeded because of the provided loop invariants or simply because the verification task is bounded to a low number of loop iterations.Since this 1-induction proof is very similar to what Frama-C's weakestprecondition analysis does, we can directly compare both approaches.As some tasks from the benchmark set do not require additional invariants (i.e., the property to be checked is already inductive) we also analyze how both tools perform on the benchmark set if we do not provide any loop invariants.
The experimental setup is the same described in Sect.4.1, except that we use a newer version of Frama-C-SV in order to use the weakest-precondition analysis of Frama-C.The results are shown in Table 3, which lists the number of successful proofs by subfolder.We can observe that both Frama-C and our constructed interactive verifier based on CPAchecker can make use of the information from the annotations and prove significantly more tasks compared to without the annotated loop invariants.This shows that the component described in Fig. 4d is indeed working and useful.

Conclusion
The verification community integrates new achievements into two kinds of tools: interactive verifiers and automatic verifiers.Unfortunately, the possibility of cooperation between the two kinds of tools was left largely unused, although there seems to be a large potential.Our work addresses this open problem, identifying witnesses as interface objects and constructing some new building blocks (transformations) that can be used to connect interactive and automatic verifiers.The new building blocks, together with a cooperation framework from previous work, make it possible to construct new verifiers, in particular, automatic verifiers that can be used interactively, and interactive verifiers that can be fed with information from automatic verifiers: Our new program transformations translate the original program into a new program that contains invariants in a way that is understandable by the targeted backend verifier (interactive or automatic).Our combinations do not require changes to the existing verifiers: they are used as 'off-the-shelf' components, provided in binary form.
We performed an experimental study on witnesses that were produced in the most recent competition on software verification and on programs with manually annotated loop invariants.The results show that our approach works in practice: We can construct various kinds of verification tools based on our new building blocks.Instrumenting information from annotations and correctness witnesses into the original program can improve the effectivity of verifiers, that is, with the provided information they can verify programs that they could not verify without the information.Our results have many practical implications: (a) automatic verification tools can now be used in an interactive way, that is, users or other verifiers can conveniently give invariants as input in order to prove programs correct, (b) new validators based on interactive verifiers can be constructed in order to complement the set of currently available validators, and (c) both kinds of verifiers can be connected in a cooperative framework, in order to obtain more powerful verification tools.This work opens up a whole array of new opportunities that need to be explored, and there are many directions of future work.We hope that other researchers and practitioners find our approach helpful to combine existing verification tools without changing their source code.
Data-Availability Statement.The witnesses that we used are available at Zenodo [10].The programs are available at Zenodo [9] and on GitLab at https:// gitlab.com/sosy-lab/benchmarking/sv-benchmarks/-/tree/svcomp22.We implemented our transformations in the verification framework CPAchecker, which is freely available via the project web site at https://cpachecker.sosy-lab.org.A reproduction package for our experimental results is available at Zenodo [23].
Funding Statement.This project was funded in part by the Deutsche Forschungsgemeinschaft (DFG) -378803395 (ConVeY).

11 <d a t
a key=" e n d o f f s e t ">165</data> 12

( a )
Encoding of an invariant in a GraphML-based correctness witness Example witness automaton for the program from Fig.1

Fig. 3 :
Fig. 3: Example of the witness format and automaton; o/w stands for otherwise, i.e., all other possible program transitions