{'fraction_non_alphanumeric': 0.04155342972062181, 'fraction_numerical': 0.017991085987607347, 'mean_word_length': 4.621295447601589, 'pattern_counts': {'":': 0, '<': 1, '<?xml version=': 0, '>': 7, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 1, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Tighter Abstract Queries in Neural Network Verification

Neural networks have become critical components of reactive systems in various domains within computer science. Despite their excellent performance, using neural networks entails numerous risks that stem from our lack of ability to understand and reason about their behavior. Due to these risks, various formal methods have been proposed for verifying neural networks; but unfortunately, these typically struggle with scalability barriers. Recent attempts have demonstrated that abstraction-refinement approaches could play a significant role in mitigating these limitations; but these approaches can often produce networks that are so abstract, that they become unsuitable for verification. To deal with this issue, we present CEGARETTE, a novel verification mechanism where both the system and the property are abstracted and refined simultaneously. We observe that this approach allows us to produce abstract networks which are both small and sufficiently accurate, allowing for quick verification times while avoiding a large number of refinement steps. For evaluation purposes, we implemented CEGARETTE as an extension to the recently proposed CEGAR-NN framework. Our results are very promising, and demonstrate a significant improvement in performance over multiple benchmarks.

Despite these remarkable achievements, neural networks suffer from multiple limitations, which undermine their reliability: the training process of DNNs is based on assumptions regarding the data, which may fail to hold later on [33,39]; the training process might cause over-fitting of the DNN to specific data [72,86]; and, independently of the above, there is a variety of attacks that can fool a DNN into performing unwanted actions [67,82].
In order to overcome these difficulties and ensure the correctness and safety of DNNs, the formal methods community has been devising techniques for verifying them [23,42,44,57,78]. Techniques for neural network verification (NNV) receive as input a neural network and a set of constraints over its input and output, and check whether there exists an input/output pair that satisfies these constraints. Typically, the constraints encode the negation of some desirable property, and so such a pair constitutes a counter-example (the SAT case); whereas if no such pair exists, the desired property holds (the UNSAT case). NNV has been studied extensively in recent years, and many different verifiers have been proposed [21-23, 42, 44, 57, 62, 78]. However, scalability remains a fundamental barrier, both theoretical and practical, which limits the use of NNV engines: generally, increasing the number of neurons of the verified neural network implies an exponential increase in the complexity of the verification problem [42].
In order to alleviate this scalability limitation, recently there have been attempts to apply abstraction techniques within NNV [9,24,25,53,64,71], often focusing on the counter-example guided abstraction refinement (CEGAR) framework [18]. CEGAR is a well-known approach, aimed at expediting the solving of complex verification queries, by abstracting the model being verified into a simpler one -in such a way that if the simpler model is safe, i.e. the query is UNSAT, then so is the original model. In case of a SAT answer from the verifier, we check whether the satisfying assignment of the abstract model is also a satisfying assignment of the original. If so, the original query is declared SAT, the satisfying assignment is returned, and the process ends. Otherwise, the satisfying assignment is called spurious (or erroneous), indicating that the abstract query is too coarse, and should be refined into a slightly "less abstract" query, which is a bit closer to the original model (but is hopefully still smaller). CEGAR has been successfully used in various formal method applications [7,12,38,60,68], and also in the context of NNV [24,25,53]. Typically, these approaches generate an abstract neural network, which is smaller than the original, and is created by the merging of neurons of the original network. The refinement, accordingly, is performed by splitting previously-merged neurons. Other related approaches have also considered abstracting the ranges of values obtained by neurons in the network [9,64,65,71].
The general motivation for abstraction schemes is that smaller, abstract networks are easier to verify. While this is often true, smaller networks tend to be far less precise, and verifying them often requires multiple refinement steps [25,65]. In extreme cases, these multiple refinement steps can render the verification process slower than directly verifying the original network [25]. Here, we seek to tackle this problem, by improving the abstract verification queries. We propose a novel verification scheme for DNNs, wherein abstraction and refinement operations include altering not only the network (as in [18,24,25,53,65]), but also the property being verified. The motivation is to render the abstract properties more restrictive, in a way that will reduce the number of spurious counter-examples encountered during the verification process; but at the same time, ensure that the abstract queries still maintain the over-approximation property: if the abstract query is UNSAT, the original query is UNSAT too. The key idea on which our approach is based is to compute a minimal difference between the outputs of the abstract network and the original network, and then use this minimal difference to tighten the property being verified, in a sound manner.
Our approach is not coupled to any specific DNN verification method, and can use multiple DNN verifiers as black-box backends. For evaluation purposes, we implemented it on top of the Marabou DNN verifier [44]. We then tested our approach on the ACAS-Xu benchmarks [40] for airborne collision avoidance, and also on MNIST benchmarks for digit recognition [50]. Our results indicate that property abstraction affords a significant increase in the number of queries that can be verified within a given timeout, as well as a sharp decrease in the number of refinement steps performed.
To summarize, our contributions are as follows: (i) we present CEGARETTE, a novel CEGAR framework for DNN verification, that abstracts not only the network but also the properties being verified; (ii) we implement our approach in a new tool, CEGARETTE-NN, and demonstrate its practical usefulness.
The rest of this paper is organized as follows. In Section 2, we provide a brief background on neural networks and their verification, followed by an explanation of the CEGAR framework and its implementation for neural network verification. In Section 3, we describe our novel verification framework CEGARETTE. In Section 4, we discuss how to apply this framework for abstracting and refining DNNs, followed by an evaluation in Section 5. Related work is discussed in Section 6, and we conclude in Section 7.

Neural Networks
A neural network [30] is a directed graph, comprised of a sequence of layers: an input layer, followed by one or more consecutive hidden layers, and finally an output layer. A layer is a collection of nodes, also referred to as neurons.
Here we focus on feed-forward neural networks, where the values of neurons are computed based on values of neurons in preceding layers. Thus, when the network is evaluated, values are assigned to neurons in its input layer; and they are then propagated, layer after layer, through to the output layer.
We use n i,j to denote the j'th neuron of layer i. Typically, the value of neuron n i,j , denoted as v i,j , is given by the following formula: where l i−1 is the number of neurons in the i − 1'th layer, act i,j is a pre-defined (neuron specific) activation function, w i k,j is the weight of the outgoing edge from n i−1,k to n i,j , and v i−1,k is the value of the k'th neuron in the i − 1'th layer. For simplicity, we assume here that the only activation function in use is the Rectified Linear Unit (ReLU) function [58], which is defined by ReLU(x) = max(0, x), and is very common in practice. Fig. 1 depicts a small neural network. The network has 3 layers, of sizes l 1 = 1, l 2 = 2 and l 3 = 1. Its weights are w 2 1,1 = 10, w 2 1,2 = 1, w 3 1,1 = 3 and w 3 2,1 = 4. For input v 1,1 = 21, node n 2,1 evaluates to 210 and node n 2,2 evaluates to 21 (both are positive, and hence not changed by the ReLU activation function). The output node n 3,1 then evaluates to 3 · 210 + 4 · 20 = 714.

Neural Network Verification
The goal of neural network verification (NNV) is to determine the satisfiability of a verification query. A query is typically defined to be a tripe N, P, Q , where: (i) N is a neural network; (ii) P is an input property, which is a conjunction of constraints on the input neurons; and (iii) Q is an output property, which is a conjunction of constraints on the output neurons [52]. The query is SAT if and only if there exists an input vector x 0 to N , such that P (x 0 ) and Q(N (x 0 )) both hold; in which case the verifier returns x 0 as the counter-example. As we previously mentioned, Q typically represents some undesirable behavior of N on inputs from P , and so the goal is to obtain an UNSAT result. Most existing verifiers focus primarily on ReLU activation functions, and we follow this line here. In addition, most existing verifiers assume that P is a conjunction of linear constraints on the input values, and we again take the same path. Finally, we make the simplifying assumption that N has a single output neuron y, and that the property Q is of the form y > c. This assumption may seem restrictive, but in fact, it does not incur any loss of generality [25], and is sufficient for expressing many properties of interest with arbitrary Boolean structure, via a simple reduction.
In recent years, various methods have been proposed for solving the verification problem (for a brief overview, see Section 6). Our abstraction-refinement mechanism is designed to be compatible with many of these techniques, as we later describe.

Counter-Example Guided Abstraction Refinement (CEGAR)
Counter-example guided abstraction refinement (CEGAR) [18] is frequently used as part of model-checking frameworks, and it has recently been applied to neural network verification, as well. The general framework, borrowed from [25], is presented in Algorithm 1. Given a verification query N, P, Q , we begin by generating an abstract network N ′ . Then, the CEGAR loop starts, where in each iteration we verify a query with the current abstract network, N ′ , P, Q . The abstract network N ′ is constructed in a way that makes N ′ , P, Q an over-approximation of N, P, Q : if the former is UNSAT, then so is the latter. Thus, if the underlying verifier returns UNSAT on the current query, we can stop and return UNSAT. Otherwise, the verifier returns a satisfying assignment x 0 for N ′ , P, Q , and we check whether this x 0 constitutes a satisfying assignment for N, P, Q as well. If so, we return SAT and x 0 as the satisfying assignment, and stop. Otherwise, we say that x 0 is a spurious counter-example, indicating that N ′ is too coarse; in which case, we refine N ′ into a new "tighter" network, N ′′ , whose verification is more likely to produce accurate results. This refinement process is guided by the spurious counter-example x 0 . This general framework can be instantiated in many ways, by implementing the abstract and refine operations.
return UNSAT 4: else 5: Extract satisfying assignment x0 6: if x0 is a satisfying assignment for N then 7: return SAT, x0 8: else 9: N ′′ ← refine(N ′ , N, x0) 10: N ′ ← N ′′ 11: Goto step 2 12: end if 13: end if There have been a few recent attempts for applying CEGAR in the context of NNV [24,25,53], all following a similar approach. At first, a preprocessing phase is performed, and every hidden neuron in the network is classified according to its effect on the network's output. Then, abstraction is carried out by repeatedly merging pairs of neurons with the same type, usually making the network significantly smaller than the original.
In one of these approaches, called CEGAR-NN [25], the preprocessing phase initially splits each hidden neuron into 4 neurons, each belonging to one of 4 categories by the effect of the neuron on values of both the next layer's neuron and the output: the output edges can be all positive (pos) or all negative neg, and the value of a neuron can increase the output when being increased (inc), or increase the output when being decreased (dec).
The splitting process changes the network's architecture but does not change its output -i.e., the preprocessed network is completely equivalent to the original. After splitting the neurons and categorizing the new neurons, pairs of neurons from the same layer that share a category can be merged into a single neuron. The weights and biases of the new, merged neuron are determined by aggregating the weights and biases of its constituent neurons, in a way that depends on the category of these neurons, and which guarantees that the abstract network's (single) output is always greater or equal than that of the original network when the two networks are evaluated on the same input. This, combined with our assumption that the output property is always of the form y > c, guarantees that the verification query on the abstract network constitutes an over-approximation of the original query. Finally, this pair-wise merging is then repeated, resulting in a much smaller network.
An example of applying such abstraction to the network from Fig. 1 appears in Fig. 2: n 2,1 and n 2,2 both already belong to the same category (in this tiny network all other categories are empty). We merge them into a single abstract neuron, n 2,1+2 . The output weights are aggregated by a sum operation, so we get an output weight of 3 + 4 = 7. For the input weights aggregation, we take the maximal value of the two, so we get an input weight of max(10, 1) = 10.
The key property here is that for every input x, it holds that N ′ (x) ≥ N (x). For additional details, as well as a discussion of various heuristics for selecting which neurons should be merged and in what order, see [25,53]. The refinement operation is then carried out by splitting an abstract neuron, which represents a set of original neurons, into two or more new neurons. In the example, such refinement step will be to split the abstract neuron n 2,1+2 into the original neurons n 2,1 and n 2,2 , and to restore their original weights.
Empirical evaluations of CEGAR-NN demonstrated its great potential to enhance the scalability of NNV engines, but as many experiments show [25], there is much room for improvement.

Motivation
Although CEGAR-NN is quite useful in many cases, it is also prone to producing spurious counter-examples, which in turn trigger multiple refinement steps that slow the process down. For example, observe again the network N from Fig. 1, and consider the verification query Here, a sound verifier will declare that v 1 is UNSAT, because for inputs in the range [20,21], network N can only produce outputs that are upper-bounded by N (21) = 714. If we attempt to verify this query using CEGAR-NN, we would generate the abstract query where N ′ is the network in Fig. 2. For this query, a sound verifier will return a satisfying assignment, such as n 1,1 = 20. Of course, this assignment is spurious: although N ′ (20) = 1400 ≥ 800, we get that N (20) = 680 < 800. Thus, refinement would be carried out, transforming N ′ back into the original network N , and the overall process would be slower than just verifying N directly.
More broadly, we recognize the following issue with CEGAR-NN and related techniques: Performance vs Accuracy. Neuron-merging-based abstraction techniques, such as CEGAR-NN, have an intrinsic trade-off between performance and accuracy. In order to avoid coarse model abstractions and the ensuing spurious counterexamples, it is required to continuously look for accurate model abstractions. On one hand, a common approach in CEGAR-based verification is to heuristically guess an accurate initial abstract model, so that future satisfying assignments will not be spurious; and if a spurious assignment is discovered nonetheless, to try and heuristically select a refinement operation that will restore as much accuracy as possible. On the other hand, a model with a higher accuracy is almost always larger and hence verifying it is slower. Thus, these two requirements conflict with each other: generating an accurate abstract model restricts our ability to generate small abstractions, and results instead in larger models that take longer to verify.

Introducing Property Abstractions
In order to overcome the aforementioned issue, we introduce an extension to CEGAR, which we term CEGARETTE: CEGAR Enhanced by TighTEning. In CEGARETTE, when we are given a verification query N, P, Q , instead of abstracting and refining only the network N , we may also alter the output property Q in order to produce an over-approximate query N ′ , P, Q ′ .
To set the stage, we introduce the following definitions: Definition 1. A verification query N ′ , P, Q ′ is an over-approximation of another verification query N, P, Q , if and only if the unsatisfiability of N ′ , P, Q ′ implies the unsatisfiability of N, P, Q .
We refer to the process in which N ′ , P, Q ′ is created from N, P, Q as query abstraction.
Definition 2. Let N, P, Q be some base verification query. A query N ′′ , P, Q ′′ is called a refinement of a query N ′ , P, Q ′ , if (i) N ′′ , P, Q ′′ is an overapproximation of N, P, Q ; and (ii) N ′ , P, Q ′ is an over-approximation of N ′′ , P, Q ′′ .
To introduce the effect of changing the property, we consider again the verification query from our running example: v 1 = N, n 1,1 ∈ [20, 21], n 3,1 > 800 .
Let us consider what happens to this query if we change its output property. Decreasing the constant 800, for example by setting n 3,1 > 400, renders the property easier to satisfy (e.g., the output 600 satisfies the latter output property, but not the former). Therefore, if N, n 1,1 ∈ [20, 21], n 3,1 > 400 is UNSAT, then v 1 is also UNSAT. Consequently, we claim that decreasing the constant that appears in an output property Q results in an over-approximation.
While the aforementioned process is sound, it goes against the grain of our approach: decreasing the constant in the output property could potentially result in additional, not fewer, spurious counter-examples. Thus, what we would like to do is to increase the constant that appears in the output property, in order to rule out spurious counter-examples. More formally, there is a set of spurious inputs S, whose outputs satisfy the property in the abstract network: ∀x ∈ S : (N ′ (x) > c), but not in the original network, where their outputs are smaller: ∀x ∈ S : (N (x) ≤ c). By increasing the constant in the output property, we seek to avoid these spurious examples.
As it turns out, there are cases in which we can increase the output bound, and still obtain an over-approximate query. Consider the query v 2 = N ′ , n 1,1 ∈ [20, 21], n 3,1 > 1486 In v 2 , there are changes (with respect to v 1 ) in both the model N and the output property Q. By applying changes to the model N and generating N ′ , the output increases: for every input x, N (x) ≤ N ′ (x). In other words, there is a minimal (non-negative) difference between the outputs: Given that the input property P := x ∈ [20,21] was not changed, and assuming that we can calculate d, we can increase the output constant by any number in [0, d], and still get an over-approximate query; if the value in the abstract network is smaller than c + d, the output of the original network is bounded from above by (c + d) − d = c (by Eq. 1). Going back to our running example, we need to calculate the minimal difference between the respective outputs of the networks, for any input vector in the range specified by property P . For P = [20,21], it can be shown that the minimal difference is bounded by d ≥ N ′ (20) − N (21) = 1400 − 714 = 686. Consequently, we can increase the constant in the output property from 800 (in v 1 ) to 800 + 686 = 1486 (in v 2 ), and still get an over-approximate query: if ∀x ∈ [20,21] : N ′ (x) ≤ 1486, then (by difference of bounds) ∀x ∈ [20,21] : N (x) ≤ 1486−686 = 800. Making this adjustment rules out the spurious counterexample we saw before, namely N ′ (20) = 1400.
More broadly, the basic idea underlying CEGARETTE is that in order to produce a small but accurate abstraction, the output property (Q) should be tightened as much as possible in parallel to reducing the size of the neural network (N ). Naturally, these two processes are linked, as the network determines the possible output properties.
The example shows how changing N enables tightening Q, but CEGARETTE is not limited to a specific order; it is also possible to first increase the constant of Q and only then change N , as long as the over-approximation property is maintained.
Algorithm 2 shows the general outline of the CEGARETTE framework. First, we generate an initial abstract verification query using queryAbstract. Then a loop starts, where in each iteration we verify the current abstract query. If the answer is UNSAT, we are guaranteed that the original query is also UNSAT (by the over-approximation property), and can stop and return UNSAT. Otherwise, the satisfying assignment x 0 is examined in the original model, and if it is also a satisfying assignment there, we return SAT and x 0 . In the case where x 0 is not a satisfying assignment for N, P, Q , the current abstract query is apparently too coarse and is thus refined using queryRefine -producing a more precise abstract query, for the next iteration. if x0 is a counterexample for N, P, Q then 7: return SAT, x0 8: else 9: N ′′ , P, Q ′′ ← queryRefine( N ′ , P, Q ′ , N, x0) 10: N ′ , P, Q ′ ← N ′′ , P, Q ′′ 11: Goto step 2 12: end if 13: end if The structure of CEGARETTE is similar to that of CEGAR-NN, but instead of invoking the abstract and refine operations as in Algorithm 1, which only abstract and refine the network, CEGARETTE invokes queryAbstract and queryAbstract, which abstract and refine both the network and the output property. Therefore, Algorithm 1 is a private case of Algorithm 2, and CEGARETTE extends CEGAR.

DNN Verification Using CEGARETTE
In this section, we describe CEGARETTE-NN, which is our implementation of CEGARETTE for NNV. Specifically, we propose a particular implementation of the queryAbstract and queryRefine operators, which modify the model and the output property in a way that soundly produces over-approximations of the original query.
Given a verification query N, P, Q , our proposed implementation of queryAbstract is shown as Algorithm 3. It begins by generating N ′ , an abstract neural network, using the same abstract from the CEGAR-NNframework; and then proceeds to tighten the output property, by adding to the output constant a scalar d, which lower-bounds the minimal difference in outputs between N ′ and N . Computing the lower and upper bounds of the abstract and the original networks with respect to a given input range in Algorithm 4 is based on bound propagation methods, which maintain and propagate tractable and sound bounds through neural networks. Bound propagation has been studied extensively, and there are many scalable methods intended for this purpose [27,31,46,47,70,77,78,83,87]. We give a simple example later on. Lemma 1. Algorithm 3 returns an over-approximation of the verification query passed to it as input.
Proof. Algorithm 3 begins by generating N ′ , an abstract network, from N . Then it invokes TightenProperty, described in Algorithm 4, which sets Q ′ := y ′ ≤ c + max(0, l N ′ − u N ), where u N is an upper bound for the output of N and l N ′ is a lower bound for the output of N ′ . We now wish to prove that if N ′ , P, Q ′ is UNSAT, then N, P, Q is also UNSAT. Differently put, we need to show that This is equivalent, modus tollens, to proving that The last implication holds since we know that for every input x, the output increases after abstracting N to N ′ by at least l N ′ − u N ; and we know also that the output cannot decrease. Overall, model abstraction increases x's output by at least max(0, l N ′ − u N ), and hence the implication holds.
⊓ ⊔ Next, queryRefine is implemented in Algorithm 5. First, we refine the previous abstraction of the network (by splitting neurons that had previously been merged), and then computing a new output property, from scratch, with respect to this new network. Proof. N ′′ is an abstract network generated from N . The remainder of the proof is the same as in the proof of Lemma 1.
⊓ ⊔ Now that we have established the soundness of our approach via Lemmas 1 and 2, we proceed to prove that it always terminates. Proof. CEGARETTE-NN implements Algorithm 2, using queryAbstract from Algorithm 3 and queryRefine from Algorithm 5. We show that with these implementations, Algorithm 2 converges.
Since the model N ′ is abstracted and refined first in both queryAbstract and queryRefine, and the output property is then updated accordingly, the convergence of Algorithm 2 is derived from the convergence of Algorithm 1, where only the model is abstracted and refined.
⊓ ⊔ Returning to our running example, given the verification query v 1 above, applying Algorithm 2 triggers Algorithm 3, which generates N ′ from N ; and then, in turn, triggers Algorithm 4, which calculates d, which bounds the minimal difference between N and N ′ . For simplicity, we use a naïve method for calculating the lower and upper bounds of a network, called interval bound propagation, or IBP [31].
In IBP, bounds are propagated forward in the network, starting from the input layer, layer by layer, to the output layer. The method assumes that lower and upper bounds for the input neurons are provided a-priori, and then uses a linear combination of the bounds of neurons from one layer to compute lower and upper bounds for neurons in the following layer. The linear combination is decided according to the weights of the edges that connect the two layers.
As an example, we show how to compute the bounds for neuron n 3,1 in the original network N . The range of the input neuron n 1,1 is [20,21]

Implementation and Evaluation
Implementation. For evaluation purposes, we created a proof-of-concept implementation of CEGARETTE, referred to as CEGARETTE-NN, where the queryAbstract and queryRefine operations are implemented according to Algorithms 3 and 5, respectively. The neuron merging and splitting operations, abstract and refine, were taken from the publicly released code of [24], which implements the methods proposed in [25].
For the lower and upper bound computation performed in Algorithm 4, we implemented the interval bound propagation (IBP) method proposed in [31]; and also used the symbolic bound tightening (SBT) method [77] and the DeepPoly method [70], both of which were already implemented as part of the Marabou engine [44]. Our tool is implemented in Python. All experiments reported below were conducted on x86-64 Gnu/Linux-based machines, using a single Intel(R) Xeon(R) Gold 6130 CPU @ 2.10GHz core.
ACAS-Xu is a set of 45 DNNs intended to operate as an airborne collision avoidance system. Each of these networks receives sensor information regarding the aircraft's trajectory and velocity, as well as those of other aircraft nearby; and produces a horizontal turning advisory, intended to reduce the chance of airborne collision. Each of these networks consists of an input layer with 5 neurons, followed by 6 hidden layers with 50 neurons each, and a final output layer with 5 additional neurons -yielding a total of 310 neurons.
For specifications, we used adversarial robustness queries, which are the defacto standard for DNN verification [10]. Each such query specifies an input point x 0 and a radius δ and states that any point within the δ-ball around x 0 must produce the same classification as x 0 . Here, we used 20 adversarial robustness properties proposed by Elboher et al. [25], each with a 2-hour timeout.
For the second family of benchmarks, we used the MNIST dataset of grayscale images of hand-written digits between 0 and 9. We used 60000 images to train 3 different networks, whose topologies are listed in Table 1. These networks achieved high accuracy rates on 10000 test images, as detailed in the "Accuracy" row in Table 1. For these networks, we again used adversarial robustness queries. Specifically, we selected 30 input points that were sampled uniformly at random. For δ, we used the values δ ∈ {1e −3 , 1e −2 , 2e −2 , 5e −2 , 7e −2 , 9e −2 , 1e −1 }. For each candidate query, i.e. a pair of input point x 0 and a radius δ, we sampled 10000 random inputs in the δ-ball around x 0 , and ensured that they were all correctly classified. If any random sample was misclassified, we discarded the query without verification. (this was done in order to filter out very simple queries, where formal verification is not needed). After this filtering, the total number of queries remaining for each of the networks was 653, 797, and 560. Because these networks were more complex than the ACAS Xu case, we set a timeout value of 3 days for each query. The actual encoding as a Marabou query was performed according to the definition of standard robustness (Definition 2, [17]). Evaluation. Recall that our approach depends on our ability to compute tight lower and upper output bounds as part of Algorithm 4. Multiple methods have been proposed for computing such bounds, with varying degrees of accuracyand with the more accurate ones typically taking longer to run. Thus, in our first experiment, we set out to compare the different bound propagation approaches, namely IBP, SBT, and DeepPoly, and measure their usefulness as part of our framework. Table 2 depicts the results obtained using the three approaches when applied to the ACAS-Xu benchmarks. IBP, which is the most lightweight but also the least precise among the approaches, performed the worst -leading to the highest number of timeouts. This indicates that the bounds it computed were fairly loose, triggering large sequences of spurious examples and refinement steps, eventually leading to the timeouts. DeepPoly, which is the most precise among the three but also the most computationally expensive, achieved better bounds, and consequently fewer timeouts. SBT, which is not as precise as DeepPoly but which is quicker to run, obtained the best results. Thus, we selected SBT as the best configuration for our tool and used it in the remaining experiments. In our second experiment, we out to measure the overall improvement afforded by our approach. Since it has already been established that abstractionrefinement often improves over direct verification [9,24,25,64], and because our approach extends the CEGAR-NN approach of Elboher et al. [25], we used CEGAR-NN as our baseline.
The results of comparing the two tools at all benchmark sets are displayed in Table 3. Most importantly, the results in the Timeouts and Finished columns confirm that CEGARETTE-NN significantly improves over CEGAR-NN in terms of finished experiments: a total of 2674 for CEGARETTE-NN, versus 1618 for CEGAR-NN -a 65% improvement. Because both tools use the same underlying verifier, and apply the same basic abstraction and reinforcement operators, this improvement stems directly from the property abstraction mechanism, and its ability to reduce the number of spurious counter-examples.
The next column, Faster Verification Time, counts the number of instances in which one tool outperformed the other. It shows that CEGARETTE-NN achieves an improvement of 12.85% over CEGAR-NN. Finally, the Fewer Refinement Steps column counts the number of experiments in which the total number of refinement steps was smaller, and shows that CEGARETTE-NN achieves an improvement of 586.25%. We note that all comparison metrics that we used (except Timeouts) consider only those benchmarks that both tools successfully solved.

Related Work
There are two main approaches to validating the robustness of deep neural networks. The first combines methods of dynamic analysis and heuristic search to find violations and test the system (e.g. [16,63,67,75]). The second, which we follow in this work, is that of formal verification, where correctness is established using a rigorous, automated procedure [52].
Several DNN verification techniques have been studied in recent years, based on multiple approaches: SMT-based techniques, such as Marabou [44], Reluplex [42], and others [35,45]; techniques based on mixed integer programming, including Planet [23], MIPVerify [76] and others [14,15,21,22]; symbolic interval propagation techniques [77]; abstract interpretation techniques [27]; and many others (e.g., [6,37,48,55,59,79,81]). Our approach can be used to extend various abstraction and refinement mechanisms, and be integrated with many sound and complete DNN verifiers as backends. Incomplete verification techniques could also be used as part of our approach, potentially improving performance but at the cost of incompleteness; we leave this for future work.
There have been multiple attempts to utilize abstract interpretation [19] to decrease the complexity of DNN verification, and expedite the verification process [27,70,84]. These methods capture the behavior of propagated values in the network using abstract domains such as boxes, zonotopes, or polyhedra. Often, these methods rely on coarse over-approximations, and are incomplete; although various refinement methods, as well as integration with complete verifiers, have been proposed to mitigate this.
Apart from the DNN abstraction technique of Elboher et al. [25] that we leveraged here, other incomplete abstraction techniques have been proposed [9]. These manipulate the neurons and the edges of the network, using semantic similarity; utilize clustering methods in order to merge similar neurons; or merge neurons and compute ranges of weights and biases that the merged neurons can take. Integrating our framework with these additional approaches should be possible, and is left for future work.
A few recent papers proposed to instrument CEGAR-based approaches for DNN verification [25,53]. The network is preprocessed such that, later on, multiple neurons can be merged while causing a strict increase in the output values, hence over-approximating the original network. Refinement is done by splitting past-merged neurons. Both are oblivious to the underlying verification engine as long as it is sound and complete.
The work in [24] uses residual reasoning to optimize CEGAR-based approaches, given that the backend applies case splitting. Another independent optimization for the CEGAR-based approach for neural network verification was recently proposed in [88], where testing methods are embedded during the formal verification process in order to quickly expose violations using adversarial attacks.
As far as we know, our work is the first formal verification scheme which extends the basic mechanism of CEGAR [18] by applying abstraction and refinement not only to the checked system but also to the (output) property. Therefore, it should be compatible with any of the aforementioned techniques.

Conclusion
Neural networks are gaining momentum in many areas, but using them entails various risks. Neural network verification tools seek to help overcome this issue, but are computationally expensive -and afford only limited scalability. Abstraction-based approaches hold great potential for expediting the verification process and allowing verifiers to scale to much larger networks. Here, we took a step in this direction, by applying abstraction and refinement not only to neural networks themselves but also to the properties being checked as part of the verification query. We demonstrated that our method dramatically improves performance, by reducing the number of spurious counter-examples encountered. The result is a significant boost to the scalability of existing verification technology.
Moving forward, we plan to pursue several research directions. First, we plan to explore additional techniques for property tightening given an abstract neural network. Second, we intend to develop novel abstraction and refinement heuristics, which are optimized for CEGARETTE-NN -i.e., which will allow better property tightening. Third, we plan to integrate our method with additional, recently-proposed CEGAR-based approaches [9,64].