Year: 2021

Abstract:
We introduce the concept of provably robust adversarial examples – connected input regions constructed from standard adversarial examples which are guaranteed to be provably robust to a set of perturbations (such as changes in pixel intensity and geometric transformations). We present a novel method for generating these regions in a scalable manner which works by iteratively refining the region initially obtained via sampling until certification with state-of-the-art methods is achieved. At each step, a novel optimization procedure is applied to maximize the region’s volume under the constraint that the resulting convex relaxation implies a chosen bound on the certification objective. Our experimental evaluation shows the effectiveness of the method: it successfully finds large provably robust regions including ones containing ≈ 10 adversarial examples for pixel intensity and ≈ 10 for geometric transformations. We verify empirically that our robust adversarial examples are significantly more effective against state-of-the-art defenses based on randomized smoothing than the individual attacks used to construct the regions.

heading: 1 INTRODUCTION
text: Deep neural networks (DNNs) are vulnerable to adversarial attacks: small input perturbations that cause misclassification (Szegedy et al., 2013). This has caused an increased interest in investigating powerful attacks (Goodfellow et al., 2015; Carlini & Wagner, 2017; Madry et al., 2018; Andriushchenko et al., 2019; Zheng et al., 2019; Wang et al., 2019; Croce & Hein, 2019; Tramèr et al., 2020). An important limitation of existing attack methods is that they only produce a single concrete adversarial example and their effect can often be mitigated with existing defenses (Madry et al., 2018; Hu et al., 2019; Sen et al., 2020; Xiao et al., 2020; Pang et al., 2020; Lécuyer et al., 2019; Cohen et al., 2019; Salman et al., 2019; Fischer et al., 2020; Li et al., 2020). The effectiveness of these attacks can be improved by robustifying them: to consolidate the individual examples to produce a large symbolic region guaranteed to only contain adversarial examples.
This Work: Provably Robust Adversarial Examples We present the concept of a provably robust adversarial example – a tuple consisting of an adversarial input point and an input region around it capturing a very large set (e.g., > 10100) of points guaranteed to be adversarial. We then introduce a novel algorithm for generating such regions and apply it to the setting of pixel intensity changes and geometric transformations. Our work relates to prior approaches on generating robust adversarial examples (Athalye et al., 2018; Qin et al., 2019) but differs in a crucial point: our regions are guaranteed to be adversarial while prior approaches are empirical and offer no such guarantees.
Main Contributions Our key contributions are:
• The concept of a provably robust adversarial example – a connected input region capturing a very large set of points, generated by a set of perturbations, guaranteed to be adversarial.
• A novel scalable method for synthesizing provably robust adversarial examples, based on iterative refinement and certification techniques.
• A thorough evaluation of our method demonstrating it can generate provable regions containing ≈ 10573 concrete adversarial points for pixel intensity changes, in ≈ 2 minutes, and ≈ 10599 concrete points for geometric transformations, in ≈ 20 minutes, on a challenging CIFAR10 network. We also demonstrate that our robust adversarial examples are significantly more effective against state-of-the-art defenses based on randomized smoothing than the individual attacks used to construct the regions.

heading: 2 BACKGROUND
text: We now discuss the background necessary for the remainder of the paper. We consider a neural network f : Rn0 → Rnl with l layers, n0 input neurons and nl output classes. The network classifies an input x to class y(x) with the largest corresponding output value, i.e., y(x) = argmaxi[f(x)]i. Note for brevity we will omit the argument to y when it is clear from the context.

heading: 2.1 NEURAL NETWORK CERTIFICATION
text: In this work, we rely on state-of-the-art neural network certification methods based on convex relaxations to prove that the adversarial examples produced by our algorithm are robust. These certification methods take a convex input region I ⊂ Rn0 and prove that every point in I is classified as target label yt by f . They propagate the set I through the layers of the network, producing a convex region that covers all possible values of output neurons (Gehr et al., 2018). Robustness follows by proving that, for all combinations of output neuron values in this region, the output neuron corresponding to class yt has a larger value than the one corresponding to any other class y 6= yt. Commonly, one proves this property by computing a function Ly : Rn0 → R for each label y 6= yt, such that, for all x ∈ I, we have Ly(x) ≤ [f(x)]yt − [f(x)]y. For each Ly, one computes minx∈I Ly(x) to obtain a global lower bound that is true for all x ∈ I. If we obtain positive bounds for all y 6= yt, robustness is proven. To simplify notation, we will say that the certification objective L(x) is the function Ly(x) with the smallest minimum value on I. We will call its corresponding minimum value the certification error. We requireLy(x) to be a linear function of x. This requirement is consistent with many popular certification algorithms based on convex relaxation, such as CROWN (Zhang et al., 2018), DeepZ (Singh et al., 2018a), and DeepPoly (Singh et al., 2019). Without loss of generality, for the rest of this paper, we will treat DeepPoly as our preferred certification method.

heading: 2.2 GEOMETRIC CERTIFICATION
text: DeepPoly operates over specifications based on linear constraints over input pixels for verification. These constraints are straightforward to provide for simple pixel intensity transformations such as adversarial patches (Chiang et al., 2020) and L∞ (Carlini & Wagner, 2017) perturbations that provide a closed-form formula for the input region. However, the geometric transformations do not yield such linear regions. To prove the robustness of our generated examples to geometric transformations, we rely on DeepG (Balunović et al., 2019) which, given a range of geometric transformation parameters, creates an overapproximation of the set of input images generated by geometric perturbations. DeepG then levarages DeepPoly to certify the input image region. When generating our geometric robust examples, we work directly in the geometric parameter space and, thus, our input region I and the inputs to our certification objective L(x) are also in geometric space. Despite this change, as our approach is agnostic to the choice of the verifier, in the remainder of the paper we will assume the certification is done using DeepPoly and not DeepG, unless otherwise stated.

heading: 2.3 RANDOMIZED SMOOTHING
text: Randomized smoothing (Lécuyer et al., 2019; Cohen et al., 2019) is a provable defense mechanism against adversarial attacks. For a chosen standard deviation σ and neural network f as defined above, randomized smoothing computes a smoothed classifier g based on f , such that g(x) = argmax
c P(y(x+ ) = c) with random Gaussian noise ∼ N (0, σ2I). This construction of g allows Cohen et al. (2019) to introduce the procedure CERTIFY that provides probabilistic guarantees on the robustness of g around a point x: Proposition 1. (From Cohen et al. (2019)) With probability at least 1− α over the randomness in CERTIFY, if CERTIFY returns a class y and a radius R (i.e does not abstain), then g predicts y within radius R around x : g(x+ δ) = y, for all ‖δ‖2 < R.
We define adversarial attacks on smoothed classifiers as follows: Definition 1 (Adversarial attack on smoothed classifiers). For a fixed σ, α and an adversarial distance R′ ∈ R>0, we call x̃ ∈ Rn0 an adversarial attack on the smoothed classifier g at the point x ∈ Rn0 , if ‖x̃− x‖2 < R′ and g(x) 6= g(x̃).
Similarly to generating adversarial attacks on the network f , we need to balance the adversarial distance R′ on g. If too big — the problem becomes trivial; if too small — no attacks exist. We outline the exact procedure we use to heuristically select R′ in Appendix A.6. Using the above definition, we define the strength of an attack x̃ as follows: Definition 2 (Strength of adversarial attack on smoothed classifiers). We measure the strength of an attack x̃ in terms of Radv– the radius around x̃, whose L2 ball is certified to be the same adversarial class as x̃ on the smoothed network g using CERTIFY for a chosen σ and α.
Intuitively, this definition states that for points x̃ for which Radv is bigger, the smoothed classifier is less confident about predicting the correct class, since more adversarial examples are sampled in this region and therefore, the attack on g is stronger. We use this measure in Section 5 to compare the effectiveness of our adversarial examples to examples obtained by PGD on g.

heading: 3 OVERVIEW
text: Existing methods for generating robust adversarial examples focus on achieving empirical robustness (Qin et al., 2019; Athalye et al., 2018). In contrast, we consider provably robust adversarial examples, defined below: Definition 3 (Provably Robust Adversarial Example). We define provably robust adversarial example to be any large connected neural network input region, defined by a set of perturbations of an image, that can be formally proven to only contain adversarial examples.
In this section, we outline how we generate such regions. The technical details are given in Section 4.
To generate a provably robust adversarial example, ideally, we would like to directly maximize the input region’s size, under the constraint that it only contains adversarial examples. This leads to multiple challenges: Small changes of the parametrization of the input region (e.g., as a hyperbox) can lead to large changes of the certification objective, necessitating a small learning rate for optimization algorithms based on gradient descent. At the same time, the optimizer would have to solve a full forward verification problem in each optimization step, which is slow and impractical. Additionally, according to Balunovic & Vechev (2020), bad initialization of the robust region might further cause convergence to local minima, resulting in small robust regions. We now provide an overview of how we generate robust adversarial regions while alleviating these problems.
Our method for generating robust examples in the shape of a hyperbox is shown in Figure 1 and assumes an algorithm A that generates adversarial examples and a neural network verifier V. We require V to provide the certification objective L(x) as a linear function of the network’s input neurons (whose values can be drawn from the input hyperbox), as described in Section 2. We split our algorithm into two steps, described in Section 3.1 and Section 3.2, to address the challenges outlined above. An optional final step, illustrated in Figure 2 and outlined in Appendix D, demonstrates the extension of our algorithm to generate polyhedral examples.

heading: 3.1 COMPUTING AN OVERAPPROXIMATING REGION
text: In the first step, we compute an overapproximation hyperbox O by fitting a hyperbox around samples obtained fromA. O is represented as a dashed blue rectangle in Figure 1. Intuitively, we use O to restrict the search space for adversarial regions to a part of the input space thatA can attack.

heading: 3.2 COMPUTING AN UNDERAPPROXIMATING REGION
text: In the second step, we compute the hyperbox robust adversarial example U , represented as a dotted violet rectangle in Figure 1. We will refer to U as underapproximation hyperbox to distinguish it from the polyhedral robust example P generated in Appendix D. U is obtained by iteratively shrinking O until arriving at a provably adversarial region. We denote the hyperbox created at iteration i of the shrinking process with Ui, where U0 = O. At each iteration i, we compute the certification objective Li−1(x) of the region Ui−1 computed in the previous iteration. If the objective is proven to be positive, we assign U to Ui−1, as in Step 4 in Figure 1, and return. Otherwise, we solve an optimization problem, seeking the largest hyperbox Ui ⊆ Ui−1 under the constraint that minx∈Ui L
i−1(x) ≥ −pi−1, for a chosen bound pi−1 ≥ 0. We describe the optimization problem involved in the shrinking procedure in the next paragraph. In Section 4, we will present and motivate our choice of pi−1.
An important property of our choice of pi−1 is that it becomes smaller over time and thus forces the certification objective to increase over time until it becomes positive. We note that optimizing L(x) this way is simpler than directly optimizing for U by differentiating through the convex relaxation of the network. In particular, our method does not require propagating a gradient through the convex relaxation of the network and the convex relaxation is updated only once per iteration. Additionally, it allows our algorithm to work with convex relaxation procedures that are not differentiable, such as the DeepG method employed in this paper. The resulting hyperbox U is a provable adversarial region.
Shrinking Ui−1 There are multiple ways to shrink Ui−1 so that the condition minx∈Ui Li−1(x) ≥ −pi−1 is satisfied. However, we aim to obtain the largest possible underapproximation box U , so we make the greedy choice to shrink Ui−1 in a way that results in the largest possible new box Ui. This may not be the globally optimal choice across all iterations of the algorithm, which is harder to compute, but our choice is locally optimal.
One possible solution to the shrinking problem is to use a scheme that we call uniform shrinking, where all lower bounds [li−1]j and upper bounds [ui−1]j in each dimension j of the hyperbox Ui−1 are changed by the same amount. The optimal amount for this uniform shrinking scheme can then be selected using a binary search. While this gives an efficient shrinking algorithm, in practice we observe that uniform shrinking produces small regions. This is expected, as it may force all dimensions of the hyperbox to be shrunk by a large amount even though it might be enough to shrink only along some subset of the dimensions.
In contrast, our shrinking scheme adjusts each [li−1]j and [ui−1]j individually. While this shrinking scheme is more powerful, optimizing the size of Ui with respect to its lower and upper bounds [li]j and [ui]j becomes more complex. We approach the problem differently in the high dimensional input setting related to L∞ pixel intensity changes and the low dimensional input setting related to geometric changes.
Shrinking for L∞ Transformations For the high-dimensional setting of L∞ pixel transformations, we choose to maximize ∑n0 j=1[w
i]j , where [wi]j = [ui]j−[li]j denotes the width of the jth dimension of Ui. The linear objective allows for solutions where a small number of dimensions are shrunk to 0 width in favour of allowing most input dimensions to retain a big width. As a result, in our computed region Ui there are few pixels that can only take a single value while most other pixles can take a big range of values. Since, ∑n0 i=j [w
i]j is a linear function of [li−1]j and [ui−1]j , the optimization can be posed as a Linear Program (LP) (Schrijver, 1998) and be efficiently solved with an LP solver to obtain optimal values for [ui]j and [li]j w.r.t the objective, as we show in Appendix A.3.
Shrinking for Geometric Transformations For the low-dimensional setting of geometric transformations, we maximize the logarithm of the volume of Ui. This objective encourages roughly equally-sized ranges for the dimensions of Ui. We solve the optimization problem using PGD, which
can lead to merely locally-optimal solutions for the volume of Ui. We, therefore, rely on multiple initializations of PGD and choose the best result. Appendix A.4 describes the process in detail.

heading: 3.3 PROVABLY ROBUST POLYHEDRAL ADVERSARIAL EXAMPLES
text: We remark that our provably robust adversarial examples are not restricted to hyperbox shapes. Appendix A describes an optional final step of our algorithm that generates provably robust polyhedral adversarial examples P from U and O. P is iteratively cut from O, such that P ⊇ U is ensured. Therefore, P represents a bigger region, but takes additional time to compute. The computation of P , requires a V that accumulates imprecision only at activation functions, such as ReLU or sigmoid, in order to work. This property is violated by DeepG’s handling of the geometric transformations. For this reason, we only apply it in the L∞-transformation setting. We refer interested readers to Appendix A for information on how we generate polyhedral adversarial examples.

heading: 4 OUR FRAMEWORK
text: We now present our algorithm in more formal terms. We already discussed in detail how to compute O in Section 3. We use Algorithm 1 to compute U . It requires a neural network f : Rn0 → Rnl with l layers, adversarial target class yt, an overapproximation hyperbox O, a speed/precision trade-off parameter c ∈ [0, 1], a maximum number of iterations uit and a neural network certification method V(f,Ui−1, yt) that takes a neural network f , a hyperbox Ui−1 and a target yt and returns a linear certification objective Li−1(x).
Algorithm 1 GENERATE_UNDERAPPROX 1: func GENERATE_UNDERAPPROX( f, O,V, yt, c, uit ) 2: U0 = O 3: for i ∈ {1, 2, . . . , uit} do 4: Li−1(x), ei−1 =V( f,Ui−1, yt ) 5: if ei−1 ≥ 0 then 6: return Ui−1 7: end if 8: pi−1 = −ei−1 · c 9: if L∞_transformation then 10: Ui = Shrink_LP(Ui−1, Li−1(x), pi−1 ) 11: else 12: Ui = Shrink_PGD(Ui−1, Li−1(x), pi−1 ) 13: end if 14: end for 15: return FailedToConverge 16: end func
As described in Section 3.2, the algorithm generates a sequence of hyperboxes U0 ⊇ U1 ⊇ . . . ⊇ Uuit with U0 = O and returns the first hyperbox from the sequence proven to be adversarial by V. At each iteration, the algorithm attempts to certify the hyperbox from the previous iteration Ui−1 to be adversarial by computing the certification error ei−1 (Line 4) and checking if it is positive (Line 5). If successful, Ui−1 is returned. Otherwise, we use Li−1(x) generated by our attempt at verifying Ui−1 (Line 4) and generate the constraint minx∈Ui L
i−1(x) ≥ −pi−1 based on a parameter pi−1 ≥ 0. We
note that minx∈Ui L i−1(x) is a function of the hyperbox Ui, parametrized by its lower and upper bounds. In order to shrink Ui−1, we optimize the lower and upper bounds of Ui explicitly, such that the constraint holds true for the bounds. The next section specifies and motivates our choice of pi−1.
Next we discuss how we choose pi−1. At each iteration i, we use the constraint minx∈Ui L i−1(x) ≥ −pi−1 to shrink Ui−1 (Line 9 – Line 13) by calling either the SHRINK_LP or SHRINK_PGD optimization procedures. SHRINK_LP and SHRINK_PGD are detailed in Appendix A.3 and Appendix A.4, respectively. To enforce progress of the algorithm, we require the constraint to remove non-zero volume from Ui−1. Therefore, the values of pi−1 for which pi−1 ≥ pmaxi−1 , with pmaxi−1 = −minx∈Ui−1 Li−1(x) = −ei−1 are invalid because: minx∈Ui Li−1(x) ≥ minx∈Ui−1 Li−1(x) ≥ −pi−1. We show the hyperplane Li−1(x) = −pmaxi−1 denoted as Upper in Step 3 in Figure 1. We note that Upper always touches Ui−1 by construction. Decreasing the value of pi−1, increases the volume removed from Ui−1, as demonstrated by the other two hyperplanes in Step 3 in Figure 1. Additionally, we require pi−1 ≥ 0 as any value of pi−1 = 0 creates Ui that is provably adversarial. Choosing a negative value for pi−1 generates smaller provably adversarial Ui than with pi−1 = 0. We denote the hyperplane corresponding to pi−1 = 0 in Step 3 in Figure 1 denoted Provable. We use pi−1 ∈ [0, pmaxi−1 ).

heading: DATASET MODEL #CORR #IMG #REG #VERREG TIME SIZE #VERREG TIME SIZE #VERREG TIME SIZEO
text: We note that while pi−1 = 0 is guaranteed to generate a provable region Ui, it is often too greedy. This is due to the fact that with an impreciseV, Li−1(x) itself is also imprecise and, therefore a more precise certification method may certify Ui as adversarial for pi−1 > 0. Further, as the region Ui−1 shrinks, the precision of V increases and vice versa. Thus V might be capable of certifying Ui, for pi−1 > 0, since on the next iteration of the algorithm the more precise certification objective Li(x) will be used for certifying the robustness of the smaller Ui. We choose pi−1 heuristically, by setting pi−1 = p max i−1 · c, for a chosen parameter c ∈ [0, 1). This is depicted in Line 8 in Algorithm 1. The closer c is to 1, the bigger the chance that the modified region will not verify, but, also, the bigger the region we produce and vice versa. Thus, c balances the precision and the speed of convergence of the algorithm. We empirically verify the effect of c in Appendix B.1. The hyperplane resulting from c = 0.65 is denoted as Chosen in Step 3 in Figure 1. We further note that, when the upper and provable hyperplanes, at a particular iteration get closer than a threshold t we set pi−1 = 0 to allow for immediate termination of the algorithm. This speeds up the convergence of the algorithm in the final stages, when the precision loss of V is not too big.

heading: 5 EXPERIMENTAL EVALUATION
text: We now evaluate the effectiveness of our approach on realistic networks. We implemented our framework in Python and used Tensorflow (Abadi et al., 2015) for generating PGD attacks. We use Gurobi 9.0 (Gurobi Optimization, LLC, 2020) for solving LP instances. We rely on ERAN (Singh et al., 2018b) for its DeepPoly and DeepG implementations. We ran all our experiments on a 2.8 GHz 16 core Intel(R) Xeon(R) Gold 6242 with 64 GB RAM.
Neural Networks We use MNIST (LeCun et al., 1998) and CIFAR10 (Krizhevsky, 2009) based networks. Table 4 in Appendix A.1 shows the sizes and types of different neural networks. All networks in our L∞ experiments except the CIFAR10 ConvBig are not adversarially trained. In our experiments, normally trained networks were more sensitive to geometric perturbations than L∞. Therefore, we use DiffAI-trained (Mirman et al., 2018) networks which tend to be less sensitive against geometric transformations. Our deepest network is the MNIST 8 × 200 fully-connected network (FFN) which has 8 layers with 200 neurons each and another layer with 10 neurons. Our largest network is the CIFAR10 ConvBig network with 6 layers and ≈ 62K neurons. This network is among the largest benchmarks that existing verifiers can handle in a scalable and precise manner. We compare the methods on the first 100 test images of the datasets, a standard practice in the verification literature (Balunović et al., 2019; Singh et al., 2019), while filtering the wrongly-classified ones. For each experiment, we tuned the value of c to balance runtime and size.

heading: 5.1 ADVERSARIAL EXAMPLES ROBUST TO INTENSITY CHANGES
text: Table 1 summarizes our results on generating examples robust to intensity changes, whose precise definition is in Appendix A.2. Further, Appendix E.2 shows images of examples obtained in the experiment. We compare the uniform shrinking described in Section 3, used as a baseline, against our method for generating robust hyperbox and polyhedral adversarial examples. In all experiments, we compute O using examples collected within an L∞ ball around a test image with the radius specified in Table 1. The values of are chosen such that the attack has a non-trivial probability (> 0 but < 1) of success. We use 2500 adversarial examples each from the Frank-Wolfe optimization algorithm (Frank & Wolfe, 1956), PGD with step 0.1 and 0.01 , respectively. For the PGD examples,
we use output diversification (Tashiro et al., 2020) with 5 iterations. In all experiments, we initialize c = 0.99 and multiply it by a factor of 0.99 at each iteration of Algorithm 1.
For the hyperbox adversarial examples obtained by both our method and the baseline, we calculate the size of the example in terms of the number of concrete adversarial examples it contains and we report the median of all regions under the Size columns in Table 1. For the polyhedral adversarial examples, we report the median number of concrete adversarial examples contained within an overapproximated hyperbox around the polyhedral region in the SizeO column. We note that an underapproximation of the number of concrete adversarial examples in the polyhedral region is the same as those in the hyperbox adversarial examples obtained by our method. We also report the average runtime of all algorithms on the attackable regions.
We note that for MNIST ConvBig and 8×200, the regions obtained forO produced huge certification error > 1000, which prevented our underapproximation algorithm U to converge on these networks. To alleviate the problem, we used uniform shrinking to lower the error to under 100. We then used the obtained box in place of O. We conjecture the reason for this issue is the huge amount of imprecision accumulated in the networks due to their depth and width and note that the uniform shrinking on these networks alone performs worse. For each network, in Table 1, we report the number of distinct pairs of an image and an adversarial target on which A succeeds (column #Reg), as well as the number of unique images on which A succeeds (column #Img). We note that #Reg > #Img. We further report the number of test images that are correctly classified by the networks (column #Corr). The table details the number of regions on which the different methods succeed (column #VerReg), that is, they find a robust adversarial example containing > 1000 concrete adversarial examples. As can be seen in Table 1, our framework creates symbolic regions that consistently contain more concrete adversarial examples (up to 10573 images on CIFAR10 ConvBig) than the baseline while being faster. Our method also succeeds more often, failing only for a single region due to the corresponding hyperbox O also containing < 1000 concrete examples versus 53 failures for the baseline. Overall, our method, unlike the baselines, generates robust examples containing large number of examples in almost all cases in which the image is attackable, in a few minutes.

heading: 5.2 ADVERSARIAL EXAMPLES ROBUST TO GEOMETRIC CHANGES
text: Next, we demonstrate the results of our algorithm for generating examples robust to geometric transformations, whose precise definition is in Appendix A.2. Our method here relies on DeepG for robustness certification, as mentioned in Section 2. To increase its precision, DeepG selectively employs input space splitting, where each split is verified individually. This strategy is effective due to the low dimensionality of the input space (3 to 4 geometric parameters in our experiments). To this end, we choose to split our method’s initial region O, instead, where all splits are individually shrunken and their sizes are summed. We compare our method against a baseline based on a more aggressive uniform splitting of O that does not use our shrinking procedure. Since the cost and precision of verification increase with splits, to allow for fair comparison we select the number of baseline splits, so the time taken by the baseline is similar or more than for our method.
Table 2 summarizes the results of our method and the baseline for the MNIST and CIFAR10 datasets. Further, Appendix E.3 shows visualizations of the adversarial examples obtained in the experiment.
The Transform column in the table represents the set of common geometric transformations on the images. Here, R(x) signifies a rotation of up to ±x degrees; Sc(x), scaling of up to ±x%; Sh(m), shearing with a factor up to ±m%; B(γ, β), changes in contrast between ±γ% and brightness between ±β%; and T (xl, xr, yd, yu), translation of up to xl pixels left, xr pixels right, yd pixels down and yu pixels up. The selected combinations of transformations contain ≤ 4 parameters, as is standard for assessing adversarial robustness against geometrical perturbations (Balunović et al., 2019). Unlike DeepG, we chose only combinations of ≥ 3 parameters, as they are more challenging. The chosen combinations ensure all transformations from DeepG are present. Similar to L∞, we chose the parameter bounds such that the attack algorithm has a non-trivial probability of success.
In all experiments, we compute O using random sampling attacks which are the state-of-the-art for geometric transformations (Engstrom et al., 2019). For the 3 dimensional experiments, we rely on 15000 random samples, while for the 4D configurations we use 50000. For all experiments, we use c = 0.65, except for the 4 dimensional CIFAR10 experiment, where we use c = 0.75. We rely on the polyhedra created by DeepG that binds the values of the image pixels to estimate the number of concrete adversarial examples contained within our robust examples. In particular, underapproximation and overapproximation hyperboxes are computed for each image, where the underapproximation hyperbox is based on (Gopinath et al., 2019) and the overapproximation relies on computing the extreme values of each pixel. The median number of concrete examples are depicted in the Over and Under columns in Table 2. For all experiments, the baseline failed to generate regions with > 1000 examples on most images and, thus, we omit its computed size in Table 2 to save space. We note that on the few images where it does not, the size generated by our method is always more.
We report the number of concrete examples, the number of splits, the average runtime on attackable regions, and the number of successfully verified regions for both the baseline and our method in the #Splits, Time, and #VerReg columns. Table 2 demonstrates that in a similar or smaller amount of time, our algorithm is capable of generating robust adversarial examples for most regions O, while the baseline fails for most. Further, our regions are non-trivial as they contain more than 1064 concrete adversarial attacks. We note that the runtimes for generating robust examples in this setting is higher than in Table 1. This is due to both the inefficiency of the attack and the time required for the robustness certification of a single region. Due to the flexibility and the generality of our method, we believe it can be easily adapted to more efficient attack and certification methods in the future.

heading: 5.3 COMPARISON WITH LIU ET AL. (2019)
text: In this section, we extend the method proposed in Liu et al. (2019) to generate provably robust hyperbox regions against pixel intensity changes and compare the resulting algorithm to our method. As the code provided in Liu et al. (2019) only applies to fully connected networks, we applied both their approach and our method on a new 8x200 MNIST fully connected network with the same architecture as the one used in Table 1. To facilitate simpler comparison, the network was trained using the code provided in Liu et al. (2019). We initialized both methods with the same overapproximation hyperbox O and compare the shrinking phase. With similar runtime (≈ 200s), out of 84 possible regions, our method and Liu et al. (2019) created 84 and 76 regions with median underapproximation volume of 10184 and 1046, respectively. We point out that our method is capable of creating polyhedral regions and handle the geometric perturbations, while Liu et al. (2019) cannot.

heading: 5.4 ROBUSTNESS OF ADVERSARIAL EXAMPLES TO RANDOMIZED SMOOTHING
text: Next, we show that our adversarial examples robust to intensity changes are significantly more effective against state-of-the-art defenses based on randomized smoothing compared to the concrete attacks byA generated for our examples, as well as the baseline from Table 1. We note that our setting
is different than Salman et al. (2019) which directly attacks the smoothed classifier. Instead, we create examples with our method on the original network f with A, based on the L2 PGD attack and evaluate them on g. For all methods, we calculate the quantity Radv for g, introduced in Definition 2, that measures the adversarial attack strength on g. For our method and the baseline we select x̃ in Definition 2 as the middle point of the underapproximation box projected back to the L2 ball, with center x and radius the adversarial distance R′. For the concrete attacks, x̃ is simply the attack itself. We exclude images whose adversarial distance R′ is more than 33% bigger than the certified radius R of x, as we consider them robust attacks. We experiment with networks f with the same architectures as in Table 1. We supply additional details on the experimental setup in Appendix A.6.
In Table 3, we show the ratio between the adversarial strengths Radv of all other methods and our method averaged across the first 100 test images. The last two rows in Table 3 depict the mean and the 95% percentile of the strength ratio across the attacks generated by A. We note the smaller the ratio in Table 3 is, the weaker the attacker is with respect to our method. We observe that our examples produce attacks on the smoothed classifier g with average strength ranging from 2× to 6× bigger compared to the alternatives. We conjecture, this is caused by our examples being chosen such that the regions around them have comparatively higher concrete example density. We note the baseline also largely performs better than the mean individual attack, further supporting our claim.

heading: 5.5 COMPARISON WITH EMPIRICALLY ROBUST EXAMPLES
text: We compare our provably robust adversarial examples to empirically robust adversarial examples (Athalye et al., 2018) – large input regions, defined by a set of perturbations of an image, that are empirically verified to be adversarial. The empirical verification is based on calculating the expectation over transformations (EoT) of the obtained region defined in Athalye et al. (2018). We consider a region to be an empirically robust adversarial example if it has an EoT ≥ 90%. We demonstrate that EoT is a limited measure, as it is not uniform. That is, empirically robust adversarial examples can exhibit high EoT - e.g 95%, while specially chosen subregions incur very low EoT scores. In Appendix A.5, we discuss our extension to Athalye et al. (2018) used in this experiment.
We execute the experiment on the first MNIST ConvBig transformation in Table 2. We note that the algorithm from Athalye et al. (2018) relies on sampling and does not scale to high dimensional L∞ perturbations. The algorithm produces 24 different regions, significantly less than our 44 provable regions. The 24 empirically robust adversarial examples produced achieve average EoT of 95.5%. To demonstrate the non-uniformness of the empirical robustness, for each region, we considered a subregion of the example, with dimensions of size 10% of the original example, placed at the corner of the example closest to the original image. We calculated the EoT of these subregions and found that 14/24 regions had an EoT of < 50%, with 9 having an EoT of 0%.
This demonstrates that the fundamental assumption that the EoT of a region is roughly uniform throughout does not hold and instead it is possible and even common in practice that a significant part of an empirically robust example is much less robust than the remaining region. Further, this often happens close to the original input image, thus providing the misleading impression that an empirically robust adversarial example is a much stronger adversarial attack than it actually is. This misleading behaviour suggests that provably robust adversarial examples, which cannot exhibit such behaviour by construction, provide a more reliable method of constructing adversarial examples invariant to intensity changes and geometric transformations. We note that a limiting factor to the practical adoption of our method remains scalability to real world networks and datasets such as ImageNet, due to the reliance on certification techniques that do not scale there yet. We note that our method is general and efficient enough to directly benefit from any future advancement in verification.

heading: 6 CONCLUSION
text: We introduced the concept of provably robust adversarial examples – large input regions guaranteed to be adversarial to a set of perturbations. We presented a scalable method for synthesizing such examples, generic enough to handle multiple perturbations types including pixel intensity changes and geometric transformations. We demonstrated the effectiveness of our method by showing it creates more and larger regions than baselines, in similar or less time, including regions containing ≈ 10573 adversarial examples for pixel intensity and ≈ 10599 for geometric transformations.

heading: A.1 NETWORKS
text: Table 4 shows the architectures of the networks on which we evaluate.

heading: A.2 ADVERSARIAL EXAMPLE DEFINITIONS
text: In this section, we provide precise definitions of our adversarial examples robust to pixel intensity changes and geometric changes, used in Table 1 and Table 2.

heading: A.2.1 ADVERSARIAL EXAMPLES ROBUST TO L∞ PIXEL INTENSITY CHANGES
text: Definition 4. For an image x ∈ Rn0 , a neural network f , adversarial budget ∈ R, and adversarial class yt 6= f(x), a convex region I ⊆ Rn0 is called an adversarial example around x robust to pixel intensity changes, iff for all points x̄ ∈ I it is satisfied that ‖x̄− x‖∞ ≤ and yt = f(x̄).

heading: A.2.2 ADVERSARIAL EXAMPLES ROBUST TO GEOMETRIC CHANGES
text: Definition 5. Let T : Rn0 × Rt → Rn0 be a geometric perturbation that takes an image x ∈ Rn0 and a vector p ∈ Rt of geometric parameters, bounded within the hyperbox [pl, pu], given by the lower and upper bound vectors pl, pu ∈ Rt, and produces geometrically transformed version of the image, denoted x̄, that should be classified the same as x. For an image x ∈ Rn0 , a neural network f , and adversarial class yt 6= f(x), a convex region I ⊆ Rt is called an adversarial example around x robust to the geometric perturbation T , iff for all points p̄ ∈ I it is satisfied that p̄ ∈ [pl, pu] and yt = f(T (x, p̄)).
We note that this definition allows for T to be a complex composition of simple geometric transformations such as rotations and translations, as it is the case in Table 2. In this case, p is a vector of the parameters of all transformations. We further note that while Definition 5 defines I in terms of the geometric parameters p, one can also look at I , as the region in image space obtained by propagating all possible p̄ through T . DeepG Balunović et al. (2019) overapproximates the later region in image space with a polyhedra to produce the polyhedral region Ī in image space. In Table 2, we report the underapproximation and overapproximation sizes of Ī in terms of number of concrete images it contains.

heading: A.3 DETAILED DESCRIPTION OF SHRINK_LP
text: In this section we describe in detail the function SHRINK_LP, used to shrink Ui−1 to Ui when generating examples robust to pixel intensity changes, based on the parameters Li−1(x) and pi−1. SHRINK_LP defines two sets of LP variables for the lower bounds li ∈ Rn0 and the upper bounds ui ∈ Rn0 of Ui. As described in Section 3.2, the LP optimizes the sum of widths of the dimensions of Ui, i.e., ∑n0 j=1([u
i]j − [li]j). Recall that Li−1(x) is a linear function of x represented as Li−1(x) = a · x+ b. As described in Section 3.2, the LP we define needs to enforce minx∈Ui Li−1(x) ≥ −pi−1. We rewrite minx∈Ui L i−1(x) as:
hp( li, ui ) = max(0, a) · li + min(0, a) · ui + b.
Algorithm 2 PGD_PROJECT 1: func PGD_PROJECT( li, ui, li−1, ui−1, hp, a, b, pi−1 ) 2: li = Clip( li, li−1, ui−1 ) 3: ui = Clip(ui, li, ui−1 ) 4: val = hp( li, ui )− b 5: if val ≥ −pi−1 then 6: return li, ui 7: end if 8: [li]a>0 = − [l i]a>0·(pi−1−b) val
9: [ui]a<0 = − [u i]a<0·(pi−1−b)
val 10: li = Clip( li, li−1, ui−1 ) 11: ui = Clip(ui, li, ui−1 ) RETURN li, ui 12: end func
Since hp(li, ui) is a linear function of li and ui, we add the constraint hp(li, ui) ≥ −pi−1 to the LP:
l i , ui = argmax ∑n0 j=1([u
i]j − [li]j) s.t. hp(li, ui) ≥ −pi−1, [li−1]j ≤ [li]j ≤ [ui]j ≤ [ui−1]j for all j.
where li−1, ui−1 ∈ Rn0 represent the lower and upper bounds of Ui−1, the second constraint enforces Ui ⊆ Ui−1 and l i , ui ∈ Rn0 denotes the LP solution. Finally, SHRINK_LP constructs Ui = [l i , ui].

heading: A.4 DETAILED DESCRIPTION OF SHRINK_PGD
text: In this section we describe in detail the function SHRINK_PGD, used to shrink Ui−1 to Ui for generating regions robust to geometric transformations, based on the parameters Li−1(x) and pi−1.
SHRINK_PGD relies on PGD to optimize the log volume of Ui with respect to its lower and upper bounds, as described in §sec:under. The optimization problem can be written as:
l i , ui = argmax ∑n0 j=1 log([u
i]j − [li]j) s.t. hp(li, ui) ≥ −pi−1
[li−1]j ≤ [li]j ≤ [ui]j ≤ [ui−1]j for all j, (1)
where we use the same notations as in the previous section. Since we rely on PGD, we need to define how to project values of li and ui that violate the constraints in equation 1.
Algorithm 2 demonstrates the heuristic we use for the projection. Algorithm 2 slightly abuses the notations above, and treats li and ui, as the concrete values of li and ui to be projected, instead of treating them as variables.
It first clips li and ui to enforce Ui ⊆ Ui−1 (Line 2—Line 3). It then checks whether hp(li, ui) ≥ −pi−1 is satisfied and if so returns (Line 4—Line 7). Otherwise, all elements of li corresponding to positive values of a, [li]a>0, and all elements of ui corresponding to negative values of a, [ui]a<0, are adjusted by a factor of −pi−1−bval , where val = hp(l
i, ui)− b. This enforces hp(li, ui) ≥ −pi−1 (Line 8—Line 9). In rare cases the second projection can result in values of li and ui violating Ui ⊆ Ui−1. Our solution is to clip again (Line 10—Line 11). After the last clip, in the rare case mentioned above the returned values for li and ui violate hp(li, ui) ≥ −pi−1. However, we did not find this to be a problem in practice, as it occurs rarely and one can continue as if choosing a different value for c in Algorithm 1.

heading: A.5 DETAILED DESCRIPTION OF ADAPTED EOT USED IN EXPERIMENTS IN SECTION 5.5
text: In this section we discuss the extension of Athalye et al. (2018) we use to produce the empirically robust adversarial examples for the experiment in §sec:eotcomp. We define an optimization procedure, where we seek a hyperbox geometric region Uemp ⊆ Rn0 , defined in terms of the lower bound lemp ∈ Rn0 and the upper bound uemp ∈ Rn0 vectors. We seek to find Uemp within the set of allowed geometric transformations I ⊆ Rn0 , such that Uemp is an empirically robust adversarial example
with maximal log volume, and high EoT. Similarly to Athalye et al. (2018) EoT is calculated on set of samples from Uemp. We rely on differentiable bilinear interpolation (Jaderberg et al., 2015) to allow gradients to flow through the geometric transformations we consider and optimize lemp and uemp using PGD.

heading: A.6 DETAILED DESCRIPTION OF EXPERIMENTAL SETUP IN SECTION 5.4
text: Neural networks In Section 5.4, we experiment with networks f with the same architectures as in Table 4. Following the standard practices for training networks used with smoothing, outlined in Cohen et al. (2019), we trained the networks on images with added Gaussian noise with a standard deviation of 0.15.
Selecting α and σ In the experiments in Section 5.4, we need to select α and σ to compute Radv using Definition 2. For all methods we use α = 0.005, as suggested by Cohen et al. (2019). We select the σ value that produces the biggest adversarial strength Radv for our method and use it in all methods. We note that tuning σ for the individual attacks generated by A is very computationally intensive and therefore we avoid it.
Selecting R′ In this paragraph, we detail how the adversarial distance R′ is chosen. We choose it heuristically, for each individual x. For each x, we select R′ by searching for the smallest adversarial distance on f , where at least 10% of 500 attacks withA on f succeed but exclude images x, whose R′ is more than 33% bigger than the certified radius R of g. This procedure allows us to select the adversarial distance R′, that is neither too small, nor too big, which is important to avoid making the problem trivial, as outlined in Section 2.3. In particular, for this choice of R′ the smoothed classifier g is likely to be attackable, since f contains enough attacks for a high density input adversarial region to exist. On top of that, the exclusion of images x with too big adversarial distance R′ experimentally allowed us to exclude trivial attacks, for which x is attackable for most classes on g.

heading: B ADDITIONAL EXPERIMENTS
text: B.1 DEPENDENCE OF OUR METHOD ON THE VALUE OF c
In this section, we examine the effect of the parameter c introduced in Algorithm 1 on the size of our output. We show how the number concrete adversarial examples contained in our regions robust to geometric transformations vary, as a function of c. Table 5 depicts the results on the MNIST ConvBig scaling and translation experiment, originally depicted in Table 2. Columns Time and #It in Table 5 depict the average time and iterations taken by Algorithm 1 to converge. The results correspond to our intuition for c: the higher the value of c is, the greater the volume produced by our method, even allowing the algorithm to succeed for two additional images. However, this increases runtime as the average number of iterations increases.

heading: C ANALYSIS OF ALGORITHM 1

heading: C.1 SOUNDNESS OF ALGORITHM 1
text: Theorem 1. If Algorithm 1 converges, it returns a provably robust region U .
Proof. Algorithm 1 can only complete its execution using Line 6 or Line 15. Since we assume the algorithm successfully converged, returning at Line 15 is impossible. Therefore, the algorithm must have returned the region Ui−1 at Line 6 and, therefore, ei−1 must be non-negative (otherwise we would not have taken the right branch at Line 5). However, ei−1 is obtained by executing the verifier V on Ui−1 at Line 4. By the definition of our verifier V, it returns non-negative ei−1 only if Ui−1 is provably robust. This finishes our proof.

heading: C.2 CONVERGENCE OF ALGORITHM 1
text: In this section, we demonstrate that Algorithm 1 converges exponentially fast under a suitable assumption for the monotonicity of the neural network certification method V. To this end, we introduce the following definition of monotonicity of V, that we will leverage for the rest of the section. Definition 6. Let V(f, I, yt) be a neural network certification method that returns the certification objective LI(x) for an input region I and target yt on the neural network f . We call V objectivemonotonic if for all f and input regions X and Y with X ⊆ Y the property:
min x∈X LX (x) ≥ min x∈X LY(x)
is satisfied.
Intuitively, Definition 6 states that a verifier is objective-monotonic if the certification objective produced for a smaller region X is always higher (closer to verification) than the certification objective produced for a bigger region Y , when both of them are optimized over the smaller region X . We note that most practical neural network certification methods, including DeepPoly, are not objective-monotonic — that is one can find triples f , X and Y violating the definitions above. However, in practice we find that for all practical neural network certification methods the definitions hold for most triples. This is expected, as for violating triples we know that the overapproximation generated for X needs to be larger than the one generated for Y . Intuitively, if that was the case for a large portion of the triples, the certification method will not be tight.
Next, we leverage this defition to demonstrate that our algorithm converges exponentially fast under the idealized condition that the certification method used is objective-monotonic. Theorem 2. For objective-monotonic certification methods V in Algorithm 1, the certification error at the i-th iteration ei converges exponentially fast towards 0 (towards certification).
Proof. To prove Theorem 2, we will leverage the definition of objective-monotonic certification method above to bind the certification error between consequitive iterations of Algorithm 1. We will then use the bound to derive a bound on the certification error ei in terms of the intial certification error e0. Finally, we will use the bound to show the exponential convergence.
Since Ui ⊆ Ui−1, we can apply Definition 6 to get the inequality:
min x∈Ui Li(x) ≥ min x∈Ui Li−1(x).
By construction of Ui, we further know:
min x∈Ui
Li−1(x) ≥ −pi−1 = ei−1 · c.
Combining both inequalities and noting that ei = minx∈Ui L i(x), we get:
ei ≥ ei−1 · c. (2)
Since equation 2 holds for all i, we can apply it recursively on its right-hand side to get:
ei ≥ e0 · ci. (3) We recall that ei is negative unless Ui verifies. Therefore by equation 3, ei converges exponentially fast towards 0, regardless of e0.

heading: D PROVABLY ROBUST POLYHEDRA ADVERSARIAL EXAMPLES
text: In this section, we show an extension to our method that allows us to generate provably robust adversarial examples represented as a general polyhedron shapes P in the neural network input space. The approach relies on the underapproximation and overapproximation boxes U and O, presented in the main body, to guide the search of P and is demonstrated in Figure 2. The results of the method presented in this section were shown in Table 1 in Section 5.1.

heading: D.1 BACKGROUND
text: Our method for generating polyhedral robust adversarial examples requires more restricted form for V, compared to the algorithms presented in the main body. In this subsection we discuss the relevant background and the additional requirements we pose on V and introduce the relevant notation for the rest of this section.
For this section, we will focus on ReLU-based neural networks. We note that our concepts can easily be extended to networks with other activation functions such as sigmoid or tanh. We consider neural network with l layers f1, . . . , fl. The first l − 1 layers are of the form fi(x) = max(0, Ai · x + bi) for i ∈ {1, . . . , l − 1} and the final layer is of the form fl(x) = Al · x + bl. The neural network f is the composition of all layers: f = fl ◦ · · · ◦ f1. Let ni be the number of neurons in layer i. If zai,j is the input to the j-th ReLU activation in layer i and z r i,j is the corresponding ReLU output, we can represent the neural network as the following system of constraints: For i ∈ {1, . . . , l} and j ∈ {1, . . . , ni},
zai,j = [bi]j + ni−1∑ k=1 [Ai]j,k · z r i−1,k, zri,j = max(0, z a i,j).
Here, zr0,j describes the j-th of n0 input activations. We call the two types of constraints affine constraints and ReLU constraints, respectively. We additionally constrain our inputs zr0 to be points
of a polyhedron P ⊆ Rn0 . An adversarial class yt has the highest score on all inputs in P if min(zal,yt − z a l,y) > 0 with respect to all constraints for all y ∈ {1, . . . , nl} \ {yt}. The goal in section will be to find a large polyhedron P for which we can verify that this is true.
Linear approximations of ReLU As reasoning about neural network constraints directly is often intractable, given bounds li,j ≤ zai,j ≤ ui,j , the triangle approximation (Ehlers, 2017) relaxes the ReLU constraints such that all involved inequalities are linear:
zri,j ≥ zai,j , zri,j ≥ 0, zri,j ≤ λi,j · zai,j + µi,j .
Figure 3 (a) visualizes the triangle approximation. Here, λi,j = ui,j/(ui,j − li,j) and µi,j = −li,j · ui,j/(ui,j − li,j) are selected such that this set of constraints describes the convex hull of the ReLU constraints in the (zai,j , z r i,j)-plane and the given bounds.
The DeepPoly approximation (Singh et al., 2019) further relaxes the triangle approximation by keeping only one of the lower bounds on each variable zri,j . It picks either z r i,j ≥ zai,j or zri,j ≥ 0, whichever minimizes the area of the resulting triangle in the (zai,j , z r i,j)-plane. Figure 3 (b) and (c) show the two convex relaxations used in DeepPoly.
We can obtain li,j and ui,j by optimizing each component of zai,j according to the previously determined constraints for layers 0, . . . , i. We note that in the special case where ui,j ≤ 0 or li,j ≥ 0, no approximation is needed and zri,j is directly assigned 0 or z a i,j , respectively. Neurons for which the approximation is needed are called undecided.
Computing neuron bounds Most verification algorithms based on convex relaxation start with a chosen input region for which they calculate the bounds li,j and ui,j of zai,j in layer-by-layer fashion, where the constraints for previous layers are used to derive the bounds for layer i. In addition to DeepPoly and the triangle approximation, this is also true for other commonly used convex relaxation algorithms such as CROWN (Zhang et al., 2018) and DeepZ (Singh et al., 2018a).
Next, we briefly describe how the bounds are computed for a particular layer in DeepPoly. We focus on DeepPoly since it is the particular convex relaxation algorithm we chose to employ in this section. For all neurons, DeepPoly stores a single linear lower and upper bound inequality. These inequalities bound the neuron’s value in terms of the values of neurons from previous layers in the network. For ReLU neurons, these are the inequalities described above. For affine neurons, these are simply the affine transformations, where the affine equality is converted to a pair of inequalities.
To arrive at the bounds li,j and ui,j of zai,j , DeepPoly repeatedly backsubstitutes variables in the linear inequalities of zai,j with their corresponding linear inequalities from previous layers. The process continues until we arrive at linear inequalitiesLi,j(zr0) ≤ zai,j ≤ Ui,j(zr0), withLi,j(x) = ai,j ·x+bi,j
and Ui,j(x) = ai,j · x + bi,j denoting linear functions in terms of input variables x ∈ Rn0 with coefficients ai,j , ai,j ∈ Rn0 and bi,j , bi,j ∈ R. The final bounds li,j and ui,j are obtained by optimizing the respective functions Li,j(x) and Ui,j(x) over the input region.
We note that our algorithm does not depend on details of DeepPoly’s backsubstitution algorithm: It only requires the existence of linear functions Li,j(x) and Ui,j(x) bounding neuron values zai,j in terms of input activations. This makes it compatible with other popular verification algorithms based on convex relaxation, such as CROWN (Zhang et al., 2018) and DeepZ (Singh et al., 2018a).
Certification Objective To certify the robustness of an input region, V needs to certify that min(zal,yt − z a l,y) > 0 for all y ∈ {1, . . . , nl} \ {yt}. To calculate lower bounds on those minima, a common trick is to introduce an affine layer that computes the objectives zal,yt − z a l,y for each y. We will refer to this layer as objective layer. To obtain lower bounds on our objectives, we compute lower bounds of the corresponding neuron activations in the objective layer with the usual backsubstitution procedure.
For the rest of the section we will denote the backsubstituted linear lower bounds on our objectives in terms of input activations for a given target yt with Ll+1,y(x) = al+1,y · x + bl+1,y for each y. Finally, to verify that min(zal,yt − z a l,y) > 0, it suffices to show that Ll+1,y(x) > 0 for each point x in the input region. We note that the function denoted Ll+1,y(x) in this section corresponds to the function denoted Ly(x) in the main body.

heading: D.2 COMPUTING P
text: The algorithm for computing P is presented in Algorithm 3. It takes as input:
– The neural network f , as described in Section D.1. – The underapproximation hyperbox U . – The overapproximation hyperbox O. – A neural network certification method V( f, Pit−1, i, j ) that takes a neural network f , a
polyhedron Pit−1 at iteration it− 1, the layer number i and the neuron number j and returns the linear functions Li,j(x) and Ui,j(x) and the corresponding concrete bounds li,j and ui,j (See Section D.1).
– The adversarial attack’s target class yt. – The maximum number pit of iterations used to generate the polyhedron P .
The algorithm computes P , such that U ⊆ P ⊆ O is satisfied. We motivate this choice by noting that we know that U is certifiably robust and it is therefore a lower bound on P . The algorithm generates a sequence of polyhedra P0 ⊇ P1 ⊇ . . . ⊇ Pp with P0 = O. At each iteration, it computes two sets of half-space constraints – hs o(Line 4) and hs b(Line 5), corresponding to the neurons in the objective and the affine layers of the network. We detail how these constraints are computed in the next two paragraphs. We add these constraints to the polyhedron from the last iteration Pit−1 to obtain Pit (Line 6). The algorithm terminates when Pit−1 is certified to be robust (Line 7 – Line 9) and Pit−1 is returned. The result of our algorithm is represented by the red region denoted as P in Step 3 in Figure 2. We note that, since P0 = O, P ⊆ O is guaranteed by construction, as each subsequent iteration of the algorithm shrinks the polyhedron further. However, U ⊆ P depends on the choice of the half-space constraints.
Generating Certification Objective Constraints Algorithm 4 details the procedure we use to collect the half-space constraints corresponding to the objective layer of the network. To obtain constraints from V, we collect Ll+1,y(x) ≥ 0 for all output classes y ∈ {1, . . . , nl} \ {yt} (Line 5). We know that adding these hyperplanes to our polyhedron Pit−1 will result in a certifiably robust region Pit, however the region will not obey U ⊆ Pit. Therefore, we adjust the bias of constraints, so that the hyperplanes Ll+1,y(x) = 0 do not intersect U (Line 8). This will be described in more detail below. All resulting bias-adjusted hyperplanes are collected in the set hs o (Line 9) and returned. We note that if lj > 0, the half-spaces Ll+1,y(x) ≥ 0 are trivial. That is {Ll+1,y(x) ≥ 0} ∩ Pit−1 = Pit−1, and thus they are filtered out of hs o (Line 6). In addition to detecting the trivial constraints, we use lj to check if Pit−1 is certifiably robust and return the result alongside hs o in Line 11.
Algorithm 3 GEN_POLY 1: func GEN_POLY( f, U , O,V, yt, pit ) 2: P0 = O 3: for it ∈ {1, 2, . . . , pit} do 4: hs o, Ver = Gen_Obj_Planes( f, U , Pit−1,V, yt ) 5: hs b = Gen_Bound_Planes( f, U , Pit−1,V ) 6: Pit = Add_Planes(Pit−1, hs b ∪ hs o ) 7: if Ver then 8: return Pit−1 9: end if 10: end for 11: return FailedToConverge 12: end func
Algorithm 4 GEN_OBJ_PLANES 1: func GEN_OBJ_PLANES( f, U , Pit−1,V, yt ) 2: hs o = [] 3: Ver = True 4: for j ∈ {1, . . . , nl} \ {yt} do 5: Ll+1,j(x), _, lj , _ = V( f, Pit−1, l + 1, j ) 6: if lj ≤ 0 then 7: Ver = False 8: L̃l+1,j(x) = Adjust_Bias(U , Ll+1,j(x) ) 9: hs o += [ L̃l+1,j(x) ≥ 0 ] 10: end if 11: end for 12: return hs o, Ver 13: end func
Issues Related to Using Only Objective Constraints In our experiments, we found that only adding bias-adjusted objective constraints leads to slow convergence of our algorithm. In particular, we found that the first few iterations of the algorithm result in a substantial improvement in the certification objective. However, after this initial fast progress, we observe that the change in the certification objective becomes very small. The reason for this is that the generated constraints from consecutive executions of V are very similar. We conjecture that the underlying reason is that the constraints no longer change the input shape enough to substantially change the convex approximation of the network. This is in contrast to what we observe when computing the underapproximation hyperbox region U . The difference between the two settings comes from the number of added constraints per iteration. For U , usually many lower and upper bounds are adjusted each iteration, while the objective constraints added are much less, especially for the pixel intensity changes experiment, where the input is very high-dimensional.
Generating Constraints from Affine Layers To facilitate faster convergence, we generate additional constraints for all undecided neurons in the network. We generate two constraints, one with respect to the lower bound of the neuron Li,j(x) ≥ 0 and one with respect to the upper bound Ui,j(x) ≤ 0. Algorithm 5 describes the process. Li,j(x) and Ui,j(x) are computed by V (Line 5) alongside their concrete bounds li,j and ui,j . The concrete bounds are used to check which neurons are undecided (Line 6).
The generated constraints have the effect of making the neurons decided and, while also enforcing substantial change in the convex relaxation of the neural network. Note that the newly obtained constraints are bias-adjusted similar to the objective constraints described above (Line 7–Line 8). We point out that the bias adjustment described below takes care of the problem that Li,j(x) ≥ 0 and Ui,j(x) ≤ 0 cannot be simultaneously true. Empirically, these hyperplanes serve an important role for improving the convergence rate of our algorithm. Algorithm 5 collects them in the set hs b (Line 9) and returns them to be added to Pit−1.
Hyperplane bias adjustment So far, we have discussed how constraints are generated but not how we adjust their biases. The bias adjustment algorithm is given in Algorithm 6. The bias adjustment
Algorithm 5 GEN_BOUND_PLANES 1: func GEN_BOUND_PLANES( f, U , Pit−1,V ) 2: hs b = [] 3: for i ∈ {1, 2, . . . , l − 1} do 4: for j ∈ {1, 2, . . . , ni} do 5: Li,j(x), Ui,j(x), li,j , ui,j =V( f, Pit−1, i, j ) 6: if li,j ≤ 0 and ui,j ≥ 0 then 7: L̃i,j(x) = Adjust_Bias(U , Li,j(x) ) 8: Ũi,j(x) = Adjust_Bias(U , −Ui,j(x) ) 9: hs b += [ L̃i,j(x) ≥ 0, Ũi,j(x) ≥ 0 ] 10: end if 11: end for 12: end for 13: return hs b 14: end func
Algorithm 6 ADJUST_BIAS 1: func ADJUST_BIAS(U , h(x) ) 2: hmin = min
x∈U (h(x))
3: badj = min( 0, hmin ) 4: h̃(x) = h(x)− badj 5: return h̃(x) 6: end func
for a lower bound constraint h(x) ≥ 0 enforces that the intersection of the constraint and the given underapproximation hyperbox U is U . It does so by computing hmin = min
x∈U (h(x))(Line 2)
and changing the given constraint to h(x) ≥ hmin (Line 4). The optimization hmin = min x∈U (h(x)) is analytically solvable, as demonstrated Section A.3. Note that our algorithm adjusts only the constraints with negative hmin (Line 3), since constraints with positive hmin already satisfy the property. The following lemma shows the soundness of our bias-adjustment algorithm:
Lemma 3. The intersection of the bias-adjusted half-space constraint h̃(x) ≥ 0 defined in Algorithm 6 with U is U .
Proof. By the construction of hmin, for all points x ∈ U we have h(x) ≥ hmin. We distinguish two cases for the value of hmin — non-negative and negative.
If hmin ≥ 0, the bias adjustment badj is assigned to 0 and h̃(x) = h(x). Since h(x) ≥ hmin for all points x ∈ U , h̃(x) = h(x) ≥ hmin ≥ 0 for all points x ∈ U . Therefore, there does not exist point in U for which the bias-adjusted half-space constraint h̃(x) ≥ 0 is violated. If hmin < 0, the bias adjustment badj is assigned to hmin and h̃(x) = h(x) − hmin. Therefore, h̃(x) = h(x) − hmin ≥ hmin − hmin = 0 for all points x ∈ U . Analogously to the other case, h̃(x) ≥ 0 is not violated by the points in U .
The bias adjustment for upper bound constraints h(x) ≥ 0 is achieved by calling Algorithm 6 with −h(x), as in Line 8 in Algorithm 5. Geometrically, the bias adjustment is represented at Step 2 in Figure 2.
Adapting DeepPoly to Polyhedral Input Regions Out of the box DeepPoly only handles certification of hyperbox input regions. This is because in order to obtain the concrete bounds li,j = minx∈I Li,j(x) and ui,j = maxx∈I Ui,j(x) for an input region I ⊆ Rn0 it uses the analytical solution of the optimization problems discussed in §sec:lpshrink. In order to use DeepPoly for polyhedral region I, we solve the optimization problem using an Linear Program (LP). This is computationally expensive – it involves solving two LP instances per neuron. For large networks, this can be prohibitive.
To alleviate this issue, in the first iteration of Algorithm 3, we remember which neurons are undecided. The computation of the undecided neurons in the first iteration can be done using regular DeepPoly, as P0 = O. In future iterations we solve the LP instances only for the undecided neurons, while using the P0 bounds for the decided neurons. This optimization is sound, since we have Pit ⊆ Pit−1 by construction. This improves the performance substantially – for most certifiably robust input regions in ReLU-based networks we have just a few undecided neurons.
Proving that P constraints U and is contained within O In this paragraph, we present a proof for the desired property of Algorithm 3 that P constraints U and is contained within O. Theorem 4. For all polyhedral regions P generated by Algorithm 3, U ⊆ P ⊆ O holds.
Proof. Here we briefly outline the proof of Theorem 4. The proof is divided into two parts. We first prove that P ⊆ O and then U ⊆ P . To prove P ⊆ O we leverage the fact that the polyhedra P is constructed from the overapproximation boxO by intersecting it with the half-space constraints hbib and hbio. Since all constraints only reduce the volume of the polyhedra, it follows by induion that Pi ⊆ O for all i. Therefore, P ⊆ O. To prove U ⊆ P we note that the generated half-space constraints hbb and hbo are chosen such that hbb ∩ U = U and hbo ∩ U = U (See Lemma 3). Applying this property by induction over the generated half-space constraints, it follows that Ui ⊆ P for all i. Therefore, U ⊆ P
E VISUALISATION OF ROBUST ADVERSARIAL EXAMPLES
E.1 DISCUSSION
Figure 4 shows an adversarial region provably robust to intensity changes containing 10284 adversarial images produced by our method on MNIST ConvBig. The original image is of the digit 5, and all images in our region are classified as 3 by the network. The colorbar in Figure 4 quantifies the number of values each pixel can take in our inferred region. The yellow and violet colors represent the two extremes. The intensity of the yellow-colored pixels can vary the most, thus these pixels contribute to more adversarial examples. The intensity of the purple-colored varies the least, thus the adversarial examples in our region are sensitive to the intensity values of these pixels. In our region, the intensity of most background pixels on the edges of the image can vary a lot, as these are green. Violet and green color are more evenly distributed among pixels closer to the foreground (part of the digit "5"). Further, the intensity of several pixels in the foreground can also vary significantly. We note that all yellow pixels occur in the foreground. In summary, our region can capture examples that can be
generated by significant variations in the intensities of several background and foreground pixels. We supply visualizations for all of the experiments described in Section 5.1 and 5.2 in Appendix E.

heading: E.2 ADVERSARIAL EXAMPLES ROBUST TO INTENSITY CHANGES
text: In Figure 5 – Figure 8 we visualise adversarial examples provably robust to pixel intensity changes for the different networks in Table 1. For all figures, the colorbar on the right-hand side quantifies the number of values each pixel can take in our inferred region. The yellow and violet colors represent the two extremes. The intensity of the yellow-colored pixels can vary the most, thus these pixels contribute more to the adversarial examples.
In Figure 5 we show adversarial examples for the MNIST ConvBig network. The 3 sub-figures represent the digits 9, 5, and 3, but the images in our regions are classified as 4, 3, and 8, respectively. Our regions are of size 10220, 10284, and 10262, respectively.
In Figure 5 we show adversarial examples for the MNIST ConvSmall network. The 3 sub-figures represent the digits 2, 9, and 9, but the images in our regions are classified as 3, 5, and 4, respectively. Our regions are of size 10520, 10652, and 10708, respectively.
In Figure 7 we show adversarial examples for the MNIST 8 × 200 network. The 3 sub-figures represent the digits 5, 9, and 2, but the images in our regions are classified as 8, 8, and 3, respectively. Our regions are of size 10148, 10128, and 10157, respectively.
In Figure 8 we show adversarial examples for the CIFAR10 ConvSmall network. The 3 sub-figures represent a boat, a bird, and another bird, but the images in our regions are classified as an airplane , a frog, and a dog, respectively. Our regions are of size 10626, 10563, and 10608, respectively.

heading: E.3 ADVERSARIAL EXAMPLES ROBUST TO GEOMETRIC CHANGES
text: In Figure 9 – Figure 11 we visualise adversarial examples provably robust to geometric perturbations for the different networks in Table 2. For all figures, the colorbar on the right-hand side quantifies the number of values each pixel can take in our inferred region. The yellow and violet colors represent the two extremes. The intensity of the yellow-colored pixels can vary the most, thus these pixels contribute more to the adversarial examples. For all figures, the subfigures represent an adversarial example for each of the rows in Table 2.
In Figure 9 we show adversarial examples for the MNIST ConvBig network. The 3 sub-figures represent the digits 6, 1, and 3, but the images in our regions are classified as 5, 8, and 7, respectively. Our regions have underapproximations of size 10159, 10183, and 1013, respectively.
In Figure 10 we show adversarial examples for the MNIST ConvSmall network. The 3 sub-figures represent the digits 6, 1, and 3, but the images in our regions are classified as 5, 8, and 7, respectively. Our regions are of size 10115, 1082, and 1063, respectively.
In Figure 11 we show adversarial examples for the CIFAR10 ConvSmall network. The 3 subfigures represent a dog, a truck, and a frog, but the images in our regions are classified as a frog, an automobile, and a deer, respectively. Our regions are of size 101422, 101270, and 101505, respectively.

Review summaries:
This paper presents a novel algorithm for identifying "provably robust adversarial examples": large regions in the input space that provably contain only adversarial examples.  Each region corresponds to a single adversarial example $\tilde{x}$ found in the center of the region, along with all the points that can be generated by applying a sequence of transformations to $\tilde{x}$. The transformations considered in the paper are semantically meaningful changes to the original image. Critically, we can be guaranteed that $\tilde{x}$ will be misclassified even if _it_ is perturbed.  The paper demonstrates that the algorithm can generate regions of non-trivial size on networks of non-trivial size. For example, for a CIFAR10 classifier with 6 layers and ~62k neurons, it finds axis-aligned regions containing a median of $10^{573}$ adversarial examples. In addition, the paper shows that provably robust adversarial examples can be used to create adversarial examples to $L_2$-smoothed classifiers that are more robust to $L_2$ noise as compared to adversarial examples generated directly via PGD attacks.

The manuscript introduces a definition of provablely-robust adversarial examples, a set of examples that are verified to be classified as different labels compared with the input of interest. The main idea of the technique is to shrink a box-like region from an over approximation to a verifiable smaller sub-region such that a robustness verifier will return robust for all points in that particular sub-region. In the evaluation part, the author demonstrates the effectiveness of the approach with several experiments, i.e. robustness against intensity transformation and randomized smoothing defense.