diff --git "a/abs_29K_G/test_abstract_long_2405.01280v1.json" "b/abs_29K_G/test_abstract_long_2405.01280v1.json"
new file mode 100644--- /dev/null
+++ "b/abs_29K_G/test_abstract_long_2405.01280v1.json"
@@ -0,0 +1,430 @@
+{
+    "url": "http://arxiv.org/abs/2405.01280v1",
+    "title": "Reinforcement Learning for Edit-Based Non-Autoregressive Neural Machine Translation",
+    "abstract": "Non-autoregressive (NAR) language models are known for their low latency in\nneural machine translation (NMT). However, a performance gap exists between NAR\nand autoregressive models due to the large decoding space and difficulty in\ncapturing dependency between target words accurately. Compounding this,\npreparing appropriate training data for NAR models is a non-trivial task, often\nexacerbating exposure bias. To address these challenges, we apply reinforcement\nlearning (RL) to Levenshtein Transformer, a representative edit-based NAR\nmodel, demonstrating that RL with self-generated data can enhance the\nperformance of edit-based NAR models. We explore two RL approaches: stepwise\nreward maximization and episodic reward maximization. We discuss the respective\npros and cons of these two approaches and empirically verify them. Moreover, we\nexperimentally investigate the impact of temperature setting on performance,\nconfirming the importance of proper temperature setting for NAR models'\ntraining.",
+    "authors": "Hao Wang, Tetsuro Morimura, Ukyo Honda, Daisuke Kawahara",
+    "published": "2024-05-02",
+    "updated": "2024-05-02",
+    "primary_cat": "cs.CL",
+    "cats": [
+        "cs.CL"
+    ],
+    "label": "Original Paper",
+    "paper_cat": "Model AND Based AND Reinforcement AND Learning",
+    "gt": "Non-autoregressive (NAR) language models are known for their low latency in\nneural machine translation (NMT). However, a performance gap exists between NAR\nand autoregressive models due to the large decoding space and difficulty in\ncapturing dependency between target words accurately. Compounding this,\npreparing appropriate training data for NAR models is a non-trivial task, often\nexacerbating exposure bias. To address these challenges, we apply reinforcement\nlearning (RL) to Levenshtein Transformer, a representative edit-based NAR\nmodel, demonstrating that RL with self-generated data can enhance the\nperformance of edit-based NAR models. We explore two RL approaches: stepwise\nreward maximization and episodic reward maximization. We discuss the respective\npros and cons of these two approaches and empirically verify them. Moreover, we\nexperimentally investigate the impact of temperature setting on performance,\nconfirming the importance of proper temperature setting for NAR models'\ntraining.",
+    "main_content": "Introduction Non-autoregressive (NAR) language models (Gu et al., 2018) generate translations in parallel, enabling faster inference and having the potential for real-time translation applications. However, despite their computational efficiency, NAR models have been observed to underperform autoregressive (AR) models due to the challenges posed by the large decoding space and difficulty in capturing dependency between target words accurately (Gu et al., 2018). To bridge the performance gap, many NAR architectures and training methods have been proposed, including edit-based models like Insertion Transformer (Stern et al., 2019) and Levenshtein Transformer (Gu et al., 2019). Prior research has also explored knowledge distilla*Work done during internship at CyberAgent AI Lab. tion (Ghazvininejad et al., 2019), which is effective but introduces additional complexity. Unlike AR models, preparing teacher data and designing appropriate training objectives have always been challenging for NAR models (Li et al., 2023). Teacher forcing with inappropriate teacher data may exacerbate the exposure bias problem (Ranzato et al., 2016), affecting model performance. Reinforcement learning (RL) is known for its ability to tackle the exposure bias (Ranzato et al., 2016) and alleviate the object mismatch issue (Ding and Soricut, 2017). Despite its importance, explorations of RL for NAR are still scarce. Shao et al. (2021) proposed a method for reducing the estimation variance. However, this method is only applicable to NAR models with a fixed output length, which is unsuitable for edit-based models. In this paper, we empirically analyze conditions for performance improvement in applying RL to edit-based NAR models in neural machine translation (NMT). Specifically, we focus on Levenshtein Transformer (LevT) (Gu et al., 2019), a prominent edit-based NAR architecture that has shown promise in reducing decoding latency and flexible length adjustment. We demonstrate that RL with self-generated data significantly improves LevT\u2019s performance. Importantly, our methods are orthogonal to existing research on NAR architectures, indicating potential for widespread applicability. We explore two RL approaches: stepwise reward maximization, which computes rewards after each edit operation, and episodic reward maximization, which only computes rewards after all generations are completed. We analyze these two approaches\u2019 respective advantages and disadvantages and empirically verify them. Furthermore, through a series of experiments, we investigate the impact of temperature settings on softmax sampling, aiming to identify the optimal temperature that strikes a balance between exploration and exploitation during the RL training process. arXiv:2405.01280v1  [cs.CL]  2 May 2024 \f2 Background Reinforcement Learning Reinforcement learning has been widely applied to improve the performance of AR NMT models (Ranzato et al., 2016; Bahdanau et al., 2016; Wu et al., 2016) because its ability to train models to optimize nondifferentiable score functions and tackle the exposure bias problem (Ranzato et al., 2016). In practice, REINFORCE (Williams, 1992) with a baseline is commonly used for estimating the policy gradient, which can be computed as follows: \u25bd\u03b8L(\u03b8) \u2248\u2212(r(y) \u2212b(s)) \u25bd\u03b8 log\u03c0\u03b8(y|s), (1) where r is the reward function, b is the baseline, y is a sample from policy \u03c0\u03b8 and state s. Softmax with Temperature In the domain of RL, we need to consider the explorationexploitation trade-off (Sutton and Barto, 2018), where temperature \u03c4 is an important parameter. \u03c4 is used to control the softness of the softmax distribution, pi = exp(yi/\u03c4) P i exp(yi/\u03c4). (2) A larger \u03c4 leads to a more uniform distribution, promoting exploration, while a smaller \u03c4 creates a more peaky distribution, emphasizing exploitation. Kiegeland and Kreutzer (2021) shows that training with an increased temperature can mitigate the peakiness effect due to RL (Choshen et al., 2020), indicating that a suitable temperature is significant for RL training in NMT. RL for NAR Compared to AR methods, studies of reinforcement learning for NAR remain unexplored. Shao et al. (2021) proposed a method to reduce the estimation variance of REINFORCE by fixing the predicted word at position t and sampling words of other positions for n times. However, this method is only applicable to models with a fixed length, which is unsuitable for edit-based models. Levenshtein Transformer Levenshtein Transformer (Gu et al., 2019) is an NAR model based on three edit operations: delete tokens, insert placeholders, and replace placeholders with new tokens. It uses a supervised dual-policy learning algorithm to minimize the Levenshtein distance (Levenshtein, 1965) for training and greedy sampling for decoding. The decoding stops when two consecutive refinement iterations return the same output or a maxFigure 1: The illustration of Levenshtein Transformer\u2019s decoding process (Gu et al., 2019). In each decoding iteration, three edit operations are performed sequentially: delete tokens, insert placeholders, and replace placeholders with new tokens. imum number of iterations (set to 10) is reached. We illustrate the decoding process in Figure 1. LevT\u2019s dual-policy learning generates teacher data by corrupting the ground truth and reconstructing it with its adversary policy. This mechanism not only offers a unique approach to data generation but also underscores the inherent difficulty in preparing teacher data. This introduces concerns regarding the exposure bias, particularly whether the training process can maintain consistency with the text during decoding. To address this issue, we employ RL approaches that use self-generated data for training. 3 Approaches In this section, we present our reinforcement learning approaches in detail. We train a Levenshtein Transformer model as our baseline using the dualpolicy learning algorithm. Based on it, we introduce two distinct RL approaches within the REINFORCE framework: stepwise reward maximization and episodic reward maximization. Moreover, we present our methods for temperature control. Stepwise Reward Maximization General RL training methods for AR NMT models are all episodic1, as it is difficult to calculate BLEU (Papineni et al., 2002) when the sentence is not fully generated. In contrast, NAR models can calculate BLEU on outputs at each decoding step. From the perspective of estimating a more accurate gradient, we propose stepwise reward maximization, which 1In this context, \u201cepisodic\u201d denotes training based on entirely generated sequences \fFigure 2: The illustration of the two RL approaches. (A) is the stepwise reward maximization, which randomly samples from a previous node for each edit operation and calculates BLEU and RL gradient after each edit operation (except for the insert operation, since it is not easy to calculate BLEU after inserting placeholders). (B) is the episodic reward maximization, where each sample is edited multiple times in a linear fashion, without branching into different paths, and BLEU and RL gradient are calculated only after the completion of all edit operations. At every orange node, we sample k times from this node (in this example, the sample size k is 2). calculates reward for each edit operation2 using score differences from one previous edit. Since every step\u2019s reward is calculated separately, this approach should be easier to learn than episodic approaches (Sutton and Barto, 2018). However, it is also more prone to learning bias since the editing process is inherently multi-step. This drawback should not be emphasized since maximizing the reward for each step will likely maximize the episodic reward in NAR models\u2019 training. We use a leave-one-out baseline (Luo, 2020) for b(s) in Equation 1 instead of the greedy baseline proposed in SCST (Rennie et al., 2017) because the greedy decoding is too strong in LevT, which makes gaining positive rewards in SCST difficult and may reduce learning efficiency. For each edit, we sample k actions from the policy at this point. Then, we calculate the baseline as follows: bi(s) = 1 k \u22121 X j\u0338=i r(yj), (3) where yj is the jth sample from the current policy. The final RL gradient estimation becomes \u25bd\u03b8L(\u03b8) \u2248\u2212(r(yi) \u2212bi(s)) \u25bd\u03b8 log\u03c0\u03b8(yi|s). (4) In a straightforward implementation, one might consider applying sampling again to all k samples 2In practice, since it is not easy to calculate BLEU after inserting placeholders, we consider placeholder insertion and token replacement as one edit operation. from the last edit. However, this will cause a combination explosion when the number of edit operations increases. Practically, we randomly choose a sample from the previous edit to perform the subsequent operations. We show an illustration of the sampling process in (A) of Figure 2 and pseudo code of our algorithm in Appendix A. Episodic Reward Maximization We also introduce episodic reward maximization, which calculates rewards only once for each sample and gives all actions the same weight. It is a more traditional way to train NMT models in RL. It allows unbiased learning but may not be efficient. We use the leave-one-out baseline for the episodic reward as well as the stepwise reward. We sample k samples from the initial input. Each sample will be edited multiple times without a branch. After the final edit, we calculate the rewards and baselines. We show an illustration of the sampling process in (B) of Figure 2 and pseudo code of our algorithm in Appendix B. Temperature Control Applying RL to NAR differs significantly from AR because there could be various types of actions rather than just predicting the next token, like deletion and insertion. Due to this difficulty, NAR may need more fine-grained temperature control during training. To investigate the impact of exploration and exploitation in the training process, we explore five different settings of the temperature. Due to the large decoding space \fof Levenshtein Transformer, default temperature 1 may result in poor rewards, and too small temperature may result in peaky distribution, which are both harmful to learning. We use three constant temperature settings set to 0.1, 0.5, and 1 to verify the effect of temperature magnitude. An annealing schedule is known for balancing the trade-off between model accuracy and variance during training (Jang et al., 2016). There are two ways of thinking here. First, to reduce the exposure bias, we want to get close to the decoding scenario, which is greedy decoding in our experiments. Thus, we can apply a regular annealing schedule to gradually reduce the temperature from 1 to 0.1 during training. The temperature function can be written as follows: \u03c4i+1 = max(\u03c4i \u2217exp(\u2212log(\u03c40/\u03c4T ) T ), \u03c4T ), (5) where T is the number of total training steps, and \u03c40 and \u03c4T are the initial and the target temperatures. Second, using high temperatures in the early stages of training may lead to poor rewards and result in low learning efficiency. We can apply an inverted annealing schedule to gradually increase the temperature from 0.1 to 1, guaranteeing stable training in the early stages and gradually increasing the exploration space for efficient training. The temperature function can be written as follows: \u03c4i+1 = min(\u03c4i/exp(\u2212log(\u03c4T /\u03c40) T ), \u03c4T ). (6) In each decoding iteration, multiple edit operations occur, and each operation has a different decoding space size. It may be beneficial to optimize this by using varying temperatures for each operation in every iteration. This is a complicated research question and we leave this exploration to future work. 4 Experiments 4.1 Experimental Setup Data & Evaluation We use WMT\u201914 EnglishGerman (EN-DE) (Bojar et al., 2014) and WAT\u201917 English-Japanese (EN-JA) Small-NMT datasets (Nakazawa et al., 2017) for experiments. We use BPE token-based BLEU scores for evaluations. Data preprocessing follows Gu et al. (2019). Baseline We use Levenshtein Transformer as our baseline. Following Gu et al. (2019), we trained a LevT with 300K steps and a max batch size of 65,536 tokens per step. However, like Reid et al. (2023), we cannot reproduce the results of Gu et al. (2019). We use our results in this paper. RL According to Gu et al. (2019), most decodings are gotten in 1-4 iterations, and the average number of decoding iterations is 2.43. To minimize the gap between the training and decoding states, we start with a null string and conduct 3 iterations (8 edits) for each sample during RL training. We set the total training steps T to 50,000, with a max batch size of 4,096 tokens per step. To prevent the out-of-memory issue, we limit the decoding space of placeholder insertion from 256 to 64. The sample size k of the baseline is set to 5. Our implementation is based on Fairseq3. Computational Cost The pre-training phase of LevT on a GCP VM instance with A100x4 GPUs requires roughly 3 days, while the subsequent RL fine-tuning process takes approximately 1 day to complete. 4.2 Results We show the BLEU scores of our approaches in Table 1. The episodic reward model4 showed notable improvement over the baseline. The score is even close to the distillation model, which requires a heavy pre-training5 of AR models. However, the stepwise reward model showed only limited improvement. To explain this, we focus on the advantage, r(y) \u2212b(s), included in the policy gradient (Equation 1), as a larger value of the advantage can increase the policy gradient\u2019s magnitude. A higher standard deviation (SD) of the advantages indicates larger fluctuations in policy gradients. Table 2 shows the SDs of the advantages of the stepwise reward model, with notably higher values in the early stages of edit operations compared to later stages. This suggests that the stepwise reward model disproportionately focuses on early operations, potentially leading to uneven learning and reduced performance. In contrast, the episodic reward model applies the same rewards and advantages across all operations, facilitating more uniform learning and improved performance. 3https://github.com/facebookresearch/fairseq 4The term \u201cepisode/stepwise reward model\u201d specifically refers to the model trained using the \u201cepisode/stepwise reward maximization\u201d approach. 5To produce a distillation model, we need to train an autoregressive Transformer first, which needs additional 3 days of training on our machine. \fModel EN-DE EN-JA LevT 24.03 31.76 LevT + distillation 26.49 LevT + RL (stepwise) 24.29 31.73 LevT + RL (episodic) 25.72 32.75 Table 1: The BLEU scores of our approaches and the baseline. Temperatures are set to 1. Due to the limited computational resources, we only trained the distillation model for the EN-DE dataset using the ready-made distillation dataset. Iteration Edit Operation EN-DE EN-JA 1 Insert + Replace 9.99 8.59 2 Delete 2.05 1.35 Insert + Replace 3.28 2.48 3 Delete 1.67 1.29 Insert + Replace 3.04 1.60 Table 2: Stepwise reward model\u2019s standard deviation (SD) of the advantage in each edit operation. Insertion and replacement share the same reward. We only report scores of applying RL to the model without distillation since we found that RL significantly improved the model without distillation (max 1.69 points) compared to when distillation was applied (max 0.5 point). Moreover, when confronted with distillation models, it raises questions such as which data we should use for RL training, the original or the distillation one. We leave these research questions to future work. We show the BLEU scores of different temperature settings in Table 3. Model performance varies significantly with temperature settings (max 1.01 points in EN-JA). Among constant setting models, the model with a temperature of 0.5 performed best in EN-DE, and the model with a temperature of 0.1 performed best in EN-JA, indicating that too large temperature harms RL training. The two models using annealing schedules performed great in both tasks, showing the effectiveness of the annealing algorithms for improving learning efficiency. However, the annealing models did not always outperform the constant models, which suggests the difficulty of seeking the optimal temperature setting for NAR models\u2019 RL training. Also, we found the inverted annealing model (\u03c4=0.1\u21921) begins dropping performance after 10,000 steps training in EN-JA, indicating that the speed of annealing will significantly affect the model training quality. Temperature EN-DE EN-JA Constant (\u03c4 = 1) 25.72 32.75 Constant (\u03c4 = 0.5) 25.98 33.45 Constant (\u03c4 = 0.1) 25.76 33.60 Annealing (\u03c4 = 1 \u21920.1) 25.83 33.76 Annealing (\u03c4 = 0.1 \u21921) 25.90 33.43 Table 3: The BLEU scores of episodic reward models using different temperature settings. We also quickly surveyed the relationship between performance and the number of decoding iterations in RL. The model performance dropped when we reduced the number of iterations to 2 during training and remained flat when we increased it to 4, indicating that our setting is reasonable. 5",
+    "additional_graph_info": {
+        "graph": [
+            [
+                "Hao Wang",
+                "Jianwei Li"
+            ],
+            [
+                "Hao Wang",
+                "Zhengyu Li"
+            ],
+            [
+                "Jianwei Li",
+                "Dongkuan Xu"
+            ],
+            [
+                "Jianwei Li",
+                "Tianchi Zhang"
+            ],
+            [
+                "Jianwei Li",
+                "Sheng Liu"
+            ],
+            [
+                "Zhengyu Li",
+                "Hong Guo"
+            ],
+            [
+                "Zhengyu Li",
+                "Curtis Bright"
+            ],
+            [
+                "Zhengyu Li",
+                "Vijay Ganesh"
+            ]
+        ],
+        "node_feat": {
+            "Hao Wang": [
+                {
+                    "url": "http://arxiv.org/abs/2405.01280v1",
+                    "title": "Reinforcement Learning for Edit-Based Non-Autoregressive Neural Machine Translation",
+                    "abstract": "Non-autoregressive (NAR) language models are known for their low latency in\nneural machine translation (NMT). However, a performance gap exists between NAR\nand autoregressive models due to the large decoding space and difficulty in\ncapturing dependency between target words accurately. Compounding this,\npreparing appropriate training data for NAR models is a non-trivial task, often\nexacerbating exposure bias. To address these challenges, we apply reinforcement\nlearning (RL) to Levenshtein Transformer, a representative edit-based NAR\nmodel, demonstrating that RL with self-generated data can enhance the\nperformance of edit-based NAR models. We explore two RL approaches: stepwise\nreward maximization and episodic reward maximization. We discuss the respective\npros and cons of these two approaches and empirically verify them. Moreover, we\nexperimentally investigate the impact of temperature setting on performance,\nconfirming the importance of proper temperature setting for NAR models'\ntraining.",
+                    "authors": "Hao Wang, Tetsuro Morimura, Ukyo Honda, Daisuke Kawahara",
+                    "published": "2024-05-02",
+                    "updated": "2024-05-02",
+                    "primary_cat": "cs.CL",
+                    "cats": [
+                        "cs.CL"
+                    ],
+                    "main_content": "Introduction Non-autoregressive (NAR) language models (Gu et al., 2018) generate translations in parallel, enabling faster inference and having the potential for real-time translation applications. However, despite their computational efficiency, NAR models have been observed to underperform autoregressive (AR) models due to the challenges posed by the large decoding space and difficulty in capturing dependency between target words accurately (Gu et al., 2018). To bridge the performance gap, many NAR architectures and training methods have been proposed, including edit-based models like Insertion Transformer (Stern et al., 2019) and Levenshtein Transformer (Gu et al., 2019). Prior research has also explored knowledge distilla*Work done during internship at CyberAgent AI Lab. tion (Ghazvininejad et al., 2019), which is effective but introduces additional complexity. Unlike AR models, preparing teacher data and designing appropriate training objectives have always been challenging for NAR models (Li et al., 2023). Teacher forcing with inappropriate teacher data may exacerbate the exposure bias problem (Ranzato et al., 2016), affecting model performance. Reinforcement learning (RL) is known for its ability to tackle the exposure bias (Ranzato et al., 2016) and alleviate the object mismatch issue (Ding and Soricut, 2017). Despite its importance, explorations of RL for NAR are still scarce. Shao et al. (2021) proposed a method for reducing the estimation variance. However, this method is only applicable to NAR models with a fixed output length, which is unsuitable for edit-based models. In this paper, we empirically analyze conditions for performance improvement in applying RL to edit-based NAR models in neural machine translation (NMT). Specifically, we focus on Levenshtein Transformer (LevT) (Gu et al., 2019), a prominent edit-based NAR architecture that has shown promise in reducing decoding latency and flexible length adjustment. We demonstrate that RL with self-generated data significantly improves LevT\u2019s performance. Importantly, our methods are orthogonal to existing research on NAR architectures, indicating potential for widespread applicability. We explore two RL approaches: stepwise reward maximization, which computes rewards after each edit operation, and episodic reward maximization, which only computes rewards after all generations are completed. We analyze these two approaches\u2019 respective advantages and disadvantages and empirically verify them. Furthermore, through a series of experiments, we investigate the impact of temperature settings on softmax sampling, aiming to identify the optimal temperature that strikes a balance between exploration and exploitation during the RL training process. arXiv:2405.01280v1  [cs.CL]  2 May 2024 \f2 Background Reinforcement Learning Reinforcement learning has been widely applied to improve the performance of AR NMT models (Ranzato et al., 2016; Bahdanau et al., 2016; Wu et al., 2016) because its ability to train models to optimize nondifferentiable score functions and tackle the exposure bias problem (Ranzato et al., 2016). In practice, REINFORCE (Williams, 1992) with a baseline is commonly used for estimating the policy gradient, which can be computed as follows: \u25bd\u03b8L(\u03b8) \u2248\u2212(r(y) \u2212b(s)) \u25bd\u03b8 log\u03c0\u03b8(y|s), (1) where r is the reward function, b is the baseline, y is a sample from policy \u03c0\u03b8 and state s. Softmax with Temperature In the domain of RL, we need to consider the explorationexploitation trade-off (Sutton and Barto, 2018), where temperature \u03c4 is an important parameter. \u03c4 is used to control the softness of the softmax distribution, pi = exp(yi/\u03c4) P i exp(yi/\u03c4). (2) A larger \u03c4 leads to a more uniform distribution, promoting exploration, while a smaller \u03c4 creates a more peaky distribution, emphasizing exploitation. Kiegeland and Kreutzer (2021) shows that training with an increased temperature can mitigate the peakiness effect due to RL (Choshen et al., 2020), indicating that a suitable temperature is significant for RL training in NMT. RL for NAR Compared to AR methods, studies of reinforcement learning for NAR remain unexplored. Shao et al. (2021) proposed a method to reduce the estimation variance of REINFORCE by fixing the predicted word at position t and sampling words of other positions for n times. However, this method is only applicable to models with a fixed length, which is unsuitable for edit-based models. Levenshtein Transformer Levenshtein Transformer (Gu et al., 2019) is an NAR model based on three edit operations: delete tokens, insert placeholders, and replace placeholders with new tokens. It uses a supervised dual-policy learning algorithm to minimize the Levenshtein distance (Levenshtein, 1965) for training and greedy sampling for decoding. The decoding stops when two consecutive refinement iterations return the same output or a maxFigure 1: The illustration of Levenshtein Transformer\u2019s decoding process (Gu et al., 2019). In each decoding iteration, three edit operations are performed sequentially: delete tokens, insert placeholders, and replace placeholders with new tokens. imum number of iterations (set to 10) is reached. We illustrate the decoding process in Figure 1. LevT\u2019s dual-policy learning generates teacher data by corrupting the ground truth and reconstructing it with its adversary policy. This mechanism not only offers a unique approach to data generation but also underscores the inherent difficulty in preparing teacher data. This introduces concerns regarding the exposure bias, particularly whether the training process can maintain consistency with the text during decoding. To address this issue, we employ RL approaches that use self-generated data for training. 3 Approaches In this section, we present our reinforcement learning approaches in detail. We train a Levenshtein Transformer model as our baseline using the dualpolicy learning algorithm. Based on it, we introduce two distinct RL approaches within the REINFORCE framework: stepwise reward maximization and episodic reward maximization. Moreover, we present our methods for temperature control. Stepwise Reward Maximization General RL training methods for AR NMT models are all episodic1, as it is difficult to calculate BLEU (Papineni et al., 2002) when the sentence is not fully generated. In contrast, NAR models can calculate BLEU on outputs at each decoding step. From the perspective of estimating a more accurate gradient, we propose stepwise reward maximization, which 1In this context, \u201cepisodic\u201d denotes training based on entirely generated sequences \fFigure 2: The illustration of the two RL approaches. (A) is the stepwise reward maximization, which randomly samples from a previous node for each edit operation and calculates BLEU and RL gradient after each edit operation (except for the insert operation, since it is not easy to calculate BLEU after inserting placeholders). (B) is the episodic reward maximization, where each sample is edited multiple times in a linear fashion, without branching into different paths, and BLEU and RL gradient are calculated only after the completion of all edit operations. At every orange node, we sample k times from this node (in this example, the sample size k is 2). calculates reward for each edit operation2 using score differences from one previous edit. Since every step\u2019s reward is calculated separately, this approach should be easier to learn than episodic approaches (Sutton and Barto, 2018). However, it is also more prone to learning bias since the editing process is inherently multi-step. This drawback should not be emphasized since maximizing the reward for each step will likely maximize the episodic reward in NAR models\u2019 training. We use a leave-one-out baseline (Luo, 2020) for b(s) in Equation 1 instead of the greedy baseline proposed in SCST (Rennie et al., 2017) because the greedy decoding is too strong in LevT, which makes gaining positive rewards in SCST difficult and may reduce learning efficiency. For each edit, we sample k actions from the policy at this point. Then, we calculate the baseline as follows: bi(s) = 1 k \u22121 X j\u0338=i r(yj), (3) where yj is the jth sample from the current policy. The final RL gradient estimation becomes \u25bd\u03b8L(\u03b8) \u2248\u2212(r(yi) \u2212bi(s)) \u25bd\u03b8 log\u03c0\u03b8(yi|s). (4) In a straightforward implementation, one might consider applying sampling again to all k samples 2In practice, since it is not easy to calculate BLEU after inserting placeholders, we consider placeholder insertion and token replacement as one edit operation. from the last edit. However, this will cause a combination explosion when the number of edit operations increases. Practically, we randomly choose a sample from the previous edit to perform the subsequent operations. We show an illustration of the sampling process in (A) of Figure 2 and pseudo code of our algorithm in Appendix A. Episodic Reward Maximization We also introduce episodic reward maximization, which calculates rewards only once for each sample and gives all actions the same weight. It is a more traditional way to train NMT models in RL. It allows unbiased learning but may not be efficient. We use the leave-one-out baseline for the episodic reward as well as the stepwise reward. We sample k samples from the initial input. Each sample will be edited multiple times without a branch. After the final edit, we calculate the rewards and baselines. We show an illustration of the sampling process in (B) of Figure 2 and pseudo code of our algorithm in Appendix B. Temperature Control Applying RL to NAR differs significantly from AR because there could be various types of actions rather than just predicting the next token, like deletion and insertion. Due to this difficulty, NAR may need more fine-grained temperature control during training. To investigate the impact of exploration and exploitation in the training process, we explore five different settings of the temperature. Due to the large decoding space \fof Levenshtein Transformer, default temperature 1 may result in poor rewards, and too small temperature may result in peaky distribution, which are both harmful to learning. We use three constant temperature settings set to 0.1, 0.5, and 1 to verify the effect of temperature magnitude. An annealing schedule is known for balancing the trade-off between model accuracy and variance during training (Jang et al., 2016). There are two ways of thinking here. First, to reduce the exposure bias, we want to get close to the decoding scenario, which is greedy decoding in our experiments. Thus, we can apply a regular annealing schedule to gradually reduce the temperature from 1 to 0.1 during training. The temperature function can be written as follows: \u03c4i+1 = max(\u03c4i \u2217exp(\u2212log(\u03c40/\u03c4T ) T ), \u03c4T ), (5) where T is the number of total training steps, and \u03c40 and \u03c4T are the initial and the target temperatures. Second, using high temperatures in the early stages of training may lead to poor rewards and result in low learning efficiency. We can apply an inverted annealing schedule to gradually increase the temperature from 0.1 to 1, guaranteeing stable training in the early stages and gradually increasing the exploration space for efficient training. The temperature function can be written as follows: \u03c4i+1 = min(\u03c4i/exp(\u2212log(\u03c4T /\u03c40) T ), \u03c4T ). (6) In each decoding iteration, multiple edit operations occur, and each operation has a different decoding space size. It may be beneficial to optimize this by using varying temperatures for each operation in every iteration. This is a complicated research question and we leave this exploration to future work. 4 Experiments 4.1 Experimental Setup Data & Evaluation We use WMT\u201914 EnglishGerman (EN-DE) (Bojar et al., 2014) and WAT\u201917 English-Japanese (EN-JA) Small-NMT datasets (Nakazawa et al., 2017) for experiments. We use BPE token-based BLEU scores for evaluations. Data preprocessing follows Gu et al. (2019). Baseline We use Levenshtein Transformer as our baseline. Following Gu et al. (2019), we trained a LevT with 300K steps and a max batch size of 65,536 tokens per step. However, like Reid et al. (2023), we cannot reproduce the results of Gu et al. (2019). We use our results in this paper. RL According to Gu et al. (2019), most decodings are gotten in 1-4 iterations, and the average number of decoding iterations is 2.43. To minimize the gap between the training and decoding states, we start with a null string and conduct 3 iterations (8 edits) for each sample during RL training. We set the total training steps T to 50,000, with a max batch size of 4,096 tokens per step. To prevent the out-of-memory issue, we limit the decoding space of placeholder insertion from 256 to 64. The sample size k of the baseline is set to 5. Our implementation is based on Fairseq3. Computational Cost The pre-training phase of LevT on a GCP VM instance with A100x4 GPUs requires roughly 3 days, while the subsequent RL fine-tuning process takes approximately 1 day to complete. 4.2 Results We show the BLEU scores of our approaches in Table 1. The episodic reward model4 showed notable improvement over the baseline. The score is even close to the distillation model, which requires a heavy pre-training5 of AR models. However, the stepwise reward model showed only limited improvement. To explain this, we focus on the advantage, r(y) \u2212b(s), included in the policy gradient (Equation 1), as a larger value of the advantage can increase the policy gradient\u2019s magnitude. A higher standard deviation (SD) of the advantages indicates larger fluctuations in policy gradients. Table 2 shows the SDs of the advantages of the stepwise reward model, with notably higher values in the early stages of edit operations compared to later stages. This suggests that the stepwise reward model disproportionately focuses on early operations, potentially leading to uneven learning and reduced performance. In contrast, the episodic reward model applies the same rewards and advantages across all operations, facilitating more uniform learning and improved performance. 3https://github.com/facebookresearch/fairseq 4The term \u201cepisode/stepwise reward model\u201d specifically refers to the model trained using the \u201cepisode/stepwise reward maximization\u201d approach. 5To produce a distillation model, we need to train an autoregressive Transformer first, which needs additional 3 days of training on our machine. \fModel EN-DE EN-JA LevT 24.03 31.76 LevT + distillation 26.49 LevT + RL (stepwise) 24.29 31.73 LevT + RL (episodic) 25.72 32.75 Table 1: The BLEU scores of our approaches and the baseline. Temperatures are set to 1. Due to the limited computational resources, we only trained the distillation model for the EN-DE dataset using the ready-made distillation dataset. Iteration Edit Operation EN-DE EN-JA 1 Insert + Replace 9.99 8.59 2 Delete 2.05 1.35 Insert + Replace 3.28 2.48 3 Delete 1.67 1.29 Insert + Replace 3.04 1.60 Table 2: Stepwise reward model\u2019s standard deviation (SD) of the advantage in each edit operation. Insertion and replacement share the same reward. We only report scores of applying RL to the model without distillation since we found that RL significantly improved the model without distillation (max 1.69 points) compared to when distillation was applied (max 0.5 point). Moreover, when confronted with distillation models, it raises questions such as which data we should use for RL training, the original or the distillation one. We leave these research questions to future work. We show the BLEU scores of different temperature settings in Table 3. Model performance varies significantly with temperature settings (max 1.01 points in EN-JA). Among constant setting models, the model with a temperature of 0.5 performed best in EN-DE, and the model with a temperature of 0.1 performed best in EN-JA, indicating that too large temperature harms RL training. The two models using annealing schedules performed great in both tasks, showing the effectiveness of the annealing algorithms for improving learning efficiency. However, the annealing models did not always outperform the constant models, which suggests the difficulty of seeking the optimal temperature setting for NAR models\u2019 RL training. Also, we found the inverted annealing model (\u03c4=0.1\u21921) begins dropping performance after 10,000 steps training in EN-JA, indicating that the speed of annealing will significantly affect the model training quality. Temperature EN-DE EN-JA Constant (\u03c4 = 1) 25.72 32.75 Constant (\u03c4 = 0.5) 25.98 33.45 Constant (\u03c4 = 0.1) 25.76 33.60 Annealing (\u03c4 = 1 \u21920.1) 25.83 33.76 Annealing (\u03c4 = 0.1 \u21921) 25.90 33.43 Table 3: The BLEU scores of episodic reward models using different temperature settings. We also quickly surveyed the relationship between performance and the number of decoding iterations in RL. The model performance dropped when we reduced the number of iterations to 2 during training and remained flat when we increased it to 4, indicating that our setting is reasonable. 5"
+                }
+            ],
+            "Jianwei Li": [
+                {
+                    "url": "http://arxiv.org/abs/2312.05725v2",
+                    "title": "FP8-BERT: Post-Training Quantization for Transformer",
+                    "abstract": "Transformer-based models, such as BERT, have been widely applied in a wide\nrange of natural language processing tasks. However, one inevitable side effect\nis that they require massive memory storage and inference cost when deployed in\nproduction. Quantization is one of the popularized ways to alleviate the cost.\nHowever, the previous 8-bit quantization strategy based on INT8 data format\neither suffers from the degradation of accuracy in a Post-Training Quantization\n(PTQ) fashion or requires an expensive Quantization-Aware Training (QAT)\nprocess. Recently, a new numeric format FP8 (i.e. floating-point of 8-bits) has\nbeen proposed and supported in commercial AI computing platforms such as H100.\nIn this paper, we empirically validate the effectiveness of FP8 as a way to do\nPost-Training Quantization without significant loss of accuracy, with a simple\ncalibration and format conversion process. We adopt the FP8 standard proposed\nby NVIDIA Corp. (2022) in our extensive experiments of BERT variants on GLUE\nand SQuAD v1.1 datasets, and show that PTQ with FP8 can significantly improve\nthe accuracy upon that with INT8, to the extent of the full-precision model.",
+                    "authors": "Jianwei Li, Tianchi Zhang, Ian En-Hsu Yen, Dongkuan Xu",
+                    "published": "2023-12-10",
+                    "updated": "2023-12-12",
+                    "primary_cat": "cs.AI",
+                    "cats": [
+                        "cs.AI",
+                        "cs.LG"
+                    ],
+                    "main_content": "Introduction A number of large-scale neural network (NN) architectures have been proposed in recent years and achieved remarkable performance in a wide range of tasks. However, large-scale models require colossal training memory, enormous storage space, and expensive inference costs, making them hard to deploy in production. For example, GPT-3, leading in many natural language processing tasks, has 175 billion parameters to evaluate (Brown et al. 2020). Quantization is one of the most popularized ways to reduce the model size and decrease deployment costs. The core operation is to map a set of continuous real-valued numbers into a fixed discrete set of numbers to reduce the number of bits required for neural networks. This way, computation with low-precision formats can be executed *Accepted by DCAA@AAAI 2023 \u2020North Carolina State University, Email: jli265@ncsu.edu \u2021University of Michigan, Email: tonyztc@umich.edu \u00a7Moffett AI, Email: ian@moffett.ai \u00b6North Carolina State University, Email: dxu27@ncsu.edu Copyright \u00a9 2023, Association for the Advancement of Artificial Intelligence (www.aaai.org). All rights reserved. Figure 1: INT8 Uniform Quantization v.s. FP8 Non-Uniform Quantization. [\u2206i, \u2206i+1] refers to the discrete quantization interval. with a smaller circuit area, fewer clock cycles, and less energy, making model inference quick and environmentfriendly (Horowitz 2014; Burgess et al. 2019). Moving from full-precision floating-point representations to low-precision fixed integer values represented in eight bits or less is currently the most widely accepted quantization method. For example, Han, Mao, and Dally (2016); Jacob et al. (2018); Banner et al. (2018) implement quantization with INT8 format and achieves low accuracy loss on CNN-based models. This kind of method primarily trains the model with the full-precision design first and then performs quantization without any finetuning, also known as PostTraining Quantization (PTQ). Therefore, the overhead of PTQ can be negligible. However, it is proved that PTQ with INT8 is unreliable because it may significantly decrease the performance of Transformer-based models (Anderson et al. 2021). For example, Kuzmin et al. (2022) discover that the accuracy of BERT on GLUE datasets significantly drops after quantization. To resolve the problem above, Kim et al. (2021); Zafrir et al. (2019); Bhandare et al. (2019) finetune the model after quantization to recover the accuracy of the original full-precision model, also known as Quantization Aware Training (QAT). However, its complexity and expensive retraining cost hinder the widespread adoption of QAT. This paper proposes quantifying the full-precision numarXiv:2312.05725v2  [cs.AI]  12 Dec 2023 \fbers to floating 8-bit values (FP8) instead of INT8. We delve into the hidden reasons for the failure of PTQ in Transformer-based models and find that there are many outliers in BERT, which is unfriendly for the uniform quantization strategy with INT8. Similarly, Miyashita, Lee, and Murmann (2016) shows that, in some trained neural networks, parameters are non-uniformly distributed. Therefore, it is intuitive that non-uniform floating-point 8-bit precision may perform better than uniformly distributed INT8 for quantization. We describe the difference between INT8 uniform quantization strategy and FP8 non-uniform quantization strategy in Figure 1. Previously, FP8 has not been frequently mentioned as a quantization target due to the lack of hardware support. However, Graphcore, AMD, and Qualcomm published their FP8 specification in 2022 (Noune et al. 2022). At a similar time, NVIDIA, Arm, and Intel released their standard (Micikevicius et al. 2022). Both of them include two encodings, E4M3 (1 sign bit, 4 exponents bits, 3 mantissa bits) and E5M2 (1 sign bit, 5 exponents bits, 2 mantissa bits). Moreover, quantization with FP8 becomes realistic as commercial computing platforms with FP8 support release. For example, NVIDIA published RTX 40 Series graphic cards with FP8 support natively (NVIDIA Corp. 2022). In addition, Habana, Graphcore, and Moffett also announced the plan to support FP8 in the future products (Habana Labs Ltd. 2022; Graphcore Inc. 2022). We describe our contribution as follows: \u2022 We corroborate the performance of the Post-Training FP8 Quantization method on a wide range of tasks, models, and datasets. \u2022 We propose a reliable Post-Training Quantization strategy for BERT and other Transformer-based models that is as simple as the most widely accepted PTQ INT8 Quantization while yielding much closer accuracy to the full-precision model. \u2022 We provide an empirical FP8 quantization guideline for future research. The rest of the paper is structured as follows. First, we introduce related work in the next section. Then we describe our Post-Training Quantization strategy in the methodology section. Finally, in the experiment section, we compare the results of FP8 quantization strategy and INT8 strategy on Transformer-based and CNN-based models, followed by analysis and conclusion. Related Work Quantization is a method to represent full or higher precision values by a discrete set of numbers to minimize the number of bits required and maximize the accuracy simultaneously. For a machine learning model using single-precision (FP32) format, encoding it with a lower-bit format, like IEEE half-precision format (FP16) or Brain floating point (BF16), can significantly reduce the model size and accelerate model training and inference (Courbariaux, Bengio, and David 2014; Gupta et al. 2015; Micikevicius et al. 2017). Quantization with 8-bit integer (INT8) is a popular trend since some edge devices only support integer arithmetic (Arm Ltd. 2020). INT8 Quantization has been well explored on many CNN-based models and achieves almost the same accuracy with full-precision versions (Han, Mao, and Dally 2016; Jacob et al. 2018; Banner et al. 2018). In parallel, previous works also find that INT8 Quantization with Transformer-based models requires more effort to keep accuracy (Anderson et al. 2021). Bhandare et al. (2019) and Zafrir et al. (2019) quantize BERT with mixed precision and achieve low accuracy loss. Kim et al. (2021) further enables the BERT model to perform integer-only inference by replacing sensitive operators with specific functions. However, both of these methods require expensive extra model retraining. In this paper, we try to overcome this deficiency with FP8. Recently, new hardware supporting 8-bit floating numbers (FP8) has been successively released (NVIDIA Corp. 2022; Habana Labs Ltd. 2022), which inspire us to explore 8-bit quantization with FP8. Early works like Sun et al. (2019); Wang et al. (2018); Cambier et al. (2020) has demonstrated FP8\u2019s potential ability to maintain accuracy on some CNNbased models compared with FP32. Furthermore, the parallel work (Kuzmin et al. 2022) also indicates that FP8 brings significant improvement of accuracy in the quantization of Transformer-based models, which is consistent with our conclusion. Methodology This section introduces the FP8 specifications we adopt and then demonstrates the FP8 quantization methods applied in our experiments. Generally, we directly borrow the strategies from INT8 quantization. FP8 Specifications The industry has released two FP8 specifications in 2022. One is supported by Graphcore, AMD, and Qualcomm, while NVIDIA, Arm, and Intel propose the other. In this paper, we adopt the standard from NVIDIA Corp. (2022), and verify the performance of two kinds of encoding: E4M3 (1 sign bit, 4 exponents bits, 3 mantissa bits) and E5M2 (1 sign bit, 5 exponents bits, 2 mantissa bits). FP8 Simulation Due to the lack of ubiquitous hardware and software supporting FP8 arithmetic, we simulate this low-precision logic with full-precision numbers. Specifically, we implement the C++ library to support the conversion between the FP32 and FP8 numbers. The converting process is rule-based: (1) the exponent values in two formats should be aligned. (2) the mantissa value in the casting process should always keep bits with high precision. Finally, we can evaluate FP8 results on general hardware (such as CPU). In addition, we also evaluate the FP8 result on Moffett\u2019s next-generation chip (Photon), which natively supports FP8 arithmetic. Non-Uniform FP8 Quantization FP8 quantization requires defining the function used to quantize neural network (NN) weights and activations with FP8 format. The core functionality of this function is to map \fthe real values in FP32 precision into a low-precision range. For example, the integer range for INT8 is [-128, 127]; the float range for FP8 E4M3 is [-448.0, 448.0]; the float range of FP8 E5M2 is [-57334.0, 57334.0]. In this paper, we borrow the idea from INT8 quantization and design Equation 1 to do this work. Qfp8(r) = Xi, if r S \u2208[\u03b4i, \u03b4i+1) (1) where Qfp8 is the quantization operator, r is the original float number, S is scaling factor, Xi denotes the discrete FP8 quantized levels, \u03b4i represents the FP8 quantized steps. In this paper, we obtain the value of Xi by simply casting r S from FP32 format to FP8 format. Therefore, we rewrite the function as Equation 2. Qfp8(r) = Castfp32 to fp8( r S ) \u2212Z. (2) where Z is the offset for zero point. Note that our resulting FP8 quantized values are non-uniformly spaced in 256 8-bit representations because of the nature of floating point numbers. In contrast, the INT8 quantized values are uniformly spaced with the same mapping function. Symmetric FP8 Quantization According to the definition of Equation 1, we know the scaling factor S decides the final FP8 quantized values. Therefore, we borrow the idea from INT8 Symmetric Quantization and design Equation 3 to obtain the scaling factor. S = \u03b2 \u2212\u03b1 Maxfp8 ; \u03b2 = \u2212\u03b1 (3) where [\u03b1, \u03b2] is the clipping range of real values. Moreover, the Z in Equation 1 is set to be 0 because of its symmetric property. Clippling Range Calibration In order to derive the optimal scaling factor, we may first need to choose the optimal clipping range. Many methods have been proposed to handle this problem. For example, Wu et al. (2020); McKinstry et al. (2019) uses the min/max value of NN weights or activations to define the clipping range; Migacz (2017) calibrates the clipping range by minimizing KL divergence between the real values and the FP8 quantized values. This paper adopts the most straightforward method: min/max signal. Therefore, the Equation 3 can be rewrite as Equation 4. S = Max(|rmax|, |rmin|) Maxfp8 (4) Static FP8 Quantization At the inference phase, NN activations will change as the input change, so we may generate the scaling factor for each input to reduce quantization error. This method of quantization is known as Dynamic Quantization. However, computing the clipping range dynamically can be expensive. Therefore, we choose static scaling factors for NN activations and weights in this paper. Channelwise and Layerwise FP8 Quantization NN weights have multiple dimensions, where the channel dimension is relatively independent. For CNN-based models, each channel corresponds to a number of filters; For Transformer-based models, each channel corresponds to a sequence of token embeddings. The filters and token embeddings from different channels mostly have different ranges of values. Therefore, the granularity of choosing clipping range [\u03b1, \u03b2] for NN weights at each channel is crucial for the final FP8 quantization performance. Currently, Channelwise Quantization is the standard approach used for the NN weights in INT8 quantization, so we adopt the same strategy in FP8 quantization. Regarding the NN activations, we choose the basic Layererwise Quantization strategy. POST Training FP8 Quantization For INT8 quantization, previous works mostly require model retraining to recover the accuracy, especially for Transformer-based models. This kind of method is known as Quantization Aware Training. In this paper, our FP8 quantization generally does not require model retraining, also known as Post-Training Quantization. Mixed-precision FP8 Quantization Some non-linear operators (such as Softmax, Gelu) and Layernorm are sensitive to Quantization. As a result, it is easy to see significant accuracy degradation when we quantized them. Therefore, we accept half-precision format (BF16) for these special operators in our strategy. Experiments In this section, we aim to empirically verify the FP8 quantization results in a wide range of tasks, models, and datasets with basic quantization strategies introduced in Section . We also compare our results with INT8 quantization in the same experimental settings. Finally, we explore and analyze the experiment results and the hidden reasons. Baselines and Setup We validate the effect of FP8 quantization with BERTbase and BERT-large on GLUE dev datasets for the natural language understanding task. In addition, we also check their quantization results on Squad v1.1 for the questionanswering task. Moreover, We do experiments on ResNet18 and ResNet50 with CIFAR10, CIFAR100, and ImageNet datasets for the image classification task. All the models are first trained and evaluated in FP32 format and then used as our first baseline. After that, the second baseline is derived from INT8 quantization. Note that the two quantization settings are the same as each other. That means the INT8 quantization strategy in the baseline and our FP8 quantization strategy are both Post-Training Quantization, which does not require retraining. In this paper, we only test the quantization results of one encoding of FP8: E4M3. \fModels MNLI-m Acc QNLI Acc QQP Acc MRPC Acc SST-2 Acc COLA Mrr RTE Acc STS-B Spear BERT-base FP32 84.58 91.4 90.91 87.6 92.43 56.3 72.3 89.0 BERT-base Int8 34.39 51.62 63.16 31.62 52.64 9.0 47.29 27.6 BERT-base FP8 (E4M3) 84.63 91.58 90.96 87.2 92.32 56.0 72.2 89.0 BERT-large FP32 86.6 92.3 91.3 89.1 93.2 60.6 74.8 90 BERT-large Int8 43.25 52.12 67.33 34.52 59.33 9.2 50.12 29.32 BERT-large FP8 (E4M3) 85.9 92.2 91.3 88.9 93.3 60.0 75.1 89.8 Table 1: BERT: FP32 v.s. INT8 Quantization v.s. FP8 Quantization on GLUE dev set. Note that our quantization results (INT8 and FP8) are both from POST-Training Quantization. We only quantize the general matrix multiply operators(GEMM). Model squad v1 EM / F1 BERT-base FP32 80.8 / 88.5 BERT-base Int8 0.18 / 4.42 BERT-base FP8 (E4M3) 78.89 / 86.44 BERT-large FP32 84.1 / 90.9 BERT-large Int8 0.24 / 6.4 BERT-large FP8 (E4M3) 82.87 / 88.9 Table 2: BERT: FP32 v.s. INT8 Quantization v.s. FP8 Quantization on SQuAD v1.1 Natural Language Understanding Task For Transformer-based models (such as BERT-base and BERT-large), we follow the previous literature (Bhandare et al. 2019; Zafrir et al. 2019) only to quantize the general matrix multiply operators (GEMM) since they are the bottleneck of execution efficiency of quantized models. In contrast, we use the half-precision (BF16) to calculate the rest operators (such as LayerNorm, Gelu, and Softmax). This kind of quantization is also known as Mixed-Precision Quantization. Finally, we verify the models\u2019 accuracy on the GLUE dev set, and Table 1 describes the FP8 quantization results. Question Answering Task In addition, we also check the FP8 quantization results of Transformer-based models on SQuAD v1.1 Different from GLUE, SQuAD is more challenging because it is a questionanswering task. We show the FP8 quantization results in Table 2. Result Analysis. Based on the results in Tables 1-??, we discover that Post-Trianing FP8 Quantization can significantly improve the accuracy of 8-bit quantized Transformerbased models, even close to the original full-precision models. We conjecture that weights and activations of Transformer-based models consist of a large number of outlier values, which is unfriendly for Post-Training INT8 Quantization. In contrast, FP8 is natively non-uniform and represents a more extensive range of values, which is ideal for the Post-Training Quantization of Transformer-based models. Therefore, our FP8 quantization method is a reliable Post-Training Quantization strategy, and the results of our experiments can provide an empirical guideline for future FP8 quantization research."
+                },
+                {
+                    "url": "http://arxiv.org/abs/2312.05720v4",
+                    "title": "Beyond Gradient and Priors in Privacy Attacks: Leveraging Pooler Layer Inputs of Language Models in Federated Learning",
+                    "abstract": "Language models trained via federated learning (FL) demonstrate impressive\ncapabilities in handling complex tasks while protecting user privacy. Recent\nstudies indicate that leveraging gradient information and prior knowledge can\npotentially reveal training samples within FL setting. However, these\ninvestigations have overlooked the potential privacy risks tied to the\nintrinsic architecture of the models. This paper presents a two-stage privacy\nattack strategy that targets the vulnerabilities in the architecture of\ncontemporary language models, significantly enhancing attack performance by\ninitially recovering certain feature directions as additional supervisory\nsignals. Our comparative experiments demonstrate superior attack performance\nacross various datasets and scenarios, highlighting the privacy leakage risk\nassociated with the increasingly complex architectures of language models. We\ncall for the community to recognize and address these potential privacy risks\nin designing large language models.",
+                    "authors": "Jianwei Li, Sheng Liu, Qi Lei",
+                    "published": "2023-12-10",
+                    "updated": "2024-03-15",
+                    "primary_cat": "cs.LG",
+                    "cats": [
+                        "cs.LG",
+                        "cs.AI",
+                        "cs.CL",
+                        "cs.CR"
+                    ],
+                    "main_content": "Introduction Language models trained under the Federated Learning paradigm play a pivotal role in diverse applications such as next-word predictions on mobile devices and electronic health record analysis in hospitals [Ramaswamy et al., 2019, Li et al., 2020]. This training paradigm prioritizes user privacy by restricting raw data access to local devices and centralizing only the model\u2019s updates, such as gradients and parameters [McMahan et al., 2017]. While the FL framework is created to protect user privacy, vulnerabilities still persist. Previous works [Geiping et al., 2020, Yin et al., 2021, Jeon et al., 2021] proved that attackers can almost perfectly recover image data with gradients, which also highlighted the potential risks in the realm of textual data. Many studies have investigated vulnerabilities of private data in FL when applied to language models [Zhu et al., 2019, Deng et al., 2021, Balunovic et al., 2022, Gupta et al., 2022]. Zhu et al. [2019] and Deng et al. [2021] leverage gradient information and well-designed objective functions to build an optimization-based pipeline that can recover certain training textual data in minimal batch sizes. Balunovic et al. [2022] and Gupta et al. [2022] further improve the recovery rate by incorporating prior knowledge embedded in LLM to provide additional optimization or retrieval signals. All of them mainly focus on algorithm design and external information but rarely notice inherent privacy leakage risks embedded in the language models themselves. In contrast to these approaches, Fowl et al. [2022] and Boenisch et al. [2023] assume a malicious central server, designing specific malicious parameters and architectures for language models to enhance attack performance. To a certain degree, their research is connected to the privacy vulnerabilities of specific module designs. However, their methods depend on matched tampered parameters, such as identity weight matrices. These approaches also violate the training objective, generating useless gradients and parameter updates. Pooler Act         Classfier Vulnerable Module Analytics-based  Estimization Gradient  Match Feature Match Selection Privacy Guarded Attack with Features, Gradients, and Priors 1 2 Optimization-based Recovery Figure 1: Schematic illustration of the two-stage privacy attack method proposed in this study. 1) The first stage involves the analytics-based reconstruction of the feature information associated with the specific Pooler layer in Transformer-based language models. 2) The second stage utilizes the reconstructed feature information, combined with gradient inversion and prior knowledge, to guide the recovery of training data. This figure highlights the approach of intermediate feature recovery while exposing the inherent privacy risks in contemporary language model architectures. Recently, Wang et al. [2023] provides a theoretical analysis that recovers training samples from gradient information for a two-layer fully connected network. A major limitation of their approach is the reliance on a randomly initialized network instead of an actual, pre-trained network. This reliance poses challenges in applying their insights to the prevalent training paradigm that fine-tuning pre-trained models. When applied to deeper networks, their method also relies on identity modules and other transparently detectable weight manipulations, limiting its practical utility. However, building upon this foundation, we have found that certain prevalent modules in contemporary language model architectures possess intrinsic privacy vulnerabilities. This paper focuses on Transformer-based language models featuring a distinctive Pooler layer and proposes a two-stage privacy attack method that exploits vulnerabilities in this specific module. Specifically, in the first stage, we employ an analytics-based reconstruction method to initially recover the direction of features associated with this module. This feature information is not averaged over the number of samples in the same batch or the sequence length, enabling the extraction of more unique information for each token. Subsequently, we utilize this feature information as an additional (beyond gradient and priors) supervisory signal to guide the recovery of training data. This research differentiates itself in the following ways: i) Different from Wang et al. [2023], the research is solidly based on textual data and deep language models in real-world scenarios. ii) Different from Fowl et al. [2022] and Boenisch et al. [2023], this research does not depend on trap weights, such as Identity module, and maintains adherence to an effective training roadmap. iii) In contrast to the honest-but-curious works [Zhu et al., 2019, Deng et al., 2021, Balunovic et al., 2022, Gupta et al., 2022], this research provides feature-level supervisory signals that differ from conventional gradients and priors. The contributions of this research are outlined as follows: 1) Instead of directly recovering the training samples of the entire model, this paper proposes a two-stage attack method to first approximate the intermediate feature information and then recover the real input. 2) We design a strategic weight initialization method coupled with a flexible tuning approach, thereby empowering an analytics-based method to accurately and efficiently deduce the direction of intermediate features in a specific module. 3) When integrated with gradient inversion and prior knowledge, our method consistently 2 \fA PREPRINT surpasses previous methods in the attack performance across a variety of benchmark datasets and scenarios. We also propose using the distance between semantic embeddings as a more comprehensive metric for evaluation. 4) This research brings to light the inherent privacy leakage risks that are embedded within the design of contemporary language model architectures. 2 Preliminaries In this section, we describe the relevant background of federated learning, gradient inversion, priors knowledge, two-layer-networks-based reconstruction, as well as the threat model of our proposed attack method. 2.1 Federated Learning Introduced by McMahan et al. [2017], federated learning solves data privacy concerns by promoting decentralized model training. In this approach, models are refined using local updates from individual clients, which are merged at a central server [Kone\u02c7 cn\u00fd et al., 2015, 2016, 2017]. This field has attracted significant attention due to its potential business applications, underlining its promise in academia and industry [Ramaswamy et al., 2019, Li et al., 2020]. 2.2 Gradient Inversion Gradient inversion is a significant technique that could potentially breach privacy in federated learning [Zhu et al., 2019, Zhao et al., 2020]. Although federated learning is designed to provide a decentralized training mechanism ensuring local data privacy, gradient inversion shows that this privacy may not be infallible. Problem definition: Consider the supervised learning framework wherein a neural network f(\u00b7; \u0398) : x \u2208Rd \u2192f(x; \u0398) \u2208R is trained using the objective: min \u0398 X (x,y)\u2208D \u2113(f(x; \u0398), y) (1) where \u2113is the loss function and D denotes the dataset of input-output pairs. In the federated paradigm, during the communication between the central server and clients, each node reports an average gradient of its local batch S [McMahan et al., 2017, Kone\u02c7 cn\u00fd et al., 2015]. This is mathematically formulated as: G := 1 B \u2207\u0398 B X i=1 \u2113(f (xi, \u0398) , yi) (2) where B is the batch size of S. Given the above definition, the challenge posed by gradient inversion becomes apparent: With access to a once-queried gradient and a known model as well as its loss function, is it possible to reconstruct the input training data? Objective of Gradient Inversion: Based on the above problem, the objective of gradient inversion can be represented as: min {\u02c6 xi,\u02c6 yi}B i=1 d   1 B B X i=1 \u2207\u0398\u2113(f (\u02c6 xi; \u0398) , \u02c6 yi) , G ! (3) Here, d(\u00b7, \u00b7) quantifies the difference between the provided and deduced gradients, and ( \u02c6 xI, \u02c6 yi) refers to the estimated input and its label. Prominent works have leveraged this objective to attempt the retrieval of private data [Zhu et al., 2019, Zhao et al., 2020, Geiping et al., 2020]. 2.3 Prior Knowledge Relying solely on gradient inversion to recover textual data often proves challenging, especially when handling larger batch sizes and long sequences. Researchers often seek to acquire the prior knowledge encapsulated in pre-trained language models like GPT-2 [Radford et al., 2019] to address this. These models are adept at predicting the probability of the next token based on the preceding sequence. This property aids in evaluating the quality of text searched through gradient inversion. Specifically, it introduces the perplexity as an evaluation metric to guide optimization by pinpointing optimal starting points or intermediate points of the attack [Balunovic et al., 2022, Gupta et al., 2022]. 3 \fA PREPRINT 2.4 Two-layer Network-based Reconstruction Wang et al. [2023] identified a gap in existing literature regarding the capability of gradient information to unveil training data. Their study demonstrates that it might be possible to reconstruct training data solely from gradient data using a theoretical approach within a two-layer neural network. Consider a two-layer neural network: f(x; \u0398) = Pm j=1 aj\u03c3(wj \u00b7 x), with parameters defined as \u0398 = (a1, ..., am, w1, ..., wm). Here, m represents the hidden dimension. The objective function is represented as: L(\u0398) = PB i=1(yi \u2212f(xi; \u0398))2. A notable finding is that the gradient for aj is solely influenced by wj, making it independent from other parameters. This gradient is represented as: gj := \u2207ajL(\u0398) = B X i=1 ri\u03c3 \u0000wT j xi \u0001 (4) where the residual ri is given by ri = f(xi; \u0398) \u2212yi. For wide neural networks with random initialization from a standard normal distribution, the residuals ri concentrate to a constant, r\u2217 i . By set g(w) := PB i=1 r\u2217 i \u03c3(w\u22a4xi), gj can be expressed as gj = g(wj) + \u03f5, where \u03f5 represents noise. Then the third derivative of g(w) is represented as: \u22073g(w) = B X i=1 r\u2217 i \u03c3(3)(wTxi)x\u22973 i (5) Here, x\u22973 i signifies the tensor product of vector xi with itself three times. The researchers postulated that if they can accurately estimate \u22073g(w), it is possible to determine {xi}B i=1 by using tensor decomposition techniques, especially when these features are independent. They used Stein\u2019s Lemma, expressed as: E[g(X)Hp(X)] = E[g(p)(X)] to approximate \u22073g(w) as: T = EW [\u22073 W g(W)] = EW \u223cN(0,I)[g(W)H3(W)] \u22481 m m X j=1 g(wj)H3(wj) = \u02c6 T (6) Where H3(wj) is the p-th Hermite function of wj. By leveraging this approach, they successfully reconstructed each unique xi. Their approach is primarily theoretical, focusing on two-layer fully connected networks and largely confined to randomly initialized networks. When applied to deeper networks, their method uses identity modules and other transparently detectable weight manipulations, which also limits its practical use. Inspired by Wang et al. [2023], we have identified a vulnerable module commonly found in current language model architectures, such as BERT and RoBERTa [Devlin et al., 2018, Liu et al., 2019]. The module, comprising the Pooler and Classifier layers, typically forms the final stages of these networks. Given this module does not have deeper topological connections, it can be treated as an independent two-layer network. Leveraging this insight, we have designed specific techniques to enhance the two-layer network-based reconstruction method, enabling it to recover the feature information associated with this special module in pre-trained language models. Further details of this methodology are discussed in Section 3.2. 2.5 Threat Model To facilitate comparisons with previous works, our threat model is based on the following principles: 1) We opt to freeze the gradients of both token and positional embeddings. This is because it is relatively easy to deduce the training text tokens or max sequence length without this restriction since only the tokens and positions in the current training batch will receive gradient updates on the embedding matrix. By freezing the updates of these embeddings, we create a more challenging attack scenario. 2) We ensure that the training process maintains effective gradient aggregation and consistently aims to minimize the training loss. This principle is crucial for preserving the integrity and efficiency of the training process, ensuring it remains free from suspicion. 3) We refrain from using trap weights, such as the Identity module, in our approach. However, instead of using pre-trained weights for initialization, we may opt to initialize randomly for partial weights of certain layers. 3 Methodology Gradient inversion seeks to reconstruct the original training data by harnessing the gradients of a known network. A closer look at this method reveals several challenges. Central to these is the nonconvexity of the issue, marked by the 4 \fA PREPRINT presence of numerous local minima that complicate the pursuit of the global optimum. Additionally, the problem is over-determined because it has more equations to resolve than unknown parameters. While these equations remain consistent, they complicate the optimization process. This complexity persists even when reduced to a single-sample scenario. As a result, gradient inversion remains an NP-complete problem, implying that procuring an exact solution within a feasible time frame is difficult [Wang et al., 2023]. From a broader perspective, it is crucial to recognize that text tokens represent discrete data, different from the continuous nature of images. Additionally, the gradients of language models are not just averaged over the number of samples in the same batch, but also across the sequence length of the longest sentence in that batch. These properties make the recovery of textual training data more challenging compared to image data. To overcome these challenges, this paper endeavors to seek more valuable information that could guide the recovery or retrieval process. Instead of solely focusing on gradients and external information (priors), we shift our attention toward the inner workings of the model itself. 3.1 Vulnerable Module Identification Building upon the work of Wang et al. [2023], which demonstrated the feasibility of recovering training data using gradient information from a two-layer fully connected network, we are reminded to scrutinize similar vulnerabilities embedded in contemporary language model architectures. However, the increasing complexity and depth of these models render it nearly impossible to apply a similar strategy without resorting to trap weights, such as an identity module. This leads us to a critical observation when examining the architecture of widely-used transformer-based language models like BERT and RoBERTa. Notably, these models contain a module consisting of a Pooler layer and a Classifier layer, with a non-linear activation function between them. By analyzing the topological operational order, we discern that this module can be treated as an independent two-layer fully connected network, given its position at the top of the language model, implying no deeper logical operations. With this keen realization, instead of attempting to recover the training samples of the entire model in one step, we propose first recovering the input information for this special module using an analytics-based method. This additional information then aids the optimization-based method (gradient inversion) with extra supervisory signals, thereby enhancing privacy attack performance. we have successfully unearthed a novel source of valuable information, distinct from conventional gradients and priors, embedded within the internal module of the model itself. We identify this module as a vulnerable module, which harbors inherent privacy leakage risks. Nonetheless, Wang et al. [2023]\u2019s reconstruction method, as described in Section 2.4, comes with its own set of assumptions and limitations. Most critically, it does not recover the actual features but their direction within the feature space. To ensure the efficacy of this analytics-based method, especially in its application to real pre-trained language models, we have designed several critical techniques to relax or remove these limitations. 3.2 First-stage Analytics-based Attack In the first-stage attack, we aim to first recover the feature information directed to the identified vulnerable module with an enhanced analytics-based method. To better elucidate our tailored design, let us first establish the notations used in this context: Let X \u2208RB\u00d7d be the input to this vulnerable module, where B is the batch size and d is the feature dimension. Let W1 \u2208Rd\u00d7v and W2 \u2208Rv\u00d7n denote the weights of the Pooler layer and the Classifier layer, respectively, with v being the pooler dimension and n being number of classes. Let \u03c3 represent the non-linear activation function that is positioned after the Pooler layer. Enlarge Pooler Dimension: The initial configuration of language models often sets the pooler dimension v to match the hidden dimension d (For BERTBASE, it\u2019s 768) [Devlin et al., 2018]. This setting is insufficient to promise the accuracy of tensor decomposition when applying the analytics-based reconstruction method. To address this limitation, we temporarily expand the pooler dimension to match the vocabulary size for BERT. To be explicit, we set v = |V |. The rationale behind this change is grounded in enhancing the model\u2019s expressiveness while ensuring our modification is subtle. It\u2019s important to note that, given the expanding width of state-of-the-art language models such as GPT-3 Brown et al. [2020], the hidden dimension has become sufficiently large to assure the accuracy of our method. Consequently, we can bypass this certain step that would otherwise be necessary in BERT. Strategic Weight Initialization: As mentioned in Section 2.4, m signifies the intermediate dimension in the two-layer network. In our setting, we should have m = v. However, during our computation of \u02c6 T as outlined in Equation 6, we noticed an anomaly in gj. Due to the random initialization of W1 by requirement, a substantial portion of gradients gj approached a value close to 0. This side effect impacts the subsequent decomposition procedure. To address this issue, rather than setting m = v, we set m = v \u2212d. This approach ensures the original pre-trained weights W \u2032 1 \u2208Rd\u00d7d are retained in the new weight matrix W1 \u2208Rd\u00d7v, allowing us to obtain optimal gradients for W1 and W2. Simultaneously, 5 \fA PREPRINT the remaining dimensions W \u2032\u2032 1 \u2208Rd\u00d7(v\u2212d) are randomly initialized and adequate to promise the accuracy of tensor decomposition. For the classifier layer, we utilize a strategy similar to that of the Pooler layer, adjusting the remaining dimensions to a constant (i/m, where i represents the class index for the classification task). More details are in Appendix B.1. From one perspective, it may appear that we have altered the parameters. However, it is important to clarify that we have not assigned any special properties to these weights. Our approach involves initializing part of the weight randomly, which is a standard operation in model initialization. Furthermore, this random initialization is confined only to the identified vulnerable module, allowing the rest of the language model to utilize pre-trained weights for initialization. Consequently, this approach avoids creating trap weights and ensures the normal training roadmap. Flexible Tuning Framework: Wang et al. [2023] suggests significantly expanding the pooler dimension m in comparison to the input dimension d to reduce the tensor decomposition error. In our setting, the specific relationship between recovery dimension d and pooler dimension v = m + d remains undetermined. Recognizing these constraints, we keep m constant and design an alternative method to tweak d. Specifically, instead of attempting to recover the full dimension d, our strategy focuses on recovering a dimension d\u2032 and d\u2032 \u2264d. This approach sets the subweights (d: , d\u2032 : ) of W1 to zero. Then the gradient gj in Equation 6 remains functional but is exclusively tied to the subweights (: , : d\u2032) of W1. As a result, we embrace a more flexible and efficient methodology by centering our reconstruction on the feature subset X \u2208RB\u00d7d\u2032. More details can be found in Appendix B.1. Reorder Feature Information: When applying tensor decomposition techniques to retrieve features from \u02c6 T, a significant issue arises when the batch size exceeds one: the exact order of the recovered features remains uncertain. Under adversarial conditions, one might try every conceivable permutation as a reference. However, we simplify the procedure by sequentially comparing each recovered feature to the actual input features with cosine similarity until the best order is discerned. In certain cases, a single recovered feature displayed a notably high cosine similarity with multiple actual inputs simultaneously. Interestingly, although a 1-m greedy relationship might exhibit a high correlation, it did not exceed the attack performance of a straightforward 1-1 match in the final outcome. Consequently, we adopted the 1-1 relationship to achieve the best attack result. Activation Function Exploration: Our empirical observations have indicated that various activation functions result in differing effects on information retrieval. Consequently, rather than limiting our focus to the original activation function, we have experimented with a range of activation functions to assess their impact on the final attack performance. Currently, we include activation functions such as Tanh, ReLU, SeLU, and a custom function defined as \u03c3(x) = x3 +x2. A more detailed discussion of this design will be presented in Section 5. 3.3 Second-stage Optimization-based Attack In the second-stage attack, we aim to recover the real input for the entire language models with an optimization-based method. Specifically, following Balunovic et al. [2022], we divide our entire optimization process into three phases: Initialization, Training, and Token Swap. In the initialization and token swap stages, we aim to leverage certain metrics to identify optimal starting or intermediary points for the subsequent training phase. This stage is also commonly recognized as discrete optimization. In this setting, we\u2019ve chosen a mix of metrics to guide the choice, including gradient match loss and perplexity obtained from pre-trained language models. In the optimization stage, we optimize the embeddings derived from input IDs to minimize gradient matching loss and cosine distance between the input of the Pooler layer with the recovered feature information from our first-stage attack. This phase falls under the category of continuous optimization. We oscillate between continuous and discrete optimization phases to bolster the final attack performance. More details can be found in Appendix B.1. 4 Experiments This section initially presents the fundamental setup for our experiments. Subsequently, we demonstrate the results of experiments in various settings and provide an in-depth analysis from multiple perspectives. 4.1 Set Up Datasets: Following previous work Balunovic et al. [2022], our experimental design incorporates three binary text classification datasets to ensure a comprehensive evaluation. Specifically, we utilize CoLA and SST-2 from the GLUE benchmark [Warstadt et al., 2018, Socher et al., 2013, Wang et al., 2019], with their sequences predominantly ranging between 5-9 and 3-13 words, respectively. Additionally, the RottenTomatoes dataset presents a more complex scenario with sequence lengths oscillating between 14 and 27 words [Pang and Lee, 2005]. More details can be found in 6 \fA PREPRINT Appendix C.3. Within the scope of our experiments, we utilize a subset of 100 randomly selected sequences from the training sets of these datasets as our evaluation benchmark, a method also endorsed by Balunovic et al. [2022]. Models: Experiments are primarily based on BERTBASE [Devlin et al., 2018] architecture. Consistent with Balunovic et al. [2022], we use models that have been fine-tuned on downstream tasks for two epochs. To ensure a fair comparison, we adopt the same fine-tuned models from Balunovic et al. [2022]. As for the auxiliary language model employed to extract prior knowledge, we choose GPT-2 [Radford et al., 2019], a choice also used by Balunovic et al. [2022]. Metrics: Following Deng et al. [2021] and Balunovic et al. [2022], we evaluate attack performance with the ROUGE metric suite [Lin, 2004]. Specifically, we present the F-scores of ROUGE-1, ROUGE-2, and ROUGE-L. These metrics respectively assess the retrieval of unigrams, bigrams, and the proportion of the longest continuous matching subsequence relative to the entire sequence. We omit all padding tokens in the reconstruction and evaluation phases. Baselines: We benchmark our approach against three baselines: DLG, TAG, and LAMP, with a similar definition of threat model described in Section 2.5. Among them, LAMP represents the state-of-the-art. We employ the open-sourced implementation from LAMP, which encompasses the implementations for all three baselines [Deng et al., 2021, Zhu et al., 2019, Balunovic et al., 2022]. Following previous work, we assume the lengths of sequences are known for both baselines and our attacks, as an adversary can run the attack for all possible lengths [Balunovic et al., 2022]. Implementation: Our method is implemented based on LAMP\u2019s framework. To ensure a fair comparison, we standardized the experimental conditions and settings when comparing our approach with baselines. We adopt all of LAMP\u2019s hyperparameters, including the optimizer, learning rate, learning rate schedule, regularization coefficient, and optimization steps. For hyperparameters unique to our method, we made selections using a grid search on BERTBASE and shared them in different settings. We also assume the prior knowledge of input labels. This is typical in text classification tasks with limited categories because we can easily iterate all the potentials. More details can be found in Appendix B.1. Table 1: Analysis of Text Privacy Attacks on BERTBASE: Impact of Various Batch Sizes and Datasets. The terms R-1, R-2, and R-L represent ROUGE-1, ROUGE-2, and ROUGE-L scores, respectively. We calculate the average change by comparing it with the baseline LAMPCOS. Symbols \u2193and \u2191denote degradation and improvement, respectively. Notably, a bold format is used to highlight the most effective attack performance under identical settings. The symbol \u22c6signifies the model\u2019s original activation function. Method B=1 B=2 B=4 B=8 Avg \u2206 R-1 R-2 R-L R-1 R-2 R-L R-1 R-2 R-L R-1 R-2 R-L R-1 R-2 R-L CoLA DLG 59.3 7.7 46.2 36.9 2.6 31.4 35.3 1.4 31.9 16.5 0.8 7.9 \u219317.7 \u219316.8 \u219319.0 TAG 78.9 10.2 53.3 45.6 4.6 36.9 35.3 1.6 31.3 33.3 1.6 30.4 \u21936.4 \u219315.4 \u219310.4 LAMP COS 84.8 46.2 73.1 57.2 21.9 49.8 40.4 6.4 36.2 36.4 5.1 34.4 \u2014 \u2014 \u2014 Ours Tanh\u22c6 84.5 46.1 72.8 56.9 22.0 49.6 41.2 7.8 40.1 37.2 5.2 34.4 \u21910.25 \u21910.4 \u21910.9 Ours ReLU 84.5 45.9 72.6 57.3 19.3 49.8 42.3 8.4 40.1 37.6 5.6 34.5 \u21910.7 \u21930.1 \u21910.9 Ours SeLU 86.6 51.5 76.7 69.5 31.2 60.6 50.5 11.8 43.9 40.8 8.3 38.1 \u21917.1 \u21915.8 \u21916.5 Ours x3+x2 84.6 45.2 72.4 57.3 19.2 49.8 43.9 11.4 40.1 37.8 5.9 34.8 \u21911.2 \u21910.5 \u21911.0 SST-2 DLG 57.7 11.7 48.2 39.1 7.6 37.2 38.7 6.5 36.4 36.6 4.7 35.5 \u219316.0 \u219319.3 \u219314.1 TAG 71.8 16.1 54.4 46.1 10.9 41.6 44.5 9.1 40.1 41.4 6.7 38.9 \u21938.0 \u219316.2 \u21939.7 LAMP COS 87.7 54.1 76.4 59.6 26.5 53.8 48.9 17.1 45.4 39.7 10.0 38.2 \u2014 \u2014 \u2014 Ours Tanh\u22c6 88.5 56.9 77.3 66.4 33.2 61.2 49.9 15.6 46.1 43.5 10.9 40.5 \u21913.1 \u21912.2 \u21912.8 Ours ReLU 88.5 56.1 77.1 67.3 32.6 60.8 50.4 14.1 46.2 43.5 11.2 40.8 \u21913.4 \u21911.6 \u21912.8 Ours SeLU 90.3 59.0 78.2 71.0 35.3 63.4 58.6 26.3 54.2 45.4 11.5 43.2 \u21917.3 \u21916.1 \u21916.3 Ours x3+x2 93.1 61.6 81.5 78.3 40.9 67.9 60.6 23.1 54.9 49.5 16.5 47.3 \u219111.4 \u21918.6 \u21919.5 Rotten Tomatoes DLG 20.1 0.4 15.2 18.9 0.6 15.4 18.7 0.4 15.7 20.0 0.3 16.9 \u219317.4 \u21935.4 \u219311.5 TAG 31.7 2.5 20.1 26.9 1.0 19.1 27.9 0.9 20.2 22.6 0.8 18.5 \u21939.5 \u21934.5 \u21937.8 LAMP COS 63.4 13.8 42.6 38.4 6.4 28.8 24.6 2.3 20.0 20.7 0.7 17.7 \u2014 \u2014 \u2014 Ours Tanh\u22c6 64.2 15.5 43.8 38.8 5.8 28.9 28.3 2.4 21.2 22.4 1.1 18.9 \u21911.7 \u21910.4 \u21911.0 Ours ReLU 64.1 15.7 44.2 40.2 5.4 28.8 31.1 2.6 23.6 22.8 1.3 18.8 \u21912.8 \u21910.5 \u21911.6 Ours SeLU 71.9 19.2 48.7 48.1 8.2 34.2 33.0 4.23 25.3 24.6 2.0 20.6 \u21917.6 \u21912.6 \u21914.9 Ours x3+x2 72.2 21.0 49.3 44.6 7.0 31.8 29.9 3.5 24.3 23.6 1.7 19.8 \u21915.8 \u21912.5 \u21914.0 4.2 Results and Analysis We present experimental results in Table 1. These findings demonstrate that our approach outperforms all baselines (DLG, TAG, and LAMP) across various datasets and batch sizes. Examining the impact of batch size variations, we notice that launching an attack becomes more challenging as the batch size increases. All attack methods, including ours, exhibit a decline in attack performance. However, our method brings a more noticeable improvement at batch 7 \fA PREPRINT sizes 2 and 4, surpassing its efficacy at batch sizes 1 and 8. We posit that for a batch size of 1, where the gradient is only averaged solely over tokens, the benefit of incorporating the feature information is less evident because the gradient information still plays a leading role in the optimization process. For a batch size of 8, the improvement scale is also not pronounced, we explore the background reason in Section 5. 100 200 300 400 500 600 700 d': Recovred Dimension 0.60 0.65 0.70 0.75 0.80 0.85 0.90 0.95 1.00 Cosine Similarity (0.6 to 1) Cos Similarity (B=1) Cos Similarity (B=2) Cos Similarity (B=4) Figure 2: Cosine similarity between recovered features and ground truth of BERTBASE on SST-2 across varying dimensions (50\u223c750 in 50-step intervals) and batch sizes (1, 2, 4) Turning our attention to variations in sequence length across datasets, we notice a clear trend: as sequences get longer, the benefit from feature information at a batch size of 1 becomes more pronounced. Specifically, for the CoLA dataset with token counts between 5-9, we see an average improvement in ROUGE metrics of 3%. This improvement grows to 5% for the SST-2 dataset with token counts from 2 to 13. For the Rotten Tomatoes dataset, which features even longer sequences with token counts ranging from 14 to 27, the average ROUGE metric improvement further increases to 8%. This suggests a correlation between sequence length and the extent of improvement observed. Moreover, when the batch size exceeds one, the benefits observed for these three datasets are consistently notable. Recall that gradient averaging occurs only over tokens at a batch size of 1, it implies that with longer sentences, the gradient information becomes less effective, leading to greater benefits from featurelevel supervision signals. When batch sizes are larger than 1, averaging happens over the number of tokens and sentences simultaneously. This results in our method consistently yielding pronounced benefits across sequences with different lengths. Our findings further reinforce the idea that relying exclusively on gradient information diminishes efficacy with larger batch sizes and longer sequences. In a word, the experiments consistently show that the use of feature information significantly enhances the success of privacy attacks on language models. This evidence further confirms that current language models, particularly in their Pooler and Classifier layers, inherently possess vulnerabilities that pose risks of privacy leakage. 5 Discussion Impact of Activation Function: As outlined in Section 3.2, we replaced the original Tanh activation function with ReLU, SeLU, and a custom activation function \u03c3 = x3 + x2 to investigate how different activation functions affect attack performance in our strategy. Table 1 presents the performance of these attacks under various settings. SeLU and \u03c3 = x3 + x2 consistently yield significant improvements in attack performance, while the enhancements seen with Tanh and ReLU are relatively less pronounced. We speculate that the latter activation functions\u2019 n-th derivative leads to a zero expectation (EZ\u223cN(0,1)[\u03c3(n)(Z)] = 0), thereby affecting the estimation of T as explained in Equation 6. In contrast, the earlier activation functions, whose n-th derivatives are neither odd nor even, do not exhibit this issue, potentially resulting in a more pronounced risk of privacy leakage. Another interesting phenomenon observed is that for the CoLA dataset, all attack methods show only minor improvements, except for attacks utilizing the SeLU. This suggests the existence of an unknown correlation between datasets and the feature information recovered in different activation functions. Further details and discussions are provided in the Appendix B.3. Impact of Recovery Dimension: In Section 3.2, we propose fixing m and adjusting d\u2032 to identify the optimal mapping for d\u2032 (where d\u2032 < d) and m. Accordingly, we conduct experiments using BERTBASE with various batch sizes to investigate the quality of the recovered feature information by calculating their cosine similarity with the ground truth. The results are illustrated in Figure 2. Our findings suggest that when the batch size is 1, the recovered quality gradually degrades as the recovery dimension d\u2032 increases, yet it remains as high as 0.99 across all configurations. However, this pattern does not hold when the batch size exceeds 1. We also observed that the recovered quality consistently declines as the batch size increases. We hypothesize that multiple inputs might exhibit some undisclosed dependencies, particularly features within the deeper layers of language models, thereby affecting the efficacy of tensor decomposition. For simplicity, we set d\u2032 = 100 across all experiments. However, under adversarial conditions, attackers might experiment with various d\u2032 settings to enhance their attack performance. Impact on Other Models: To demonstrate the effectiveness of our attack method on various model architectures, we also apply our method on the RoBERTa [Liu et al., 2019]. While RoBERTa shares similarities with BERT, it distinguishes itself through unique training configurations and datasets. Notably, unlike BERTBASE, RoBERTa does not 8 \fA PREPRINT have a Pooler layer. Instead, it employs a classifier composed of two linear layers in the head. In our experiments, we treat the first layer as an analogous Pooler layer and endeavor to reconstruct its input first. All the models used in this experiment are from Hugging Face, contributed by TextAttack [Morris et al., 2020]. As for the auxiliary model, we employ RoBERTa itself due to a specific challenge: we can\u2019t locate another generative model using the same tokenizer with RoBERTa. However, it\u2019s essential to note that we use the exact same settings for baselines and our method. We present the experiment results in Table 2. While the overall attack performance significantly decreases due to the auxiliary masked language model, our approach still outperforms the baseline. Furthermore, in numerous instances (as illustrated in Table 2), our method appears to restore the essence of the reference sample almost flawlessly. However, due to the limitation of evaluation metrics, they may have equal or even worse evaluation metrics than some terrible cases. Hence, we also employ the cosine similarity metric between the embeddings generated by SBERT for both the reference and recovery texts to assess the attack performance [Reimers and Gurevych, 2019]. Table 2: Text privacy attack on RoBERTa BASE. R-1, R-2, and R-L are same within Table 1. CosS indicates the average cosine similarity between references and recovered samples. Dataset Method R-1 R-2 R-L CosS Recovered Samples CoLA reference sample: The box contains the ball LAMP 15.5 2.6 14.4 0.36 likeTHETw box contains divPORa Ours 17.4 3.8 15.9 0.41 like Mess box contains contains balls SST2 reference sample: slightly disappointed LAMP 20.1 2.2 15.9 0.56 likesmlightly disappointed a Ours 19.7 2.1 16.8 0.59 like lightly disappointed a Toma reference sample: vaguely interesting, but it\u2019s just too too much LAMP 19.9 1.6 15.1 0.48 vagueLY\u2019, interestingtooMuchbuttoojusta Ours 21.5 1.8 16.0 0.51 vagueLY, interestingBut seemsMuch Toolaughs 6 Related Work While federated learning features with data privacy, recent studies show that model updates (gradients and parameters) can be intentionally leveraged to uncover sensitive data [Phong et al., 2017, Zhao et al., 2020, Zhu and Blaschko, 2020, Zhu et al., 2019]. This susceptibility is especially pronounced in the field of CV [Huang et al., 2021, Geiping et al., 2020, Yin et al., 2021, Jeon et al., 2021]. Textual data poses unique challenges in the context of private data attacks, especially given the prevalence of Transformer architectures. In Transformer, gradients average across sequences and tokens, which inherently masks specific token details. Furthermore, the inputs, expressed as discrete token IDs, starkly contrast the continuous features found in image data. Nonetheless, numerous studies have highlighted the risks associated with textual information. Fowl et al. [2021, 2022], Boenisch et al. [2023] distribute networks with embedded backdoors or trap parameters that facilitate easy reconstruction of training data. However, one can employ prefixed, recognized architectures to counter the former attack and guard against potential backdoor threats. For the latter attack, consistently monitoring statistics of features and weights across different layers can help detect malicious parameter [Balunovic et al., 2022]. Some approaches assume a trustworthy central server. Even with its integrity, the shared parameters and gradients could still be leveraged to extract private data [Zhu et al., 2019]. For example, methods introduced by Zhu et al. [2019] and Deng et al. [2021] employ optimization-based strategies using finely-tuned objective functions for data retrieval. Balunovic et al. [2022] leverages prior knowledge from extensive language models for data recovery. However, due to the self-imported limitation (Server is benign without doing any change to the model), these methods tend to be less effective with larger batch sizes. Notably, the method introduced by [Gupta et al., 2022] remains effective even with considerable batch sizes. Nevertheless, this vulnerability can be easily defended by suspending updates of embedding matrix. 7"
+                },
+                {
+                    "url": "http://arxiv.org/abs/2310.13191v3",
+                    "title": "Towards Robust Pruning: An Adaptive Knowledge-Retention Pruning Strategy for Language Models",
+                    "abstract": "The pruning objective has recently extended beyond accuracy and sparsity to\nrobustness in language models. Despite this, existing methods struggle to\nenhance robustness against adversarial attacks when continually increasing\nmodel sparsity and require a retraining process. As humans step into the era of\nlarge language models, these issues become increasingly prominent. This paper\nproposes that the robustness of language models is proportional to the extent\nof pre-trained knowledge they encompass. Accordingly, we introduce a\npost-training pruning strategy designed to faithfully replicate the embedding\nspace and feature space of dense language models, aiming to conserve more\npre-trained knowledge during the pruning process. In this setup, each layer's\nreconstruction error not only originates from itself but also includes\ncumulative error from preceding layers, followed by an adaptive rectification.\nCompared to other state-of-art baselines, our approach demonstrates a superior\nbalance between accuracy, sparsity, robustness, and pruning cost with BERT on\ndatasets SST2, IMDB, and AGNews, marking a significant stride towards robust\npruning in language models.",
+                    "authors": "Jianwei Li, Qi Lei, Wei Cheng, Dongkuan Xu",
+                    "published": "2023-10-19",
+                    "updated": "2024-01-11",
+                    "primary_cat": "cs.CL",
+                    "cats": [
+                        "cs.CL",
+                        "cs.AI"
+                    ],
+                    "main_content": "Introduction Pruning is a widely recognized compression method employed to decrease the model size and accelerate model inference (Frankle and Carbin, 2018; Chen et al., 2020; Prasanna et al., 2020; Chen et al., 2021). In the age of large language models (Andrew and Gao, 2007; Brown et al., 2020; Chowdhery et al., 2022; OpenAI, 2023; Touvron et al., 2023; Ouyang et al., 2022; Smith et al., 2022), the necessity of pruning has increased because it greatly reduces deployment costs (Frantar and Alistarh, 2023). In addition to the significant computation cost, the robustness of language models has emerged as a crucial factor that demands attention. This is primarily because models need to remain resilient against adversarial attacks, even in challenging real-world circumstances (Tran et al., 2022; Wang et al., 2023). Therefore, exploring robust pruning strategies against adversarial attacks in language models could potentially yield a substantial impact (Xu et al., 2021; Du et al., 2023). Recent research has extended the pruning of language models beyond accuracy and sparsity, with an emphasis on the trade-off between accuracy, sparsity, robustness and cost (Du et al., 2023; Xu et al., 2021; Liang et al., 2021; Xi et al., 2022). Zheng et al. (2022) propose a joint optimization objective to guide the pruning and adversarial training simultaneously. Their approach views the identified subnetworks as robust tickets, which can be trained as normal and offer enhanced robustness. Despite achieving state-of-the-art results on target datasets, these methods still display vulnerabilities, as evidenced by a significant gap between metrics of clean accuracy 1 and accuracy under attack. Moreover, the performance also rapidly declines when sparsity exceeds a moderate level. Expanding on their work, Xi et al. (2022) propose using robust early-bird tickets to reduce the computational cost from adversarial training. However, they face similar challenges regarding the trade-off between robustness and sparsity. In summary, existing robust pruning works often demonstrate limited sparsity, insufficient robustness, and expensive cost, indicating the ongoing challenge of the balance between accuracy and the other three aspects. To address this challenge, this paper investigates why language models are susceptible to adversarial attacks. (Wang et al., 2021; Garg and Ramakrishnan, 2020; Jin et al., 2020). Previous studies have indicated that language models frequently capitalize on biases and artifacts inherent in datasets as predictive shortcuts, which impedes reasoning ability and skills to develop advanced semantic comprehension. (Du et al., 2021; Niven and Kao, 2019; 1accuracy without adversarial attacks arXiv:2310.13191v3  [cs.CL]  11 Jan 2024 \fMcCoy et al., 2020; Du et al., 2023). This reliance leads to a more severe loss of pre-trained knowledge during the pruning process. Furthermore, the adversarial samples in Natural Language Processing (NLP) are crafted by replacing components of sentences with semantically similar counterparts, thereby retaining high semantic similarity in the entire sentence (Li et al., 2020a; Ren et al., 2019; Jin et al., 2020). In this way, language models that depend on spurious features from particular words can not defend against adversarial attacks constructed by replacing those words with semantically similar alternatives. To put it more plainly, this primarily stems from the fact that, without pre-trained knowledge, the sparse language model treats the substitute word simply as an integer identifier. Based on the above observation, we explore the following questions in this paper: Question 1. What is the core to defend against adversarial attacks for sparse language models? This paper proposes that the robustness of sparse language models is directly proportional to the amount of pre-trained knowledge retained after pruning. Intuitively, the robustness of a sparse language model is fundamentally tied to its capability to distill advanced semantic features from input sentences. This capability is largely established during the pre-training phase of dense language models, emphasizing the pivotal role of acquired semantic knowledge. The extensive experiments well support our statement. Question 2. How can we efficiently prevent the loss of pre-trained knowledge in pruning to preserve or even enhance robustness? Previous research has demonstrated that pruning exacerbates the model\u2019s dependency on spurious features (Xu et al., 2021; Du et al., 2023). We further confirm that traditional pruning methods lead to a considerable loss of pre-trained knowledge and poor robustness. To prevent the above things, we propose a pruning approach that minimizes damage to the embedding space and feature space of dense language models, striving to replicate the features in each layer completely. Specifically, for each layer, we iteratively eliminate a single weight at a time and counterbalance the loss by updating the remaining weights based on the Hessian Matrix. In this setup, the reconstruction error at each layer arises not only from its own layer but also incorporates the accumulated error from preceding layers. This is achieved by adaptively updating the pruning-dependent information in accordance with the sparse output generated by previous layers. Concurrently, there\u2019s an ongoing effort to correct these errors collectively. Moreover, our method, being a post-training approach, is cost-effective for current language models, as it circumvents rigorous retraining processes. Extensive experiments show that our approach achieves a better trade-off between accuracy, sparsity, robustness, and pruning cost in SST2, AGNews, and IMDB compared with other state-of-art methods. 2 Related Work Textual Adversarial Attacks and Defense. Textual adversarial attacks pose a significant challenge to the robustness of language models. These attacks, formulated by carefully altering certain segments of sentences with semantically similar counterparts, aim to fool language models (Jin et al., 2020; Li et al., 2020a). To enhance the robustness of language models and defend against adversarial attacks, a range of potent defensive strategies, such as adversarial training, has been proposed. (Madry et al., 2017; Zhu et al., 2019; Li and Qiu, 2021). Different from their research, which focuses on dense models, we explore the robustness in the context of language model pruning. Robust Model Pruning. Prior studies indicate that sparse models tend to underperform in Compression Identified Examples (CIE), suggesting that the pruning process exacerbates the inherent algorithmic biases hidden within the datasets (Hooker et al., 2020). In Computer Vision (CV), simultaneous optimization of model pruning and adversarial training has been advocated as an effective solution to this issue (Gui et al., 2019; Ye et al., 2019; Sehwag et al., 2020; Vemparala et al., 2021). In NLP, Du et al. (2023) propose to prevent model overfitting on easy samples by leveraging sample difficulty in the context of pruning. Concurrently, Xu et al. (2021) suggest the generation of robust subnetworks through Knowledge Distillation and Posttraining Quantization. Taking a different approach, Liang et al. (2021) strive to enhance model generalizability by extracting the super tickets, while Zheng et al. (2022) and Xi et al. (2022) seek to identify robust tickets. Despite recent advancements, achieving enhanced robustness alongside increased sparsity remains a challenge. This paper significantly promotes a better trade-off among accuracy, robustness, sparsity, and pruning cost. \f3 Preliminary 3.1 Shortcut Learning and Mitigation Recent studies provide evidence that language models are inclined to capitalize on inherent biases and spurious features present in datasets, using these as convenient predictive shortcuts (Niven and Kao, 2019; Du et al., 2021; McCoy et al., 2020). This tendency impedes the development of more advanced semantic understanding and reasoning capacity necessary for NLU tasks. Various preliminary studies have begun to address this bias issue, such as adversarial training and posterior regularization (Stacey et al., 2020; Chen et al., 2021). From a unique perspective, we let language models against adversarial attacks by mitigating this shortcut issue through weight averaging. This method will be elaborated further in Section 4.2. 3.2 Pruning with Hessian Matrix Drawing inspiration from (LeCun et al., 1989; Hassibi et al., 1993), previous study has provided mathematical formulations for effectively eliminating a single weight from a layer and updating the remaining weights to correct the resulting error according to the information from Hessian Matrix (Frantar and Alistarh, 2022). The equations are presented below: wp = argmin wp w2 p [H\u22121]pp wr\u2212= wp [H\u22121]pp \u00b7 H\u22121 :,p (1) where H is the Hessian Matrix, wp represents the single weight that will be pruned, while wr denotes the remaining weights that will be updated. The notation [H\u22121]pp refers to the pth diagonal entry of the inverse Hessian Matrix, and H\u22121 :,p represents its pth column. However, the inversion of the Hessian Matrix requires updates at each weight removal, which is exceedingly costly. Frantar and Alistarh (2022) observes that Hessian values across different weight matrix rows are independent, as a single weight removal only impacts its respective row output. Accordingly, they simplify the calculation of Hessian Matrix H and leverage the Gaussian elimination technique to accelerate the update of H\u22121, as described mathematically below: H = XXT H\u22121 \u2212p = (H\u22121 \u2212 1 [H\u22121]pp H\u22121 :,p H\u22121 p,: )\u2212p (2) Here, \u2212p denotes the removal action of a single weight at index p. A more detailed explanation can be found in the Appendix. 4 Methodology This section proposes a pruning method for language models that can better balance accuracy, sparsity, robustness, and pruning cost. Figure 1 depicts the architecture of this method. 4.1 Rethink Robust Model Pruning Given that the predominant challenge in robust pruning primarily centers on robustness and pruning cost, we mainly focus on these two aspects in this paper. To enhance the robustness, we explore the root cause of the poor performance of sparse language models under adversarial attacks. We note that adversarial samples are often crafted by replacing certain words in the sentence with semantically similar substitutes. Thus it is essential to ensure that the representation of the original words and their substitutes remain similar in the embedding space and feature space even after pruning. Based on the above observation, we propose to maintain a highly close alignment between the sparse and dense language models. In other words, robust pruning is supposed to seek sparse parameters \u02c6 Wl that minimize the discrepancy between the outputs of dense and sparse layers. The problem can be formally expressed as follows: argmin \u02c6 W l EXl L(fl(Xl, Wl), fl(Xl, \u02c6 Wl)) s.t. \u2225\u02c6 Wl\u22250 \u2264k (3) Here, each layer of language models is represented by a mathematical function fl(Wl, Xl), and Xl denotes inputs, k designates the total number of weights that remain non-zero after the pruning process. Predominantly, the Mean Squared Error (MSE) is usually employed to measure the pruning error of each layer. Therefore, the preceding problem can be further reformulated using the MSE, as expressed in the subsequent equation: argmin \u02c6 Wl||WlXl \u2212\u02c6 WlXl||2 s.t. \u2225\u02c6 Wl\u22250 \u2264k (4) To reduce the pruning cost, we adopt a posttraining setting in our strategy. Specifically, we only utilize a small subset of data to calibrate the weights and generate sparse substitutes to replace them. In summary, our pruning method does not need a rigorous retraining process. 4.2 Weight Averaging for Robust Dense Model We also realize that language models may rely on surface-level or spurious features in the data \fM1 M2 M3 Mn h1, s1 m1 m2 m3 mn Descending order with mi M6 M2 M4 M9 M3 M2 M Aggressively chose ingredients Robust dense model Weight Average W0 W1 W2 x1 \u2026 \u2026 y0 A: Weight Averaging for Robust Dense Model B: Adaptive Pruning for Robust Sparse Model ! \"0 ! \"1 ! \"2 w0 w1 w2 1 2 3 1 ! \"0 ! \"1 ! \"2 ! #0 ! #1 ! #2 y1 y2 x2 x0 $ %1 H=x1x1T x1 w1 y1 % &1 Pruning With Hessian Matrix 2 Adaptive  Hessian x1 w1 y1 % &1 % '0 Adaptive Weight Pruning With Hessian Matrix $ %1 Adaptive Pruning with Hessian Matrix Pruning with Hessian Matrix h2, s2 h3, s3 hn, sn Figure 1: Architecture of Main Strategy. A: First, we generate a robust and dense language model in two steps: 1 we fine-tune the pre-trained weight with various hyperparameters and settings, resulting in multiple models with different knowledge; 2 we then employ a greedy algorithm to only average the weights of models that contribute to the final performance. B: Second, 3 we apply our adaptive pruning method to generate robust and sparse language models in a layer-wise setting. Specifically, we optimize the 1 original independent pruning process of each layer to 2 an adaptive way. This requires subsequent layers to update the Hessian Matrix and the optimal dense weight according to the sparse outputs of preceding layers, thereby inheriting and correcting the accumulated error together. rather than capturing sophisticated semantic features. Thus, when sparse language models fail to defend against adversarial attacks, it becomes challenging to determine whether the failure stems from the pruning methods or inherent issues within the dense model. We circumvents this risk by constructing a robust and dense model before pruning. Inspired by Croce et al. (2023) and Wortsman et al. (2022), we generate a robust language model via weight averaging. The key idea is to train multiple models with different hyperparameters and settings, allowing each model to capture distinct nuances of the data and generalize in diverse ways. By averaging their weights, we can create a robust model that benefits from collective knowledge. Specifically, we order these models in descending order based on the accuracy under attack. Then, we selectively average the weights that contribute to the final robustness. Finally, we obtain a robust and dense model as the foundation of subsequent operations. This approach ensures that any detected vulnerabilities in sparse language models result from the pruning process, eliminating the possibility of them arising from spurious features. More details can be found in Algorithm 3. 4.3 Ada-Pruning for Robust Sparse Model 4.3.1 Notation To accurately replicate the dense model\u2019s behavior regarding embedding space and feature space of each layer, we use the method described in Section 3.2 as the backbone. However, its layer-wise setting, which treats each layer as an independent pruning problem, introduces limitations in realizing a globally optimal solution. To elaborate, let\u2019s consider a single layer as an example in the following sections. We\u2019ll use Xl, Wl, and Yl to represent the input, weight, and output of the layer, respectively, with the subscript l indicating lth layer. The use of a hat, as seen in \u02c6 Xl, \u02c6 Wl, or \u02c6 Yl, represents the input, weight, or output within a sparse context. 4.3.2 Adaptive Hessian Matrix After completing the pruning of the lth layer, a certain amount of error stemming from the sparse matrix operation inevitably arises. No matter how minor this error might be, it\u2019s important to realize that the output of this layer, denoted as \u02c6 Yl, influ\fAlgorithm 1 Prune linear layers {l1..ln} of BERT with target sparsity s and calibration data X Require: Collect original X, W, Y for l 1: procedure LAYERWISE PRUNING({l1..ln}) 2: for i \u21901 to n do 3: Wi, Xi, Yi \u2190li 4: 5: # Adaptive update 6: H\u22121 i \u2190(XiXT i )\u22121 7: if i \u0338= 0 then 8: Wi \u2190H\u22121 i XT i Yi 9: end if 10: 11: # Pruning with Hessian Matrix 12: din \u2190input dimension 13: k \u2190int (din \u00b7 s) 14: for j \u21901 to k do \u25b7parallel in rows 15: p \u2190argminp\u2208din 1 [H\u22121 i ]pp \u00b7 [Wi]2 p 16: Wi \u2190Wi \u2212[Hi]\u22121 :,p 1 [H\u22121 i ]pp \u00b7 [Wi]p 17: tmp \u2190[Hi]\u22121 :,p [Hi]\u22121 p,: 18: H\u22121 i \u2190H\u22121 i \u2212 1 [H\u22121 i ]pptmp 19: Wi \u2190Wi remove [Wi]p 20: end for 21: 22: # Adaptive update 23: Yi \u2190WiXi 24: Xi+1 \u2190post-process(Yi) 25: end for 26: return {Wi..Wn} 27: end procedure ences the input of the subsequent layer, denoted as \u02c6 Xl+1. As a result, the initial Hessian Matrix for the (l + 1)th layer, defined as Hl+1 = Xl+1XT l+1, becomes outdated. Thus it\u2019s crucial to recalculate the Hessian Matrix to obtain more precise pruningdependent information. We suggest adaptively updating the Hessian Matrix for the subsequent layer after pruning the preceding layers. 4.3.3 Adaptive Dense Weight We also note that the loss generated by removing a single weight depends on the current weight Wl from corresponding layer, as derived from Equation 1. However, an inevitable fact is that the original dense weight Wl is not optimal for the expected dense output Yl after pruning the preceding layers (\u02c6 0th . . . \u02c6 (l \u22121)th). Given that the input Xl has been altered to \u02c6 Xl due to the accumulated error, it would be suboptimal to continue using the original weight Wl to calculate the pruning loss for the current layer. To be more clear, the result of \u02c6 XlWl could substantially deviate from the original output Yl. This is incompatible with our goal of producing an output \u02c6 Yl identical to the original Yl in the pruning process. Thus, it\u2019s essential to update the dense weight so that \u02c6 Xl \u00af Wl can approximates the original output Yl more closely. Here, \u00af Wl denotes the updated dense weight, and we design the following equations to derive \u00af Wl: \u00af Wl = ( \u02c6 XT l \u02c6 Xl)\u22121 \u02c6 XT l Yl (5) where T represents the transpose operation, and \u22121 denotes the inverse operation. To ensure that \u02c6 XT l \u02c6 Xl is invertible, we also introduce a regularization term, such as 1e \u22124, to the diagonal entries of the matrix. Finally, we can compute the pruning loss more accurately with the updated weight \u00af Wl. We also calibrate the optimal weights for nonpruned layers (such as the pooler layer and classification layer in BERT) with Equation 5, aligning the dense layers\u2019 output with the altered input. Algorithm 1 provides detailed steps for the code implementation, offering a comprehensive overview of our methodology. We also provide a comprehensive analysis of the computational complexity of our method in the Appendix. 5 Experiments We first compare our method against several baseline methods, assessing accuracy, robustness, sparsity, and cost. Then, an ablation study is performed to elucidate the contributions of each part in our method. Finally, we augment our core findings with additional experiments and analyses to further illuminate our method. 5.1 Baselines and Datasets Consistent with the previous works (Devlin et al., 2018; Du et al., 2023; Xu et al., 2021; Zheng et al., 2022; Xi et al., 2022), BERTbase serves as the foundational model for all our experiments. We compare our approach with various baselines including:RobustT (Zheng et al., 2022), which optimizes the pruning mask and input perturbation simultaneously for robust tickets; Bag-of-Ticks (Xu et al., 2021), which improves sparse model robustness via Knowledge Distillation and Post-Training Quantization; RMC (Du et al., 2023), a technique preventing sparse language models from overfitting on easy samples using sample difficulty; SuperTicket (Liang et al., 2021), which identifies a super mask during pruning to reduce variance while preserving bias. Our evaluation primarily involves three text classification datasets: Internet Movie Database (IMDB, Maas et al. 2011), AG News Corpus (AGNEWS, Zhang et al. 2016), and Stanford Sentiment Treebank for binary classification (SST-2, Socher et al. 2013). \fMethods #Param Re-T SST2 AGNEWS IMDB Acc Aua Asr Acc Aua Asr Acc Aua Asr Fine-tune 85M Y 92.3 12.7 86.2 94.7 19.1 80.0 95.1 7.4 92.2 FreeLB 85M Y 91.5 28.3 69.1 94.8 37.8 60.1 94.3 36.2 61.6 Weight Average 85M Y 91.4 30.4 66.75 94.4 48.5 48.6 95.2 44.4 53.4 sparsity \u226430% SuperTicket 72M Y 93.2 14.3 84.7 94.8 9.7 89.8 95.0 17.3 81.8 Bag-of-Tricks 60M N 86.3 25.7 70.3 87.3 31.8 63.6 85.4 24.6 71.2 RMC 60M Y 91.2 17.6 80.7 94.2 21.4 77.3 93.9 22.3 76.3 RobusT 60M Y 90.8 28.9 68.2 94.9 33.4 64.8 92.1 55.7 39.5 Ours 60M N 90.2 42.3 53.1 93.8 48.6 48.2 94.6 57.3 39.4 sparsity = 50% Bag-of-Tricks 43M N 87.2 21.6 75.2 90.6 33.5 63.0 91.3 21.2 76.8 RMC 43M Y 90.8 9.7 89.3 94.1 21.2 77.5 94.1 14.7 84.4 RobusT 43M Y 90.5 24.8 73.9 94.8 28.8 69.7 93.2 31.5 66.2 Ours 43M N 88.31 43.1 51.2 93.4 48.5 48.1 94.2 53.2 43.6 sparsity = 87.5% Bag-of-Tricks 11M N 85.9 17.8 85.7 89.4 11.3 87.4 87.7 8.9 89.9 RMC 11M Y 86.3 3.6 95.8 92.1 4.5 95.5 91.3 11.2 87.7 RobusT 11M Y 85.2 7.8 90.8 91.8 8.3 91.0 89.2 6.5 92.7 Ours 11M N 85.6 37.6 56.1 92.4 41.3 55.3 91.6 35.6 61.1 Table 1: Summary of Adversarial Robustness Assessment on BERTbase. The entry highlighted with an orange background denotes our robust and dense model, which serves as the initialization for a range of robust pruning methods except RobustT (RobustT is generated from the pre-trained weight). Obviously, our method consistently outperforms all baselines in terms of the Aua% and Asr% metrics. Regarding Acc%, there is a minor decrease in our method\u2019s performance at lower sparsity levels, yet it regains superiority at higher sparsity levels. The highest performance is highlighted in bold. The column Re-T indicates whether the method necessitates model retraining. Consistent with previous research, we exclude embedding matrices from the calculation of parameter count. 5.2 Robustness Evaluation We assess our model\u2019s effectiveness against adversarial attacks using the TextFooler, which substitutes crucial words in sentences with semantically similar synonyms (Jin et al., 2020). Following previous works (Zheng et al., 2022; Xi et al., 2022), our evaluations utilize key metrics like Clean Accuracy Acc% (accuracy on clean test data), Accuracy Under Attack Aua% (accuracy when subjected to adversarial attacks), and Attack Success Rate Asr% (ratio of successful text perturbations to total attempts). A robust method is expected to show higher clean accuracy and accuracy under attack coupled with a lower attack success rate. We also evaluate more attack methods in the Appendix. 5.3 Implementation Details To begin with, we employ the technique mentioned in Section 4.2 to generate a robust language model for each dataset. Subsequently, we use our method to prune these robust language models with a small calibration dataset. All experimental results are the average of five trials, each initiated with different seeds. Furthermore, we assess the performance under three different levels of sparsity: 30%, 50%, and 87.5%. Additional implementation details can be found in Appendix. 5.4 Main Result on Robustness Evaluation Table 1 provides a comprehensive comparison of various robust pruning methods, evaluated across three distinct datasets: SST2, AGNEWS, and IMDB, and under varying degrees of model sparsity. Key observations can be made as follows: 1) Our strategy even enhances the robustness of language models after pruning. We believe this enhancement stems from the regularization effect of sparse architecture. 2) Our strategy distinguishes itself by consistently surpassing other methods in the Aua% and Asr%s, regardless of the dataset or the level of sparsity. These results imply that our strategy effectively maintains robustness during the pruning of language models. 3) Impressively, our method achieves higher robustness even with fewer parameters compared to several other approaches, which further underscores the effectiveness of our robust pruning method. 4) Although the Acc% of \f(a) (b) (c) (d) (e) (f) Figure 2: Attention Score Visualisation in BERTbase. We have selected an adversarial sample (\"it\u2019s a bewitching and often repercussions journey.\") from SST2 and visualized the attention scores in the robust and dense model (2b, 2e), the sparse language model generated with IMP+FreeLB (2a, 2d), and the sparse language model created using our method (2c, 2f). Here, Figures 2a, 2b, and 2c depict the attention scores from the first transformer block of BERTBase, while Figures 2d, 2e,and 2f show scores from the last transformer block. Evidently, the attention scores produced by our method align more closely with those from the robust and dense model. Methods #Param ReT SST2 AGNEWS IMDB Acc Aua Asr Acc Aua Asr Acc Aua Asr Fine-tune 85M Y 92.3 12.7 86.2 94.7 19.1 80.0 95.1 7.4 92.2 Weight Average 85M Y 91.4 30.4 66.75 94.4 48.5 48.6 95.2 44.4 53.4 IMP 43M Y 92.6 4.8 94.8 94.9 7.1 92.5 94.1 7.7 91.8 IMP + FreeLB 43M Y 92.4 7.9 91.5 94.3 9.2 90.2 93.8 14.3 84.8 LTH 43M Y 91.6 2.8 96.9 93.5 10.1 89.2 93.2 4.6 95.1 LTH + FreeLB 43M Y 91.7 9.8 89.3 93.2 12.3 86.8 93.1 9.5 89.8 Ours 43M N 88.31 43.1 51.2 93.4 48.5 48.1 94.2 53.2 43.6 Table 2: Ablation Study with Pruning Methods Replacement. We replace our pruning method with most famous others (IMP and LTH) supplemented with adversarial training (FreeLB). Similarly, the orange entry is used for model initialization. Once again, our method outperforms others in preserving or even enhancing robustness. our method is generally lower than other baselines at lower sparsity levels, the improvement of robustness (reflected in Aua% and Asr%) far outweighs the degree of accuracy degradation. 5) At higher levels of sparsity, our method outperforms other baselines across all metrics. 6) Our method does not require model retraining, confirming that our approach offers a better trade-off between accuracy, robustness, sparsity, and pruning cost. Beyond Bertbase, our methodology was also extended to Bertlarge, a model encompassing 330M parameters. The resulting performance, as presented in Table 3, reaffirms the superiority of our method when compared to the baselines. Moreover, we explore the effectiveness of our methods within a structured pruning context, and once again, our approach outperforms the state-of-the-art method: EarlyRobust (Xi et al., 2022). More details can be found in Appendix. 5.5 Ablation Study To elucidate the contributions of each part of our approach, we conduct an ablation study with the following settings:We replace our pruning technique with methods known as LTH and IMP (Frankle et al., 2020; Frankle and Carbin, 2018), and supple\fMethods #Param Re-T SST2 AGNEWS IMDB Acc Aua Asr Acc Aua Asr Acc Aua Asr Weight Average 309M Y 93.5 36.4 61.1 96.2 56.5 41.3 95.9 48.4 49.6 Bag-of-Tricks 155M N 90.3 27.6 69.4 93.1 35.5 61.9 93.4 29.3 68.6 RMC 155M Y 92.6 14.7 84.1 95.4 19.2 79.9 95.8 16.7 82.6 RobusT 155M Y 92.1 29.8 67.7 95.1 32.8 65.6 95.2 31.9 66.5 Ours 155M N 91.7 47.1 48.6 95.5 53.5 44.0 95.3 55.8 41.4 Table 3: Summary of Adversarial Robustness Assessment on BERTlarge. Similarly, the entry highlighted with an orange background is used for model initialization. Once again, our method consistently outperforms all baselines in terms of the Aua% and Suc% metrics. ment them with the additional adversarial training method FreeLB (Zhu et al., 2019). The results are presented in Table 2. From the results, we can make the following key observations: 1) Sparse language models generated by traditional pruning methods performs even worse than the vanilla finetuned dense model. This highlights the challenges associated with robust pruning. 2) Our approach consistently generates more robust sparse language models than conventional pruning methods, even supplemented with adversarial training methods. 3) We conjecture that the limited effect of adversarial training here stems from the discrete nature of word tokens and the substantial loss of pre-trained knowledge during pruning. 5.6 Discussion In this section, we design additional experiments to illustrate our robust pruning method further. 5.6.1 Pretrained Knowledge Detection To demonstrate the effectiveness of our robust pruning mechanism in preserving pre-trained knowledge, we\u2019ve chosen adversarial samples that are effectively defended by our method but not by others. We then visualize the attention scores of them in Figure 2. Our method demonstrates superior performance, as evidenced by more reasonable attention scores that align more closely with those from the robust and dense model. In addition, we visualize the distance of sentence representation from sparse language models and their dense counterparts in the feature space. As depicted in Table 4 and Figure 5, our method results in smaller distances between the dense and sparse representations. These findings indicate the superior ability of our robust pruning method to preserve semantic knowledge and maintain cognizance. In other words, our method outperforms others in maintaining robustness during pruning. Table 4: Quantitative Analysis of Distance from Sentence Embeddings. We compare the distances between sentence embeddings derived from various layers of dense and sparse language models. Our findings reveal that our method aligns better with the dense model, regardless of whether we use the original or adversarial sentence. Refer to Figure 5 for a visualization of these sentence embeddings. Layer Distance with dense Data IMP + ADT (2x) v.s. Ours (2x) 1 0.0086 > 0.0000 Ori 0.0086 > 0.0000 Adv 2 0.0144 > 0.0015 Ori 0.0142 > 0.0015 Adv 3 0.0156 > 0.0014 Ori 0.0258 > 0.0012 Adv 4 0.0193 > 0.0017 Ori 0.0407 > 0.0017 Adv 5 0.0324 > 0.0067 Ori 0.1319 > 0.0069 Adv 6 0.0763 > 0.0255 Ori 0.0967 > 0.0253 Adv 7 0.1299 > 0.0496 Ori 0.1478 > 0.0501 Adv 8 0.2530 > 0.1308 Ori 0.2547 > 0.1078 Adv 9 0.1880 > 0.0958 Ori 0.2767 > 0.0749 Adv 10 0.2804 > 0.1254 Ori 0.3909 > 0.1049 Adv 11 0.4932 > 0.2322 Ori 0.7317 > 0.0625 Adv 12 0.6872 > 0.2231 Ori 0.6903 > 0.0349 Adv 5.6.2 Impact of Calibration Data The calibration data is crucial for our methodology because it directly affects the computation of the Hessian Matrix. As outlined in Algorithm 1, the Hessian Matrix can be derived from H = XT X. To further explore the impact of the number of data points, we designed experiments that gradually increased the number of data points used in our strategy. The results of these experiments are detailed in Figure 3. Our observations indicate that as the number of used data points increases, the robustness and accuracy of the sparse language modes increase, but only up to a certain threshold. We hypothesize that the model can initially retain \fmore general knowledge as data points increase. However, once a threshold is crossed where the new data cannot provide additional information for general features, adding more data points from a similar distribution no longer contributes to model robustness and accuracy. 5.6.3 Impact of Sparsity As illustrated in Figure 4, we explore the robustness and accuracy of our sparse language models across a range of sparsity levels. In a departure from previous studies Zheng et al. (2022), our observations indicate that as sparsity increases, robustness decreases with a similar pace like accuracy. This trend suggests that the impact of increasing sparsity on model robustness might be less severe than previously assumed. This disparate pattern may stem from the post-training nature of our method. Furthermore, our observations regarding the trend in robustness align with the findings of previous studies by Zheng et al. (2022) and Liang et al. (2021). We note that the robustness of our sparse language models initially improves as sparsity escalates up to a certain threshold. After crossing this threshold, the robustness begins to decline. However, it sustains a level of robustness that is higher than the peak value observed in other models and does not collapse even with 10x compression. This finding further highlights the outstanding performance of our method in robust pruning. Figure 3: Impact of # of Calibration Data from SST2. 6"
+                },
+                {
+                    "url": "http://arxiv.org/abs/2310.13183v2",
+                    "title": "Breaking through Deterministic Barriers: Randomized Pruning Mask Generation and Selection",
+                    "abstract": "It is widely acknowledged that large and sparse models have higher accuracy\nthan small and dense models under the same model size constraints. This\nmotivates us to train a large model and then remove its redundant neurons or\nweights by pruning. Most existing works pruned the networks in a deterministic\nway, the performance of which solely depends on a single pruning criterion and\nthus lacks variety. Instead, in this paper, we propose a model pruning strategy\nthat first generates several pruning masks in a designed random way.\nSubsequently, along with an effective mask-selection rule, the optimal mask is\nchosen from the pool of mask candidates. To further enhance efficiency, we\nintroduce an early mask evaluation strategy, mitigating the overhead associated\nwith training multiple masks. Our extensive experiments demonstrate that this\napproach achieves state-of-the-art performance across eight datasets from GLUE,\nparticularly excelling at high levels of sparsity.",
+                    "authors": "Jianwei Li, Weizhi Gao, Qi Lei, Dongkuan Xu",
+                    "published": "2023-10-19",
+                    "updated": "2024-01-11",
+                    "primary_cat": "cs.CV",
+                    "cats": [
+                        "cs.CV",
+                        "cs.CL"
+                    ],
+                    "main_content": "Introduction One of the main challenges in deploying large neural networks (such as BERT (Devlin et al., 2019) and GPT-3 (Brown et al., 2020)) in production is the huge memory footprint and computational costs. Meanwhile, studies show that large and sparse models often yield higher accuracy than small but dense models (Gomez et al., 2019). As a result, pruning has been popularized to dramatically reduce memory size and computational power consumption with little to no performance degradation. (Hoefler et al., 2021; Glorot et al., 2011; Kaplan et al., 2020; Li et al., 2020; Mhaskar and Poggio, 2016; Brutzkus et al., 2017; Du et al., 2018). Pruning aims to eliminate redundant weights, neurons, and even layers in models. Many works focus on magnitude-based pruning (Hagiwara, 1993; Gale et al., 2019; Thimm and Fiesler; Han et al., 2015; Zhu and Gupta, 2017; Cuadros et al., \u03c4 = 0.027 2/3\u03c4  4/3\u03c4  28.74% 1.15e-8 0.8645 Magnitude Min Max 28.16% 1.15e-8 36% 15.6% 13.1% 34.8% 64% 18.35 9.8% 7.18% 2/3\u03c4  4/3\u03c4  0.8645 \u03c4 = 0.055 Min Max Magnitude (1) (2) Figure 1: Weight Distribution in a Feedforward Layer of BERTBase at Various Sparsity Levels (0.52 and 0.83), Corresponding to Pruning Thresholds \u03c4 = 0.027 and \u03c4 = 0.055. Notably, around 29% of the weights lie within the range [ 2 3\u03c4, 4 3\u03c4]. This observation puts into question the efficacy of magnitude-based pruning, as these weights, despite their proximity to the threshold, might play a crucial role in maintaining the model\u2019s accuracy. This suggests that directly eliminating weights with smaller magnitudes could potentially lead to a suboptimal pruning strategy. 2020), namely to remove the elements with the smallest magnitude. Here the magnitude refers to not only the weights but also the output sensitivity, gradients, or Hessian matrices of the training loss (Luo et al., 2017; Yu et al., 2018; He et al., 2019; Lis et al., 2019; Molchanov et al., 2019; Singh and Alistarh, 2020; Dong et al., 2017). While magnitude-based pruning can generate state-of-theart results in a wide range of tasks, its pruning strategy is deterministic and solely depends on a single criterion, which lacks variety (we demonstrate this more thoroughly in the next paragraph). Furthermore, magnitude-based pruning is proven not optimal at high-level sparsity (Sanh et al., 2020). To further improve the pruning performance, Zhuang et al. (2020); Ge et al. (2011); Savarese et al. (2020); Verdenius et al. (2020); arXiv:2310.13183v2  [cs.CV]  11 Jan 2024 \fAzarian et al. (2020) try to enlarge the search space of sparse architecture with regularization-based methods, which are non-deterministic. They design fine-designed L0 or L1 penalty terms added to the loss function. In this way, the model proactively shrinks some of the weights until they don\u2019t contribute to the final loss. Regularization-based methods can achieve noticeably better results than magnitude-based methods, especially at high-level sparsity (Sanh et al., 2020). However, this line of work often suffers from a non-convex landscape and is challenging to optimize with extra hyperparameters. In parallel, Su et al. (2020); Liu et al. (2022) adopt a more aggressive strategy to prune elements in a completely random way. Their methods demonstrate the competitive effect in small datasets (such as CIFAR-10, CIFAR-100 (Krizhevsky et al., 2009)) but fail in large datasets (such as ImageNet (Deng et al., 2009)). Different from these works, this paper introduces a mildly random pruning method that brings a controllable degree of randomness into the pruning mask generation procedure. We demonstrate the weakness of magnitudebased pruning in Figure 1. It presents the weight distribution of a feedforward layer of BERT (Devlin et al., 2019). Define \u03c4 as the pruning boundary. We consider two scenarios: \u03c4 = 0.027 and \u03c4 = 0.055, leading to sparsity levels of 0.52 and 0.83, respectively. As shown in Figure 1, a large portion of weights (\u224829%) falls into the range of [2 3\u03c4, 4 3\u03c4], which cannot be overlooked because that it is unclear if the pruned weights close to the threshold contribute less than the kept weights in the final accuracy. The weights with smaller magnitudes can still be crucial, especially when dealing with edge cases or infrequent situations. Proximity between weights can intensify decisionmaking challenges. This is why the direct removal of weights with smaller magnitudes is sub-optimal, as also demonstrated in Gomez et al. (2019). Based on the above observations, we investigate the following questions in this paper: Question 1. Which is better for pruning? a deterministic way or a randomized way? Previous literature has not reached a consistent conclusion. While Su et al. (2020) and Liu et al. (2022) have provided evidence that random pruning can yield competitive or better results compared to deterministic methods, this finding does not consistently hold true for larger datasets. Moreover, these results have not been universally extended to language models. We conjecture that their methods introduce unbridled randomness but do not provide any effective negative feedback. Moreover, exploring the extent of introduced randomness in a principled way has also not been explored in the previous literature. In this paper, we study and extend the above question systematically. Question 2. Can we design a consistently effective randomized pruning method? This paper answers the above question with the following contribution. First, we propose a randomized pruning mask generation strategy that can introduce controllable randomness in a principled way. Second, we design Mask Candidate Selection Strategy (MCSS) to choose the optimal mask from the pool of mask candidates, ensuring the introduced randomness always guides pruning in a beneficial direction. Third, to further enhance efficiency, we introduce Early Mask Evaluation Pipeline (EMEP) to mitigate the overhead associated with training under multiple pruning masks. Last, we offer an empirical guidance for randomized pruning on Bertbase and Bertlarge. Our results show a consistent accuracy boost (0.1%\u223c2.6%) on the GLUE benchmark, outperforming other stateof-the-art pruning techniques at a 16x compression rate. Notably, our approach showcases even more significant enhancements (2%\u223c4%) at extreme sparsity levels like the 100x compression rate. 2 Preliminaries 2.1 Pruning Iterative Magnitude Pruning Iterative Magnitude Pruning (IMP) is the most well-known strategy because it yields state-of-art results than others (Frankle and Carbin, 2019; Frankle et al., 2020), such as Single-shot Network Pruning (SNIP) (Lee et al., 2018). Specifically, we divide the pruning process into multiple stages by gradually increasing the sparsity. In each stage, pruning is to find and eliminate redundant parameters or neurons at that time. The most intuitive approach is to assign an importance score to each element and keep only the top-k elements. The score used to rank elements can be the absolute value of weights, output sensitivity, gradients, or other fine-designed metrics (Hagiwara, 1993; Gale et al., 2019; Thimm and Fiesler; Han et al., 2015; Zhu and Gupta, 2017; Cuadros et al., 2020; Luo et al., 2017). In this work, \fdifferent from the traditional deterministic way, we extend the IMP in a random way. 2.2 Knowledge Distillation Knowledge Distillation (KD) (Hinton et al., 2015) is another compressing technique trying to transfer the knowledge from a well-trained large model T to a small model S. Many previous works have proved that pruning with KD can significantly reduce accuracy loss for Transformer-based models (Xu et al., 2021; Xia et al., 2022). Our experiments evaluate the pruning methods based on BERT (Devlin et al., 2019), and we apply the KD method to both the baseline and our strategy. Specifically, we distill the knowledge from the hidden state of each transformer block and the attention score of each self-attention layer. Figure 6 demonstrates the distillation strategy in our settings. 2.3 Multinomial Distribution In probability theory, a multinomial distribution describes the probability distribution of n (n > 2) sampling trials from elements with k (k > 2) categories, which is a generalization of the binomial distribution (Ross, 2010). In our setting, the number of categories equals the number of elements, and the target sparsity and the total number of elements determine the number of trials. Note that the sampling process in this paper is done without replacement. This kind of sampling is also referred to as sampling from a multivariate hypergeometric distribution (Berkopec, 2007). 3 Methodology In this section, we first rethink the traditional deterministic pruning method and introduce our basic idea and method. Following that, we elaborate on the details of our randomized pruning mask generation and selection strategy. The architecture of our strategy is depicted in Figure 2, and the detailed procedure is outlined step-by-step in Algorithm 1. 3.1 Rethink Iterative Magnitude Pruning Traditional IMP divides pruning into multiple stages and generates a deterministic pruning mask by retaining the top-k elements at each stage. This process is based on the assumption that the top-k elements contribute more than the removed part. However, given the complex topology of model architecture and observations from Figure 1, it is difficult to draw such a conclusion. In this paper, we aim to introduce a certain degree of randomness into the process of pruning mask generation, thereby expanding the search space for locally optimal pruning masks at each stage. Specifically, we propose a strategy for generating and selecting randomized pruning masks at each pruning stage. 3.2 Randomized Pruning Mask Generation 3.2.1 Mask Sampling Different from the deterministic mask generation, we seek to infuse controllable randomness into this process. In essence, our approach is to sample the retained elements from a multinomial distribution without replacement. Specifically, the first step is to derive a probability distribution by normalizing the magnitude of the elements. Within our framework, magnitude is defined as the absolute value of the weight. Subsequently, we sample k indices from this distribution, where k represents the number of elements retained. Finally, we generate a binary mask, with locations corresponding to these indices set to one, effectively outlining the sparse architecture of the model. The utilization of this approach offers a refreshing departure from the deterministic way and creates a larger optimization space for model pruning. 3.2.2 Controllable Randomness We have proposed a random method to generate pruning masks. However, for current models with several million parameters per layer, a single iteration of sampling leads to considerable randomness due to the minute probability post-normalization. To quantify this randomness, we propose ir (introduced randomness) in Equation 1: ir = (C \u2217sparsity \u2212Cs)/Cs (1) Here, C and Cs represent the total count of weights and the count of weights pruned by both deterministic and random approaches, respectively. A small value of ir indicates that the sampled mask resembles the deterministic one. Conversely, a larger value suggests a noticeable departure from the deterministic method. We assess the introduced randomness with ir and simultaneously strive to regulate its quantity. Drawing inspiration from the concept of model soup (Wortsman et al., 2022), we manage the randomness by sampling M masks and adding them element-wise to craft an ensemble mask. This mask has its top-k values set to 1, with the remainder set to 0, thus yielding a mask with controllable \fDense Sparsity = 0.31 A B Prune Sparsity = 0.52 Prune Prune Iterative Magnitude-Based Pruning Deterministic Pruning Randomized Pruning Top K Abs (Weight Matrix) Sparse Weight Matrix 2 1 Randomized Pruning Mask Generation Randomized Pruning Mask Selection normalization Probability Distribution Abs (Weight Matrix) + Sampling Sampling Sampling + Top K Pruning Mask Mask1 Mask2 Mask3 Mask4 Mask Early Evaluation Pipeline 1. Train one epoch for each mask  candidate with large learning rate 2. Chose the mask with highest  validation score Figure 2: Main Architecture of Our Strategy. We replace A the deterministic mask generation way in IMP with B our randomized method. Specifically, 1 we first introduce a degree of randomness into the process of mask generation in a principled way, 2 then we employ a specific mask selection rule, paired with an efficient evaluation pipe, to distinguish the optimal mask from a pool of candidates. randomness (k is the number of kept elements). Importantly, the degree of introduced randomness shows a positive correlation with the value of M. 3.2.3 Accelerated Mask Sampling Controlling randomness solely by increasing the number of sampled masks can be time-intensive. To address this, we suggest deriving the sampling probability distribution from the wT , where w is the weight of the corresponding layer. In this scenario, the power value T in the exponential term is used to control the variance of the sampling probability. As T increases, the sampling probabilities for larger and smaller magnitudes diverge more, allowing Mask Sampling to curtail the introduced randomness swiftly. Moreover, aligning with our motivation to introduce randomness in mask generation, we only sample weights whose magnitudes are close to the pruning boundary \u03c4. We introduce more details in Appendix. 3.3 Randomized Pruning Mask Selection 3.3.1 Mask Candidate Selection Strategy Our sampling approach expands the search space for locally optimal masks compared to the deterministic way. However, this inadvertently introduces undesired noise, leading to poor model accuracy because we introduce randomness without providing any effective negative feedback to the model optimization. To address this, we propose Mask Candidate Selection Strategy (MCSS) to ensure the introduced randomness always guides the model optimization in a beneficial direction. Specifically, at each pruning stage, we generate N candidate masks and select the best one for the next pruning stage. To ensure robustness in our approach, we adopt a deterministic mask as one of our mask candidates. By doing so, we are not solely relying on random or heuristic methods but also have a reliable fallback. 3.3.2 Early Mask Evaluation Pipeline To accelerate the mask selection, we design Early Mask Evaluation Pipeline (EMEP) to reduce computational costs. Specifically, we only fine-tune the model one epoch with a large learning rate for each candidate mask. The candidate that achieves a superior early-stop evaluation metric on the validation dataset is then deemed the winner. We crafted this strategy based on findings by Li et al. (2019) and You et al. (2019), which suggest that using a high learning rate during the earlier optimization iterations can yield a good approximation of the sparse network structure. Once the winner has \fAlgorithm 1: Randomized Pruning Mask Generation and Selection Input: w ; /* one layer weight */ Result: w, M; /* mask */ s \u2190[s1, s2, ...] ; /* pruning schedule */ sr \u21900.00005 ; /* sampling ratio */ n \u21908 ; /* # of candidates */ train w ; /* dense model */ foreach st \u2282s do for i \u21900 to n do p \u2190|w|/ P |w| ; p \u2190p5 ; /* sampling prob */ x \u2190st \u00d7 numw ; /* x is # of zeros in wj after pruning */ k \u2190numw \u2212x ; /* k is # of non-zeros in wj after pruning */ Mi \u2190zeros_like w; m \u2190zeros_like w; y \u2190int(sr \u00d7 x); for _ \u21900 to y do m \u21900 pos \u2190sampling k positions from p; m[pos] \u21901; Mi \u2190Mi + m end Mi[topk] \u21901; otherwise 0 w = w \u00d7 Mi; finetune one epoch with large lr; metrici \u2190evaluate validation dataset; end select M with best metric; rewind w and lr; w = w \u00d7 M; finetune w ; /* sparse model */ end been chosen, we revert the weights and learning rate to their state before the last pruning step. Subsequently, the winning candidate mask is employed for continuous regular training. 4 Experiments We evaluate the effectiveness of our pruning strategy in a wide range of natural language understanding tasks. Following previous work, we use BERT as our backbone and then apply different pruning methods to compare their performance. 4.1 Baselines BERTbase and BERTlarge are first chosen as our baseline models. Based on them, we apply IMP to generate 16x sparse models. These sparse models are used as our main baselines. In addition, we compare our strategy with previous works that have reported results on the same datasets, which including: BERT-PKD (Sun et al., 2019), Stru-PruningRoberta (Wang et al., 2020), SNIP (Lin et al., 2020), EBERT (Liu et al., 2021), BERT-of-Theseus (Xu et al., 2020), EfficientBERT (Dong et al., 2021), SparseBERT (Xu et al., 2021), RPP (Guo et al., 2019), Pretrained Ticket (Chen et al., 2020), Lottery Ticket (Prasanna et al., 2020), Prune at Pretraining (Gordon et al., 2020), Movement Pruning (Sanh et al., 2020), DistillBert6 (Sanh et al., 2019), and TinyBert6 (Jiao et al., 2020). 4.2 Datasets and Data Augmentation Following previous works, we select eight tasks from the GLUE dataset (excluding WNLI) to evaluate the effectiveness of our pruning strategy (Wang et al., 2018). We also follow the data augmentation method from TinyBert (Jiao et al., 2020). More details can be found in Appendix. 4.3 Setup We follow the strategy from SparseBert (Xu et al., 2021) to do pruning and knowledge distillation simultaneously at downstream tasks. We also imitate the setting from (Frankle and Carbin, 2019) to adopt a simple pruning schedule in our experiments. Specifically, we only use 4-9 pruning stages to increase the sparsity gradually (such as 0.54, 0.83. 0.91, 0.9375). Furthermore, after choosing a decision mask at each pruning stage, the number of epochs in the finetuning phase is no longer limited until the model converges. We apply exactly the same setting for the IMP baseline and our approach. For more details about hyperparameters, please refer to Appendix. 4.4 Main Results and Analysis We report the results on dev set of 8 datasets from GLUE and summarize them in Table 1-2. We also compare our results with distillation-based methods and describe the results in Appendix. From the above results, we can easily observe that our strategy consistently generates better performances than the main baseline IMP in a totally same setting. Moreover, the result of our method is also optimal in similar settings compared to other pruning techniques. These findings demonstrate the superiority of our random way in the mask generation process over the deterministic approach and confirm that our mask selection rule can effectively navigate the optimization after introducing randomness. In other words, our methods successfully increase the probability of finding better pruning \fMethods #params MNLI-m Acc QNLI Acc QQP F1/Acc MRPC F1 SST-2 Acc COLA Mrr RTE Acc STS-B Spear BERTBase 110M 84.5 91.4 89.59/91.0 90.1 92.5 56.3 69.3 89.0 left #params \u226550% BERT-PKD 50% 81.3 88.4 -/88.4 85.7 91.3 45.5 66.5 86.2 Stru Pruning 73% 89.05 88.61 92.09 88.18 SNIP 50% 82.4 89.5 88.1 91.8% EBERT 60% 83.1 90.2 87.5/90.8 92.2 BERT-of-Theseus 50% 82.3 89.5 -/89.6 89.0 91.5 51.1 68.2 88.7 Pretrained Ticket 50%-90% 82.6 88.9 -/90.0 84.9 91.9 53.8 66.0 88.2 Lottery Ticket 38%-51% 84.0 91.0 -/91.0 84.0 92.0 54.0 61.0 88.0 IMP 50% 84.6 91.3 88.0/91.0 90.8 92.8 53.1 72.0 89.4 Ours 50% 84.7 91.5 88.1/91.1 91.5 93.0 54.3 72.3 89.5 left #params \u226410% RPP 10% 78 87 88.0/80.0 89 Movement Pruning 10% 80.7 87.1/90.5 EfficientBERT 9% 81.7 89.3 86.7/90.1 90.1 39.1 63.2 79.9 SparseBERT 5% 90.6 88.5 52.1 69.1 IMP 6% 83.3 90.5 87.6/90.8 90.2 92.2 53.1 66.7 87.0 Ours 6% 83.4 90.9 87.9/90.9 91.5 92.7 53.4 69.3 87.5 Table 1: Main Comparison Results between Our Strategy and Other Pruning Baselines with BertBase on dev Sets of 8 Datasets from GLUE Benchmark. Note that the pruning results of IMP and Ours are achieved by ourselves in a totally same setting, while others are from the corresponding literature. masks by introducing randomness in a principled way. We also notice that the potential improvement of performance may be limited by the magnitude used to derive sampling probability. In our setting, we use the absolute value of weights to decide the importance of each neuron connection. Thus our pruning results can not surpass the theoretical optimal result (upper bound) when pruning with the absolute value of weights. This reminds us that our method can be easily transplanted to other magnitude-based pruning methods, such as the gradients-based methods, and may produce the same effect, helping us find better pruning masks. Furthermore, we realize that the effect of our strategy in different datasets is not uniform. We obtain a more noticeable improvement in accuracy on small datasets. We argue that small datasets have more local minimums of loss surface, and therefore our strategy can more easily help find better pruning masks. 4.5 Ablation Study We try different ablation settings to figure out the functionality of each part of our strategy and analyze why they are effective for model pruning. 4.5.1 Impact of Randomness and Schedule Prior studies have demonstrated that there is no loss in accuracy at lower levels of sparsity, particularly when sparsity is less than 50%. This suggests that the model maintains robustness with the architectures identified in the early stages of pruning. We conjecture there is a high level of redundancy in the weights at the early pruning stage. As such, introducing more randomness could potentially expand the search space for sparse architecture in the early stages without hurt to the accuracy. However, previous works also argue the concept of early model adaptions and emphasize the importance of early searched architecture to the final pruning targets. Thus, introducing too much randomness at the beginning stage may not be a good idea. In the last pruning stage, the closely-matched magnitudes of the remaining weights significantly impact accuracy. Careful selection is required for the elements to be pruned. Too much randomness could corrupt the model, hindering recovery from the last pruning step, while too little might restrict our search for potentially optimal masks. Hence, deciding the best schedule of randomness at each pruning stage is crucial. \fMethods #params MNLI-m Acc QNLI Acc QQP F1 MRPC F1 SST-2 Acc COLA Mrr RTE Acc STS-B Spear BERTLarge 330M 86.6 92.3 91.3 89.1 93.2 60.6 74.8 90.0 IMP 20% 85.2 91.6 90.8 90.9 92.8 59.0 73.2 89.1 Ours 20% 86.2 91.8 91.1 91.9 93.7 60.9 75.5 89.9 Table 2: Comparison between Our Strategy and IMP with BERTLarge on GLUE dev Sets. (a) MRPC 16x (b) RTE 16x (c) SST-2 16x Figure 3: Comparing the Impact of Randomness in Two Different Schedules with a Deterministic Approach (IMP), which features zero randomness. The horizontal axis presents the logarithmic outputs of ir, with larger ir indicating a greater amount of total introduced randomness. The vertical axis signifies the model\u2019s accuracy. To investigate the impact of randomness, we introduce a hyper-parameter sr that controls the number of sampled masks M, and thereby controls the total introduced randomness. We also propose two simple randomness schedules at varying pruning stages: (1) Decrease, where we reduce the introduced randomness by increasing the number of sampled masks as the count of pruned weights increases (M = sr \u2217Cpruned), and (2) Increase, where we enhance the introduced randomness by decreasing the number of sampled masks as the count of pruned weights increases (M = sr \u2217(C \u2212Cpruned)). We conduct experiments comparing these two schedules against our primary baseline (IMP) under different sr values. The results are displayed in Figure 3, leading us to the following observations: 1) Excessive randomness results in our strategy performing even worse than the deterministic method (the region blue and orange lines below the green line). In this region, the Decrease strategy outperforms the Increase strategy. 2) Existing a threshold below which both our two randomness schedules outperform IMP, highlighting the superiority of our random approach over the deterministic way. 3) Existing another threshold above which the performances of the two randomness schedules become virtually identical. 4) The Decrease strategy consistently equals or outperforms the Increase strategy. This proves that the model accuracy is not sensitive to randomness in the early pruning stage and is gradually becoming sensitive as it approaches target sparsity. 4.5.2 Impact of MCSS We assessed the role of MCSS by removing it from our strategy and comparing the results with our primary findings. The results are summarized in Figure 4. We make the following observation: 1) In the setting with MCSS, there is a certain threshold of randomness below which our strategy significantly outperforms the deterministic way. 2) In contrast, In the setting without MCSS, the model\u2019s performance against the deterministic approach is inconsistent and lacks a clear trend or pattern. This precisely demonstrates that MCSS can ensure the introduced randomness consistently guides the model optimization toward a beneficial direction. In other words, MCSS effectively enhances the lower accuracy boundary in our experiments. 4.5.3 Impact of Sparsity We have examined our strategy across various levels of sparsity, and the findings have been encapsulated in Figure 5(a). We observe that our random pruning strategy has consistently demonstrated superior performance compared to the baseline (IMP) across all levels of compression. The advantage is particularly pronounced at higher levels of sparsity, \f(a) MRPC with MCSS (b) MRPC w/o MCSS Figure 4: Mask Sampling 4(a) v.s. Mask Sampling + MCSS 4(b). Note that the green line in 4(a) and 4(b) represents the same value of accuracy from IMP. The value on the horizontal axis represents the amount of introduced randomness. The value on the vertical axis indicates model accuracy. such as those equal to or greater than 16x sparsity. 4.5.4 Impact of Masks Candidates To verify the relationship between the number of mask candidates in MCSS with the final performance, we design experiments to increase the number of candidate masks at each pruning stage from 2 to 10, and the results are depicted in Figure 5(b). We conclude a positive correlation between the quality of the searched mask and the number of candidate masks at each stage. As the number of mask candidates close to 10, the performance gain is gradually missing. Additionally, the variance of the performance gain is also gradually minimized, which proves that the MCSS can effectively navigate the optimization of pruning in a beneficial direction. 4.6 Discussion 4.6.1 Efficiency Analysis We analyze the efficiency of our method through the training and inference phases. Training Phase: In the training phase, we compare the required computation of our method with the traditional IMP method. It\u2019s easy to find that (a) (b) Figure 5: Impact of Sparsities 5(a) and Impact of #Mask Candidates in MCSS 5(b). The horizontal axes represent the sparsity level and the number of mask candidates for Figures 5(a) and 5(b) respectively, while the vertical axes in both figures denote model accuracy. additional computation mainly from the randomized mask generation and selection. For the generation process, it\u2019s crucial to emphasize that the creation of each mask is independent of the others. This independence allows for parallel processing, meaning that the time consumption doesn\u2019t increase linearly as the increase of mask candidates. On the other hand, we measured the GFLOPS required to generate a single mask and compared it with the GFLOPS needed for one forward pass of BERTbase. It\u2019s roughly 1 percent to the later operation. However, due to implementation challenges, we couldn\u2019t concurrently sample k positions multiple times from the weight matrix, leading to an overall increase in processing time for single randomized mask generation. For the selection process, we only require one epoch to identify the optimal mask, where the overhead is minimal compared with the entire pruning process. Inference Phase: In real-world applications, although there might be overheads during training, the benefits reaped during inference make it worthwhile. Our method stands out with a 16x compression rate and can sustain performance even at \fhigher sparsity levels, achieving up to a 100x compression rate. This ensures that our pruned neural networks, once deployed, bring about significant improvements in performance and efficiency. 4.6.2 Extending to Billion Parameters In the current age of large language models, achieving effective pruning is a formidable challenge, particularly when striving to preserve high sparsity without sacrificing performance. While initiatives like SparseGPT have ventured into pruning for these colossal models, they have only managed a 2x compression rate (Frantar and Alistarh, 2023). The computational complexity of our method is primarily determined by the number of parameters involved. Consequently, our random pruning technique is not yet adaptable to models with billions of parameters. Nevertheless, we are diligently working on refining methods that incorporate controllable randomness more efficiently. 5 Related Work A number of researchers have explored pruning in BERT. Prasanna et al. (2020) prunes the model with Michel et al. (2019)\u2019s first-order importance metric and proves that unstructured magnitudebased pruning always produces sparser and higheraccuracy models than structured pruning. Gordon et al. (2020) and Chen et al. (2020) both argue that pruning in the pre-trained stage is better than finetuning stage because there is no need to prune for each downstream task. They also conclude that knowledge in sparse training can be transferred as well as dense models. In contrast, Xu et al. (2021) find that pruning at the pre-trained stage has huge computational problems while pruning at the finetuning stage can save computational efforts and keep accuracy simultaneously. These pruning methods are based on the magnitude and prune weights in a deterministic way. In parallel, a linear of works defeats magnitude-based methods at highlevel sparsity by applying a non-deterministic way: regularization-based pruning. Specifically, a finedesigned L0 or L1 penalty terms are added to the loss function. Then the model proactively shrinks some of the weights until they do not contribute to the final loss. The regularization-based method can generally achieve significantly better results than the magnitude-based methods, especially at highlevel sparsity (Sanh et al., 2020). However, penalty terms can introduce additional local minima to the loss function and are difficult to navigate optimization. On the other hand, there is a lack of research on random pruning applied to Transformer-based models (such as BERT) in previous studies. Therefore, our paper complements the gap in this area. 6"
+                },
+                {
+                    "url": "http://arxiv.org/abs/2306.14490v1",
+                    "title": "TaiChi Action Capture and Performance Analysis with Multi-view RGB Cameras",
+                    "abstract": "Recent advances in computer vision and deep learning have influenced the\nfield of sports performance analysis for researchers to track and reconstruct\nfreely moving humans without any marker attachment. However, there are few\nworks for vision-based motion capture and intelligent analysis for professional\nTaiChi movement. In this paper, we propose a framework for TaiChi performance\ncapture and analysis with multi-view geometry and artificial intelligence\ntechnology. The main innovative work is as follows: 1) A multi-camera system\nsuitable for TaiChi motion capture is built and the multi-view TaiChi data is\ncollected and processed; 2) A combination of traditional visual method and\nimplicit neural radiance field is proposed to achieve sparse 3D skeleton fusion\nand dense 3D surface reconstruction. 3) The normalization modeling of movement\nsequences is carried out based on motion transfer, so as to realize TaiChi\nperformance analysis for different groups. We have carried out evaluation\nexperiments, and the experimental results have shown the efficiency of our\nmethod.",
+                    "authors": "Jianwei Li, Siyu Mo, Yanfei Shen",
+                    "published": "2023-06-26",
+                    "updated": "2023-06-26",
+                    "primary_cat": "cs.CV",
+                    "cats": [
+                        "cs.CV",
+                        "cs.AI"
+                    ],
+                    "main_content": "Introduction Human motion capture (Mocap) is usually used to obtain 3D human movement information in proactive health care and intelligent sports. Sports performance analysis and evaluation can improve athletes\u2019 competitive ability or promote public scientific fitness. The widely used inertial and optical motion capture systems can track and record human movement well, but need to bind sensors or paste marks on human body, which may affect human movement. Moreover, most current optical and inertial motion capture systems are expensive, and how to stick the markers also requires certain professional knowledge. Visual motion capture methods use cameras to non-invasively capture human motion images and then obtain the motion data through human pose estimation (HPE) and 3D reconstruction. Vision-based human action analysis is an important research topic in computer vision, and in recent years it has been widely applied in intelligent sports. Accurate 3D human motion modeling is the prerequisite for reliable human motion analysis. Human action recognition (HAR) and action quality assessment (AQA) are two tasks of performance analysis in intelligent sports. The former aims to identify the action classification, while the latter aims to automatically quantify the performance of the action or to score its performance. Traditional methods for action analysis are mainly based on artificial design features, and compare the action sequences by estimating the distance error or dynamic time warping. Deeplearning methods use the deep network to directly learn action features and have shown more powerful performance. Generally speaking, deep-learning methods consist of video-based methods and skeleton-based methods. Algorithms based on video generally extract features directly from images, such as C3D [Parmar and Morris, 2020], I3D [Carreira and Zisserman, 2017], and TSN [Xiang et al., 2018] and Pseudo3D [Qiu et al., 2017], and then extract time domain features by LSTM, pooling, and so on. The finally score prediction is performed by a fully connected neural network. Skeletonbased methods first detect the human skeleton in the images or video, and then model the correlation information between human joints, so as to realize human motion modeling and motion quality evaluation. At present vision-based performance analysis is mature in motion recognition and has made remarkable progress, but the performance of action quality assessment in sports motion scoring and intelligent sports training is still lower than the current application needs. Many studies on human movement evaluation with computer vision have been proposed, however most of them only select a few relatively simple fitness or clinical rehabilitation movements to identify and evaluate. As the current mainstream method, deep learning needs largescale human motion dataset to train a better model, which limits their effects on sports action analysis. Although some human professional sports datasets have been presented in recent years, however most of them are RGB images or videos collected from the Internet, such as AQA-7[Parmar and Morris, 2019a] and Yoga-82 [Verma et al., 2020]. The performance of sports scoring or quality evaluation is still below the current application requirements. According to above analyses, existing studies focus more on the recognitions of regular actions or assessments of competitive sports, and lack of 3D action dataset. As a complement to above work, we focus on how to capture and intelligently assess the quality of TaiChi actions. In summary the arXiv:2306.14490v1  [cs.CV]  26 Jun 2023 \fFigure 1: The system of TaiChi performance capture and analysis. main contributions of this paper are the followings: 1. A professional TaiChi dataset consists of 23,232 action samples captured through multi-view cameras; 2. An effective 3D human modelling framework with multi-camera calibration, 3D skeleton fusion and 3D surface reconstruction; 3. A normalized modeling method for skeleton sequences based on motion transfer to analyse TaiChi performance from different groups. 2 Related Work Vision-based motion capture. Human Mocap system based on vision technology can obtain 3D movement information non-invasively, and is gradually applied in the field of sports performance analysis. The type of human motion description includes human skeleton model (e.g., MPII [Andriluka et al., 2014]), human parametric model (e.g., SMPL [Loper et al., 2015]) and dense shape model (e.g., HumanNeRF [Weng et al., 2022]). Among them, the skeleton model of human body describes the non-rigid motion of 3D surface with high degrees of freedom as surface motion driven by the dynamic chain. As a structured representation of human pose, skeleton model can conveniently and effectively represent quantitative information of human movements, and is widely used in action analysis. According to the number of viewpoints, visual Mocap systems can be divided into single-view system and multi-view system. The single-view system generally uses a single camera to capture human motion from a fixed perspective, while the multi-view system obtains human motion images from multiple perspectives based on the multicamera system. The main challenge of single-view method is the problems of occlusion and depth uncertainty. Compared with the single-view method, the multi-view method can provide multi-view information, which can alleviate the occlusion problems and better restore 3D human posture. Imocap[Dong et al., 2020] can capture human motion from multiple Internet videos, and open a new direction for 3D HPE. DeepMultiCap[Zheng et al., 2021] uses the pixel alignment implicit function based on the parameterized model to reconstruct the invisible region response to the severe occlusion problem in the close-range interaction scene, and captures geometric details of human surface over time based on the attention module. Multi-view video data can contain more temporal and spatial information, but human posture may vary dramatically in continuous frames of video data, so how to integrate the data effectively remains to be solved. Currently, mainstream deep learning methods often require a large number of labeled data, which increases the difficulty of model training for sports action. Vision-based human motion datasets. NTU RGB+D [Liu et al., 2019] is so far the largest Kinect-based action dataset collected from 106 distinct subjects and contains more than 114 thousand video samples and 8 million frames. The dataset contains 120 different action classes including daily, mutual, and health-related activities. Human 3.6M [Ionescu et al., 2014] is another large dataset with 3.6 million human poses and corresponding images. There are 11 subjects and 17 action scenes, and the data is made up of four digital cameras, one time sensor and ten motion cameras. UCF-sport [Soomro and Zamir, 2014] is the first sports action dataset, and contains close to 200 action video sequences collected from various sports which are typically featured on broadcast television channels such as BBC and ESPN. Since then a number of sports motion datasets [Li et al., 2018a; Shao et al., 2020; Verma et al., 2020] used for action recognition have emerged. FineGym [Shao et al., 2020] provides coarse-to-fine annotations both temporally and semantically for gymnastics videos. There are three levels of categorical labels, and the temporal dimension is also divided into two levels, i.e., actions and sub-actions. UMONS-TAICHI [Tits et al., 2018] includes 2,200 sequences of 13 classes (relative to different Taijiquan techniques) performed by 12 participants of different levels of expertise. Fitness-AQA [Parmar et al., 2022] is a new exercise dataset comprising of three exercises (BackSquat, BarbellRow and OverheadPress), has been annotated by expert trainers for multiple crucial and typically occurring exercise errors. At present, most sports action datasets used for performance analysis are competition data based on publicly available RGB images or videos, such as public FSD-10[Liu et al., 2020] and Finediving [Xu et al., 2022], but few of them have multi-view 3D skeleton poses. Vision-based action analysis. With the development of intelligent sports and computer vision, many action analysis methods for sports have been gradually proposed in recent years. Deep learning is currently the mainstream method for vision-based action analysis, where the most widely used models are RNNs, CNNs, GCNs and Transform-based. According to the type of input data, there are mainly imagebased [Duan et al., 2022; Parmar and Morris, 2019b] and skeleton-based [Yan et al., 2018; Pan et al., 2019] methods. ScoringNet [Li et al., 2018b] and SwingNet [McNally et al., 2019] are based on images, and support fine-grained action classification and action scoring. These methods focus on the visual activity information of the whole scene including the performer\u2019s body and background, but may tend to ignore the motion relationship within the human skeleton joints. Skeleton-based methods generally begin by extracting human skeleton, and then conduct spatio-temporal modeling on the association information between skeleton joints. For example, the joint relational graph method proposed by Pan et al. [Pan et al., 2019] models the conventional motion and motion difference between different parts of human body according to the joint common module and joint difference \fFigure 2: The organization of TaiChi data. module respectively. HDVR [Hu and Ahuja, 2021] proposes a hierarchical dance video recognition framework by estimating 3D human pose from the corresponding 2D human pose sequences. For competitive gymnastics, SportsCap [Chen et al., 2021] uses ST-GCN [Yan et al., 2018] method to predict a fine-grained semantic action attributes, and adopts a semantic attribute mapping block to assemble various correlated action attributes into a high-level action label for the overall detailed understanding of the whole movement. In recent years, vision-based HAR methods are mature and have made remarkable progress, and AQA technologies have also been developed gradually. However, human body is often in self-occlusion with large folding or bending in sports, the performance of existing methods in rehabilitation training and sports scoring is still lower than current application requirements. The recognition accuracy of uncommon or highly similar human motion is still limited, and how to effectively model and analyze human motion with challenging situation, such as complex movements and view change, needs to be further studied. 3 Methods For TaiChi performance capture and analysis, we design a non-invasive system with multi-view geometry and artificial intelligence technology. 3.1 Experimental Setup Since there has a lot of body rotation in TaiChi movements, we set up a ring array multi-camera system to realize a better motion capture. The installation bracket of the system is a positive 16-sided shape with a diameter of 450 cm and a height of 250 cm, with a total of 16 columns. Each two RGB cameras (2448\u00d72048p) from the FLIR company are installed on each column. There are 32 cameras in total, 16 of them are 100 cm from the ground and the rest of them are 200 cm from the ground. Cameras on the top are tilted down about 20 degrees, and cameras on the bottom are tilted down about 10 degrees. Each four cameras are connected to a server, and the 8 servers are networked through a 10 GB router. All cameras are synchronously controlled through a special trigger device. Data process and experiments are conducted on the PyTorch deep-learning framework on a standard desktop PC with 11 GB 1080Ti GPUs. 3.2 System Composition As shown in Figure 1, the proposed system mainly contains five modules: Figure 3: Visual simulation of our multi-camera calibration. \u2022 Multi-camera calibration. Before motion capture, the system is calibrated to obtain the internal reference matrix of each camera and the pose relationship between multi cameras. \u2022 Motion capture. The 32 high frame rate RGB cameras through 8 servers are synchronously controlled to capture and store the high-definition TaiChi motion data. \u2022 3D skeleton fusion. The 2D skeletons are obtained by the HPE method from each RGB image and then fused into 3D human skeleton by multi-visual geometry matching. \u2022 3D surface reconstruction. The 3D human surface model is reconstructed with multi-view images through camera poses estimation and neural radiance field rendering. \u2022 Performance analysis. The skeleton sequences of different subjects are transferred to a standard model to eliminate individual appearance differences, and then TaiChi action quality is compared and evaluated by comparing the trajectory and angle changes of the re-targeted skeletons. 4 TaiChi Performance Capture 4.1 Multi-view Data Organization Figure 2 shows the organization of multi-view TaiChi action data, which contains 23,232 action samples, including each sample\u2019s RGB image, depth image, 2D skeleton and 3D skeleton data. Each TaiChi action sample is captured by 32 RGB cameras from 32 different views and a RGB-D camera (Kinect Azure) from the front view simultaneously. During TaiChi data acquisition, 11 subjects (3 female and 8 male) have performed the 24-form TaiChi actions same as TaiChi24 [Li et al., 2022]. Each action sample is manually segmented and labeled with category and action quality. The 2D skeletons are computed through Openpose [Cao et al., 2017] algorithm, while the 3D skeletons are obtained from Kinect Azure SDK. 4.2 Multi-camera Calibration To get the pose relationship of the 32 RGB cameras, we design a multi-camera calibration tool by the 2D planar checkerboard calibration method [Zhang, 2000]. Figure 3 shows a visual simulation of our multi-camera calibration process. The 2D checkerboard is located in the center of the multi-camera system, and its orientation and pitch angle are changed uniformly. More than 100 checkerboard images are selected in \fFigure 4: Example of 3D skeleton fusion results from 8 different views. each calibration. The grids in the checkerboard are 10 \u00d7 15, and the actual side length of each grid is 5 cm. In the process of data acquisition and processing, we have carried out 10 times of calibration. Based on the camera projection model, we construct a minimization objective function with re-projection error to solve the camera parameters: min X \u2225PXi \u2212xi\u22252, (1) where x is the feature in RGB image, X is the of in the checkerboard, and P = K[R|t] is the camera projection matrix. K is the i-th camera internal reference matrix, and [Ri|ti] is the i-th camera external reference matrix. In order to further improve the accuracy of calibration, bundleadjustment (BA) [Triggs et al., 2000] is used for optimization. 4.3 3D Skeleton Fusion 2D skeletons estimated from a single view RGB image often have the problem of occlusion, which will affect the accuracy of performance analysis. Therefore, we make 3D skeleton fusion by direct linear transformation (DLT) [Adbel-Aziz, 1971] algorithm. The main calculation process is shown in the following formula: si = Ki[Ri|ti]S, i \u2208(1, m) (2) where si = {s1, s2, ...sN} is the 2D skeleton with N joints in the i-th camera view, S = {S1, S2, ...SN} is the corresponding 3D skeleton, and m is the number of fused camera views. Figure 4 shows an example of 3D skeleton fusion results (rendered on 2D images) for a subject from 8 different views. 4.4 3D Surface Reconstruction Considering the excellent modeling and rendering capabilities of neural radiation fields (NeRFs), we realize 3D human surface reconstruction by joint using the traditional Colmap [Schonberger and Frahm, 2016] and deep-learning based Instant NeRF [M\u00a8 uller et al., 2022]: 1) Firstly, we detect and extract SIFT features from each input image; 2) And then the positions of the multi cameras are estimated by feature matching; 3) Finally, data conversion is performed for NeRF rendering. Given a 3D point and a viewing direction d \u2208R3, NeRF estimates RGB color values and density (c, \u03c3) that are Figure 5: 3D human surface reconstruction with NeRFs. then accumulated via quadrature to calculate the expected color of each camera ray: C(r) = Z tf tn exp(\u2212 Z t tn \u03c3(s)ds)\u03c3(t)c(t, d)dt, (3) where tf and tn define the near and far bounds, and the camera ray is indicated as r(t) = o + td. In order to speed up the signed distance function (SDF) training, 3D training positions are uniformly sampled and computed to the triangle mesh. Figure 5 shows the 3D surface reconstruction results of a subject with Instant NeRF. The top are the overall relationship between the camera poses and human models, while the bottom are the reconstruction details from the front, top and back views respectively. 5 TaiChi Performance Analysis 5.1 Data Precision Analysis Accurate recovery of 3D human movement information is the premise of reliable analysis of human movement. In order to verify the accuracy of our multi-camera system with IMUbased motion capture system, we conduct experiments using these two systems in time and space synchronization. A subject has wore the IMU equipments (Perception Neuron Studio, PNS) and performed three upper limb exercises (lateral hand lift, left punch and right punch) and three lower limb exercises (left knee lift, right knee lift and lunging squat) when the frame rates of the multi-camera system are 30 fps and 60 fps respectively. Figure 6 shows the wearing position of the PNS sensors and human skeleton nodes (Body-25) extracted by Openpose. It can be seen that there has a position deviation for the joints obtained by these two Mocap systems. We have compared and analyzed the Mocap data by the coordinate information of shoulder, elbow, hip and knee joints. Figure 7 shows the MSE error between our multi-camera system and IMU-based Mocap system. The average angle error \f(a) The wearing positions of the PNS sensor (b) The joints extracted with Openpose algorithm Figure 6: Comparison of the wearing positions of IMU and human skeleton joints extracted from our visual Mocap system. Figure 7: Comparison of multi-camera and IMU-based Mocap system by angle error (deg) and distance error (cm) of key joints. and distance error are 6.18 deg and 6.81 cm respectively in 30 fps. The average angle error and distance error are 6.68 deg and 6.41 cm respectively in 60 fps. The main reason for the error lies in the deviation between the paste positions of the PNS sensor and skeleton nodes obtained by visual estimation (as shown in Figure 6). 5.2 Performance Analysis For TaiChi performance analysis, we combine 32 camera views from 16 orientations into 16 stereo pairs to obtain 3D skeletons. 3D skeleton of each camera pair also is computed with 3D reconstruction module of Openpose. The quantization accuracies of TaiChi action recognition and assessment have been discussed in [Li et al., 2022]. Therefore, we mainly conduct performance analysis by comparing the movements between the coach and the students. To avoid the influence of individual differences, the action skeleton sequences from the coach and students are uniformly transferred to a standard virtual human model for comparison. The flowchart of performance analysis with the motion transfer network is shown in Figure 8. The model decomposes the skeleton sequences and recombines the elements to generate a new skeleton sequence, which can be viewed at any desired view-angle. We implement the action transfer based on Transmomo [Yang et al., 2020] without using any paired data for supervision. The transfer network is trained in an unsupervised manner by exploiting invariance properties of three orthogonal factors of variation including motion, Figure 8: The flowchart of performance analysis with motion transfer network. structure, and view-angle. The motion is invariant despite structural and view-angle perturbations, the structure is consistent through time and invariant despite view-angle perturbations, and the view-angle is consistent through time and invariant despite structural perturbations. For an input sequence sT \u2208RT\u00d72N where T is the length of the skeleton sequence and N is the number of body joints. The motion encoder uses several layers of one dimensional temporal convolution to extract the motion information. The structure encoder has a similar network structure with the difference that the final structure code is obtained after a temporal max pooling. The view code is obtained the same way we obtained the structure code. The decoder takes the motion, body and view codes as input and reconstructs a 3D joint sequence ST \u2208RT\u00d73N through convolution layers, in symmetry with the encoders. The total loss function is derived based on invariance and weighted by the following loss terms: Ltotal = \u03bbrecLrec + \u03bbcrsLcrs + \u03bbtripLtrip +\u03bbinvLinv + \u03bbadvLadv, (4) where Lrec is the reconstruction loss to minimize the difference between real data and 3D reconstructions projected back to 2D, Lcrs is the cross reconstruction loss for two sequences, Ltrip is the triplet loss to map views, Linv is the structural invariance loss to ensure that the view code is invariant to structural change estimations from the same sequence to a small neighborhood while alienating estimations from rotated sequences, and Ladv is used to measure the domain discrepancy between the projected 2D sequences and real 2D sequences. We evaluate the action quality by comparing the trajectory and angle changes of the key joints, such as shoulder, elbow, hip and knee. We select the first 15 key points defined in \f(a) Trajectories before motion transfer from student 1. (b) Trajectories after motion transfer from student 1. (c) Trajectories before motion transfer from student 2. (d) Trajectories after motion transfer from student 2. Figure 9: The changes of the key joints\u2019 trajectories before and after motion transfer. (a) Angles before motion transfer from student 1. (b) Angles after motion transfer from student 1. (c) Angles before motion transfer from student 2. (d) Angles after motion transfer from student 2. Figure 10: The changes of the key joints\u2019 angles before and after motion transfer. \fFigure 11: Examples of the re-targeted key-frame skeletons (top: the coach; middle: student 1; bottom: student 2). Body-25 for motion transfer. For the j-th joint in the skeleton model, the angle sequence (\u03b8T j ) for an action sample is calculated as follows: \u03b8T j = arccos((Sj\u22121 \u2212Sj) \u00b7 (Sj+1 \u2212Sj) |Sj\u22121 \u2212Sj || Sj+1 \u2212Sj| ), j \u2208(0, 15) (5) In our experiments, we take the RGB image (1920\u00d71080p) sequence of the coach collected by Kinect camera as the target, and two skeleton sequences of the students captured by our multi-camera system as input data. Figure 9 and Figure 10 show the changes of the trajectories and angels of the shoulder (S-l and S-r), elbow (E-l and E-r), hip (H-l and Hr) and knee (K-l and K-r) joints respectively. The length of the action sample is 48 frames. By analyzing the changes of trajectories and angles after motion transfer, we can find the major difference joints and emergence moments. In the case of these two students, the differences of them are mainly concentrated in the shoulder and knee joints during the movements located at the end of the action. Figure 11 shows the visual analysis results of re-targeted skeletons from two students compared with the coach. It can be seen that the TaiChi motion of student1 is more standard. According to the scores of professional coach, student 1 (100) also scored higher than student 2 (86). 6"
+                },
+                {
+                    "url": "http://arxiv.org/abs/2211.16922v3",
+                    "title": "Learning Motion-Robust Remote Photoplethysmography through Arbitrary Resolution Videos",
+                    "abstract": "Remote photoplethysmography (rPPG) enables non-contact heart rate (HR)\nestimation from facial videos which gives significant convenience compared with\ntraditional contact-based measurements. In the real-world long-term health\nmonitoring scenario, the distance of the participants and their head movements\nusually vary by time, resulting in the inaccurate rPPG measurement due to the\nvarying face resolution and complex motion artifacts. Different from the\nprevious rPPG models designed for a constant distance between camera and\nparticipants, in this paper, we propose two plug-and-play blocks (i.e.,\nphysiological signal feature extraction block (PFE) and temporal face alignment\nblock (TFA)) to alleviate the degradation of changing distance and head motion.\nOn one side, guided with representative-area information, PFE adaptively\nencodes the arbitrary resolution facial frames to the fixed-resolution facial\nstructure features. On the other side, leveraging the estimated optical flow,\nTFA is able to counteract the rPPG signal confusion caused by the head movement\nthus benefit the motion-robust rPPG signal recovery. Besides, we also train the\nmodel with a cross-resolution constraint using a two-stream dual-resolution\nframework, which further helps PFE learn resolution-robust facial rPPG\nfeatures. Extensive experiments on three benchmark datasets (UBFC-rPPG, COHFACE\nand PURE) demonstrate the superior performance of the proposed method. One\nhighlight is that with PFE and TFA, the off-the-shelf spatio-temporal rPPG\nmodels can predict more robust rPPG signals under both varying face resolution\nand severe head movement scenarios. The codes are available at\nhttps://github.com/LJW-GIT/Arbitrary_Resolution_rPPG.",
+                    "authors": "Jianwei Li, Zitong Yu, Jingang Shi",
+                    "published": "2022-11-30",
+                    "updated": "2022-12-02",
+                    "primary_cat": "cs.CV",
+                    "cats": [
+                        "cs.CV"
+                    ],
+                    "main_content": "Introduction Heart rate (HR) is an important physiological signal which is widely used in many circumstances, especially for healthcare or medical purposes. Electrocardiography (ECG) and Photoplethysmograph (PPG)/Blood Volume Pulse (BVP) are the two most common methods of measuring heart activities. However, these sensors need to be attached to body parts, limiting their usefulness and scalability. Due to the inconvenience of long-term monitoring and discomfort for the *Equal contribution \u2020Corresponding author Copyright \u00a9 2023, Association for the Advancement of Arti\ufb01cial Intelligence (www.aaai.org). All rights reserved. Figure 1: rPPG measurement from arbitrary resolution videos with head movements. (a) The ROIs might have different spatial size and shape across the temporal dimension. (b) Compared with the baseline PhysNet (Yu, Li, and Zhao 2019), the proposed TFA-PFE can predict more accurate rPPG signals with the ground truth BVP signals. users, traditional ways limit the application scenarios such as driver status assessment and burn patient health monitoring. To solve this problem, non-contact HR measurement, which aims to measure heart activity remotely, has become an increasingly popular research problem in physiological signal measurement in recent years. Most existing non-contact HR measurement approaches are based on the facial video-based remote Photoplethysmograph (rPPG) technique (Yu, Li, and Zhao 2021). The rPPG method uses digital cameras to record variations of re\ufb02ected ambient light on facial skin, which contains information on cardiovascular blood volume and pulsation. However, the rPPG measurement is very susceptible and vulnerable to the quality of video recording and head motions. In the early stage, handcrafted features based methods (Takano and Ohta 2007; Verkruysse, Svaasand, and Nelson 2008) require an exhausted multi-stage process (preprocessing, \ufb01ltering and post-processing) and are with low robustness to head motions and illumination changes. Thus, they are usually tested and deployed under controlled lab environment scenarios. With the rapid development of deep learning, neural network models have also been widely applied in the rPPG \ufb01eld. Recent spatio-temporal representation map (Niu et al. 2020; Lu, Han, and Zhou 2021) based and end-to-end (Yu, Li, and Zhao 2019; Chen and McDuff 2018) based modarXiv:2211.16922v3  [cs.CV]  2 Dec 2022 \fels utilize Convolutional Neural Networks (CNNs) to learn the spatio-temporal rPPG cues from facial videos with \ufb01xed resolution, which have shown superior performance compared with traditional approaches. However, most of the existing rPPG approaches rarely consider the real-world practical situation with arbitrary resolution face videos (e.g., the distance of the participants varies by time, see Figure 1(a) for visualization). Previous methods (McDuff 2018) simply use the spatial interpolation method to scale the face frames with arbitrary resolutions to a \ufb01xed size to adapt the model input, where the vital pixels of the region of interest (ROI) might be confused by the interpolation method, thus harming the accuracy of rPPG measurement. Meta-SR (Hu et al. 2019) and LIIF (Chen, Liu, and Wang 2021) bring the scalearbitrary super-resolution problem into the horizon. To our best knowledge, there is still no solution proposed yet to counter the problem of rPPG measurement from arbitrary face resolution videos. Besides arbitrary face resolution, another noteworthy issue of rPPG measurement is the motion-robustness. Due to the limited spatio-temporal receptive \ufb01eld of CNN with weak capacity of spatial contextual ROI localization, both rigid and non-rigid head motions usually have serious impacts on rPPG measurement. Existing end-to-end models (Yu, Li, and Zhao 2019; Yu et al. 2021) do not take initiative (e.g., face alignment operation) to describe the head movement to compensate the motion artifacts, resulting the vulnerability to severe head movement. Few works passively adopt the ROI tracking (Niu et al. 2018b) or utilize normalized frame difference motion representation as input (Chen and McDuff 2018; Liu et al. 2020). However, these methods have limited stability and are hard to directly plug in the off-the-shelf end-to-end spatio-temporal rPPG models. Motivated by the discussions above, we propose two plug-and-play blocks (i.e., Physiological Signal Feature Extraction block (PFE) and Temporal Face Alignment block (TFA)) to capture resolutionand motion-robust rPPG features. To learn the similarity of rPPG signals from arbitrary resolution frames, we design a new cross-resolution constraint using a dual-resolution framework, which further helps PFE learn resolution-robust facial rPPG features. As shown in Figure 1(b), compared with the vanilla PhysNet (Yu, Li, and Zhao 2019), the proposed TFA and PFE blocks can bene\ufb01t more accurate rPPG measurement from arbitrary resolution videos with head movements. The contributions of this work are as follows: \u2022 To our best knowledge, we provide the \ufb01rst solution to plug-and-play modules on robust rPPG measurement from facial videos with arbitrary \ufb01xed resolution or varying face resolution. \u2022 We propose the PFE block to adaptively encode the arbitrary resolution facial frames to the \ufb01xed-resolution facial structure features. Besides, we propose to train the model with a cross-resolution constraint using a twostream dual-resolution framework, which further helps PFE learn resolution-robust facial rPPG features. \u2022 We propose the TFA block to counteract the rPPG signal confusion caused by the head movement via wrapping facial frames by the estimated optical \ufb02ow, which bene\ufb01ts the motion-robust rPPG signal recovery and alleviates the in\ufb02uence of head movement. \u2022 We conduct extensive experiments on benchmark datasets to demonstrate the superior performance of the proposed method under both arbitrary face resolution and severe head movement scenarios. Related Work Remote Photoplethysmography Measurement Plenty of handcrafted rPPG measurement methods have been proposed since the researches (Takano and Ohta 2007; Verkruysse, Svaasand, and Nelson 2008) show the feasibility of recovering physiological signals through a digital camera. Some early works take traditional signal processing methods into consideration, which contain matrix transformation (Tulyakov et al. 2016; Shi et al. 2020), Least Mean Squares (Li et al. 2014), and Blind Source Separation (BSS) (Poh, McDuff, and Picard 2010a,b). In recent years, with the boost of deep learning methods, Deephys (Chen and McDuff 2018) and PhysNet (Yu, Li, and Zhao 2019) \ufb01rstly introduce end-to-end based CNN framework to this \ufb01eld. Meanwhile, spatio-temporal signal map based methods (Niu et al. 2020; Lu, Han, and Zhou 2021) also attract more attention due to their excellent performance. Towards ef\ufb01cient rPPG measurement, Auto-HR (Yu et al. 2020) and Ef\ufb01cientPhys (Liu et al. 2022) search and design lightweight end-to-end models. Recently, PhysFormer (Yu et al. 2022a) gains progress via temporal difference transformers to explore the long-range spatio-temporal relationship for rPPG representation. Besides supervised learning with labeled facial videos, unsupervised learning has also been validated in (Gideon and Stent 2021) to achieve rPPG measurement. The vulnerability of rPPG models has also been discussed recently, such as phase difference (Mironenko et al. 2020; Moc \u00b8o et al. 2018), camera rolling (Moc \u00b8o et al. 2018; Zhan et al. 2020) and video compression format (McDuff, Blackford, and Estepp 2017). Face Resolution and its Impact for RPPG In real-world applications, the distances between the camera and participants are variant, resulting in arbitrary resolution on facial region. Some recent works aim to extract rPPG from low-resolution videos with \ufb01xed size. They use superresolution models through the end-to-end (McDuff 2018) or two-stage (Song et al. 2020; Yue et al. 2021) network to recover the high-quality face videos and corresponding rPPG signals simultaneously. However, the target of superresolution (Shi et al. 2018; Shi and Zhao 2019) is mainly toward the recovery of visual performance, but not to maintain the quality of rPPG signals. Furthermore, it is still a challenge to obtain reasonable rPPG signals in the arbitrary face resolution scenario, which is more practical in the realworld application. Face Alignment for RPPG The alignment of face video enhances the performance of rPPG measurement. One straightforward evidence is that \fFigure 2: Overall framework of the proposed method. The frames in the sequence can be the arbitrary resolution. In the spatial stream, each arbitrary resolution face frame in the sequence forwards the Physiological Signal Feature Extraction (PFE) block, which maps the arbitrary size features to the \ufb01xed size facial structure features. In the temporal stream, the Temporal Face Alignment (TFA) block interpolates the frames to the same shape to generate the temporal aligned features. The facial structure and temporal aligned features are added to form the facial structure-motion features. Finally the facial structure-motion features forwards a rPPG Signal backbone to predict the rPPG signals. with the assistance of face landmark (Xia et al. 2022; Wan et al. 2020; Shi et al. 2022), generated facial ROI-based spatio-temporal signal maps (Lu, Han, and Zhou 2021; Lu and Han 2021; Niu et al. 2018a, 2020, 2018b) bene\ufb01t the motion-robust rPPG measurement. However, the ef\ufb01cacy of these methods highly depend on the accuracy of the detected face landmarks. As reported in (Niu et al. 2018b), the huge rotation of head easily causes the loss of landmarks. Recently, temporal alignment is wildly applied in video frame interpolation and video super-resolution. Optical \ufb02ow calculated for image-level alignment (Yi et al. 2019) and featurelevel alignment (Chan et al. 2021) are two representative streams for temporal alignment. In this work, we introduce the optical \ufb02ow guided feature alignment for motion-robust rPPG measurement. Methodology Overall Framework As illustrated in Figure 8, given a arbitrary resolution face sequence X = [x1, x2, ..., xi] , xi \u2208R3\u00d7hi\u00d7wi, i \u2208{1, ..., T} as input, the proposed method forwards the two-stream pathway including the Physiological Signal Feature Extraction block (PFE) and the Temporal Face Alignment block (TFA) to form the facial structure-motion features. Then the rPPG backbone (e.g., PhysNet (Yu, Li, and Zhao 2019)) is used for rPPG signals prediction. Please note that the arbitrary width hi and height wi of each frame can be different. Before the PFE stream, we adopt a ConvBlock to extract features Xar = \u0002 x1 ar, x2 ar, ..., xi ar \u0003 , xar \u2208RC\u00d7 hi 2 \u00d7 wi 2 from the arbitrary resolution face sequence X. Speci\ufb01cally, the ConvBlock is formed by a convolutional block with kernel size (1 \u00d7 5 \u00d7 5) cascaded with batch normalization (BN), RELU, and MaxPool, where the pooling layer halves the spatial dimension. Then Xar forwards the PFE block to generate facial structure features Xst \u2208RT \u00d7C\u00d7H\u00d7W . T, C, H, W indicate constant clip length, channel, height and width, respectively. In term of the TFA stream, the TFA block \ufb01rst interpolates the arbitrary resolution sequence X to \u02c6 X \u2208RT \u00d73\u00d7H\u00d7W , which has the same height and width as Xst. Then, TFA uses the bi-directional optical \ufb02ow (forward and backward) from successive frames to obtain temporal face alignment features Xmo \u2208RT \u00d7C\u00d7H\u00d7W . The output of PFE Xst and the output of TFA Xmo are summed to form the facial structure-motion features Xst\u2212mo \u2208RT \u00d7C\u00d7H\u00d7W . Finally, the rPPG signal backbone predicts the 1D rPPG signals Y \u2208RT from Xst\u2212mo. More details for reproducibility could be found in our code. Physiological Signal Feature Extraction (PFE) The PFE block is used in the spatial dimension for each face frame. As shown in Figure 3, the proposed PFE contains two parts. The upper and lower branches are devised for facial information and position information respectively. For upper branch, the features xar from arbitrary-resolution frame are \ufb01rst interpolated to constant resolution features xcr \u2208RC\u00d7H\u00d7W . To exploit the facial features, receptive \ufb01eld expansion is conducted as Eq.(1) to obtain the expanded features \u02c6 xcr \u2208R(n2C)\u00d7H\u00d7W . Meanwhile, in the lower branch, Representative area encoding (RAE) is em\fFigure 3: The structure of the PFE block. ployed as Eq.(2) to record the mapping relationship of pixel positions between xar and xcr. The relationship is described as coordinate tensor xsize \u2208R2\u00d7H\u00d7W , where two channels represent the scaling ratio on the height and width accordingly. Then, the expanded features \u02c6 xcr together with coordinate tensor xsize are fed into the facial feature encoding as Eq.(3) to produce the facial structure features xst \u2208RC\u00d7H\u00d7W . Receptive \ufb01eld expansion. To enrich and mine the contextual information contained in the facial structure features xcr, we unfold the facial structure features xcr \ufb01rst, and then expand its receptive \ufb01eld via concatenating the n \u00d7 n neighboring features to obtain \u02c6 xcr. Formally, the receptive \ufb01eld expansion is de\ufb01ned as \u02c6 xcr(i, j) = Concat({xcr(i + n, j + n)}n\u2208Neighbor), (1) where i and j indicate the spatial position of the features. n = 3 is used as the default setting. Representative area encoding (RAE). As the arbitrary size features xar have different spatial size with the structure features xst, spatial positions in xst correspond to different areas from xar. It is important to explicitly describe the representative area for each spatial position. Here we formulate the representative area information xsize \u2208R2\u00d7H\u00d7W as xsize (i, j) = [\u03c3H, \u03c3W ], \u03c3H = h H , \u03c3W = w W , (2) where \u03c3H and \u03c3W mean the scaling ratio on the height and width dimensions when xar is transformed to xst. Facial feature encoding. We concatenate \u02c6 xcr and xsize along the channel dimension. A shallow facial feature encoding function is designed to mine the semantic facial structure features, which is simply parameterized as an MLP. Facial feature encoding takes the form: xst = Reshape (MLP (Flatten(Concat (\u02c6 xcr, xsize)))) (3) After extracting the facial structure features xst \u2208RC\u00d7H\u00d7W from each frame, we merge them in temporal dimension to form the Xst \u2208RT \u00d7C\u00d7H\u00d7W . Temporal Face Alignment (TFA) The facial structure features Xst from the PFE block have rich representation capacity on the arbitrary resolution conFigure 4: The structure of TFA block. Pf and Pb mean the forward and backward optical \ufb02ow face alignment block, respectively. dition. However, in practice, head movement in\ufb02uences endto-end rPPG measurement signi\ufb01cantly. For example, hugeangle rotation will make partial facial features out of the scope of the facial structure features Xst. Previous works use landmark detection methods such as OpenFace (Baltru\u02c7 saitis, Robinson, and Morency 2016) to extract the face landmarks for facial ROI alignment. However, the robustness of rPPG measurement is highly depended on the accuracy of face landmarks. Here, three problems are noted for face alignment: 1. Landmarks status. The position of face landmarks could change dramatically because of head motion, which induces the inaccurate detection of ROIs in the facial clips. 2. Interpolation. The shape of ROI might be different, and interpolation is usually used to keep the consistency (Hu et al. 2021). However, interpolation may corrupt the color change of pixels, and eliminate the rPPG cues. 3. Lost landmarks. When the head movement encounters huge-angle rotation, partial face may disappear from the frame. In this case, the predicted landmarks would mark some regions randomly. Head rotation is a continuous process, and the state of each frame is correlated with the forward and backward states. According to these observations, we propose the temporal face alignment (TFA) block to leverage optical \ufb02ow to describe the facial motion and wrap the facial structure features. As shown in Figure 4, TFA adopts a typical bidirectional recurrent network. The video sequence \u02c6 X forwards optical \ufb02ow face alignment as Eq.(4) to get head motion features Hb,f = h hb,f 1 , hb,f 2 , ..., hb,f i i , hb,f i \u2208RC\u00d7H\u00d7W . Then, hb and hf are fed into bidirectional aggregation as Eq.(5) to produce the facial structure features xst. Optical \ufb02ow face alignment. The video sequence \u02c6 X is \ufb01rst fed into \u2018Optical\u2019 to calculate the optical \ufb02ow si by SPyNet (Ranjan and Black 2017). Then, the optical \ufb02ow si is utilized to \u2019Warp\u2019 the head motion features hi\u22121 of previous frame to get aligned features \u00af hi\u22121 for frontalizing faces. Notice status h0 is initialized by features of all zeros. The aligned features together with the recent frame are then \fpassed to 15 basic residual blocks for obtaining hi. Optical \ufb02ow face alignment takes the form: sb,f i = Optical (xi, xi\u00b11) , \u00af hi\u00b11 = Wrap \u0010 hi\u00b11, sb,f i \u0011 , hb,f i = ResBlock \u0000Concat \u0000xi, \u00af hi\u00b11 \u0001\u0001 , (4) The head motion features hi can be represented from two temporal directions (i.e., forward and backward). Thus, we use hf i and hb i to represent the hi via forwarding and backwarding xi. Bidirectional aggregation. To aggregate the backward and forward head motion features, we concatenate hb i and hf i along the channel dimension and introduce a convolutional layer to maintain the number of channels. Formally, the bidirectional aggregation is de\ufb01ned as xmo = F \u0010 Concat \u0010 hb i, hf i \u0011\u0011 (5) where F (\u00b7) represents a 1 \u00d7 1 convolutional layer and xmo \u2208RC\u00d7H\u00d7W represents generated temporal face alignment features. Finally, the facial structure features xst are added to xmo to obtain the facial structure-motion features xst\u2212mo \u2208RC\u00d7H\u00d7W . Cross-Resolution Constraint and Loss Functions Despite we have designed the PFE block to tackle with arbitrary resolution problem, it is still hard to learn resolutioninvariant rPPG features with the traditional Negative Pearson loss Ltime (Yu, Li, and Zhao 2019) and frequency crossentropy loss Lfre (Niu et al. 2020). Here we design a novel cross-resolution constraint Lcrc which forces the model to learn consistent rPPG predictions between two resolution views. Speci\ufb01cally, as shown in Figure 5, we sample video clip into different resolutions as X1 \u2208RT \u00d73\u00d7h1\u00d7w1 and X2 \u2208RT \u00d73\u00d7h2\u00d7w2. The two sampled clips forward the unshared PFE and shared TFA blocks \ufb01rst, and then go through a shared rPPG backbone model to predict the corresponding rPPG signals Y1 \u2208RT \u00d71 and Y2 \u2208RT \u00d71. The crossresolution constraint Lcrc can be formulated via calculating the L1 distance between two predicted signals. The overall loss function Loverall can be formulated as Lcrc = \u2225Y1 \u2212Y2 \u22251, Loverall = Ltime + Lfre + \u03b1 \u00b7 Lcrc, (6) where hyperparameter \u03b1 equals to 0.1. The loss function avoids the model to pay attention to the similarity of lowlevel features from different resolution. In other words, Lcrc focuses on the consistency of predicted rPPG signals, instead of the feature-level consistency, which determines the performance measurement and provide the direct supervision signals for the model learning. Experiment We \ufb01rst conduct experiments of rPPG-based HR measurement on three benchmark datasets with their original protocols and normal setting. Then, the UBFC-rPPG (Bobbia Figure 5: The framework of the Cross-Resolution Constraint. It is calculated on the two sequence inputs of arbitrary face images from the same clip. et al. 2019) dataset is used for performance evaluation on arbitrary-resolution facial videos and ablation studies. Dataset UBFC-rPPG. The UBFC-rPPG dataset (Bobbia et al. 2019) includes 42 videos, which are about 2 minutes long and recorded. The bio-signals ground-truth were recorded by a pulse oximeter with a 60 Hz sampling rate. PURE. The PURE dataset (Stricker, M\u00a8 uller, and Gross 2014) contains 60 videos from 10 subjects performing six different head motion tasks: steady, talking, slow translation, fast translation, small rotation, and medium rotation. COHFACE. The COHFACE dataset (Heusch, Anjos, and Marcel 2017) is consisted of 160 one-minute videos from 40 healthy individuals, captured under studio and natural light. The videos are heavily compressed using MPEG-4 Visual, which was noted by (McDuff, Blackford, and Estepp 2017) to potentially cause corruption of the rPPG signal. Implementation Details Preprocessing and training procedure. For each video clip, we use the MTCNN (Zhang et al. 2016) to crop the enlarged face area and resize each frame to 128 \u00d7 128 pixels. And then we downsample the face image ranging from 1.0 to 4.0 times to get the arbitrary scale frames. The facial video clip with arbitrary sizes would be mapped to the \ufb01xed size H=W=64 after PFE and TFA blocks while C=16. Random horizontal \ufb02ipping is used for clip-level spatial data augmentation. The proposed method is trained with batchsize 2 on RTX3090 GPU with PyTorch. The Adam optimizer is used and the learning rate is set as 1e-4. The weight decay is 5e-5. Metrics and evaluation. Following (Comas, Ruiz, and Sukno 2022), we calculate the root mean squared error (RMSE) and mean absolute error (MAE) between the predicted average HR versus the groundtruth HR. We \ufb01rst forward the models using 160-frame clips without overlapping to predict clip-level HR. To fairly compare our method with the state-of-the-art methods (\u02c7 Spetl\u00b4 \u0131k, Franc, and Matas 2018; Comas, Ruiz, and Sukno 2022; Lokendra and Puneet 2022), the whole-video performance comparisons are calculated via averaging the clip-level predictions. \fTable 1: HR estimation results (bpm) on UBFC, PURE, and COHFACE datasets. The proposed TFA and PFE remarkably improve the performance of the baseline PhysNet. Method UBFC PURE COHFACE MAE\u2193 RMSE \u2193 MAE \u2193 RMSE \u2193 MAE \u2193 RMSE \u2193 CHROM 3.44 4.61 2.07 2.5 POS 2.44 6.61 3.14 10.57 HR-CNN 1.84 2.37 8.10 10.8 DeepPhys 2.90 3.63 1.84 2.31 Zhan et al. 2.44 3.17 1.82 2.29 Gideon et al. 3.60 4.60 2.30 2.90 2.30 7.60 AND-rPPG 2.67 4.07 TDM 2.32 3.08 1.83 2.33 PhysNet 2.95 3.67 2.16 2.7 5.38 10.76 TFA-PFE (Ours) 0.76 1.62 1.44 2.50 1.31 3.92 Comparison on Normal Face Resolution Setting For fair comparison, we train the baseline model PhysNet (Yu, Li, and Zhao 2019) and our methods using the same recipe to alleviate the in\ufb02uence of arbitrary resolution and data resolution augmentation. As shown in Table 4, the performance of our re-implemented PhysNet is slightly better than the result reported in (Gideon and Stent 2021). The UBFC-rPPG (UBFC) dataset is used for the ablation study about the proposed TFA and PFE blocks under arbitrary-resolution and head motion scenarios. We compare our method with eight state-of-the-art methods (CHROM (De Haan and Jeanne 2013), POS (Wang et al. 2016), HR-CNN (\u02c7 Spetl\u00b4 \u0131k, Franc, and Matas 2018), DeepPhys (Chen and McDuff 2018),Zhan et al. (Zhan et al. 2020), Gideon et al. (Gideon and Stent 2021), AND-rPPG (Lokendra and Puneet 2022), TDM (Comas, Ruiz, and Sukno 2022)) in Table 1. Results on UBFC-rPPG. It can be seen from the second column of Table 1 that the vanilla 3DCNN-based PhysNet performs worse than two other deep learning based methods (DeepPhys and TDM). When assembled with the proposed TFA and PFE blocks, the PhysNet+TFA+PFE achieves the best performance on UBFC-rPPG, outperforming the DeepPhys and TDM by -1.86 bpm and -1.28 bpm MAE, respectively. On other words, the proposed TFA and PFE blocks improve the baseline PhysNet performance, and reduce 1.81 bpm MAE and 1.39 bpm RMSE on UBFC-rPPG, indicating the effectiveness of robust rPPG features representation via TFA-PFE blocks. Results on PURE. As shown in the third column of Table 1, compared with the baseline PhysNet, the proposed TFA and PFE blocks improve the MAE performance from 2.16 bpm to 1.44 bpm on PURE. It indicates that TFA-PFE is able to represent more motion-robust rPPG features as there are plenty of hard samples with severe head movement in PURE. As for the RMSE metric, the proposed method performs slightly worse than TDM (+0.17 bpm), which is mainly caused by the difference of rPPG backbones (two extra differential temporal convolutions are used in TDM). Please note that the proposed TFA and PFE blocks might also plug-and-play on TDM to further improve performance. Results on COHFACE. Compared with UBFC-rPPG and PURE, the face videos are highly compressed on COHFACE, resulting obvious compression artifacts. As can Table 2: The performance of TFA and PFE on UCLA-rPPG Method Vanilla PFE PFE+TFA MAE\u2193 RMSE \u2193 MAE \u2193 RMSE \u2193 MAE \u2193 RMSE \u2193 PhysNet 11.82 17.23 9.15 14.82 8.73 13.23 PhysFormer 11.75 16.39 8.92 11.28 5.96 12.17 Figure 6: HR estimation results (bpm) on UBFC-rPPG under different \ufb01xed face resolution setting. be seen from the last column of Table 1, existing supervised CNN-based methods (HR-CNN, Gideon et al. (Gideon and Stent 2021), and PhysNet) performs poorly (>5 bpm RMSE) due to the low face video quality. Thanks to the feature re\ufb01nement from the TFA and PFE blocks, the proposed method achieves state-of-the-art performance (RMSE=3.92 bpm), outperforming previous methods by a large margin. Results on UCLA-rPPG. UCLA-rPPG involves more diverse scenarios and presence of subject skin tones. To show our paper is trying to target the general issues of rPPG, we also train and test the TFA and PFE blocks on it. As shown in Table 2, our method still improve the performance. Comparison on Arbitrary Face Resolution Settings Here we downsample the face images from the UBFC dataset with two settings: \ufb01xed face resolution and varying face resolution. The former one describes the long-distance scenario while the latter mimics the varying face-cameradistance scenario. Results on \ufb01xed face resolution. It can be seen from the Figure 6 that the baseline PhysNet is easily in\ufb02uenced by the face resolution. When the \ufb01xed face resolutions are smaller than 50x50, the performance of PhysNet drops sharply (e.g., MAE>5 bpm). In contrast, when assembled with the proposed TFA and PFE blocks, it can predict accurate rPPGbased HR (MAE<2 bpm) in most face solution settings. Results on varying face resolution. rPPG measurement from varying face resolution video is challenging due to the complex temporal contextual interference. The results of varying face resolution on UBFC are shown in Table 3. Compared with the vanilla PhysNet, the proposed TFA and PFE blocks bene\ufb01t the facial feature alignment and re\ufb01nement among consecutive frames, thus improving the MAE performance (8.87 bpm, 6.17 bpm, 10.00 bpm and 5.17 bpm) in four scenarios (high/low resolution gradually decreasing resolution, and high/low resolution gradually decreasing and then increasing resolution), respectively. Ablation Study We also provide the ablation studies of the PFE and TFA blocks under arbitrary face resolution and severe head movement scenarios on the UBFC dataset. \fTable 3: MAE results (bpm) of the PFE and TFA blocks on UBFC under varying face resolution setting. \u2018128 to 64\u2019 means that the face resolution gradually decreases from 128x128 to 64x64 in a video clip. Model Resolution 128 to 64 64 to 32 128 to 64 to 128 64 to 32 to 64 Baseline 10.73 8.14 11.85 7.15 PFE 3.49 3.84 3.29 5.59 TFA 5.44 5.04 5.14 4.33 TFA-PFE 1.86 1.97 1.85 1.88 Table 4: MAE results (bpm) of the PFE and TFA blocks on UBFC under different \ufb01xed face resolution settings. Model Resolution 128\u00d7128 96\u00d796 85\u00d785 75\u00d775 64\u00d764 Baseline 2.38 2.64 2.21 6.06 6.82 PFE w/o RAE 3.79 3.77 3.80 3.73 3.76 PFE w/o Lcrc 2.87 2.85 2.89 2.86 2.84 PFE 2.40 2.39 2.41 2.34 2.33 TFA 8.73 8.30 8.72 8.76 8.29 TFA(single)-PFE 2.28 2.29 2.35 2.35 2.44 TFA-PFE 1.60 1.61 1.62 1.60 1.63 Ef\ufb01cacy of the cross-resolution constraint. In the default setting, the models with PFE are trained in two views with different face resolution frames using a cross-resolution constraint Lcrc. In this ablation, we consider how Lcrc impacts the PFE. As shown in Table 4, \u2018PFE\u2019 outperforms \u2018PFE w/o Lcrc\u2019 by a convincing margin (0.4 to 0.5 bpm MAE) for almost all different face resolution settings. It indicates such simple resolution consistency bene\ufb01ts the PFE learn resolution-robust rPPG cues. Ef\ufb01cacy of the PFE block on arbitrary face resolution. Here we investigate the impacts of the representative area encoding (RAE) of PFE on \ufb01xed face resolution UBFC \ufb01rst. It can be seen from the results \u2018PFE w/o RAE\u2019 and \u2018PFE\u2019 in Table 4 that the PFE without RAE performs even worse than the baseline PhysNet itself under high-resolution cases. When equipped PFE with RAE, it can achieve robust HR estimation under all different \ufb01xed face resolution settings. Besides, under more challenging varying face resolution scenarios, we can also \ufb01nd the consistent conclusion from Table 3 that PFE signi\ufb01cantly improves the baseline performance (reducing 7.24 bpm MAE for high resolution gradually decreasing resolution scenario). Ef\ufb01cacy of the TFA block on arbitrary face resolution. As shown in the result of \u2018TFA\u2019 in Table 4, the baseline with only TFA block performs even worse than the baseline itself. It is because when estimating the optical \ufb02ow, all clips are interpolated to a \ufb01xed resolution, which makes the TFA block be weak in describing rPPG-aware color area (Xue et al. 2019). We can \ufb01nd from the result \u2018TFA-PFE\u2019 that the best performance can be achieved for all different \ufb01xed face resolution settings when assembling baseline with both PFE and TFA blocks. Similar conclusion can be also drawn from the varying face resolution setting in Table 3. Moreover, we also consider the online testing case that the temporal alignment state from backward frames is not available. In this case, we design a TFA block with a single forward direction for facial feature alignment. It can be seen from the result \u2018TFA(single)-PFE\u2019 in Table 4 that the MAE performance degrades sightly (around 0.6 bpm) compared with Figure 7: HR estimation results (bpm) on the samples with severe head movement and huge face rotation. Table 5: The number of parameters and FLOPs for the model and inference time on edge devices. Model Parameters FLOPs Xavier AGX Agx orin Physnet 768.64KB 35.00G 0.18s 0.25s Physnet+PFE 805.77KB 46.51G 2.24s 3.63s Physnet+PFE+TFA 1344.67KB 92.67G 3.37s 4.82s Physformer 7.37MB 50.48G 1.83s 2.18s Physformer+PFE 7.42MB 81.52G 2.47s 3.81s Physformer+PFE+TFA 8.24MB 129.59G 3.52s 4.67s bi-directional TFA, but still can improve the performance of the model compared with baseline with only PFE. Ef\ufb01cacy of the PFE and TFA blocks on severe head movement. To con\ufb01rm the ef\ufb01cacy of the PFE and TFA blocks on severe head movements with large angle rotation, we also conduct studies on the carefully selected videos with large angle rotation from UBFC, PURE and COHFACE. Speci\ufb01cally, the participants in COHFACE quickly rotate their heads at an average angle of 80\u00b0, while the participants in UBFC and PURE rotate their heads very slowly at an average angle of 35\u00b0. The results are shown in Figure 7. We can \ufb01nd that 1) compared with baseline PhysNet, the PFE obviously improves the performance on these videos with severe head movement, and reduces MAE by 1.76 bpm, 2.05 bpm, and 5.63 bpm on UBFC, PURE and COHFACE, respectively; 2) the proposed TFA-PFE further decreases the MAE by 0.57 bpm, 0.58 bpm, and 2.07 bpm on these datasets due to the excellent motion-robust capacity of TFA. Edge Deployment. Considering that rPPG will be employed mostly on edge devices with limited computational capacity, we provide a detailed analysis of our model in Table 5."
+                }
+            ],
+            "Zhengyu Li": [
+                {
+                    "url": "http://arxiv.org/abs/2306.13319v7",
+                    "title": "A SAT Solver and Computer Algebra Attack on the Minimum Kochen-Specker Problem",
+                    "abstract": "One of the fundamental results in quantum foundations is the Kochen-Specker\n(KS) theorem, which states that any theory whose predictions agree with quantum\nmechanics must be contextual, i.e., a quantum observation cannot be understood\nas revealing a pre-existing value. The theorem hinges on the existence of a\nmathematical object called a KS vector system. While many KS vector systems are\nknown, the problem of finding the minimum KS vector system in three dimensions\n(3D) has remained stubbornly open for over 55 years.\n  To address the minimum KS problem, we present a new verifiable\nproof-producing method based on a combination of a Boolean satisfiability (SAT)\nsolver and a computer algebra system (CAS) that uses an isomorph-free orderly\ngeneration technique that is very effective in pruning away large parts of the\nsearch space. Our method shows that a KS system in 3D must contain at least 24\nvectors. We show that our sequential and parallel Cube-and-Conquer (CnC)\nSAT+CAS methods are significantly faster than SAT-only, CAS-only, and a prior\nCAS-based method of Uijlen and Westerbaan. Further, while our parallel pipeline\nis somewhat slower than the parallel CnC version of the recently introduced\nSatisfiability Modulo Theories (SMS) method, this is in part due to the\noverhead of proof generation. Finally, we provide the first computer-verifiable\nproof certificate of a lower bound to the KS problem with a size of 40.3 TiB in\norder 23.",
+                    "authors": "Zhengyu Li, Curtis Bright, Vijay Ganesh",
+                    "published": "2023-06-23",
+                    "updated": "2024-04-09",
+                    "primary_cat": "quant-ph",
+                    "cats": [
+                        "quant-ph",
+                        "cs.CC",
+                        "math.CO"
+                    ],
+                    "main_content": "Introduction Quantum Mechanics (QM) is often described as one of the most successful physical theories of all time, and yet many questions regarding the very foundations of QM 1 arXiv:2306.13319v7  [quant-ph]  9 Apr 2024 \fremain unresolved. To address these foundational issues, many interpretations of QM (i.e., mappings from mathematical formalisms of QM to physical phenomena) have been proposed. Hidden-variable theories are attempts at understanding counterintuitive QM phenomena through a deterministic lens by positing the existence of (possibly) unobservable physical entities or hidden variables [1] that standard QM theory does not account for (and hence is deemed incomplete). Over the years, many constraints have been imposed on hidden-variable theories, e.g., Bell\u2019s inequalities that rule out the possibility of local hidden-variable theories that are also in agreement with the predictions of QM [2]. In a similar vein, Simon Kochen and Ernst Specker [3] proved their famous Kochen\u2013Specker (KS) theorem in 1967 (and independently by John Bell in 1966 [4]) that essentially asserts that non-contextual hidden variable theories cannot reproduce the empirical predictions of QM. The KS theorem rules out non-contextual hidden-variable theories via the existence of a finite set of three-dimensional vectors, referred to as a KS vector system [3]. A KS vector system (or simply a KS system) is a combinatorial object that witnesses a contradiction between non-contextuality (i.e., the assumption that observables can be assigned values prior to measurement and independent of measurement context) and the SPIN axiom of QM. The first KS vector system, discovered in 1967, contains 117 vectors [3]. Another theorem that relies on the existence of KS systems in an essential way is the \u201cFree Will\u201d theorem of John Conway and Simon Kochen [5]. Since the publication of Kochen and Specker\u2019s theorem in 1967, physicists and mathematicians have wondered about the cardinality of the smallest-sized KS vector system (see Table 2 and Section 3). Finding the minimum KS system, referred to as the minimum KS problem, is not only of scientific and historical interest but also has direct applications in quantum information processing [6]. For example, finding a minimum KS system could enable applications in the security of quantum cryptographic protocols based on complementarity [7], zero-error classical communication [8], and dimension witnessing [9]. Further, the large size of all known KS systems has hindered physicists from using them for empirical tests of the KS theorem, similar to the empirical tests of Bell\u2019s theorem [10]. 1.1 Two definitions of the Kochen-Specker System There are two definitions of the KS system widely used in literature. The \u201coriginal\u201d KS set definition used in this paper (Section 2) contains only the vectors necessary to prove the KS theorem mathematically. This \u201coriginal\u201d definition of a KS set is the one originally used by Kochen and Specker themselves. KS systems developed by this definition are commonly referred to as \u201coriginal KS systems\u201d [11]. However, from an experimental perspective, another definition that requires additional vectors in the KS system is used, since constructing the set in practice would involve vectors not explicitly needed in the mathematical proof. Specifically, this definition requires that every pair of vectors in a 3-dimensional KS set belongs to a set of 3 mutually orthogonal vectors. KS systems developed by this alternative definition are commonly referred to as \u201cextended KS systems\u201d [11]. Both definitions are well-known and used extensively in the literature. For examples, the \u2018original\u2019 definition used in this paper is also used in [12], [13], [14], [15], [5], [16], 2 \fDiscoverers Original System Extended System Kochen, Specker [3] 117 192 Sch\u00a8 utte [15] 33 49 Peres [26] 33 57 Conway, Kochen [14] 31 51 Table 1: Size of 3-dimensional KS systems and how they differ based on the definition used, as discussed in Subsection 1.1. In addition, Pavi\u02c7 ci\u00b4 c and Megill [27] discovered many other unique 3-dimensional extended KS systems with 51, 53, 54, 55, 57, 69, etc. vectors through automated generation. [17], [18], [19], while the other definition is used in [11], [20], [21], [22], [23], [24], [25]. As a result of the difference in the two definitions, the lower bound on the original KS system and the extended KS system are also different, as shown in Table 1. John Conway has stressed the problem of finding the minimum number of threedimensional vectors necessary to prove the \u201cFree Will theorem\u201d in public lectures on the topic (see [17]). Thus, knowing the smallest \u2018original\u2019 KS set is of interest since such a set would correspond to a proof of the Free Will theorem using the fewest number of three-dimensional directions. This in a certain sense would lead to the \u2018simplest\u2019 proof of the theorem. We believe the question of the minimal size of an \u2018original\u2019 KS set is theoretically interesting (independent of what the minimal size of an \u2018experimental\u2019 KS set is). In this paper, we investigate the lower bound of the original KS system. However, the paradigm proposed in this paper is easily adaptable and scalable, and the approach can be applied to both definitions given the appropriate SAT encoding of the problem. 1.2 The SAT+CAS Paradigm for Hard Combinatorial Problems In recent years we have witnessed the dramatic impact of satisfiability (SAT) solvers\u2014 computer programs that take as input Boolean logic formulas and decide whether they have solutions\u2014in areas as diverse as AI, software engineering, program verification, program synthesis, and computer security [28, 29]. Unfortunately, despite these fantastic achievements of SAT solvers, they struggle with certain problems such as those containing many symmetries [30] or those requiring the usage of more advanced mathematical theories than propositional logic [31]. Much work has been done to remedy these drawbacks, including the development of sophisticated symmetry breaking techniques [32] and the development of solvers that support richer logic such as \u201cSAT modulo theories\u201d or SMT solvers [33]. However, the mathematical support of SMT solvers is quite limited when compared with the vast mathematical functionality available in a modern computer algebra system (CAS). In response to this need for a solver that combines the efficient search capabilities of SAT solvers with the mathematical knowledge available in CASs, a new kind of solving methodology was developed in 2015 by Zulkoski, Ganesh, and Czarnecki [34] and independently by \u00b4 Abrah\u00b4 am [35]. This SAT+CAS solving methodology has been successfully applied to many diverse problems, including circuit verification [36, 37], automatic debugging [38], finding circuits for matrix multiplication [39], computing directed Ramsey numbers [40], and verifying mathematical conjectures [41]. For other 3 \fDiscoverers Year Bound Kochen, Specker [3] 1967 \u2264117 Jost [43] 1976 \u2264109 Conway, Kochen [14] 1990 \u226431 Arends, Ouaknine, Wampler [17] 2009 \u226518 Uijlen, Westerbaan [18] 2016 \u226522 Li, Bright, Ganesh [44] 2022 \u226523 Li, Bright, Ganesh [45] / 2023 \u226524 Kirchweger, Peitl, Szeider [19] Table 2: A chronology of the bounds on the size of the minimum KS vector system in three dimensions. This table should not be regarded as a comprehensive catalog of all three-dimensional KS systems (Section 3); rather, it is a chronological overview highlighting the advancements in reducing the size of the minimal 3-D KS system in line with its initial definition. The present work (presented at CanaDAM 2023) was performed independently of Kirchweger, Peitl, Szeider (presented at IJCAI 2023). work in the intersection of symbolic computation and satisfiability checking, see Matthew England\u2019s summary [42] of the SC-Square project. In short, the SAT+CAS methodology has found wide application in diverse fields that somehow require solving hard combinatorial problems. In this paper, we use the SAT+CAS solving methodology (see Figure 1) to dramatically improve the performance of the search for KS systems compared to all previous approaches developed to prove lower bounds for the minimum KS problem (see Section 1.4). This is made possible via a combination of the powerful search and learning algorithms used in modern SAT solvers with an \u201cisomorph-free exhaustive generation\u201d approach that prevents the duplicate exploration of isomorphic parts of the search space by the solver. For example, such an approach was recently used to resolve the Lam\u2019s problem from projective geometry [46]. Although isomorph-free exhaustive generation has been used extensively in combinatorial enumeration, it has only recently been combined with SAT solving [47, 48]. The traditional approach to preventing a SAT solver from repeatedly exploring isomorphic parts of a search space is via the use of symmetry breaking techniques [30]. One such symmetry breaking approach is to add \u201cstatic\u201d constraints to the input formula at the beginning of the search aimed at reducing the size of the search space [49, 50]. Unfortunately, such an approach can be quite expensive in the sense that the number of added constraints can be large (e.g., exponential in the number of variables of the formula that encodes the problem-at-hand). Another approach is to \u201cdynamically\u201d break symmetries during the solver\u2019s search [30, 51] such as in the SAT modulo symmetries (SMS) paradigm [52, 53]. Our approach is similar in that it also dynamically adds constraints to the problem during the solving process. However, an important difference is that the SAT+CAS paradigm is more general since it goes beyond breaking symmetries. For example, in the resolution of the smallest counterexample of the Williamson conjecture, we used the Discrete Fourier Transform (DFT) as part of the CAS computations [54]. 4 \fCaDiCaL  Preprocessor Simplifier Orderly Generation  via SAT+CAS Embeddability  Checker CNF  Instance CaDiCaL +  CAS Simplified  Instance KS  Candidates Z3 SMT  Solver KS Vector System  MapleSAT CAS Partial  Solution Blocking  Clause Fig. 1: A flowchart of our SAT+CAS based tool MathCheck for solving the KS problem in the sequential setting. The CNF instance encoding the KS problem (see Section 4) is simplified using CaDiCaL+CAS. The simplified instance is passed to the MapleSAT+CAS tool (see Section 5) either sequentially or in parallel using Cubeand-Conquer (CnC). Finally, an embeddability checker applies the SMT solver Z3 to determine whether the candidates are embeddable (see Section 6). 1.3 Automated Verification of Results Verification is of utmost importance in the context of computer-assisted proofs, given the mathematical nature of such computations\u2014especially for nonexistence proofs. Fortunately, the SAT+CAS paradigm naturally lends itself to automated verification, given the fact that all modern SAT solvers produce verifiable proofs. By contrast, all previous computer-assisted proofs of lower bounds for the minimum KS problem are not verifiable. Since our problem requires the solver to perform an exhaustive search, the validity of our nonexistence result is crucially dependent on the encodings and the computational tools that we use. For example, our nonexistence result crucially relies on the correctness of the SAT solver\u2019s search and the computer algebra system\u2019s isomorph-free exhaustive generation routine. Fortunately, our SAT+CAS method generates verifiable certificates that allow an independent third party to certify that the SAT solver\u2019s search is exhaustive and also that the facts provided by the isomorph-free generation are correct. Thus, one does not need to trust either the SAT solver or the CAS to trust that our results are correct\u2014instead, one only needs to trust the correctness of the proof verifier. This is quite significant, as SAT solvers and CASs are complicated pieces of software that typically cannot be guaranteed to be bug-free. By contrast, a proof verifier is a 5 \fmuch simpler piece of software that can be formally checked. In Section 9, we provide details on the verification techniques that we used to certify our results. 1.4 Our Contributions \u2022 Proof-producing SAT+CAS with Orderly Generation (OG) Method: In this paper, we present the design and implementation of a verifiable proofproducing SAT+CAS system with orderly generation (OG) aimed at combinatorial problems (as part of the SAT+CAS tool, MathCheck1), thus showing that the minimum KS system must contain at least 24 vectors. Also, we extend our work to complex vectors in three dimensions (3D), and thus establish a lower bound of 24 for both the real and complex KS problem. \u2022 Speedup over Competing Methods: We show that our sequential and parallel Cube-and-Conquer (CnC) SAT+CAS methods are significantly faster than SATonly, CAS-only, and prior CAS-based methods by [18]. Further, while our pipeline is somewhat slower than the recently introduced SMS method, this is in part due to the generation of verifiable proofs by our methods which added some additional complexity and slowed down our method. \u2022 Formal Verification of Results: Finally, our approach provides a formal verification of the lower bound of 24 for the minimum KS problem in 3D by verifying all certificates computed by the SAT+CAS solvers in all orders up to and including order 23 (see Section 9). By contrast, [19] describe a method to verify their result, but they only report having verified 5% of the proofs in order 23. 2 Background In this section, we introduce several fundamental concepts from quantum foundations such as the SPIN axiom, 010-colorability, the KS theorem, and the KS vector system. For a deeper dive, we refer the reader to the QM section in the Stanford Encyclopedia of Philosophy [1]. We assume that the reader is familiar with Boolean logic and SAT solvers. While we provide a very brief overview of cube-and-conquer SAT solvers, we refer the reader to the Handbook of Satisfiability [28] for a comprehensive overview. 2.1 The KS Theorem Informally, the KS theorem states that there is a contradiction between the SPIN axiom of standard QM and the assumption of non-contextuality. The Stanford Encyclopedia of Philosophy provides a comprehensive background to the KS theorem and stresses its importance in the foundations of QM [1]. The proof of the KS theorem crucially relies on the existence of a KS vector system (see Figure 2). More precisely, exhibiting the existence of a KS vector system proves the KS theorem, which essentially states that the unit sphere is not 010-colorable (defined below). Spin of an Elementary Particle: Spin is an intrinsic form of angular momentum of elementary particles whose existence can be inferred from the Stern\u2013Gerlach experiment [55]. In our context, a spin-1 particle is shot through a magnetic field in a given 1Code at https://github.com/BrianLi009/MathCheck 6 \fX \u22122.0 \u22121.5 \u22121.0 \u22120.5 0.0 0.5 1.0 1.5 2.0 Y \u22122.0 \u22121.5 \u22121.0 \u22120.5 0.0 0.5 1.0 1.5 2.0 Z \u22122.0 \u22121.5 \u22121.0 \u22120.5 0.0 0.5 1.0 1.5 2.0 Fig. 2: The 31 vectors of the smallest known KS system in three dimensions (discovered by John Conway and Simon Kochen circa 1990). For simplicity, the vectors have been scaled to lie on the cube with vertices (\u00b12, \u00b12, \u00b12) instead of the unit sphere. direction and continues undisturbed, deflects up, or deflects down\u2014corresponding to 3 possible angular momentum states, namely 0, 1, and \u22121. Thus, the square of this measurement is 0 or 1. SPIN axiom: The SPIN axiom of QM states that the squared spin components of a spin-1 particle are 1, 0, 1 in three pairwise orthogonal directions of measurement. Thus, the observable corresponding to the question \u201cis the squared spin 0?\u201d measured in three mutually orthogonal direction always produces yes in exactly one direction and no in the other two orthogonal directions. We use the dual of the above form in the present work, i.e., the \u2018010\u2019 convention rather than \u2018101\u2019, following Uijlen and Westerbaan. The SPIN axiom follows from the postulates of QM and is experimentally verifiable [56]. KS Vector System: A KS vector system can be represented in multiple ways and we describe it as a finite set of points on a sphere. As a consequence of the SPIN axiom, the squared-spin measurements along opposite directions must yield the same outcome. Therefore, two collinear vectors are considered to be equivalent. To define a KS vector system, we first formally define a vector system and the notion of 010-colorability. For 7 \fthe purposes of this paper, we limit ourselves to the 3D version of the KS problem as the size of the minimum KS system in higher dimensions is already known [57]. Definition 1 (Vector System). A vector system is a finite set of non-collinear points on the unit sphere in R3. A {0, 1}-coloring of a vector system is an assignment of 0 and 1 to each vector in the system. The colorings of interest to us are described in the following definition. Definition 2 (010-Colorability of Vector Systems). A vector system is 010colorable if there exists an assignment of 0 and 1 to each point such that: 1. No two orthogonal points are assigned 1. 2. Three mutually orthogonal points are not all assigned 0. Definition 3 (KS Vector System). A KS vector system is one that is not 010-colorable. Definition 4 (Orthogonality Graph). For a vector system K, define its orthogonality graph GK = (V, E), where V = K, E = { (v1, v2) : v1, v2 \u2208K and v1 \u00b7 v2 = 0 }. Essentially, the vertices of GK are the vectors in K, and there is an edge between two vertices exactly when their corresponding vectors are orthogonal. Similarly, the notion of 010-colorability can be translated from a vector system to an orthogonality graph. Definition 5 (010-colorability of Graphs). A graph G is 010-colorable if there is a {0, 1}-coloring of the vertices such that the following conditions are satisfied simultaneously: 1. No two adjacent vertices are colored 1. 2. For each triangle, the vertices are not all colored 0. It is not always the case that an arbitrary graph has a corresponding vector system, but if one does exist then we say that such a graph is embeddable. Definition 6 (Embeddable Graph). A graph G = (V, E) is embeddable if it is a subgraph of an orthogonality graph for some vector system. Being embeddable implies the existence of a vector system K whose vectors have a one-to-one correspondence with the vertices of G, such that adjacent vertices are assigned to orthogonal vectors. An example of an unembeddable graph is the cyclic graph C4 on 4 vertices, as the orthogonality constraints force a pair of opposite vertices to be mapped to collinear vectors (which are not allowed in this context). Definition 7 (KS Graph). An embeddable and non-010-colorable graph is called a KS graph. Observation 1. There exists a KS vector system if and only if there exists a KS graph. Definition 8 (KS Candidates). A KS Candidate is a satisfying assignment generated by the SAT+CAS solver. If a KS candidate is also embeddable, then it is a KS graph. As described in Section 6, our solver dynamically blocks all minimal unembeddable subgraphs up to order 12, and hence our KS candidates are graphs that do not contain any unembeddable subgraphs of order up to 12. 8 \f2.2 The Minimum KS Problem The minimum KS problem is to find a KS vector system of minimum cardinality, that is, a system with the fewest number of vectors in three-dimensional space (or equivalently a KS graph with the fewest number of vertices). Every KS system has an associated KS graph, so if a KS graph with cardinality n does not exist then a lower bound on the minimum KS problem is at least n + 1. 2.3 Cube-and-conquer The cube-and-conquer SAT solving paradigm was developed in [58] to solve hard combinatorial problems. The method applies two (possibly) different types of SAT solvers in two stages: First, a \u201ccubing solver\u201d splits a SAT instance into a large number of distinct subproblems specified by cubes\u2014formulas of the form x1 \u2227\u00b7 \u00b7 \u00b7\u2227xn where xi are literals. Second, a \u201cconquering solver\u201d solves each subproblem under the assumption that its associated cube is true (more precisely, the conjunction of the original instance and the cube). The cube-and-conquer method has empirically been shown to be effective at quickly solving large satisfiability problems when the cubing solver generates many cubes encoding subproblems of similar difficulty. It has since been applied to solve huge combinatorial problems such as the Boolean Pythagorean triples problem [59], the computation of Schur number five [60], and a SAT-based resolution of Lam\u2019s problem [46]. 3 Previous Work Over the last 55+ years, many mathematicians and physicists such as Roger Penrose, Asher Peres, and John Conway have attempted to find a minimum 3-dimensional KS system (see Table 2). The first KS system was constructed in 1967 and it contained 117 vectors [3]. A KS system with 109 vectors was found by Res Jost [43] in 1976. Peres found a KS system of size 33 in 1991, and Sch\u00a8 utte found a KS system of size 33 in 1996. The current smallest known KS system in three dimensions contains 31 vectors and was discovered by John Conway and Simon Kochen circa 1990 (see Figure 2). All these discoveries were made analytically, without the assistance of computational methods. Recently, Pavi\u02c7 ci\u00b4 c and Megill [27] applied an automated generation approach to robustly generate KS systems in odd dimensions. This approach led to the discovery of many more three-dimensional KS systems. In 2011, Arends, Ouaknine, and Wampler proved several interesting properties of KS graphs and leveraged them to computationally establish that a KS system must contain at least 18 vectors [17]. Seven years later, Uijlen and Westerbaan showed that a KS system must have at least 22 vectors [18]. This computational effort used around 300 CPU cores for three months and relied on the nauty software package [61] to exhaustively search for KS graphs. Pavi\u02c7 ci\u00b4 c, Merlet, McKay, and Megill [57] have improved a variation of the KS problem, one in which each vector is part of a mutually orthogonal triple (or a mutually orthogonal d-tuple in d dimensions). Under this restriction, they show a KS system must have at least 30 vectors in d = 3 dimensions, 9 \fand in d \u22654 dimensions the minimum KS system has 18 vectors. However, in three dimensions the gap between the lower and upper bounds of a KS system remains significant and the minimum size remains unknown. Another way of measuring the size of a d-dimensional KS system is the number of mutually orthogonal \u201ccontexts\u201d (cliques of size d in the orthogonality graph). Lison\u02c7 ek, Badzi\u00b8 ag, Portillo, and Cabello [62] found a six-dimensional KS system with seven contexts and showed this is the simplest possible KS system allowing a symmetry parity proof of the KS theorem. This KS system was later experimentally used by Ca\u02dc nas et al. [6] to perform measurements verified to arise from a quantum system rather than a classical system. Preliminary versions of the present work were announced at the 2022 SC-Square workshop, as well as at the 2023 Southeastern International Conference on Combinatorics, Graph Theory and Computing, and at CanaDAM 2023. At the former two venues, we presented searches for KS systems with up to 22 vectors, and at CanaDAM 2023 we presented our work that extends this to a search for KS systems with up to 23 vectors. In each case the searches were exhaustive and no KS systems were found. Thus, a KS system in three dimensions must contain at least 24 vectors. Kirchweger, Peitl, and Szeider [19] completed an independent search for KS systems establishing a lower bound of 24 vectors with a similar approach as SAT+CAS but with an SMS solver and an alternate definition of canonicity. Also, they do not use OG, as their definition of canonical does not satisfy property (2) from Sec. 5, but otherwise the SMS approach is similar in that it combines a SAT solver with a canonical checking routine. Their approach can also be used to generate proof certificates, though the certificate verification was not performed with the exception of 5% of the certificates in the order 23 search. By constrast, ours formally verifies all results. 4 SAT Encoding of the Minimum KS Problem As stated earlier, every KS vector system K can be converted into a KS graph GK. Each vector in K is assigned to a vertex in GK, so that if two vectors are orthogonal, then their corresponding vertices are connected. We say a KS graph is minimal if the only subgraph that is also a KS graph is itself. Arends, Ouaknine, and Wampler [17] proved that a three-dimensional minimal KS graph must satisfy the following properties: 1. The graph does not contain the 4-cycle graph C4 as a subgraph. 2. Each vertex of the graph has a minimum degree 3. 3. Every vertex is part of a 3-cycle triangle graph C3. We encode these three properties and the non-010-colorability of the KS graph in conjunctive normal form (CNF), as described below. If a SAT solver produces solutions for such an encoding, then these solutions are equivalent to graphs that satisfy all of the above-mentioned four constraints. A simple undirected graph of order n has \u0000n 2 \u0001 potential edges, and we represent each edge as a Boolean variable. The edge variable eij is true exactly when the vertices i and j are connected, where 1 \u2264i < j \u2264n. For convenience, we let both eij and eji denote the same variable since the graphs we consider are undirected. We also use the \u0000n 3 \u0001 10 \ftriangle variables tijk denoting that distinct vertices i, j, and k are mutually connected. In Boolean logic this is expressed as tijk \u2194(eij \u2227eik \u2227ejk) which in conjunctive normal form is expressed via the four clauses \u00actijk \u2228eij, \u00actijk \u2228eik, \u00actijk \u2228ejk, and \u00aceij \u2228\u00aceik \u2228\u00acejk \u2228tijk. Again, the indices i, j, and k of the variable tijk may be reordered arbitrarily for notational convenience. 4.1 Encoding the Squarefree Constraint To encode the property that a KS graph must be squarefree, we construct encodings that prevent the existence of any squares in the graph. Observe that three squares can be formed on four vertices. Therefore, for every choice of four vertices i, j, k, l, we use clauses \u00aceij \u2228\u00acejk \u2228\u00acekl \u2228\u00aceli, \u00aceij \u2228\u00acejl \u2228\u00acelk \u2228\u00aceki, and \u00aceil \u2228\u00acelj \u2228\u00acejk \u2228\u00aceki to encode the fact that a solution produced by the solver must be squarefree. By enumerating all possible choices of four vertices and constructing the above CNF formula, we force the graph to be squarefree. The total number of clauses used is 3\u00b7 \u0000n 4 \u0001 . 4.2 Encoding the Minimum Degree Constraint For each vertex i, to ensure that i is connected to at least three other vertices, we take each subset S of {1, . . . , i \u22121, i + 1, . . . , n} with cardinality n \u22123 and construct the clause W j\u2208S eij. By enumerating over all such subsets we enforce a minimum degree of 3 on vertex i. Thus, constructing similar formulae for all vertices 1 \u2264i \u2264n, enforces that any vertex in the graph has a degree of at least 3. The total number of clauses used is therefore n \u00b7 \u0000n\u22121 n\u22123 \u0001 = n \u00b7 \u0000n\u22121 2 \u0001 . 4.3 Encoding the Triangle Constraint We encode the property that every vertex is part of a triangle as follows: for each vertex i, we require 2 other distinct vertices to form a triangle, and there are \u0000n\u22121 2 \u0001 possible triangles containing i. At least one of those triangles must be present in the KS graph\u2014this is encoded by the clause W j,k\u2208S tijk where S is {1, . . . , i \u22121, i + 1, . . . , n} and j < k. Using this clause for each 1 \u2264i \u2264n ensures that every vertex is part of a triangle and hence there are n triangle clauses. 4.4 Encoding the Noncolorability Constraint Recall that the key property of a KS graph is that it is non-010-colorable. As stated earlier, a graph is non-010-colorable if and only if for all {0, 1}-colorings of the graph, a pair of color-1 vertices is connected or a set of three color-0 vertices are mutually connected. For each {0, 1}-coloring, a KS graph has a set V0 of color-0 vertices and a set V1 of color-1 vertices. Given a specific such coloring, the clause _ i,j\u2208V1 i<j eij \u2228 _ i,j,k\u2208V0 i<j<k tijk 11 \fencodes that this coloring is not a 010-coloring of a graph\u2014since either a pair of color-1 vertices is connected or three color-0 vertices are mutually connected. Note that we have to generate such a clause for all possible colorings, and conjunct them together to obtain a non-colorability constraint for graphs of order n. An assignment that satisfies such a constraint corresponds to a graph that is not 010-colorable under any possible coloring. Observe that in order n the total number of such clauses is 2n. Fortunately, an empirical observation allows cutting the size of the formula dramatically: {0, 1}-colorings with more than \u2308n 2 \u2309color-1 vertices are unlikely to be 010-colourings and in practice are not useful in blocking 010-colourable graphs. Put differently, by dropping the constraints with |V1| \u2265\u2308n 2 \u2309we reduce the formula size drastically (making the formula easier to solve) and the corresponding increase in the number of satisfying assignments is small enough that these candidates can be ruled out via post-processing (Section 9). In fact, for graphs up to order 23, no additional satisfying assignments (or candidate KS graphs) were generated. 4.5 Encoding Static Isomorphism Blocking Clauses Following [63], we use symmetry breaking constraints that enforce a lexicographical order among rows of the graph\u2019s adjacency matrix. These small number of additional constraints enable us to statically block many isomorphic graphs. Given an adjacency matrix A of a graph, we define Ai,j as the ith row of A without columns i and j. Codish et al. prove that up to isomorphism every graph can be represented by an adjacency matrix A for which Ai,j is lexicographically equal or smaller than Aj,i for all 1 \u2264i < j \u2264n. We express that Ai,j = [x1, x2, . . . , xn] is lexicographically equal or less than Aj,i = [y1, y2, . . . , yn] using 3n \u22122 clauses and auxiliary variables a1, . . . , an\u22121 [64]. The clauses are \u00acxk \u2228yk \u2228\u00acak\u22121, \u00acxk \u2228ak \u2228\u00acak\u22121, and yk \u2228ak \u2228\u00acak\u22121 for k = 1, . . . , n \u22121. The literal \u00aca0 is omitted and the clause \u00acxn \u2228yn \u2228\u00acan\u22121 is also included. 5 Orderly Generation via SAT+CAS The symmetry breaking constraints described in Section 4.5 do not block all isomorphic copies of adjacency matrices. Thus, a crucial part of the MathCheck pipeline is the use of a SAT+CAS combination of a SAT solver and an isomorph-free generation routine (the CAS part). The orderly isomorph-free generation approach was developed independently by Read et al. [65] and Faradvzev et al. [66]. It relies on the notion of a canonical representation of an adjacency matrix. Definition 9 (Canonical Graph). An adjacency matrix M of a graph is canonical if every permutation of the graph\u2019s vertices produces a matrix lexicographically greater than or equal to M, where the lexicographical order is defined by concatenating the above-diagonal entries of the columns of the adjacency matrix starting from the left. An intermediate matrix of A is a square upper-left submatrix of A. If A is of order n then its intermediate matrix of order n \u22121 is said to be its parent, and A is said to be a descendant of its intermediate matrices. The OG method is based on the following two consequences of Definition 9: (1) Every isomorphic class of graphs only has exactly one canonical representative. 12 \fOrder Squarefree + Min. Degree 2 Min. Unembed. Runtime 4\u20139 164 0 30 s 10 563 2 4.1 m 11 3,257 5 1.3 h 12 23,699 10 27 h Table 3: Counts for the number of minimal unembeddable graphs in orders up to 12 and the computation time for the embeddability check. (2) If a matrix is canonical, then its parent is also canonical. Note that the contrapositive of the second property implies that if a matrix is not canonical, then all of its descendants are not canonical. The OG process only generates canonical matrices and they are built starting from the upper-left. Therefore, any noncanonical intermediate matrix that is encountered during an OG exhaustive search can be discarded, as none of its descendants will be canonical. As described in Figure 1, in our SAT+CAS implementation, when the SAT solver finds an intermediate matrix the canonicity of this matrix is determined by a canonicitychecking routine implemented in the MathCheck system. If the matrix is noncanonical, then a \u201cblocking\u201d clause is learned which removes this matrix (and all of its descendants) from the search. Otherwise, the matrix may be canonical and the SAT solver proceeds as normal. When a matrix is noncanonical, the canonicity-checking routine also provides a \u201cwitness\u201d of this fact (a permutation of the vertices that produces a lex-smaller adjacency matrix). We combine this process with the symmetry breaking clauses of Codish et al. that canonical matrices can be shown to satisfy [63, Def. 8]. The OG technique provides a speedup that seems to increase exponentially in the order n of the KS graph\u2014see Table 4, which provides experimental running times comparing the SAT+CAS approach against SAT-only and CAS-only approaches. These timings were run on an Intel Xeon E5-2667 CPU and the CAS compared against was the nauty graph generator [61] with the same configuration from [18]. More details on our experimental setup can be found in Section 8. As described in Figure 1, we simplify the SAT instance using the SAT solver CaDiCaL [67] before solving the instance using MapleSAT [68]. 6 Embeddability Checking We refer to the solutions generated by the SAT solver as KS candidates. Note that we have to additionally check whether a KS candidate is embeddable in order to detect whether it is a KS graph (and hence corresponds to a KS vector system). Hence, we perform an embeddability check on every KS candidate generated by the SAT+CAS solver of MathCheck. Operationally, a graph G is said to be embeddable if every pair of adjacent Gvertices can be mapped to two orthogonal vectors on the unit sphere in R3 (refer to Definition 6). Otherwise, we say that G is unembeddable. Our embeddability checking algorithm consists of two parts. The first part is an integration of the vector assignment algorithm of [18] that finds all possible vector assignments describing the orthogonal relations between the vectors vi in a KS 13 \fcandidate defined by a set of edges E. A vector assignment is a set of edge pairs C = {(eij, eik), (elm, eln), . . . } \u2286E2 where each pair of edges share one common vertex and each pair is disjoint from each other, meaning the same edge cannot exist in more than one pair. Each pair (eij, eik) in C can be interpreted as a cross product relationship between the vectors vi, vj, and vk, since the presence of eij and eik in the KS graph means that vector vi must be orthogonal to both vj and vk in any embedding of the candidate. (a) (b) Fig. 3: The only two minimal nonembeddable graphs of order 10. These are the smallest squarefree graphs that are not embeddable. The second part of the algorithm applies an SMT solver to determine the satisfiability of a system of nonlinear equations generated from a particular vector assignment as described below. More precisely, an assignment generated by Uijlen and Westerbaan\u2019s algorithm is converted into a set of cross and dot product equations, and these equations are passed to the theorem prover Z3 [69] that solves the equations over the real numbers. We denote the vector corresponding to vertex vi as Vi in Z3, where Vi is a 3-tuple of real numbers. Given a specific vector assignment generated by the previous algorithm, the system of constraints is as follows: 1. If (eij, eik) \u2208C, we add the cross product constraint Vi = Vj \u00d7 Vk. 2. If eij is one of the edges of E that is not contained in any of the pairs of C, we add the dot product constraint Vi \u00b7 Vj = 0. 3. If i \u0338= j then Vi must not be collinear with Vj, so we add the noncollinearity constraint Vi \u00d7 Vj \u0338= \u20d7 0. A free vector is one that has not been fixed as the cross product of two other vectors. Of all possible assignments, we first choose the one with the least number of free vectors, since in practice such an assignment is likely to be solved more quickly. It is important to note that for any vector assignment, each edge of the KS graph is encoded into either constraint 1 or 2, making the encoding shorter and more efficient than the naive encoding. Constraint 3 requires two vectors to be noncollinear rather than only being nonequal since we do not enforce vectors to have unit length for 14 \freasons of efficiency. This is a harmless optimization since vectors can be projected onto the unit sphere without disturbing these constraints. We also fix two orthogonal vectors to be the standard vectors (1, 0, 0) and (0, 1, 0) to cut down on the number of free variables. To check whether a graph is embeddable, we use Z3 to determine whether these nonlinear arithmetic constraints are satisfiable over the real numbers. Z3 applies a CDCL-style algorithm to decide the satisfiability of such systems [70]. If a solution is found, it is an assignment of vertices to vectors that satisfies all orthogonality constraints and the graph is therefore embeddable. Embeddability checking of large graphs can be further optimized by precomputing minimal unembeddable graphs, as defined below. Definition 10 (Minimal Unembeddable Graph). An unembeddable graph G is said to be a minimal unembeddable graph if any proper subgraph of G is embeddable. A graph is unembeddable if and only if it contains a minimal unembeddable subgraph. To optimize embeddability checking, we precomputed all minimal unembeddable graphs of orders up to and including 12. We only consider squarefree graphs with a minimum degree of 2 or greater, as the square graph C4 is minimally unembeddable itself, and a graph containing a vertex of degree 0 or 1 is not minimally unembeddable. We implement the unembeddable subgraph blocking technique as part of MathCheck. If a graph contains one of the 17 minimal unembeddable graphs up to order 12 as a subgraph, the graph is blocked dynamically and is not considered as a satisfying assignment by MathCheck. This technique leads to a significant reduction of the number of satisfying assignment (candidates) generated by the SAT+CAS solver. 7 Parallelization In prior applications of the CnC technique [71, 72], the cubing solver generates a collection of cubes before the conquering solver is invoked. Subsequently, each of these subproblems is solved using the conquering solver in parallel. However, this approach presents two primary challenges. Firstly, the generated cubes might exhibit imbalanced solving times, especially since the cubing solver does not have the ability to call the CAS to incorporate isomorph-free generation. Secondly, the proof size for each subproblem also varies, making it difficult to allocate an appropriate amount of memory to individual cores. In MathCheck, we implement a slight modification of traditional CnC practices to resolve the above challenges. In addition, we use a new CnC solver AlphaMapleSAT [73] that provides significant speedup for the cubing process. In our proposed method, the cubing solver of AlphaMapleSAT operates on a much smaller CNF instance obtained by omitting all non-colorability constraints (Section 4.4). This approach is substantiated by empirical evidence suggesting that the same set of cubes can be obtained even without the non-colorability constraints. AlphaMapleSAT iteratively generates cubes until the total number of cubes surpasses a predefined cutoff, which is based on available computational resources. Following cube generation, each subproblem is processed by the simplifcation solver (CaDiCaL with OG), and then it is passed to the conquering solver (MapleSAT with OG) and solved in parallel. To efficiently manage the termination of each subproblem, a termination strategy is implemented: if the proof size for a subproblem exceeds 7 GiB, the problem 15 \fn SAT+CAS SMS CAS-only SAT-only 17 0.3 m 0.2 m 25.2 m 9.0 m 18 1.8 m 1.2 m 455.4 m 266.4 m 19 9.0 m 8.4 m 9506.4 m 11,705.8 m 20 140.5 m 100.8 m timeout timeout 21 1945.0 m 1574.4 m timeout timeout Table 4: SAT+CAS vs. SMS, CAS-only (nauty), and SAT-only: The total CPU time (in minutes) compared on orders 17 \u2264n \u226421. All tools are sequential. For higher orders, CAS-only and SAT-only time out at 12,000 minutes. Number of Cubes Total CPU time n SAT+CAS SMS SAT+CAS SMS 22 26,646 18,659 932 h 628.1 h 23 173,097 313,665 12,116 h 11,921.8 h Table 5: Parallel CnC SAT+CAS vs. parallel SMS: The number of cubes and total CPU time for the parallel versions of SAT+CAS and the SAT Modulo Symmetries tool on orders 22 \u2264n \u226423. is further divided into more cubes and solved accordingly. This iterative process continues until every subproblem can be resolved with proof sizes under 7 GiB. We overcome the challenges posed by varying proof sizes by implementing this slight modification and it allows us to verify all generated proof certificates with at most 4 GiB of memory allocation. 8 Results 8.1 Experimental Setup Results in Table 4 were conducted on a cluster of Intel E5-2683 v4 Broadwell @ 2.1GHz CPUs, each with access to 4 GiB of RAM and running 64-bit CentOS Linux 7. Results in Table 5 were conducted on a cluster of Dual Intel Xeon Gold 6226 CPUs @ 2.7 GHz (24 cores/node). We used the g++ compiler version 9.3.0 with option -O3 to compile the SAT solvers used. 24 CPUs were used to solve and verify order 22 (in about 4 days wall clock time), and 240 CPUs were used for order 23 (in about 7 days wall clock time). To compare MathCheck against other approaches, we computed the total CPU time used by all processes in the solving process, including simplification, cubing, SAT solving, CAS queries, and embeddability checking. 8.2 Key Findings Tables 4 and 5 contain our experimental results. As can be seen from Table 4, the sequential version of MathCheck outperforms the sequential SAT-only (MapleSAT) 16 \f(a) (b) Fig. 4: The only two KS candidates up to order 23 that do not contain minimal nonembeddable graphs up to and including order 14. These two graphs are determined to be unembeddable by Z3. and CAS-only (nauty) tools. Further, the sequential MathCheck is comparable to sequential SMS on orders 17 to 21, even with proof production switched on. (Note that we are using the results reported by the SMS authors [19] which did not include generating proofs.) The sequential MathCheck also outperforms the parallel tool of [18]. For example, for order 21, sequential MathCheck takes about 32.4 hours while their tool took 3 months on 300 CPUs in 2014 (the exact kind of CPUs used are not specified). Further, their tool does not solve orders 22 or greater. For higher orders of KS (i.e., 22 and 23), we do not expect the sequential versions of MathCheck and SMS to scale in a reasonable amount of time, and hence we compare only their parallel CnC versions (Table 5). The authors of SMS also do not report on the performance of their sequential version for orders 22 and 23. In comparison to SMS, our approach was hindered due to our generating and verifying all proof certificates\u2014requiring us to ensure each proof certificate did not grow too large in order to permit effective verification. Such an approach requires splitting each cube whose proof certificate grows too large, and this additional splitting slows down our approach. Our method benefits from dynamically blocking minimal unembeddable subgraphs up to order 12, which enables MathCheck to generate significantly fewer KS candidates compared to [19]. Specifically, we generate a single candidate in order 22 and 41 candidates in order 23, while Kirchweger et al. generates 88,282 and 3,747,950 candidates respectively. We compared our KS candidates with Uijlen and Westerbaan\u2019s findings, and verified their conclusion that there is no KS system with strictly less than 22 vectors. In order 20, we found four additional KS candidates that were not present in the collection of Uijlen and Westerbaan, indicating that their search missed some KS candidates. We present one of the missing graphs in Figure 5. We verified that these four additional graphs satisfy the constraints of a KS candidate and therefore would be KS systems were they embeddable, but unfortunately, they are not. 17 \fAnother notable question we address is the existence of a complex KS vector system. Specifically, is there a KS graph that can be embedded over the complex sphere? We employ a similar embeddability verification pipeline as mentioned earlier, with the distinction that vectors now may possess complex number coordinates. We discover that each KS graph up to order 23 either contains a complex unembeddable subgraph or is determined to be unembeddable over the complex numbers via Z3. Therefore, we conclude that the minimum size for both the real and complex KS system are at least 24. Fig. 5: One of the four graphs with 20 vertices that were not present in Uijlen and Westerbaan\u2019s enumeration. The four graphs satisfy all constraints mentioned in Section 4, but are not embeddable, and therefore do not constitute a KS system. 9 Verification of Results In order to verify the computations produced by MathCheck, we use DRAT proof logging which is standard in all modern SAT solvers. This makes it possible for a third-party proof verifier to provide an independent certification of the correctness of the solver\u2019s conclusion (assuming the input Boolean formula correctly encodes the minimum KS problem). A DRAT proof consists of a trace of the clauses learned by the solver during its execution. A proof verifier checks that each clause can be derived from the previous clauses using simple rules known to be logically consistent. The CASderived noncanonical blocking clauses cannot be verified using the normal rules, so we specially tag them to be verified separately. Specifically, they are justified via a CASderived permutation that, when applied to the blocked adjacency matrix, produces a lex-smaller adjacency matrix\u2014and therefore provides a witness that the blocked matrix is noncanonical and is safe to block. Similarly, the unembeddable subgraph blocking clauses are justified by a CAS-derived permutation that when applied to the 18 \fblocked subgraph transforms it into one of the minimal unembeddable subgraphs (see Section 6). The CAS-derived clauses in the DRAT proof are prefixed by the character \u2018t\u2019 to signify they should be trusted and we modified DRAT-trim [74] to trust such clauses following the approach first used in [75]. The trusted CAS-derived clauses are separately verified by a permutation-applying Python script that applies the witnesses produced by the CAS to verify the blocked matrices are noncanonical or unembeddable. Similarly, when a KS candidate is found, the solver learns a trusted clause blocking the candidate (so that the search continues until all candidates have been found). The DRAT proof ends with the empty clause, which by definition is not satisfiable. If the verifier is indeed able to verify the empty clause then we can have confidence that the SAT solver\u2019s search missed no candidates without needing to trust the solver. All results have been certified. The uncompressed proofs for order 22 are about 6.1 TiB in total, and 40.3 TiB for order 23. The certification for orders 22 and 23 required using CnC (as described in Sec. 7) to ensure that each DRAT proof could be verified with at most 4 GiB of memory. All KS candidates produced by our method have been extensively checked. For example, each KS candidate is passed into a verification script implemented using the NetworkX [76] graph package to verify that they satisfy all encoded constraints (see Section 4). Further, we test the embeddability pipeline by performing a verification on all squarefree graphs of order up to 12 with minimal vertex degree 2. Specifically, if a graph is embeddable and corresponds to a set of vectors, we check that no pair of vectors in the set are collinear, and a pair of vectors are orthogonal if their corresponding vertices are connected. 10"
+                }
+            ],
+            "Dongkuan Xu": [
+                {
+                    "url": "http://arxiv.org/abs/2201.12507v2",
+                    "title": "AutoDistil: Few-shot Task-agnostic Neural Architecture Search for Distilling Large Language Models",
+                    "abstract": "Knowledge distillation (KD) methods compress large models into smaller\nstudents with manually-designed student architectures given pre-specified\ncomputational cost. This requires several trials to find a viable student, and\nfurther repeating the process for each student or computational budget change.\nWe use Neural Architecture Search (NAS) to automatically distill several\ncompressed students with variable cost from a large model. Current works train\na single SuperLM consisting of millions of subnetworks with weight-sharing,\nresulting in interference between subnetworks of different sizes. Our framework\nAutoDistil addresses above challenges with the following steps: (a)\nIncorporates inductive bias and heuristics to partition Transformer search\nspace into K compact sub-spaces (K=3 for typical student sizes of base, small\nand tiny); (b) Trains one SuperLM for each sub-space using task-agnostic\nobjective (e.g., self-attention distillation) with weight-sharing of students;\n(c) Lightweight search for the optimal student without re-training. Fully\ntask-agnostic training and search allow students to be reused for fine-tuning\non any downstream task. Experiments on GLUE benchmark against state-of-the-art\nKD and NAS methods demonstrate AutoDistil to outperform leading compression\ntechniques with upto 2.7x reduction in computational cost and negligible loss\nin task performance.",
+                    "authors": "Dongkuan Xu, Subhabrata Mukherjee, Xiaodong Liu, Debadeepta Dey, Wenhui Wang, Xiang Zhang, Ahmed Hassan Awadallah, Jianfeng Gao",
+                    "published": "2022-01-29",
+                    "updated": "2022-02-20",
+                    "primary_cat": "cs.CL",
+                    "cats": [
+                        "cs.CL"
+                    ],
+                    "main_content": "Introduction While large pre-trained language models (e.g., BERT Devlin et al. [2019], GPT-3 Brown et al. [2020]) are effective, their huge size poses signi\ufb01cant challenges for downstream applications in terms of energy consumption and cost of inference Strubell et al. [2019] limiting their usage in on the edge scenarios and under constrained computational inference budgets. Knowledge distillation Wang et al. [2020a], Sanh et al. [2019], Jiao et al. [2020], Sun et al. [2020] has shown strong results in compressing pre-trained language models, where we train a small student model to mimic the full output distribution of the large teacher model. However, these works require pre-speci\ufb01cation of the student model architecture and corresponding computational cost (e.g., number of parameters, FLOPs) before they can perform distillation. This poses two signi\ufb01cant challenges: (i) since the architectures are hand-engineered, it requires several trials to come up with viable architectures and to de\ufb01ne a myriad of hyper-parameters (e.g., number of layers, hidden dimension, number of attention heads, etc.); (ii) one has to re-run the distillation process with any change in speci\ufb01cation for either the student architecture or the desired computational cost for using the student in a target environment. arXiv:2201.12507v2  [cs.CL]  20 Feb 2022 \fFew-shot Task-agnostic Neural Architecture Search Figure 1: AutoDistil uses few-shot task-agnostic Neural Architecture Search to distill several compressed students with variable #FLOPs (x-axis) from K=3 SuperLMs (corresponding to each point cloud) trained on K sub-spaces of Transformer search space. Each student (blue dot) extracted from the SuperLM is \ufb01ne-tuned on MNLI with accuracy on y-axis. The best student from each SuperLM is marked in red. Given any state-of-the-art distilled model, AutoDistil generates a better candidate with less #FLOPs and improved task performance from corresponding search space. To address these challenges, Neural Architecture Search (NAS) Pham et al. [2018], Tan et al. [2019], Cai et al. [2020], Yu et al. [2020] provides a natural solution to automatically search through a large space of candidate models while accounting for often con\ufb02icting objectives like computational cost vs. task performance. The dominant paradigm for NAS comprises of two main components: (a) Super model training which combines all possible architectures into a single graph and jointly training them via weight-sharing; and (b) Searching for optimal architecture from Super model with the best possible accuracy on a downstream task, satisfying a user-speci\ufb01ed latency constraint for a speci\ufb01c device. NAS has demonstrated promising results in some recent explorations Hou et al. [2020], Yin et al. [2021], Xu et al. [2021a] in the natural language understanding domain. However, these works suffer from the following drawbacks. (D1) All of these works train one single large Super Language Model (SuperLM) consisting of millions of diverse student architectures. This results in some undesirable effects of co-adaptation Bender et al. [2018] like con\ufb02icts in weight-sharing where bigger student models converge faster in contrast to the smaller ones converging slower Zhao et al. [2021], Yu et al. [2020]. Also, a single SuperLM may not have suf\ufb01cient capacity to encode a large search space. As a result, these works use a multi-stage training process, where they \ufb01rst conduct NAS to identify candidate student models and then perform further pre-training Yin et al. [2021] and knowledge distillation Xu et al. [2021a] of the candidates. (D2) Additionally, these works are not fully task-agnostic. For instance, Yin et al. [2021] performs task-agnostic SuperLM training, but task-speci\ufb01c search for the student with proxy tasks like SQuAD and MNLI. Similarly, Xu et al. [2021a] performs two-stage knowledge distillation with pre-training and \ufb01ne-tuning of the candidates. Table 1 contrasts AutoDistil with existing KD and NAS works. We address these challenges with few-shot task-agnostic NAS consisting of the following three steps. (S1) Search space design. We partition the Transformer search space into K sub-spaces (K = 3 in our work for typical student model sizes like base, small and tiny) considering important architectural hyper-parameters like the network depth, width and number of attention heads. We further leverage inductive bias and heuristics to limit the number of student architectures in each sub-space. (S2) Task-agnostic SuperLM training. We train K SuperLM, one for every sub-space. This allows each SuperLM more capacity to encode a sub-space as opposed to a single large one. We train each SuperLM with a task-agnostic objective like deep self-attention distillation, where we transfer knowledge from the self-attention module (including keys, queries and values) of a pre-trained teacher (e.g., BERT) to the student and use weight-sharing to train the SuperLM. (S3) Lightweight optimal student search. We obtain optimal student(s) directly from well-trained SuperLM(s) without any re-training. We propose two strategies to \ufb01nd the optimal student with task-agnostic or task-proxy search. Overall, our contributions can be summarized as: (1) We develop a few-shot task-agnostic Neural Architecture Search framework to distill several compressed models with variable computational cost. We address the challenge of co-adaptation and weight-sharing of compressed models by few-shot NAS and a compact search space design. 2 \fFew-shot Task-agnostic Neural Architecture Search Table 1: Comparing AutoDistil with existing KD and NAS methods on aspects as task-agnostic training and search; generating multiple students with variable compression cost; single-stage training without additional adaptation; SuperLM training with compact search space to mitigate interference (P denotes partial). Method TaskVariable NAS agnostic Compression Single SuperLM Compact Stage Training Search BERT-PKD \u0017 \u0017 N/A SparseBERT \u0017 \u0017 DistilBERT \u2713 \u0017 TinyBERT \u2713 \u0017 MOBILEBERT \u2713 \u0017 MINILM \u2713 \u0017 DynaBERT \u0017 \u2713 \u2713 One-shot \u0017 NAS-BERT P \u2713 \u0017 One-shot \u0017 AutoTinyBERT P \u2713 \u0017 One-shot \u0017 AutoDistil \u2713 \u2713 \u2713 Few-shot \u2713 (2) We use self-attention distillation to train the SuperLM and demonstrate this to be better than masked language modeling objective for task-agnostic SuperLM training. (3) We perform extensive experiments in the GLUE benchmark where our method achieves 62.4% reduction in computational cost and 59.7% reduction in model size over state-of-the-art task-agnostic distillation methods with similar downstream task performance, with a comprehensive summary of the results in Figure 1. 2 Background We present an overview of Transformers Vaswani et al. [2017], especially its two main sub-layers, multi-head selfattention (MHA) and feed-forward network (FFN). Transformer layers are stacked to encode contextual information for input tokens as: Xl = Transformerl(Xl\u22121), l \u2208[1, L] (1) where L is the number of Transformer layers, Xl \u2208Rs\u2217dhid, s is the sentence length, and dhid is the hidden dimension. In the following, we omit the layer indices for simplicity. Multi-Head Self-Attention (MHA). Given the previous Transformer layer\u2019s output X, the MHA output is given as: Qh, Kh, Vh = XW Q h , XW K h , XW V h , (2) Attention(Qh, Kh, Vh) = softmax( QhK\u22a4 h \u221adhead )Vh, (3) MHA(X) = Concat(head1, \u00b7 \u00b7 \u00b7 , headH)W O, (4) where W Q h , W K h , W V h \u2208Rdhid\u2217dhead, W O \u2208Rdhid\u2217dhid are linear transformations. Qh, Kh, Vh \u2208Rs\u2217dhead are called queries, keys, and values, respectively. H is the number of heads. headh = Attention(Qh, Kh, Vh) denotes the h-th attention head. Concat is the concatenating operation. dhead = dhid/H is the dimension of each head. Feed-Forward Network (FFN). Each Transformer layer contains an FNN sub-layer, which is stacked on the MHA. FFN consists of two linear transformations with a ReLU activation as: FFN(x) = max(0, xW 1 + b1)W 2 + b2, (5) where W 1 \u2208Rdhid\u2217df , W 2 \u2208Rdf \u2217dhid, b1 \u2208Rdf , and b2 \u2208Rdhid. In addition, there are residual connection and layer normalization on top of MHA and FFN (denoted by \u2295in Figure 2), which are formulated as LayerNorm(x + MHA(x)) and LayerNorm(x + FFN(x)), respectively. 3 \fFew-shot Task-agnostic Neural Architecture Search Search Engine Task Agnostic Task Proxy \ud835\udefc\ud835\udc9c \u2217 Performance Cost \ud835\udcd0\ud835\udfd1 \ud835\udcd0\ud835\udfd0 \ud835\udcd0\ud835\udfcf K-shot Learning for SuperLM Subnetwork Search K Search Partitions \u2026 Transformer 1 Transformer 2 Transformer 3 Transformer 4 Transformer 5 Transformer T x1 x2 x3 \u2026 Transformer 1 Transformer 2 Transformer 3 x1 x2 x3 Transformer S Q K V Distill Q K V Attention WQ WK WV Wo W1 W2 Sampled Subnetworks Pre-trained Teacher Adaptive Transformer Block of Sampled Subnetworks Multi-head Self-attention Relation Distillation Figure 2: Overview of AutoDistil . It considers K=3 partitions of the Transformer architecture subspace to train one SuperLM for each partition with weight-sharing of the constituent subnetworks trained via task-agnostic deep self-attention distillation. Optimal compressed subnetworks can be easily extracted from the SuperLMs without additional training by task-agnostic or task-proxy search. Table 2: The search space of AutoDistil with K=3 partitions, each consisting of 256 subnets with variable computational cost. We train one SuperLM with weight-sharing for each partition with child models sharing transformer blocks. Each tuple represents the lowest value, highest value, and steps for each factor. SuperLMTiny SuperLMSmall SuperLMBase BERT #Subnets 256 256 256 N/A #Layers (4, 7, 1) (9, 12, 1) (9, 12, 1) 12 #Hid_dim (128, 224, 32) (256, 352, 32) (544, 640, 32) 768 MLP Ratio (2.0, 3.5, 0.5) (2.5, 4.0, 0.5) (2.5, 4.0, 0.5) 4.0 #Heads (7, 10, 1) (7, 10, 1) (9, 12, 1) 12 #FLOPs 40-367M 0.5-2.1G 2.1-7.9G 11.2G #Params 4-10M 12-28M 39-79M 109M 3 Few-shot Task-agnostic NAS Given a large pre-trained language model (e.g., BERT) as teacher, AutoDistil distills several compressed models with variable computational cost in a task-agnostic fashion. In the following, we describe our major components. 3.1 Search Space Design Searchable transformer components. We presented an overview of Transformers in Section 2 and our framework in Figure 2. We observe that four important hyper-parameters for the Transformer building blocks, include: \u2022 Number of layers (L) to capture the network depth \u2022 Hidden dimension (dhid) to encode input representation \u2022 Attention heads (H) for multi-head self-attention \u2022 Feed-forward network (FFN) dimension: we encode this by the MLP (multi-layer perceptron) ratio de\ufb01ned as r = df dhid with df and dhid representing the intermediate dimension of the FFN and hidden dimension respectively All of the above factors are important for model capacity and have a signi\ufb01cant impact on the model size and computational cost. For instance, different layers have different feature representation capabilities. Recent works show 4 \fFew-shot Task-agnostic Neural Architecture Search that Transformer models are overparameterized Michel et al. [2019a], Voita et al. [2019a], such as the feed-forward layer (FFN), which is one of the most computation intensive components Ganesh et al. [2020]. Therefore, we search for the optimal MLP ratio and hidden dimension that reduce computational cost resulting from the FFN layers. Furthermore, studies Michel et al. [2019b], Voita et al. [2019b] show that attention heads can be redundant when they learn to encode similar relationships and nuances for each word. Thus, we make the number of attention heads searchable as well. Inductive bias. Prior work Romero et al. [2015] demonstrate that thinner and deeper neural networks with improved representation capacity perform better than wider and shallower ones. We incorporate this as an inductive bias to decide the number of layers to consider for the students in each of our K sub-spaces (base, small, tiny), where we prefer deeper students in terms of the number of layers. Furthermore, we constrain all the Transformer layers in a given student model to share identical and homogeneous structures, i.e., the same number of attention heads, hidden dimension, etc. This not only reduces the size of the search space, it is also more friendly to hardware and software frameworks Yin et al. [2021]. Search space partition. Existing works Yin et al. [2021], Xu et al. [2021a] train a single large SuperLM containing millions of student architectures by weight-sharing. This leads to performance degradation due to optimization interference and convergence of subnetworks with very different sizes Yu et al. [2020]. To mitigate such interference, we employ a few-shot learning strategy Chen et al. [2021], Zhao et al. [2021] as follows: we partition the whole Transformer search space into K sub-spaces such that each sub-space covers different sizes of student models given by the number of parameters. We set K = 3 to cover typical student sizes, namely base, small and tiny versions. Table 2 shows the parameter ranges for the K sub-spaces, along with the student con\ufb01gurations contained in each. We now encode each sub-space into a SuperLM, where each student model in the space is a subnetwork of the SuperLM. Furthermore, all the student subnetworks share the weights of their common dimensions, with the SuperLM being the largest one in the search space. Considering K independent SuperLMs, each one now has more capacity to encode a sub-space, in contrast to a limited capacity single SuperLM in prior works. Furthermore, our choices for the heuristic partition and inductive bias result in less number of student models of comparable size in each sub-space which alleviates con\ufb02icts in weight-sharing. The student subnetworks are extracted from the SuperLM via bottom-left extraction. In particular, given a speci\ufb01c architecture \u03b1 = {l, dhid, r, h}, (i) we \ufb01rst extract alternate l Transformer layers from the SuperLM; (ii) then extract bottom-left sub-matrices in terms of dhid and r from the original matrices that represent the hidden dimension and the MLP ratio respectively; (iii) \ufb01nally, for the attention heads, we extract the leftmost h heads and retain the dimension of each head as the SuperLM. 3.2 Task-agnostic SuperLM Training We illustrate the SuperLM training process in Algorithm 1. Given a large pre-trained language model (e.g., BERT) as the teacher, we initialize the SuperLM with the weights of teacher. In each step of SuperLM training, we randomly sample several student subnetworks from the search space; apply knowledge distillation between the sampled subnetworks and the teacher to accumulate the gradients; and then update the SuperLM. We leverage deep self-attention distillation Wang et al. [2020a] for task-agnostic training. To this end, we employ multi-head self-attention relation distillation to align the attention distributions as well as the scaled dot-product of keys, queries and values of the teacher and sampled student subnetworks. Consider A1, A2, A3 to denote the queries, keys and values of multiple relation heads of teacher model, and B1, B2, B3 respectively for a sampled subnetwork. The mean squared error (MSE(\u00b7)) between multi-head self-attention relation of the teacher and sampled subnetwork is used as the distillation objective: L = 3 X i=1 \u03b2iLi (6) Li = 1 H H X k=1 MSE(RT ik, RS ik) (7) RT i = softmax(AiA\u22a4 i \u221adk ), RS i = softmax(BiB\u22a4 i \u221adk ) (8) where H is the number of attention heads; RT i represents the teacher\u2019s Q\u2212Q, K \u2212K, or V \u2212V relation; RS i represents the same for student. RT ik is the relation information based on one attention head, and dk is the attention head size. Relation knowledge distillation avoids the introduction of additional parameters to transform the student\u2019s representations with different dimensions to align to that of the teacher. For the teacher model and subnetworks with different 5 \fFew-shot Task-agnostic Neural Architecture Search Algorithm 1 Few-shot Task-agnostic Knowledge Distillation with AutoDistil . Input: Partitioned K sub-spaces Ak; initialized K SuperLMs Sk on Ak; pre-trained teacher model T; unlabeled data D; training epochs E; sampling steps M Output: Trained SuperLMs {Sk} for k = 1 to K do for i = 1 to E do Get a batch of data from D for batch in D do Clear gradients in SuperLM Sk for m = 1 to M do Randomly sample a subnetwork s from Sk Calculate self-attention distil. loss between subnetwork s and teacher T with Eqn. (6) Accumulate gradients end for Update Sk with the accumulated gradients end for end for end for number of attention heads, we \ufb01rst concatenate the self-attention vectors of different attention heads of the subnetwork and then split them according to the number of relation heads of the teacher model. Then, we align their queries with the same number of relation heads for distillation. In addition, we only transfer the self-attention knowledge from the last layer of the teacher model to the last layer of the student model. Automatically selecting which layers to align is an interesting research direction that we defer to future work. Formally, the SuperLM for sub-space Ak is trained as: W \u2217 Ak = arg min W E\u03b1\u2208A[L(W\u03b1; U; Dtrain)], (9) where, K is the number of sub-space partitions; W are the weights of the SuperLM; W\u03b1 are the weights in W speci\ufb01ed by the architecture \u03b1; U are the weights of the teacher model including the self-attention module used for distillation; Dtrain is the training data set, and L(\u00b7) is the self-attention loss function from Eqn. (6). 3.3 Lightweight Optimal Student Search We outline two search strategies for selecting the optimal student subnetwork. Task-agnostic search. We compute the task-agnostic self-attention distillation loss for all student subnetworks using Eqn. (6) on a heldout validation set from the unlabeled training corpus. The student subnetworks are directly obtained by bottom-left extraction from the well-trained SuperLM (outlined in Section 3.1). This process is lightweight since it does not require any training or adaptation of the student and the number of subnetworks is limited. The optimal student is given by the subnetwork with the least validation loss subject to the following constraint. \u03b1\u2217 A = arg min \u03b1\u2208A1,2,\u00b7\u00b7\u00b7K L(W \u2217 \u03b1; Dval), s.t. g(\u03b1) < c, (10) where W \u2217 \u03b1 is the weights of architecture \u03b1 obtained from W \u2217 Ak, Dval is the validation data set, L is the self-attention distillation loss, and g(\u00b7) is a function to calculate the computational cost (e.g., #FLOPs, #parameters) of the subnetwork subject to a given constraint c. Task-proxy search. This strategy considers a proxy task (e.g., MNLI Williams et al. [2018]) with label information to \ufb01ne-tune each of the 256 candidate subnetworks in each of the K=3 sub-spaces. The optimal student in each sub-space is given by the one with the best downstream task performance (e.g., accuracy). Although this strategy is more resource expensive than the task-agnostic one, we demonstrate this to obtain better trade-off in computational cost vs. task performance given the auxiliary task label information. 6 \fFew-shot Task-agnostic Neural Architecture Search Table 3: Performance comparison between models distilled by AutoDistil against several task-agnostic students (6 layer, 768 hidden size, 12 heads) distilled from BERTBASE. We report the relative reduction in computational cost (#FLOPs and #Parameters) and improvement in average task performance on GLUE (dev) over all baselines. AutoDistilAgnostic is obtained by task-agnostic search. AutoDistilProxyB and AutoDistilProxyS are obtained by task-proxy search from SuperLMbase and SuperLMsmall respectively. Model AutoDistilAgnostic AutoDistilProxyB AutoDistilProxyS \u2206FLOPs \u2206Para \u2206Avg. \u2206FLOPs \u2206Para \u2206Avg. \u2206FLOPs \u2206Para \u2206Avg. BERTBASE Devlin et al. [2019] (teacher) 81.1% 75.5% -2.6 60.9% 54.3% -0.5 82.0% 76.2% -2.3 BERTSMALL Turc et al. [2019] 62.4% 59.7% -0.3 22.3% 24.7% +1.8 64.3% 60.8% -0.02 Truncated BERT Williams et al. [2018] 62.4% 59.7% +2.5 22.3% 24.7% +4.6 64.3% 60.8% +2.8 DistilBERTSanh et al. [2019] 62.4% 59.7% +1.1 22.3% 24.7% +3.2 64.3% 60.8% +1.4 TinyBERT Jiao et al. [2020] 62.4% 59.7% -0.3 22.3% 24.7% +1.8 64.3% 60.8% +0.0 MINILM Williams et al. [2018] 62.4% 59.7% -1.4 22.3% 24.7% +0.7 64.3% 60.8% -1.1 4 Experiments 4.1 Setup Datasets. We conduct experiments on the General Language Understanding Evaluation (GLUE) benchmark Wang et al. [2018]. We compare our method with the baseline methods on two single-sentence classi\ufb01cation tasks (CoLA Warstadt et al. [2018], SST-2 Socher et al. [2013]), two similarity and paraphrase tasks (MRPC Dolan and Brockett [2005], QQP Chen et al. [2018]), and three inference tasks (MNLI Williams et al. [2018], QNLI Rajpurkar et al. [2016], RTE Dagan et al. [2005], Haim et al. [2006], Giampiccolo et al. [2007], Bentivogli et al. [2009])1. We report accuracy for MNLI, QNLI, QQP, SST-2, RTE, report f1 for MRPC, and report Matthew\u2019s correlation for CoLA. Baselines. We compare against several task-agnostic methods2 generating compressed models from BERTbase teacher, using (i) knowledge distillation like BERTSMALL Turc et al. [2019], Truncated BERT Williams et al. [2018], DistilBERT Sanh et al. [2019], TinyBERT Jiao et al. [2020], MINILM Williams et al. [2018]; as well as those based on Neural Architecture Search, like AutoTinyBERT Yin et al. [2021], and NAS-BERT Xu et al. [2021a]. AutoDistil con\ufb01guration. We use uncased BERTBASE as the teacher consisting of 12 Transformer layers, 12 attention heads; with the hidden dimension and MLP ratio being 768 and 4, respectively. It consists of 109M parameters with 11.2G FLOPs. We use English Wikipedia and BookCorpus data for SuperLM training with WordPiece tokenization. We use 16 V 100 GPUs to train the SuperLM, with 128 as the batch size and 4e-5 as the peak learning rate for 10 epochs. The maximum sequence length is set to 128. The coef\ufb01cients in distillation objective (Eqn. (6)), \u03b21, \u03b22, and \u03b23, are all set to 1. We distill the self-attention knowledge of the last layer to train the SuperLM. Both the teacher and SuperLM are initialized with pre-trained BERTBASE. Other hyper-parameter settings are shown in Appendix. 4.2 Finding the Optimal Compressed Models We use the following search strategies and constraints to \ufb01nd the optimal compressed models by AutoDistil . AutoDistilAgnostic is obtained by task-agnostic search without any task label information. We set a constraint in Eqn. (10) such that the #FLOPs of the optimal compressed model is atleast 50% less than the teacher model. We rank all the subnetworks contained in all the partitions of the trained SuperLM by their self-attention distillation loss on the heldout validation set, and select the one that meets the constraint with the minimum loss. AutoDistilProxy uses MNLI Williams et al. [2018] as a proxy to estimate downstream task performance of different subnetworks. Prior work Chen et al. [2020] has demonstrated performance improvements in MNLI to be correlated to other GLUE tasks. To this end, we \ufb01ne-tune all subnetworks in each partition of the trained superLMs, and select corresponding subnetworks with the best trade-off between task performance (accuracy) and computational cost (#FLOPs). This results in K=3 optimal students, corresponding to AutoDistilProxyB, AutoDistilProxyS and AutoDistilProxyT obtained from the corresponding sub-spaces with SuperLMBase, SuperLMSmall and SuperLMTiny, 1We ignore STS-B for a fair comparison with our strongest baseline MiniLM Wang et al. [2020a] that do not report the task. 2For a fair comparison, we do not include DynaBERT Hou et al. [2020] with task-speci\ufb01c search, and MobileBERT Sun et al. [2020] that uses BERTlarge as teacher in our main result tables. 7 \fFew-shot Task-agnostic Neural Architecture Search Table 4: Performance comparison between AutoDistil students, and popular task-agnostic students distilled from BERTBASE (6 layer, 768 hidden size, 12 attention heads). Our results are averaged over 5 runs. Baseline numbers are reported from corresponding papers. Model #FLOPs #Para MNLI-m QNLI QQP SST-2 CoLA MRPC RTE Average (Metric) (G) (M) (Acc) (Acc) (Acc) (Acc) (Mcc) (Acc) (Acc) BERTBASE Devlin et al. [2019] (teacher) 11.2 109 84.5 91.7 91.3 93.2 58.9 87.3 68.6 82.2 BERTSMALL Turc et al. [2019] 5.66 66.5 81.8 89.8 90.6 91.2 53.5 84.9 67.9 80.0 Truncated BERT Williams et al. [2018] 5.66 66.5 81.2 87.9 90.4 90.8 41.4 82.7 65.5 77.1 DistilBERTSanh et al. [2019] 5.66 66.5 82.2 89.2 88.5 91.3 51.3 87.5 59.9 78.6 TinyBERT Jiao et al. [2020] 5.66 66.5 83.5 90.5 90.6 91.6 42.8 88.4 72.2 79.9 MINILM Williams et al. [2018] 5.66 66.5 84.0 91.0 91.0 92.0 49.2 88.4 71.5 81.0 AutoDistilAgnostic 2.13 26.8 82.8 89.9 90.8 90.6 47.1 87.3 69.0 79.6 AutoDistilProxyB 4.40 50.1 83.8 90.8 91.1 91.1 55.0 88.8 71.9 81.7 AutoDistilProxyS 2.02 26.1 83.2 90.0 90.6 90.1 48.3 88.3 69.4 79.9 AutoDistilProxyT 0.27 6.88 79.0 86.4 89.1 85.9 24.8 78.5 64.3 72.6 Table 5: Architecture comparison between the optimal compressed students searched by AutoDistil with state-of-theart hand-engineered students distilled from BERTBASE. Model #Layers #Hid Ratio #Heads #FLOPs #Para BERTBASE 12 768 4 12 11.2G 109M MINILM 6 768 4 6 5.66G 66.5M AutoDis.Agnostic 11 352 4 10 2.13G 26.8M AutoDis.ProxyB 12 544 3 9 4.40G 50.1M AutoDis.ProxyS 11 352 4 8 2.02G 26.1M AutoDis.ProxyT 7 160 3.5 10 0.27G 6.88M respectively. We visualize the selected subnetworks for each superLM in Figure 3 with the architectures of the optimal compressed models shown in Table 5. 4.2.1 Comparison with Baselines We compare the above AutoDistil compressed models against state-of-the-art KD and NAS models distilled from the same teacher BERTBASE. We present the relative performance improvement of AutoDistil over several baselines in Table 3 with respect to the following measures: savings in computational cost in the form of (i) FLOPs and (ii) parameter reduction, along with (iii) improvement in the average task performance aggregated over all the GLUE tasks with detailed results in Table 4. From Table 3, we observe that the compressed model AutoDistil Agnostic generated via our SuperLM training and task-agnostic search has 80% less FLOPs and 75% less parameters, while incurring 2.6 point accuracy drop in comparison to the large teacher model. When compared to all other baseline models distilled from BERTBASE, AutoDistil Agnostic leads to 62.4% less FLOPs with 59.7% less parameters while incurring a maximum accuracy drop of less than 1.5 points \u2013 demonstrating the effectiveness of AutoDistil in obtaining a better trade-off between task performance and computational cost. 4.2.2 Search Strategy and Architectures From Table 3, we observe that both the task-agnostic and task-proxy search strategies achieve better trade-off between performance and cost than the baselines. The compressed model AutoDistilProxyB obtained from SuperLMbase by the task-proxy search strategy reduces FLOPs and parameters by 22.3% and 24.7%, respectively, while obtaining better task performance than all the baselines. Moreover, by comparing AutoDistilAgnostic and AutoDistilProxyS from SuperLMsmall, we observe that task-proxy search obtains better trade-off in cost vs. performance than the task-agnostic one by making use of task label information. 8 \fFew-shot Task-agnostic Neural Architecture Search (a) Acc vs #FLOPs (SuperLMBase). (b) Acc vs #FLOPs (SuperLMSmall). (c) Acc vs #FLOPs (SuperLMTiny). (d) Acc vs #Para (SuperLMBase). (e) Acc vs #Para (SuperLMSmall). (f) Acc vs #Para (SuperLMTiny). Figure 3: Computational cost vs. task (MNLI) performance trade-off for all 256 subnetworks contained in each of K SuperLMs (base, small and tiny). 3(a)-3(c) show the trade-off between accuracy (Y-axis) and #FLOPs (X-axis), and 3(d)-3(f) show the trade-off between accuracy (Y-axis) and #Para (X-axis). We show the optimal compressed AutoDistil student for each SuperLM marked in red, along with other state-of-the-art KD and NAS techniques for comparison. From Table 5 we observe that optimal compressed models have thin-and-deep structure which is consistent with \ufb01ndings that thinner and deeper models perform better Romero et al. [2015] than wider and shallower ones. While we use this as an inductive bias for sub-space partitioning, our search space (Table 2) also contains diverse subnetworks with different depth and width. Non-maximal MLP ratio and attention heads for optimal compression indicate that self-attention and feed-forward layers of Transformers are overparameterized Michel et al. [2019a], Voita et al. [2019a]. 4.2.3 Subnetwork Performance without Additional Training We compare the performance of different student subnetworks generated by AutoDistil with state-of-the-art NAS and KD techniques in Figure 3. The blue points represent the 256 subnetworks extracted from each SuperLM and the red points denote the corresponding optimal compressed student, all \ufb01ne-tuned on the MNLI task. We observe that most of the students (blue points) achieve a good trade-off between performance (accuracy) and cost (#FLOPs or #Para) when simply \ufb01ne-tuned on the downstream task, without additional pre-training or adaptation. Moreover, the optimal compressed students (marked in red) outperform recent NAS methods like NAS-BERT Xu et al. [2021a] and AutoTinyBERT Yin et al. [2021] that perform an additional stage of pre-training or distillation of the candidate students obtained from NAS. More than half of the subnetworks in Figure 3(d) also show better trade-off than the best task-agnostic KD method MiniLM Wang et al. [2020a]. These observations demonstrate the effectiveness of our few-shot task-agnostic SuperLM training and search mechanism. 4.2.4 Task-agnostic Training Strategies We study different task-agnostic strategies for SuperLM training in AutoDistil . Speci\ufb01cally, we compare three strategies in Table 6. (i) Replacing the KD loss in Eqn. (6) with masked language modeling (MLM) loss Devlin et al. [2019] to calculate gradients. (ii) KDatt+Cont further continues training the searched compressed models on the large language corpus. (iii) KDatt is the strategy adopted in AutoDistil for self-attention distillation. We evaluate subnetworks with the same architecture (6 layers, 768 hidden, 12 heads, MLP ratio 4) from the trained SuperLM. We \ufb01ne-tune the subnetworks on RTE and MRPC tasks, and report accuracy and f1 respectively. First, we observe self-attention distillation to perform better than MLM, for SuperLM training. Second, we observe limited performance gains with continued training demonstrating the effectiveness of our single-stage training protocol. 9 \fFew-shot Task-agnostic Neural Architecture Search Table 6: Comparing task-agnostic SuperLM training strategies. Strategy MRPC RTE MLM 89.4 68.2 KDatt+Cont. 91.0 71.8 KDatt 91.2 71.5 Table 7: Comparing search space design strategies. Task Search Space Size (number of subnetworks) One-shot K=3-shot 27 864 11232 256*3 MRPC 88.2 87.5 85.1 91.2 RTE 67.2 64.5 62.8 71.8 4.2.5 Search Space Design Strategies In Table 7, we compare one-shot NAS versus few-shot NAS training for our SuperLM. For one-shot NAS, we consider a single search space containing different numbers of subnetworks (e.g., 27, 864, 11232). For few-shot NAS, we consider K=3 sub-spaces containing 256 subnetworks each. We extract subnetworks with the same architecture (6 layers, 768 hidden, 12 heads, MLP ratio 4) from trained SuperLM for each strategy for evaluation. We \ufb01ne-tune the subnetworks on RTE and MRPC tasks, and report accuracy and f1 respectively. We observe fewer subnetworks contained in a single search space for one-shot NAS result in a better performance. This results from optimization interference as the number and size of subnetworks increase. Finally, we observe our design strategy with few-shot NAS to perform the best while containing lesser number of subnetworks. 5 Related Work Task-speci\ufb01c knowledge distillation. Knowledge distillation (KD) Hinton et al. [2015] is one of the most widely used techniques for model compression, which transfers knowledge from a large teacher to a smaller student model. Task-speci\ufb01c distillation aims to generate smaller student models by using downstream task label information. Typical task-speci\ufb01c distillation works include BERT-PKD Sun et al. [2019], BERTSMALL Turc et al. [2019], TinyBERT Jiao et al. [2020], DynaBERT Hou et al. [2020], and SparseBERT Xu et al. [2021b]. While task-speci\ufb01c KD methods often achieve good task performance, a typical drawback is that it is resource-consuming to run distillation for each and every task, and also not scalable. Task-agnostic knowledge distillation. In contrast to task-speci\ufb01c distillation, we explore task-agnostic KD that does not use any task label information. The distilled task-agnostic models can be re-used by simply \ufb01ne-tuning on downstream tasks. They can also be used to initialize students for task-speci\ufb01c distillation. Task-agnostic distillation leverages knowledge from soft target probabilities, hidden states, layer mappings and self-attention distributions of teacher to train student models. Typical task-agnostic distillation works include DistilBERT Sanh et al. [2019] MobileBERT Sun et al. [2020], and MiniLM Wang et al. [2020a]. MobileBERT assumes that students have the same number of layers as the teacher for layer-by-layer distillation. MiniLM transfers self-attention knowledge from the last layer of the teacher to that of the student. These works rely on hand-designed architecture for the student models for KD that requires several trials, and needs to be repeated for a new student with a different cost. In contrast, we develop techniques to automatically design and distill several student models with variable cost using NAS. Neural Architecture Search. While NAS has been extensively studied in computer vision Pham et al. [2018], Tan et al. [2019], Cai et al. [2020], Yu et al. [2020], there has been relatively less exploration in natural language processing. Evolved Transformer So et al. [2019] and HAT Wang et al. [2020b] search for ef\ufb01cient sub-networks from the Transformer architecture for machine translation tasks. Some recent approaches closest to our method include, DynaBERT Hou et al. [2020], AutoTinyBERT Yin et al. [2021] and NAS-BERT Xu et al. [2021a]. While DynaBERT performs task-speci\ufb01c distillation, AutoTinyBERT uses task-agnostic KD and MLM strategies for SuperLM training, but task-speci\ufb01c search for the compressed models. NAS-BERT uses a different search space, and performs two-stage knowledge distillation with pre-training and \ufb01ne-tuning of the candidates. Both of these approaches employ one-shot NAS as a single large search space containing millions of subnetworks that result in co-adaption and weight-sharing challenges between them for SuperLM training. In contrast, our method employs few-shot NAS with a compact search 10 \fFew-shot Task-agnostic Neural Architecture Search space design to address the above challenges. This further allows us to do a lightweight search for the optimal student without re-training in a fully task-agnostic fashion. 6"
+                },
+                {
+                    "url": "http://arxiv.org/abs/2110.15438v1",
+                    "title": "InfoGCL: Information-Aware Graph Contrastive Learning",
+                    "abstract": "Various graph contrastive learning models have been proposed to improve the\nperformance of learning tasks on graph datasets in recent years. While\neffective and prevalent, these models are usually carefully customized. In\nparticular, although all recent researches create two contrastive views, they\ndiffer greatly in view augmentations, architectures, and objectives. It remains\nan open question how to build your graph contrastive learning model from\nscratch for particular graph learning tasks and datasets. In this work, we aim\nto fill this gap by studying how graph information is transformed and\ntransferred during the contrastive learning process and proposing an\ninformation-aware graph contrastive learning framework called InfoGCL. The key\npoint of this framework is to follow the Information Bottleneck principle to\nreduce the mutual information between contrastive parts while keeping\ntask-relevant information intact at both the levels of the individual module\nand the entire framework so that the information loss during graph\nrepresentation learning can be minimized. We show for the first time that all\nrecent graph contrastive learning methods can be unified by our framework. We\nempirically validate our theoretical analysis on both node and graph\nclassification benchmark datasets, and demonstrate that our algorithm\nsignificantly outperforms the state-of-the-arts.",
+                    "authors": "Dongkuan Xu, Wei Cheng, Dongsheng Luo, Haifeng Chen, Xiang Zhang",
+                    "published": "2021-10-28",
+                    "updated": "2021-10-28",
+                    "primary_cat": "cs.LG",
+                    "cats": [
+                        "cs.LG"
+                    ],
+                    "main_content": "Introduction Inspired by their success in the vision and language domains, contrastive learning methods have been wildly adopted by recent progress in graph learning to improve the performance of a variety of tasks [42, 13, 22]. In a nutshell, these methods typically learn representations by creating two augmented views of a graph and maximizing the feature consistency between the two views. Inheriting the advantages of self-supervised learning, contrastive learning relieves graph representation learning from its reliance on label information in graph domain, where label information can be very costly or even impossible to collect while unlabeled/partially labeled data is common, such as chemical graph data [28]. Graph contrastive learning methods have achieved similar (and even better) performance as compared to the equivalent methods trained with labels on benchmark graph datasets [42, 13, 6]. Despite being effective and prevalent, existing graph contrastive learning models differ mostly in augmented view design, encoding architecture, and contrastive objective (refer to Table 1 in Appendix for more comparisons). For a learning task, it usually requires a substantial degree of domain expertise to carefully design and customize these modules for the speci\ufb01c dataset. For example, while both DGI [33] and InfoGraph [28] seek to obtain graph representations by maximizing the mutual information between patch-level and graph-level representations, they adopt different graph encoders, GCN [15] and GIN [38] respectively. mvgrl [13] applies graph diffusion convolution to construct the Preprint. Under review. arXiv:2110.15438v1  [cs.LG]  28 Oct 2021 \fGNN + MLP GNN + MLP Positive Pair for Contrasting View Augmentation View Encoding Representation Contrasting Figure 1: Graph contrastive learning approaches consist of three stages: 1) a graph G undergoes view augmentation, qi(\u00b7), qj(\u00b7), to obtain two semantically similar views, vi, vj. 2) the two views are fed into view encoder networks, fi(\u00b7), fj(\u00b7), to extract latent representations, zi, zj. 3) the feature consistency between representations is maximized to optimize the objective function based on contrastive mode (ci(\u00b7), cj(\u00b7)), where ci(\u00b7), cj(\u00b7) are aggregation operations applied to representations. augmented view, while GCC [22] and GRACE [45] adopt subgraph sampling and graph perturbation, respectively. The main question this paper attempts to answer is: how to perform contrastive learning for your learning tasks on speci\ufb01c graph datasets? However, answering this question is challenging. First, contrastive learning consists of multiple components, such as view augmentation and information encoding. For each of them, there are various choices. Numerous variations make it dif\ufb01cult to design models that are both robust and ef\ufb01cient. Existing graph contrastive learning approaches are carefully designed for different learning tasks on different datasets, however, none of them studies the guiding principles for choosing the best components. Second, graph data has unique properties that distinguish it from other types of data, such as rich structural information and highly diverse distribution [33, 28, 11, 10]. Thus, it is desirable to design the contrastive learning model that \ufb01ts your graph data properties, even without any domain knowledge of the data. We propose to address these challenges via Information Bottleneck (IB) [31], which provides a crucial principle for representation learning. Speci\ufb01cally, IB encourages the representations to be maximally informative about the target in the downstream task, which helps keep task-relevant information. Concurrently, IB discourages the representation learning from acquiring the task-irrelevant information from the input data, which is related to the idea of minimal suf\ufb01cient statistics [27]. However, different from the typical representation learning, there are two information \ufb02ows involved in the two augmented views in contrastive learning. Therefore, we extend the previous IB work [37, 43] and propose InfoGCL, an information-aware contrastive learning framework for graph data. To study how information is transformed and transferred, we decouple a typical graph contrastive learning model into three sequential modules (as shown in Figure 1): view augmentation, view encoding, and representation contrasting. We further formalize how to \ufb01nd the optimal of the three modules into three optimization problems. To build the optimal graph contrastive learning model for the particular dataset and task, we argue that it is necessary and suf\ufb01cient to minimize the mutual information between contrastive representations while maximizing task-relevant information at the levels of both individual module and entire framework. Our work is also motivated by the InfoMin theory [30], which suggests that a good set of views for contrastive learning in the vision domain should share the minimal information necessary to perform well at the downstream task. Beyond view selection, our work extends InfoMin to suggest principles of selecting view encodings and contrastive modes for graph learning considering the unique properties of graph data. We suggest practically feasible principles to \ufb01nd the optimal modules in graph contrastive learning and show that all recent graph contrastive learning methods can be uni\ufb01ed by these principles: i) the augmented views should contain as much task-relevant information as possible, while they should share as little information as possible; ii) the view encoder should be task-relevant and simple as much as possible; iii) the contrastive mode should keep task-relevant information as much as possible after contrasting. Besides, we also investigate the role of negative samples in graph contrastive learning and argue that negative samples are not necessarily required, especially when graph data 2 \fis not extremely sparse. Our proposed method, InfoGCL, is validated on a rich set of benchmark datasets for both node-level and graph-level tasks, where we analyze its ability to capture the unique structural properties of the graph data. The results demonstrate that our algorithm achieves highly competitive performance with up to 5.2% relative improvement in accuracy on graph classi\ufb01cation task and competitive results on node classi\ufb01cation task over the state-of-the-art unsupervised methods. 2 Related Work Graph Contrastive Learning. Some recent research efforts in graph domain have been attracted by the success of contrastive learning in vision and language domains [3, 8, 4]. A number of graph contrastive learning approaches have been proposed [28, 22, 42, 13]. Despite all of them creating two views and targeting at maximizing the feature disagreement between the two views, these methods are carefully designed and differ in various aspects. Deep graph Infomax (DGI) [33] applied the InfoMax principle [18] to graph data by contrasting the representations of node-level and graph-level for node classi\ufb01cation tasks. Different from DGI, InfoGraph [28] aims at node classi\ufb01cation tasks and it contrasts the representations of graph-level and substructure-level of different granularity. In addition, DGI and InfoGraph use different graph encoders to extract latent representations. mvgrl [13] studies both node and graph classi\ufb01cation tasks. It transforms the adjacency matrix to a diffusion matrix and treat the two matrices as two congruent views. However, in GCC [22] and GRACE [45], subgraph sampling and graph perturbation are used to create the augmented views. GraphCL [42] explores the view augmentations approaches for graph contrastive learning. Speci\ufb01cally, it studies the approaches of node dropping, edge perturbation, attribute masking, and subgraph sampling. A recent work [44] also studies graph data augmentations. However, it focuses on graph neural networks for node classi\ufb01cation and does not study the contrastive learning framework. Our method differs from them. We aim to answer the question how to perform contrastive learning for your graph data and tasks. Instead of carefully designing the architectures, we decouple typical graph contrastive learning into three stages and provide our InfoGCL principles to analyze the optimality theoretically and practically. Information Bottleneck. Our method is related to the Information Bottleneck (IB) theory [31], which aims to \ufb01nd the best trade-off between accuracy and complexity when summarizing a random variable. IB has been recently used to study the deep learning approaches [26, 37, 43]. Speci\ufb01cally, IB expresses the trade-off between the mutual information measures I(D, Z) and I(Z, y) as max IB\u03b2 = \u2212I(D; Z) + \u03b2I(Z; y), (1) where D, Z, y are the input, the latent representation and the task label, respectively. \u03b8 is a hyperparameter. In other words, IB aims to learn representation Z that is maximally expressive about y, while being minimally expressive about D. More recently, there are some efforts applying the IB theory to graph representation learning. [37] aims to generate both expressive and robust graph representations, while [43] studies the subgraph recognition problem. In contrast, our work focuses on graph contrastive learning, where the two augmented views make the optimization objective (information trade-off) different. Our work is also related to the idea of minimal suf\ufb01cient statistics [27], which has been recently studied in the vision domain [30], claiming that a good set of image views should share the minimal information necessary to perform well at the downstream task. Different from [30], we focus on the graph domain and propose three stages considering the unique properties of graph data. 3 Preliminaries and Notations Graph Representation Learning. A graph is denoted by G = (A, X). A \u2208Rn\u00d7n is the adjacency matrix. X \u2208Rn\u00d7d is the node attribute matrix, where d is the attribute dimension. In this work, we focus on both node-level and graph-level tasks. For node-level task, given graph G and the labels of a subset of nodes, denoted by Yv, the goal is to learn the latent representation zv for each node v such that zv preserves both network structures and node attributes, which can be further used to predict Yv. For graph-level task, given a set of graphs G = {G1, G2, \u00b7 \u00b7 \u00b7 } and the labels of some graphs, denoted by Yg, the goal is to learn the latent representation zg for each graph such that zg can be used to predict Yg. Typically, the graph data is fed into graph neural networks (GNNs) to generate the representations, such as zg = GNNs(G). 3 \fA B D C E A B D C E A B D C E Figure 2: Illustration of optimal views. (Left) The relationships between graph G, two views, vi, vj, and task y in terms of information entropy. A, B, C, D, E are overlapping areas. Two views are contained by graph because views are functions of graph. (Middle) A, B, E become null when Eqs. (4)-(5) hold, which indicates the views and graph share the same amount of task-relevant information. (Right) C further becomes null when Eq. (3) holds, which indicates all the shared information between views is task-relevant, i.e., the views are optimal. Graph Contrastive Learning. Given an input graph, graph contrastive learning aims to learn the representations of graph or nodes (for graph-level or node-level tasks respectively) through maximizing the feature consistency between two augmented views of the input graph via contrastive loss in the latent space. We decouple a typical graph contrastive learning model into three sequential modules. (i) View augmentation. Graph G undergoes data augmentation q(\u00b7) to obtain two views vi, vj, i.e., vi \u223cqi(G) and vj \u223cqj(G). A view is represented as graph data, such as vi = (Avi, Xvi), where Avi \u2208Rn\u00d7n and Xvi \u2208Rn\u00d7d. In practice, view augmentation approaches include node dropping, edge perturbation, subgraph sampling, etc. (ii) View encoding. Graph-level or node-level latent representation is extracted from views vi, vj by using the view encoder networks f(\u00b7) (a GNN backbone plus a projection MLP), i.e., zi \u223cfi(vi) and zj \u223cfj(vj). The two encoders might or might not share parameters depending on whether they are from the same domain. (iii) Representation contrasting. Given the latent representations, a contrastive loss is optimized to score the positive pairs zi, zj higher compared to other negative pairs. Typically, the negative pairs are constructed from the augmented views of other graphs in the same minibatch. The InfoNCE loss [21] has been adopted as one of popular contrastive losses, which is de\ufb01ned as: LNCE = \u2212E \" log exp(h(zi,n, zj,n)) PN n\u2032=1 exp(h(zi,n, zj,n\u2032)) # , (2) where h(\u00b7) is a contrasting operation to score the agreement between two representations. Theoretically, minimizing the InfoNCE loss equivalently maximizes a lower bound on the mutual information between the views of positive pairs. In other words, I(zi, zj) \u2a7elog(N) LNCE, where I(\u00b7) measures the mutual information. 4 Information-Aware Graph Contrastive Learning In this paper, we study how to perform contrastive learning for speci\ufb01c graph tasks and datasets. In particular, we attempt to answer the following questions for graph contrastive learning: (i) What is the optimal augmented views? (ii) What is the optimal view encoder? (iii) What is the optimal contrastive mode? 4.1 View Augmentation The goal of view augmentation is to create realistically rational data via the transformation approaches that do not affect the semantic label. Compared to the augmentation in other domains, graph view augmentation needs to consider the structural information of graph data, such as the node, the edge, and the subgraph. There are various graph view augmentation methods proposed recently. We follow 4 \fa similar de\ufb01nition used in [42] to categorize four kinds of view augmentation approaches for graph data. Node dropping discards a certain part of nodes along with their edges in the input graph to create a new graph view. Edge perturbation perturbs the connectivity in the graph via adding or dropping partial edges. Attribute masking masks part of node attributes and assumes that the missing attributes can be well predicted by the remaining ones. Subgraph sampling samples a subgraph from the input graph. The rationale behind these approaches is that the semantic meaning of graph has certain robustness to graph perturbation. The augmented views generated in the graph contrastive framework are typically used in a separate downstream task. To characterize what views are optimal for a downstream task, we de\ufb01ne the optimality of views. The main motivation is: the optimal augmented views should contain the most task-relevant information, and the information shared between views should only be task-relevant. Corollary 1. (Optimal Augmented Views) For a downstream task T whose goal is to predict a semantic label y, the optimal views, v\u2217 i , v\u2217 j, generated from the input graph G are the solutions to the following optimization problem : (v\u2217 i , v\u2217 j) = arg min vi,vj I(vi; vj) (3) s.t. I(vi; y) = I(vj; y) (4) I(vi; y) = I(G; y) (5) This says that for the optimal graph views, the amount of information shared between them is minimized (Eq. (3)), while the two views contain the same amount of information with respect to y (Eq. (4)), which is also the amount of information that the input gprah contains about the task (Eq. (5)). The illustration of the optimal views is shown in Figure 2 and the proof is in the Appendix. 4.2 View Encoding View encoding aims to extract the latent representations of nodes or graphs via feeding the data of two views into view encoder networks such that the generated representations preserve both structure and attribute information in the views. The view encoders are quite \ufb02exible in graph contrastive learning and typically they are GCN [15], GAT [32], or GIN [38], etc. The representations extracted via view encoding are further utilized to optimize the objective function of contrastive learning. After well trained, the view encoders are used to generate the graph/node representations for a downstream task. To characterize what encoders are optimal, we de\ufb01ne the optimality of view encoders for graph contrastive learning. The main motivation is: the representation generated by the optimal encoder for a view should keep all the shared information by the two contrastive views, meanwhile the kept information is all task-relevant. Corollary 2. (Optimal View Encoder) Given the optimal views, v\u2217 i , v\u2217 j, for a downstream task T whose goal is to predict a semantic label y, the optimal view encoder for view v\u2217 i is the solution to the following optimization problem : f \u2217 i = arg min fi I(fi(v\u2217 i ); v\u2217 i ) (6) s.t. I(fi(v\u2217 i ); v\u2217 j) = I(v\u2217 i ; v\u2217 j) (7) It indicates that for the optimal view encoder, the amount of information shared between the optimal view and the extracted representation is minimized (Eq. (6)), while the information shared between the two optimal views is kept after the encoding process of one view (Eq. (7)). The illustration of the optimal encoder is shown in Figure 3 and the proof is illustrated in the Appendix. 4.3 Representation Contrasting To allow \ufb02exible contrasting for graph data, we consider contrastive modes similar to [13]. A contrastive mode is denoted by (ci(\u00b7), cj(\u00b7)), where ci(\u00b7), cj(\u00b7) are the aggregation operations applied to the representations extracted by view encoders, The contrastive modes are unique to graph data because of the structural information inside a graph. Speci\ufb01cally, we consider \ufb01ve contrastive modes. In global-global mode, the graph representations from two views are contrasted. Thus, ci(\u00b7), cj(\u00b7) are averaging aggregation operations in this mode. In local-global mode, we contrast the node 5 \fD C B A D C B A D C B A Figure 3: Illustration of optimal view encoding. (Left) The relationships between two (optimal) views, v\u2217 i , v\u2217 j, task y, and representation zi in terms of information entropy. A, B, C are null because the two views are optimal here. zi is contained by view v\u2217 i because representations are functions of views. (Middle) zi covers D when Eq. (7) holds, which indicates the shared information between views is kept after encoding. (Right) View zi further exactly covers D and the view encoding becomes optimal, i.e., z\u2217 i , which indicates all the information shared between view v\u2217 i and representation z\u2217 i is task-relevant. representations from one view with the graph representations from the other view. Thus, ci(\u00b7), cj(\u00b7) are the identical transformation and averaging aggregation operations, respectively. In local-local mode, the node representations from two views are contrasted. In multi-scale mode, we contrast graph representation of one view with the intermediate representation from the other. In hybrid mode, both global-global and local-global are applied. To characterize which mode is optimal, we de\ufb01ne the optimality of contrastive mode for graph contrastive learning. The main motivation is: the optimal contrastive mode keeps the most taskrelevant information after the representations are aggregated. The proof is included in the Appendix. Corollary 3. (Optimal Contrastive Mode) Given the latent representations, z\u2217 i , z\u2217 j, extracted by the optimal view encoders, i.e., z\u2217 i = f \u2217 i (v\u2217 i ), z\u2217 j = f \u2217 j (v\u2217 j) , and a downstream task T with label y, the optimal contrastive mode is the solution to the following optimization problem, where ci, cj are the aggregation operations applied to the latent representations: (c\u2217 i , c\u2217 j) = arg min (ci,cj) \u2212I(ci(z\u2217 i ); cj(z\u2217 j)). (8) 4.4 InfoGCL Principle According to our proposed corollaries, we can theoretically design the optimal contrastive learning approach for our speci\ufb01c graph data and task. However, in real-world scenarios, the conditions to meet the exact optimality of contrastive learning is hard or even not practically possible to reach because of data noise and limited model capability. Therefore, we propose to achieve the optimal for each stage independently and practically, which is an approximation to achieve the original optimality. Speci\ufb01cally, we make the following propositions to address the questions of the optimal views, optimal view encoder, and optimal contrastive mode. Proposition 1. For a task T with label y, given a bunch of graph view augmentation methods, {q1(\u00b7), q2(\u00b7), \u00b7 \u00b7 \u00b7 }, that create two views vi, vj, the recommended augmentation methods are the ones, qi(\u00b7), qj(\u00b7), that maximize I(vi; y) + I(vj; y) I(vi; vj), i.e., the area of A+B+D in Figure 2. Proposition 2. Given a task T with label y and a set of view encoders, {f 1 i (\u00b7), f 2 i (\u00b7), \u00b7 \u00b7 \u00b7 }, that generate representation zi via taking view vi as input, the recommended view encoder is the one that maximizes the mutual information between vi, zi and y. Symmetrically the same for view vj. Proposition 3. Given a task T with label y, the extracted representations, zi, zj, and a set of aggregation operations, {c1(\u00b7), c2(\u00b7), \u00b7 \u00b7 \u00b7 }, the recommended contrastive mode is the one, (ci, cj), that has the largest amount of mutual information between ci(zi), cj(zj) and y. The qualitative and quantitative evaluation of these propositions are shown in Section 5.3. 4.5 Role of Negative Samples Current graph contrastive learning approaches heavily depend on negative samples. However, recent progresses of contrastive learning in vision domain indicate that negative samples are not necessarily 6 \fGraph Task Datasets Node Task Datasets MUTAG PTC-MR IMDB-B IMDB-M NCI1 COLLAB Cora Citeseer Pubmed # Graphs 188 344 1000 1500 4110 5000 1 1 1 # Nodes 17.9 14.3 19.8 13.0 29.9 74.5 3327 2708 19717 # Edges 19.8 14.7 193.1 65.9 1.1 33.0 4732 5429 44338 # Classes 2 2 2 2 2 3 6 7 3 Table 1: Dataset statistics. required [8, 4], of which the main bene\ufb01t is to avoid careful treatment to retrieve the negative pairs. To study the in\ufb02uence of negative samples on graph contrastive learning, we follow the framework of SimSiam [4] to revise the loss function as Eq.(9). A very recent work [29] also studies graph contrastive learning without negative samples. Different from it, we focus on both node and graph classi\ufb01cation tasks. L = \u22121 N N X n=1 zi,n \u2225zi,n\u2225\u00b7 zj,n \u2225zj,n\u2225, (9) 5 Experiments In this section, we evaluate our InfoGCL with a number of experiments. We \ufb01rst describe datasets, evaluation protocol, and experimental setup. Then, we present the experimental results on both node and graph classi\ufb01cation. Last, we analyze our proposed principles via ablation study. 5.1 Setup We use both graph classi\ufb01cation and node classi\ufb01cation benchmark datasets that are widely used in the existing graph contrastive learning approaches. The graph classi\ufb01cation datasets include MUTAG [17], PTC-MR [17], IMDB-B [40], IMDB-M [40], NCI1 [34], and COLLAB [40]. MUTAG is a collection of nitroaromatic compounds represented as graphs, where vertices stand for atoms and edges represent bonds between atoms. PTC-MR is a collection of 344 chemical compounds which report the carcinogenicity for rats. IMDB-B and IMDB-M are two movie collaboration datasets, where nodes represent actors/actress and there is an edge between them if they appear in the same movie. In NCI1, graphs are the representation of chemical compounds, where vertices stand for atoms and edges represent bonds between atoms. COLLAB is a collaboration dataset, where researchers are nodes and an edge indicates collaboration between two researchers. The node classi\ufb01cation datasets include Citeseer, Cora, and Pubmed [23]. All of them are citation networks, where nodes are documents and edges are citation links. These datasets are summarized in Table 1. We closely follow the evaluation protocol of previous state-of-the-art graph contrastive learning approaches. For graph classi\ufb01cation, we report the mean 10-fold cross validation accuracy after 5 runs followed by a linear SVM. The linear SVM is trained by applying cross validation on training data folds and the best mean accuracy is reported. For node classi\ufb01cation, we report the mean accuracy on test set after 50 runs of training followed by a linear neural network model. To make comparison fair, we adopt the basic setting of InfoGraph for graph classi\ufb01cation. We conduct experiment with the values of the number of GNN layers, the number of epochs, batch size, the parameter C of SVM in the sets {2, 4, 8, 12}, {10, 20, 40, 100}, {32, 64, 128, 256} and {10\u22123, 10\u22122, ..., 102, 103 }, respectively. We adopt the basic setting of DGI for node classi\ufb01cation. Speci\ufb01cally, we set the number of GNN layers to 1 and experiment with the batch size in the set {2, 4, 8}. The hidden dimension of representations is set to 512. We also apply the early stopping strategy. 5.2 Experimental Results To evaluate our method InfoGCL on graph classi\ufb01cation, we use thhree categories of baselines. The kernel approaches include shortest path kernel (SP) [2], Graphlet kernel (GK) [25], WeisfeilerLehman sub-tree kernel (WL) [24], deep graph kernels (DGK) [39], and multi-scale Laplacian kernel (MLG) [16]. The supervised baselines include GraphSAGE [12], GCN [15], GIN [38], GAT [32]. We also compare with the unsupervised approaches, including RandomWalk [7], node2vec [9], sub2vec [14], graph2vec [20], InfoGraph [28], GraphCL [42], and mvgrl [13]. Table 2 shows the 7 \fMethod MUTAG PTC-MR IMDB-B IMDB-M NCI1 COLLAB Kernel Approaches SP 85.2 \u00b1 2.4 58.2 \u00b1 2.4 55.6 \u00b1 0.2 38.0 \u00b1 0.3 73.5 \u00b1 0.1 GK 81.7 \u00b1 2.1 57.3 \u00b1 1.4 65.9 \u00b1 1.0 43.9 \u00b1 0.4 66.0 \u00b1 0.1 72.8 \u00b1 0.3 WL 80.7 \u00b1 3.0 58.0 \u00b1 0.5 72.3 \u00b1 3.4 47.0 \u00b1 0.5 80.0 \u00b1 0.5 78.9 \u00b1 1.9 DGK 87.4 \u00b1 2.7 60.1 \u00b1 2.6 67.0 \u00b1 0.6 44.6 \u00b1 0.5 80.3 \u00b1 0.5 73.1 \u00b1 0.3 MLG 87.9 \u00b1 1.6 63.3 \u00b1 1.5 66.6 \u00b1 0.3 41.2 \u00b1 0.0 80.8 \u00b1 1.3 Supervised Approaches GraphSAGE 85.1 \u00b1 7.6 63.9 \u00b1 7.7 72.3 \u00b1 5.3 50.9 \u00b1 2.2 77.7 \u00b1 1.5 68.3 \u00b1 4.2 GCN 85.6 \u00b1 5.8 64.2 \u00b1 4.3 74.0 \u00b1 3.4 51.9 \u00b1 3.8 80.2 \u00b1 2.0 79.0 \u00b1 1.8 GIN-0 89.4 \u00b1 5.6 64.6 \u00b1 7.0 75.1 \u00b1 5.1 52.3 \u00b1 2.8 82.7 \u00b1 1.7 80.2 \u00b1 1.9 GIN-e 89.0 \u00b1 6.0 63.7 \u00b1 8.2 74.3 \u00b1 5.1 52.1 \u00b1 3.6 82.7 \u00b1 1.6 80.1 \u00b1 1.9 GAT 89.4 \u00b1 6.1 66.7 \u00b1 5.1 70.5 \u00b1 2.3 47.8 \u00b1 3.1 66.6 \u00b1 2.2 67.4 \u00b1 2.9 Unsupervised Approaches RandomWalk 83.7 \u00b1 1.5 57.9 \u00b1 1.3 50.7 \u00b1 0.3 34.7 \u00b1 0.2 64.3 \u00b1 0.3 node2vec 72.6 \u00b1 10.2 58.6 \u00b1 8.0 50.2 \u00b1 0.9 36.0 \u00b1 0.7 54.9 \u00b1 1.6 56.1 \u00b1 0.2 sub2vec 61.1 \u00b1 15.8 60.0 \u00b1 6.4 55.3 \u00b1 1.5 36.7 \u00b1 0.8 52.8 \u00b1 1.5 graph2vec 83.2 \u00b1 9.6 60.2 \u00b1 6.9 71.1 \u00b1 0.5 50.4 \u00b1 0.9 75.4 \u00b1 1.2 InfoGraph 89.0 \u00b1 1.1 61.7 \u00b1 1.4 73.0 \u00b1 0.9 49.7 \u00b1 0.5 76.2 \u00b1 1.4 70.7 \u00b1 1.1 GraphCL 86.8 \u00b1 1.3 61.3 \u00b1 2.1 71.1 \u00b1 0.4 49.2 \u00b1 0.6 77.9 \u00b1 0.4 71.4 \u00b1 1.2 mvgrl 89.7 \u00b1 1.1 62.5 \u00b1 1.7 74.2 \u00b1 0.7 51.2 \u00b1 0.5 77.0 \u00b1 0.8 76.0 \u00b1 1.2 InfoGCL 91.2 \u00b1 1.3 63.5 \u00b1 1.5 75.1 \u00b1 0.9 51.4 \u00b1 0.8 80.2 \u00b1 0.6 80.0 \u00b1 1.3 Table 2: Graph classi\ufb01cation results (%). Method Cora Citeseer Pubmed Supervised Approaches MLP 55.1 46.5 71.4 ICA 75.1 69.1 73.9 LP 68.0 45.3 63.0 ManiReg 59.5 60.1 70.7 SemiEmb 59.0 59.6 71.7 Planetoid 75.7 64.7 77.2 Chebyshev 81.2 69.8 74.4 GCN 81.5 70.3 79.0 JKNet 82.7 \u00b1 0.4 73.0 \u00b1 0.5 77.9 \u00b1 0.4 GAT 83.0 \u00b1 0.7 72.5 \u00b1 0.7 79.0 \u00b1 0.3 Unsupervised Approaches Linear 47.9 \u00b1 0.4 49.3 \u00b1 0.2 69.1 \u00b1 0.3 DeepWalk 70.7 \u00b1 0.6 51.4 \u00b1 0.5 74.3 \u00b1 0.9 GAE 71.5 \u00b1 0.4 65.8 \u00b1 0.4 72.1 \u00b1 0.5 VERSE 72.5 \u00b1 0.3 55.5 \u00b1 0.4 DGI 83.8 \u00b1 0.5 72.0 \u00b1 0.6 77.9 \u00b1 0.3 GraphCL 82.5 \u00b1 0.1 73.1 \u00b1 0.2 mvgrl 86.8 \u00b1 0.5 73.3 \u00b1 0.5 80.1 \u00b1 0.7 InfoGCL 83.5 \u00b1 0.3 73.5 \u00b1 0.4 79.1 \u00b1 0.2 Table 3: Node classi\ufb01cation results (%). graph classi\ufb01cation results. We observe that our approach achieves the best results compared to other unsupervised approaches. Our approach also outperforms or matches the best kernel approaches across the datasets. Even compared with the supervised ones, our approach achieves the best in 2 out of 6 datasets and the results of our approach on other 4 dataset are among the top. For node classi\ufb01cation tasks, we compare InfoGCL with some supervised approaches and unsupervised approaches. The supervised baselines include a simple MLP model, iterative classi\ufb01cation algorithm (ICA) [19], manifold regularization (ManiReg) [1], semi-supervised embedding (SemiEmb) [35], Planetoid [41], Chebyshev [5], GCN, JKNet [36], GAT. Table 3 shows the node classi\ufb01cation results. It is observed that our approach achieves the state-of-the-art results and competes the best one with respect to the existing unsupervised approaches. Compared to supervised baselines, our approach outperforms all the baselines. 8 \fMethod MUTAG IMDB-B COLLAB Cora Citeseer Pubmed InfoGCL (w/o neg) 91.0 \u00b1 1.4 75.1 \u00b1 0.5 80.2 \u00b1 1.0 78.6 \u00b1 0.4 70.4 \u00b1 0.6 77.4 \u00b1 0.7 InfoGCL (w/ neg) 91.2 \u00b1 1.3 75.1 \u00b1 0.9 80.0 \u00b1 1.3 83.5 \u00b1 0.3 73.5 \u00b1 0.4 79.1 \u00b1 0.2 Table 4: Comparison between InfoGCL with negative samples and without negative samples. 5.3 Evaluation of InfoGCL Principle We can unify the existing graph contrastive learning methods through the perspective of InfoGCL principle: all recent graph contrastive learning methods can be decoupled into three stages that implicitly follow the InfoGCL principle, though being different in model architecture design and optimization strategies. Below, we analyze some observations from several recent work. Because of the limited space, please refer to the Appendix for more results of the quantitative analysis. Obs. i. Composing a graph and its augmentation bene\ufb01ts downstream performance [42]. Compared to composing a graph and the graph itself, augmentation leads to smaller I(vi; vj) (Proposition 1). Obs. ii. Composing different augmentations bene\ufb01ts more [42]. Compared to composing a graph and its augmentations, two augmentations further decrease I(vi; vj) (Proposition 1). Obs. iii. Node dropping and subgraph sampling are generally bene\ufb01cial across datasets [42]. When compared to attribute masking and edge perturbation, they change the semantic meaning of the graph relatively slightly, which leads to higher I(vi; y), I(vj; y) (Proposition 1). Obs. iv. Edge perturbation bene\ufb01ts social networks but hurts some biochemical molecules [42]. The semantic meaning of social networks are robust to edge perturbation. However, the semantic meaning of some biochemical molecules are determined by local connection pattern, where edge perturbation decreases I(vi; y) (Proposition 1). Obs. v. Contrasting node and graph representations consistently performs better than other contrastive modes across benchmarks [13]. Compared to other contrastive modes, node-graph (i.e., local-global) mode generally extracts more graph structure information, which bene\ufb01ts predicting task label y (Proposition 3). 5.4 Effect of Negative Samples To study the effect of negative samples on graph contrastive learning, we follow SimSiam [4] and design the objective as Eq. (9). We conduct experiments on three graph task and three node task datasets. The results are reported in Table 4. It is observed that the negative samples show little in\ufb02uence on the three graph task datasets, while performance drops on the three node task datasets, especially the Cora dataset. According to the dataset statistics summarized in Table 1, we see the networks of Cora, Citeseer, Pubmed are much sparser (in terms of network topology). Furthermore, we know the node features of these three datasets are also much sparser (one-hot encoding with high dimensionality). We speculate this because the contrastive learning models tends to collapse easier if negative samples are not used, especially when data is too sparse. Therefore,we make the hypothesis: negative samples bene\ufb01t graph modeling, especially when i) network topology, and ii) node features are extremely sparse. 6"
+                },
+                {
+                    "url": "http://arxiv.org/abs/2104.08682v2",
+                    "title": "Rethinking Network Pruning -- under the Pre-train and Fine-tune Paradigm",
+                    "abstract": "Transformer-based pre-trained language models have significantly improved the\nperformance of various natural language processing (NLP) tasks in the recent\nyears. While effective and prevalent, these models are usually prohibitively\nlarge for resource-limited deployment scenarios. A thread of research has thus\nbeen working on applying network pruning techniques under the\npretrain-then-finetune paradigm widely adopted in NLP. However, the existing\npruning results on benchmark transformers, such as BERT, are not as remarkable\nas the pruning results in the literature of convolutional neural networks\n(CNNs). In particular, common wisdom in pruning CNN states that sparse pruning\ntechnique compresses a model more than that obtained by reducing number of\nchannels and layers (Elsen et al., 2020; Zhu and Gupta, 2017), while existing\nworks on sparse pruning of BERT yields inferior results than its small-dense\ncounterparts such as TinyBERT (Jiao et al., 2020). In this work, we aim to fill\nthis gap by studying how knowledge are transferred and lost during the\npre-train, fine-tune, and pruning process, and proposing a knowledge-aware\nsparse pruning process that achieves significantly superior results than\nexisting literature. We show for the first time that sparse pruning compresses\na BERT model significantly more than reducing its number of channels and\nlayers. Experiments on multiple data sets of GLUE benchmark show that our\nmethod outperforms the leading competitors with a 20-times weight/FLOPs\ncompression and neglectable loss in prediction accuracy.",
+                    "authors": "Dongkuan Xu, Ian E. H. Yen, Jinxi Zhao, Zhibin Xiao",
+                    "published": "2021-04-18",
+                    "updated": "2022-01-16",
+                    "primary_cat": "cs.CL",
+                    "cats": [
+                        "cs.CL",
+                        "cs.AI"
+                    ],
+                    "main_content": "Introduction Pre-trained language models, such as BERT (Devlin et al., 2019), become the standard and effective methods for improving the performance of a variety 1The code and models are publicly available at https:// github.com/DerronXu/SparseBERT. The work was done during an internship at Moffett AI. of natural language processing (NLP) tasks. These models are pre-trained in a self-supervised fashion and then \ufb01ne-tuned for supervised downstream tasks. However, these models suffer from the heavy model size, making them impractical for resourcelimited deployment scenarios and incurring cost concerns (Strubell et al., 2019). In parallel, an emerging sub\ufb01eld has studied the redundancy in deep neural network models (Zhu and Gupta, 2017; Gale et al., 2019) and proposed to prune networks without sacri\ufb01cing performance, such as the lottery ticket hypothesis (Frankle and Carbin, 2019). Common wisdom in CNN literature shows that sparse pruning leads to more compression rate than structural pruning. For example, for the same number of parameters (0.46M), the sparse MobileNets improve by 11.2% accuracy over the dense ones (Zhu and Gupta, 2017). However, similar conclusions are not observed for pre-trained language models. The main question this paper attempts to answer is: how to perform sparse pruning under the pre-train and \ufb01ne-tune paradigm? Answering this question correctly is challenging. First, these models adopt pre-training and \ufb01ne-tuning procedures, during which the general-purpose language knowledge and the task-speci\ufb01c knowledge are learned respectively. Thus, it is desirable and challenging to keep the weights that are important to both knowledge during pruning. Second, unlike CNNs, pre-trained language models have a complex architecture consisting of embedding, self-attention, and feed-forward layers. To address these challenges, we propose SparseBERT, a knowledge-aware sparse pruning method for pre-trained language models, with a special focus on the widely used BERT model. SparseBERT is executed in the \ufb01ne-tuning stage. It preserves both general-purpose and task-speci\ufb01c language knowledge while pruning. To preserve the generalpurpose knowledge learned during pre-training, arXiv:2104.08682v2  [cs.CL]  16 Jan 2022 \f!\", $\" L Pre-Training !%, $% &' \u2192&') D Fine-Tuning Domain Error !*, $* LD + D Testing Genera. Error !\", $\" & \u2192&' L Pre-Training !%, $% &' \u2192&') D Fine-Tuning Domain Error !*, $* D Testing Genera. Error !\", $\" L Pre-Training !%, $% D Fine-Tuning Domain Error !*, $* L+, + D Testing Genera. Error &'./ \u2192& './ ) & \u2192&'./ !\", $\" & \u2192&' L Pre-Training !%, $% &' \u2192&') D Fine-Tuning !*, $* L+, + D Testing Genera. Error !%, $% & ') ./ D Distilling Domain Error & \u2192&' (a) General Pre-Training & Fine-Tuning !\", $\" L Pre-Training !%, $% &' \u2192&') D Fine-Tuning Domain Error !*, $* LD + D Testing Genera. Error !\", $\" & \u2192&' L Pre-Training !%, $% &' \u2192&') D Fine-Tuning Domain Error !*, $* D Testing Genera. Error !\", $\" L Pre-Training !%, $% D Fine-Tuning Domain Error !*, $* L+, + D Testing Genera. Error &'./ \u2192& './ ) & \u2192&'./ !\", $\" & \u2192&' L Pre-Training !%, $% &' \u2192&') D Fine-Tuning !*, $* L+, + D Testing Genera. Error !%, $% & ') ./ D Distilling Domain Error & \u2192&' (b) Pruning at Fine-Tuning !\", $\" L Pre-Training !%, $% &' \u2192&') D Fine-Tuning Domain Error !*, $* LD + D Testing Genera. Error !\", $\" & \u2192&' L Pre-Training !%, $% &' \u2192&') D Fine-Tuning Domain Error !*, $* D Testing Genera. Error !\", $\" L Pre-Training !%, $% D Fine-Tuning Domain Error !*, $* L+, + D Testing Genera. Error &'./ \u2192& './ ) & \u2192&'./ !\", $\" & \u2192&' L Pre-Training !%, $% &' \u2192&') D Fine-Tuning !*, $* L+, + D Testing Genera. Error !%, $% & ') ./ D Distilling Domain Error & \u2192&' (c) Pruning at Pre-training L L!\" L# L \u226bL!\" L \u226bL# L# !\" %& '())( L# \u2229L# !\" \u226b L# !\" /0, 20 3 \u219235 L Pre-Training /6, 26 35 \u2192357 D Fine-Tuning /8, 28 L# !\" + D Testing Genera. Error /6, 26 Teacher = 357 Student = 35 \u21923 57 9: D Distilling Domain Error (d) Pruning at Distilling (Proposed) Figure 1: How knowledge is transferred under different pruning strategies. (a) is the general pre-training and \ufb01ne-tuning procedure (Section 3.1). g is an encoder. gL and gLD are the encoders well-trained on the pre-training and \ufb01ne-tuning datasets respectively. L and D are the general-purpose language knowledge and the task-speci\ufb01c knowledge respectively. There is a domain error between pre-training and testing, and a generalization error between \ufb01ne-tuning and testing. (b) and (c) are two basic pruning strategies (Section 3.2.1). Both LD and Lpr are subsets of knowledge L. LD is related to the downstream task. Lpr is preserved in a pruned encoder gLpr. (d) is the proposed pruning strategy (Sections 3.2.2-3.2.3). (Lpr)D refers to the knowledge obtained by \ufb01rst pruning and then \ufb01ne-tuning. (LD)pr corresponds to \ufb01rst \ufb01ne-tuning and then pruning while distilling. L L!\" L# L \u226bL!\" L \u226bL# L# !\" %& '())(* )+,L!\" # L# \u2229L# !\" \u226bL# \u2229L!\" L# !\" /0, 20 3 \u219235 L Pre-Training /6, 26 35 \u2192357 D Fine-Tuning /8, 28 L# !\" + D Testing Genera. Error /6, 26 Teacher = 357 Student = 35 \u21923 57 9: D Distilling Domain Error (a) Knowledge Relationship L!\" L# L \u226bL!\" L \u226bL# L# !\" %& '())(* )+,L!\" # L# \u2229L# !\" \u226bL# \u2229L!\" L# !\" /0, 20 3 \u219235 L Pre-Training /6, 26 35 \u2192357 D Fine-Tuning /8, 28 L# !\" + D Testing Genera. Error /6, 26 Teacher = 357 Student = 35 \u21923 57 9: D Distilling Domain Error (b) Why Distilling Figure 2: Knowledge Analysis. SparseBERT uses the pre-trained BERT without \ufb01ne-tuning as the initialized model and prunes the linear transformations in self-attention and feedforward layers, which is inspired by the recent \ufb01ndings that self-attention and feed-forward layers are overparameterized (Michel et al., 2019; Voita et al., 2019) and are also the most computation consumption parts (Ganesh et al., 2020). To learn the task-speci\ufb01c task knowledge during pruning while preserving the general-purpose knowledge at the same time, we apply knowledge distillation (Hinton et al., 2015). We adopt the task-speci\ufb01c \ufb01ne-tuned BERT as the teacher network and the pre-trained BERT that is being pruned as the student. We feed the downstream task data into the teacher-student framework to train the student to reproduce the behaviors of the teacher. We summarize different types of BERT pruning approaches in Figure 1 (see Section 3.2 for detailed discussion) Experimental results on the GLUE benchmark demonstrate that SparseBERT outperforms all the leading competitors and achieves 1.4% averaged loss with down to only 5% remaining weights compared to BERT-base. 2 Related Work A lot of efforts have been made on studying network redundancy and pruning networks without accuracy loss (Gale et al., 2019; Renda et al., 2020). For example, the work on lottery ticket hypothesis (Frankle and Carbin, 2019) showed that there exist sparse smaller subnetworks capable of training to full accuracy in CNNs. Common wisdom in CNN literature shows that spare pruning leads to much more compression rate than structural pruning (Gale et al., 2019; Elsen et al., 2020). For example, for the same number of parameters (0.46M), the sparse MobileNets achieve 61.8% accuracy while the dense ones achieve 50.6% (Zhu and Gupta, 2017). However, similar observations are not observed in existing approaches for pretrained language models (Fan et al., 2019; Michel et al., 2019; Chen et al., 2020; McCarley et al., 2020; Jiao et al., 2020). Our method aims to \ufb01ll the gap and summarize these pruning strategies. There are other compression approaches for pre-trained language models, such as quantization (Zafrir et al., 2019) and weight factorization (Wang et al., 2019), which are out of the scope of this work. \f3 SparseBERT We \ufb01rst formalize the knowledge transfer involved in \ufb01ne-tuning pre-trained language models. Then, we introduce our SparseBERT. 3.1 Knowledge Transfer under the Pre-train and Fine-tune Paradigm The practice of \ufb01ne-tuning pre-trained language models has become prevalent in various NLP tasks. The two-stage procedure is illustrated in Figure 1(a). The language model is denoted by f = g \u25e6h, where g is a text encoder and h is a task predictor head. Text encoders, like Transformers in BERT, are used to map input sentences to hidden representations and task predictors further map the representations to the label space. The pre-trained model is trained on a large amount of data examples (xp, yp) from the pre-training task domain via different tasks that resemble language modeling. During pre-training, the general-purpose language knowledge, denoted by L, is learned based on (xp, yp). L contains a subset that is related to the downstream task, denoted by LD, and the amount of L is far greater than that of LD (see Figure 2(a)). To transfer knowledge L (especially LD) from pre-training domain to downstream domain, the well-trained encoder gL is used to initialize the downstream encoder. In \ufb01ne-tuning, downstream encoder is trained based on the task-speci\ufb01c knowledge D preserved in a small amount of data examples (xd, yd) from downstream domain. Finally, the well-trained downstream encoder gLD is evaluated on test data. 3.2 Knowledge-Aware Compression 3.2.1 Two Basic Pruning Strategies Intuitively, there are two pruning strategies. One is that pruning is applied to the downstream encoder gL during \ufb01ne-tuning (see Figure 1(b)). However, because the loss to update the weights during \ufb01netuning is exclusively based on the data examples (xd, yd) from the downstream task domain, this pruning strategy might destruct the knowledge LD, which is learned based on (xp, yp) and encoded in the initialization of gL. The other strategy is that pruning is executed during pre-training (see Figure 1(c)). The generated pruned network preserves a subset of knowledge L, denoted by Lpr. Unfortunately, because this strategy ignores the downstream task information and the amount of L is extremely large, i.e., L \u226bLpr, the knowledge Lpr could be much different from LD that we hope to preserve (see Figure 2(a)). 3.2.2 The Proposed Pruning Strategy As shown in Figure 1(d), SparseBERT executes pruning at the distilling stage. It prunes the pretrained encoder without \ufb01ne-tuning, gL, while \ufb01netuning the pruned encoder based on the downstream dataset (xd, yd). Recent \ufb01ndings indicate that self-attention and feed-forward layers are overparameterized and are the most computation consumption parts (Michel et al., 2019; Voita et al., 2019; Ganesh et al., 2020). Thus, SparseBERT applies network pruning to the linear transformations matrices in self-attention and feed-forward layers (see Figure 3). The choice of pruning approach is \ufb02exible. We choose magnitude weight pruning (Han et al., 2015) in this paper, mainly because it is one of the most effective and popular pruning methods. More details about the pruning strategy used in SparseBERT can be found in the codes. 3.2.3 Knowledge Distillation Helps Pruning Preserve Task-Speci\ufb01c Knowledge To mitigate the loss of LD, we propose to utilize knowledge distillation while pruning. We use the task-speci\ufb01c \ufb01ne-tuned BERT as the teacher network and the pre-trained BERT that is being pruned as the student (see Figure 1(d) and Figure 3). The motivation is that the task-speci\ufb01c \ufb01ne-tuned BERT preserves LD. By feeding downstream task data (xd, yd) into the teacher-student framework, we help the student reproduce the behaviors of the teacher to learn both Ld and L as much as possible. We design the distillation loss as Ldistil = Lemb + Latt + Lhid + Lprd. (1) Lemb = MSE(ES, ET ) is the difference between the embedding layers of student and teacher. Latt = PMSE(AS i , AT i ) is the difference between attention matrices and i is the layer index. Lhid = PMSE(HS i , HT i ) is the difference between hidden representations. Lprd = -softmax(zT ) \u00b7 log_softmax(zS/temp) is the soft cross-entropy loss between the logits of student and teacher. temp represents the temperature value. The proposed distillation loss is inspired by (Jiao et al., 2020) and it helps the student imitate the teacher\u2019s behavior as much as possible. In addition, we perform the same data augmentation as (Jiao et al., 2020) does to generate more task-speci\ufb01c data for teacher-student \fSelf-Attention Add LayerNorm Feedforward Feedforward Gelu Add LayerNorm Embedding Layer Output Layer Output Input Knowledge Distillation Block (light purple) repeats multiple times Pruned Layers Teacher Network: finetuned BERT Student Network: pretrained BERT Self-Attention Add LayerNorm Feedforward Feedforward Gelu Add LayerNorm Embedding Layer Output Layer Output Input Knowledge Distillation Knowledge Distillation Knowledge Distillation Figure 3: Illustration of the proposed knowledge-aware compression. Pruning is performed in parallel with distillation, based on speci\ufb01c data from downstream tasks. learning. Notably, the choices of distillation loss and data augmentation method are \ufb02exible and we found the ones we adopted worked well in general. 4 Experiments 4.1 GLUE Benchmark We evaluate SparseBERT on four data sets from the GLUE benchmark (Wang et al., 2018). To test if SparseBERT is applicable across tasks, we include the tasks of both single sentence and sentence-pair classi\ufb01cation. We report the results on dev sets. We run 3, 20, 20, 50 epochs for QNLI, MRPC, RTE, CoLA separately. The baselines include BERTbase, ELMo (Peters et al., 2018), BERT-PKD (Sun et al., 2019), Bert-of-Theseus (Xu et al., 2020), DistilBERT (Sanh et al., 2019), MiniLM (Wang et al., 2020), TinyBERT (Jiao et al., 2020), BERTTickets (Chen et al., 2020), CompressBERT (Gordon et al., 2020), and RPP (Guo et al., 2019). The results are shown in Table 1. Compared to BERT-base, SparseBERT achieves 1.4% averaged performance loss with down to 5% weights. In addition, SparseBERT outperforms all leading competitors with the highest sparsity. 4.2 SparseBERT v.s. Pruning at Downstream We compare SparseBERT with the pruning described in Figure 1(b) on the question answer tasks of SQuAD v1.1 and v2.0 (Rajpurkar et al., 2016, 2018). Given a question and a passage containing Method Remain. QNLI MRPC RTE CoLA Avg. Weights (Acc) (F1) (Acc) (Mcc) Without Pruning BERT-base 91.8 88.6 69.3 56.3 76.5 ELMo 71.1 76.6 53.4 44.1 61.3 Structural Pruning BERT6-PKD 50% 89.0 85.0 65.5 45.5 71.3 BERT-of-Theseus 50% 89.5 89.0 68.2 51.1 74.5 DistilBERT 50% 89.2 87.5 59.9 51.3 72.0 MiniLM6 50% 91.0 88.4 71.5 49.2 75.0 TinyBERT6 50% 90.4 87.3 66.0 54.0 74.4 TinyBERT4 18% 88.7 86.8 66.5 49.7 72.9 Sparse Pruning BERT-Tickets 30-50% 88.9 84.9 66.0 53.8 73.2 CompressBERT 10% 76.8 RPP 11.6% 88.0 81.9 67.5 SparseBERT 5% 90.6 88.5 69.1 52.1 75.1 Table 1: Comparison on the dev sets of GLUE. the answer, the two tasks are to predict the answer text span in the passage. The difference between them is that SQuAD v2.0 allows for the possibility that no short answer exists in the passage. We follow the general setting of SparseBERT, except that we only apply the logit distillation, i.e., Ldistil = Lprd, and do not perform data augmentation, which are the most common distillation strategies. The results are shown in Figure 4. It is observed that SparseBERT consistently outperforms the baseline method, especially at high sparsity. The performance gain of SparseBERT decreases on SQuAD v2.0 mainly because SQuAD v2.0 is more challenging than SQuAD v1.1. These observations demonstrate advantage of SparseBERT compared to pruning at downstream. \f(a) SQuAD v1.1. (b) SQuAD v2.0. Figure 4: Performance comparison of SparseBERT and the pruning approach described in Figure 1(b). 4.3 SparseBERT v.s. Pruning at Pre-Training To get more insights about the advantage of SparseBERT over the pruning described in Figure 1(c), we compare their \ufb01tting abilities. Speci\ufb01cally, we use TinyBERT as an example of the baseline pruning method. We compare SparseBERT with TinyBERT with 4 layers and 312 hidden dimensions, which has a similar number of parameters as SparseBERT (sparsity=95%). SparseBERT only distills knowledge from the same layers as TinyBERT does. We vary the number of pruning epochs and report the results (loss on training set and accuracy on dev set) on RTE in Figure 5. It is observed that SparseBERT consistently shows smaller training loss while higher evaluation performance, which demonstrates that SparseBERT has a better \ufb01tting ability when pruning compared to the baseline. (a) Loss (training set). (b) Performance (dev set). Figure 5: Fitting ability comparison of SparseBERT and the pruning approach described in Figure 1(c). 5 Discussion 5.1 Hardware Performance Sparse networks were not hardware-friendly in the past. However, hardware platforms with sparse tensor operation support have been rising up. For example, the latest release of Nvidia high-end GPU A100 has native support of sparse tensor operation up to 2x compression rate, while startup company such as Moffett AI has developed computing platform with sparse tensor operation acceleration up to 32x compression rate. Figure 6: Hardware performance under different compression ratios on the MRPC dataset, with 818, 1594, 3029, 5508, 9326, and 10826 SPS (sentences per second) respectively. Here we deployed SparseBERT of different sparse compression ratios (1, 2, 4, 8, 16, 20) on Moffett AI\u2019s latest hardware platform ANTOM to measure the real inference speedup induced by sparse compression, where \u20184\u2019 indicates the model is compressed by a factor of 4, with 75% of the parameters being zeros. As shown in Figure 6, the sparse compression has almost linear speedup up to 4x and leads to more than 10x speedup when compression rate is 20x. 5.2 Reduction of Parameters and FLOPS We studied the reduction of parameters and FLOPS. For example, on the MRPC dataset, BERT-base (backbone) vs SparseBERT (backbone) = 85.53 vs 4.84 (#parameters, M) and BERT-base vs SparseBERT = 10.87 vs 0.54 (GFLOPS). 5.3 Inference/Training Time We studied the time and convergence speed. For example, to get the reported 20x pruned result (Table 1), it needed 12 epochs of \ufb01ne-tuning on MRPC and each epoch took 1.5 h (two RTX 2080 Ti). The inference time was around 20 s. 6"
+                }
+            ],
+            "Tianchi Zhang": [
+                {
+                    "url": "http://arxiv.org/abs/2109.02904v1",
+                    "title": "Numerical convergence of pre-initial conditions on dark matter halo properties",
+                    "abstract": "Generating pre-initial conditions (or particle loads) is the very first step\nto set up a cosmological N-body simulation. In this work, we revisit the\nnumerical convergence of pre-initial conditions on dark matter halo properties\nusing a set of simulations which only differs in initial particle loads, i.e.\ngrid, glass, and the newly introduced capacity constrained Voronoi tessellation\n(CCVT). We find that the median halo properties agree fairly well (i.e. within\na convergence level of a few per cent) among simulations running from different\ninitial loads. We also notice that for some individual haloes cross-matched\namong different simulations, the relative difference of their properties\nsometimes can be several tens of per cent. By looking at the evolution history\nof these poorly converged haloes, we find that they are usually merging haloes\nor haloes have experienced recent merger events, and their merging processes in\ndifferent simulations are out-of-sync, making the convergence of halo\nproperties become poor temporarily. We show that, comparing to the simulation\nstarting with an anisotropic grid load, the simulation with an isotropic CCVT\nload converges slightly better to the simulation with a glass load, which is\nalso isotropic. Among simulations with different pre-initial conditions, haloes\nin higher density environments tend to have their properties converged slightly\nbetter. Our results confirm that CCVT loads behave as well as the widely used\ngrid and glass loads at small scales, and for the first time we quantify the\nconvergence of two independent isotropic particle loads (i.e. glass and CCVT)\non halo properties.",
+                    "authors": "Tianchi Zhang, Shihong Liao, Ming Li, Jiajun Zhang",
+                    "published": "2021-09-07",
+                    "updated": "2021-09-07",
+                    "primary_cat": "astro-ph.CO",
+                    "cats": [
+                        "astro-ph.CO",
+                        "astro-ph.GA"
+                    ],
+                    "main_content": "INTRODUCTION Cosmological N-body simulations are one of the most crucial tools in cosmology to study the formation of structures in the universe (see e.g. Frenk & White 2012; Kuhlen, Vogelsberger & Angulo 2012, for reviews). To prepare an initial condition for a largevolume cosmological N-body simulation, the \ufb01rst step is to generate a homogeneous distribution of N particles. This uniform particle distribution is usually named a pre-initial condition or a particle load1. There are several known methods to prepare a pre-initial condition: (i) The grid (or simple cubic lattice) load (e.g. Efstathiou et al. 1985) simply places N particles in a regular grid, and it is uniform but anisotropic (see Joyce, Marcos & Baertschiger 2009, for considerations on other related Bravais lattice con\ufb01gurations, e.g. body-centred cubic and face-centred cubic). (ii) The glass \u22c6Email: tczhang@bjp.org.cn 1 Note that we use these two terms interchangeably in this article. method (White 1996) starts from a random distribution of N particles, and then evolves the whole con\ufb01guration under anti-gravity until it reaches an equilibrium state (see Couchman, Thomas & Pearce 1995, for a similar consideration of relaxing smoothed particle hydrodynamics (SPH) particles at constant entropy under the in\ufb02uence of gas pressure until all particles have roughly equal SPH densities). The glass pre-initial condition is homogeneous and isotropic. (iii) The Q-set method (Hansen et al. 2007) partitions the space recursively using the quaquaversal tiling and places a particle in each quaquaversal tile. Note that the total particle number of a Q-set con\ufb01guration is restricted to 2 \u00d7 8Niter, with Niter being the number of iterations. A Q-set con\ufb01guration with \ufb01nite particle number is not essentially isotropic, but it approaches the condition of isotropy in a statistical sense with large Niter (see Hansen et al. 2007, for detailed discussions). (iv) Recently, Liao (2018) adopts the capacity constrained Voronoi tessellation (CCVT) from computer graphics to generate a particle con\ufb01guration which satis\ufb01es two constraints, i.e. the volume of each particle\u2019s Voronoi cell is equal and each particle resides in the centre-of-mass position of \u00a9 0000 The Authors arXiv:2109.02904v1  [astro-ph.CO]  7 Sep 2021 \f2 Zhang et al. its Voronoi cell. It is shown in Liao (2018) that a CCVT con\ufb01guration is uniform and isotropic. The CCVT pre-initial conditions have been used in simulations of interacting dark energy models (Zhang et al. 2018). Quantifying and understanding the impacts of numerical setups on physical results is an essential task for simulation studies. Many previous studies have investigated the impacts of pre-initial conditions on the formation and evolution of large-scale structures by performing cosmological N-body simulations starting from grid, glass, and Q-set loads. For example, Baugh, Gaztanaga & Efstathiou (1995) use cosmological simulations starting from grid and glass loads to study the discreteness effects on two-point correlation functions and power spectra for the matter distribution. These authors \ufb01nd that at early times, glass simulations show higher correlation functions on small scales than grid simulations, but such small discrepancies become negligible at later times. These observations are qualitatively con\ufb01rmed by Joyce et al. (2009), who further quantify that the impacts of pre-initial conditions on matter power spectra at scales around the Nyquist frequency are at per cent levels (see also Smith et al. 2003 and L\u2019Huillier, Park & Kim 2014). Apart from the aforementioned two-point statistics, halo mass functions and pairwise velocities have also been shown to converge at a level of several per cent among simulations starting from grid and glass particle loads (see e.g. L\u2019Huillier et al. 2014; Liao 2018). Schmittfull, Regan & Shellard (2013) show that at z \u22723, the bispectra measured from grid and glass simulations also converge at per cent levels. Different particle loads would also produce spurious structures in \ufb01laments in warm/hot dark matter simulations, these effects have been addressed by e.g. G\u00a8 otz & Sommer-Larsen (2002, 2003) and Wang & White (2007). Especially Wang & White (2007) disfavor the use of Q-set loads by showing that the spurious low-mass structures produced in hot dark matter simulations with the Q-set load are more abundant and more complex than the cases with grid and glass loads. Recently Masaki, Nishimichi & Takada (2021) study the impacts of pre-initial conditions on the anisotropic separate universe simulations, by studying the tidal response function caused by the supersurvey modes. They show that the grid load can produce arti\ufb01cial features which can be seen until z \u223c9 while the simulations of glass loads are more stable and accurate over the interested range of scales. But the impacts of pre-initial conditions become negligible at z \u2a7d3 in their simulations. In this work, with the newly introduced uniform and isotropic CCVT particle load, we revisit the study of numerical convergence for pre-initial conditions. Liao (2018) has shown that the largescale statistics (e.g. power spectrum, two-point correlation function, pairwise velocity and halo mass function) converge at per cent level among simulations starting from grid, glass and CCVT loads. Here we extend the work of Liao (2018) to study the numerical convergence of pre-initial conditions on small-scale halo properties. We would like to quantify how well CCVT simulations converge to the widely used grid and glass simulations at small scales. Especially, CCVT and glass are two independent isotropic pre-initial conditions, for the \ufb01rst time we are able to quantify the convergence of isotropic pre-initial conditions, and to compare it with the convergence between grid and glass which has been studied before. As we will show below, when looking at halo properties, CCVT simulations converge slightly better to glass simulations compared to their convergence to grid simulations. The goal of this work is to study the numerical convergence (i.e. the agreement between different simulations) instead of the physical convergence (i.e. the agreement between the simulation results and the absolute physical results which are independent of numerical setups and parameters). Although the latter is of ultimate interest, currently we still lack analytical tools to precisely study the physical convergence in the nonlinear structure formation process (but see e.g. Joyce et al. 2005; Marcos et al. 2006, for the introduction of analytical tools to study the discreteness effects on the evolution of power spectrum). The structure of this paper is as follows. We describe the details of our simulations, halo identi\ufb01cations and computations of halo properties in Section 2. In Section 3, we present the convergence results of halo properties from simulations with different pre-initial conditions, and the environmental dependence of convergence results. We conclude and summarise in Section 4. Not to make the results too tedious, we list some examples and discussions on the numerical convergence of halo masses, centres and other properties in Appendices A and B. 2 NUMERICAL METHODS 2.1 Simulations We use the GADGET-2 code (Springel 2005) to perform three cosmological N-body simulations starting from three different preinitial conditions, i.e. grid, glass and CCVT2. The glass load containing 643 particles is prepared using the GADGET-2 code, while the CCVT pre-initial condition containing 643 particles is from Liao (2018) with a capacity parameter of 203. Our adopted cosmological parameters are \u2126m = 0.3,\u2126\u039b = 0.7,\u03c38 = 0.9,h = 0.7 and ns = 0.96. The initial conditions are generated at redshift z = 127 using the N-GENIC code and the input matter power spectra are from Eisenstein & Hu (1998). Each simulation contains Np = 5123 dark matter particles in a periodic cube with a side length of Lbox = 200 h\u22121Mpc. The mass resolution of each simulation is mp = 4.96\u00d7109 h\u22121M\u2299. The gravitational softening length is 7.81 h\u22121kpc (i.e. approximately 1/50 of the mean inter-particle separation), which is roughly the optimal softening length for the haloes studied in this work according to Zhang et al. (2019). There are 135 output snapshots (with a time interval of \u223c0.1 Gyr) in total for each simulation. Note that we input the same random seed in N-GENIC to generate the initial conditions for all three simulations, and thus we can cross-match haloes in these simulations which produce identical large-scale structures. We have also varied the random seed to perform two additional sets of simulation, and made sure that all our conclusions do not depend on simulation realizations. In the following sections, we will only present the results of the \ufb01rst realization set. Also note that both glass and CCVT particle loads are not unique and they can have different realizations. To study the impacts from different realizations of glass/CCVT loads, we have performed two additional simulations starting from a different glass realization (denoted as \u2018glass-1\u2019) and a different CCVT realization (denoted as \u2018CCVT-1\u2019). The glass-1 (CCVT-1) simulation and the aforementioned glass (CCVT) simulation only differ in the input particle load and otherwise they use the same parameters and setup. 2 Note that we do not consider the Q-set pre-initial condition here because its particle number is restricted to some speci\ufb01c numbers, it is not ideally isotropic, and it has been shown to perform worse than either a grid or a glass load (Wang & White 2007). MNRAS 000, 000\u2013000 (0000) \fConvergence of pre-ICs 3 Table 1. Number of haloes in different simulations. Halo sample Glass Grid CCVT ALL 2460 2481 2474 MATCHED 1192 1192 1192 MISMATCHED 1268 1289 1282 2.2 Halo identi\ufb01cation and cross matching Dark matter haloes are identi\ufb01ed by the friends-of-friends (FOF) algorithm (Davis et al. 1985) with a linking length parameter of 0.2 times the mean inter-particle separation. We further use the HBT+ halo \ufb01nder code (Han et al. 2018), which is an improved version of the HBT code (Han et al. 2012), to identify subhaloes with at least 20 particles from the FOF groups and construct the subhalo merging history. The halo centre is de\ufb01ned as the position of the most bound particle, r r rmin,pot, in each FOF group. The boundary of a halo is de\ufb01ned by the virial radius, R200, within which the mean density is 200 times the cosmic critical density. In this article, we use M200 and N200 to denote the halo virial mass and the halo total particle number inside R200 respectively. To achieve better numerical resolution for the halo sample, we only use haloes with N200 \u2a7e2000 (i.e. M200 \u2a7e9.9\u00d71012 h\u22121M\u2299) for analysis. In total we have 2460, 2481 and 2474 haloes in the glass, grid and CCVT simulations respectively (i.e. the \u2018ALL\u2019 sample in Table 1). To have one-to-one comparisons between haloes from different simulations, we have tried to cross-match the z = 0 haloes from three simulations by comparing their centre positions and virial masses. Taking glass haloes as reference, we \ufb01rst match haloes between the glass and grid simulations. Speci\ufb01cally, for each glass halo, we compute its relative centre offset and relative mass difference with respect to every grid halo, \u2206dist,i = \f \f \fr r rgrid,i min,pot \u2212r r rglass min,pot \f \f \f Rglass 200 , (1) and \u2206mass,i = \f \f \fMgrid,i 200 \u2212Mglass 200 \f \f \f Mglass 200 , (2) where r r rgrid,i min,pot and Mgrid,i 200 represent the centre and mass of the ith grid halo respectively, and r r rglass min,pot and Mglass 200 denote the centre and mass of the targeted glass halo respectively. The matched grid halo of this glass halo is de\ufb01ned as the one with the minimum \u22062 dist,i + \u22062 mass,i. Similarly, we can also match glass haloes to the CCVT haloes. We have also cross-matched the haloes in the simulations starting from different particle load realizations (i.e. glass-1 versus glass and CCVT-1 versus CCVT). The probability distribution functions (PDFs) of \u2206dist and \u2206mass for all matched haloes in both grid and CCVT simulations are shown in the upper panels of Fig. 1. As a comparison, we also overplot the results from the haloes matched in simulations starting from different load realizations (i.e. grey lines for glass-1 versus glass, and light blue lines for CCVT-1 versus CCVT). Grid and CCVT haloes have fairly similar PDFs for \u2206mass, with a median of \u223c0.03, and this convergence in halo mass among different particle loads is fairly similar to that among different realizations of the same load class. However, for \u2206dist, CCVT haloes are more skewed to lower values comparing to grid haloes. The median values of \u2206dist are 0.07 and 0.14 for CCVT and grid haloes, respectively. This indicates that CCVT haloes converge better to glass haloes in halo centres. Especially, the convergence in halo centres between CCVT and glass simulations is almost indistinguishable from that between different realizations of the glass (or CCVT) class. This implies that CCVT and glass loads share fairly similar properties in uniformity and isotropy. If a glass halo has both its grid and CCVT counterparts satisfying \u2206dist \u2a7d0.15and\u2206mass \u2a7d0.15 (3) at the same time, which indicates that the corresponding haloes in three simulations converge better than a level of 15% in both halo centre positions and virial masses, we classify this glass halo and its matched grid/CCVT counterparts into the MATCHED halo sample. In total, there are 1192 MATCHED haloes in each simulation. Then, the remaining haloes in each simulation are referred as MISMATCHED haloes. See Table 1 for the numbers of MATCHED and MISMATCHED haloes in different simulations. Note that we have followed similar criteria to de\ufb01ne the matched and mismatched halo samples between glass-1 and glass (also CCVT-1 and CCVT) simulations. We will compare the convergence among different particle loads with the convergence between different realizations of the same load class from time to time in the following sections. In the bottom panels of Fig. 1, we plot the mass dependence of \u2206dist and \u2206mass. Most of MISMATCHED haloes are low-mass haloes. However, we can also \ufb01nd that even some massive haloes are poorly converged in simulations with different pre-initial conditions. For example, two grid haloes with masses M200 > 1014.5 h\u22121M\u2299have \u2206dist > 0.15 and thus they are classi\ufb01ed as MISMATCHED haloes. We have examined the growth histories of these massive haloes, and found that they are usually either merging haloes which have their major merger events happened in signi\ufb01cantly different paces in different simulations or haloes in the relaxing process after recent major merger events which are outof-sync in different simulations. During these out-of-sync merging processes, the scaled centre offset and mass difference can be larger than the threshold of 15% temporarily (see Appendix A for further details and discussions). Note that, apart from the threshold of 0.15 which classi\ufb01es about half of the haloes in ALL sample as MATCHED haloes, we have also used other thresholds to de\ufb01ne the MATCHED halo sample (e.g. 0.1 and 0.2) and con\ufb01rmed that our main conclusions in this paper are not affected by these choices. In the rest of this paper, we will only present the results using the threshold of 0.15. 2.3 Computations of halo properties In this work, we will examine the impacts of pre-initial conditions on various halo properties at z = 0 including halo concentration, spin, maximum rotation velocity, radius corresponding to the maximum rotation velocity, shape, one-dimensional velocity dispersion, formation time, and subhalo mass fraction. These physical quantities have been widely used in the literature to quantify halo structures and properties, and they are important for us to understand the formation of haloes. We summarise the computation procedures of these halo properties as follows. (1) Halo concentration cNFW. For each halo, we compute its density pro\ufb01le in 20 equally logarithmic radius bins in the range of [0.05R200,R200], and \ufb01t the density pro\ufb01le with the Navarro-FrenkMNRAS 000, 000\u2013000 (0000) \f4 Zhang et al. 1 Figure 1. Top: Probability distribution functions of \u2206dist (left) and \u2206mass (right). We use blue and green colours to distinguish results from grid and CCVT simulations. The median values of \u2206dist or \u2206mass are shown in each panel accordingly. The pink vertical lines mark the threshold of 0.15 which we used to de\ufb01ne MATCHED haloes. As a comparison, we use grey (light blue) lines to overplot the PDFs of the relative centre offset and relative mass difference for simulations starting from two different glass (CCVT) realizations. Bottom: Halo mass dependence of \u2206dist (left) and \u2206mass (right). Again, the grid and CCVT simulations are plotted with blue and green colours respectively. The pink horizontal lines mark the threshold of 0.15. White (NFW) model (Navarro et al. 1996, 1997), \u03c1(r) = \u03c1s (r/rs)(1+r/rs)2 , (4) where \u03c1s and rs are free parameters. The halo concentration is then computed as cNFW = R200/rs. (2) Halo spin \u03bb. Following Bullock et al. (2001), the spin parameter is computed as \u03bb = J \u221a 2M200V200R200 , (5) where J is the magnitude of the total angular momentum J J J = \u2211N200 i=1 mp(r r ri \u2212r r rhalo,COM) \u00d7 (v v vi \u2212v v vhalo,COM), r r ri and v v vi are the ith particle\u2019s position and velocity vectors respectively, r r rhalo,COM and v v vhalo,COM denote the halo centre-of-mass position and velocity respectively, V200 \u2261 p GM200/R200 is the halo rotation velocity at R200 and G is the gravitational constant. (3) Halo maximum rotation velocity Vmax. Vmax is the maximum of the halo rotation curve, V(r) = r GM(< r) r , (6) where M(< r) is the enclosed mass within the halo radius r. (4) rmax. It marks the halo radius where the halo rotation curve reaches the maximum velocity (i.e. the aforementioned Vmax). (5) Halo shape. To measure halo shape, we \ufb01rst compute the tensor I\u03b1\u03b2 = N200 \u2211 i=1 \u0010 ri,\u03b1 \u2212r\u03b1 min,pot \u0011\u0010 ri,\u03b2 \u2212r\u03b2 min,pot \u0011 , (7) where \u03b1 and \u03b2 refer to x, y or z, ri,\u03b1 is the \u03b1-component of the ith particle\u2019s position vector, and r\u03b1 min,pot is the \u03b1-component of the halo centre position vector. We then compute the eigenvalues of I\u03b1\u03b2 , \u03bb1 \u2a7e\u03bb2 \u2a7e\u03bb3. The lengths of the halo major, mediate and minor axes are given by a = p \u03bb1, b = p \u03bb2 and c = p \u03bb3, respectively. In this work, we mainly present the results of the minor-tomajor axial ratio c/a. (6) Halo one-dimensional velocity dispersion \u03c3v. Following Evrard et al. (2008), we compute the one-dimensional velocity dispersion as \u03c3v = v u u t 1 3N200 N200 \u2211 i=1 |v v vi \u2212v v vhalo,COM|2. (8) (7) Halo formation time zf. The halo formation time is de\ufb01ned as the redshift when the halo main progenitor \ufb01rst reaches half of MNRAS 000, 000\u2013000 (0000) \fConvergence of pre-ICs 5 the virial mass at z = 0, i.e. M200(z = zf) = M200(z = 0)/2. In practice, we follow the main branch of a halo\u2019s merger tree, and \ufb01nd out the snapshot at which the mass of the main progenitor \ufb01rst exceeds M200(z = 0)/2, then the formation time is computed with a logarithmic interpolation between this snapshot and the previous one. (8) Subhalo mass fraction fsub. For each halo, we add up the masses of all resolved subhaloes (i.e. with at least 20 particles) within the halo virial radius, \u2211Msub, and compute the subhalo mass fraction as fsub = \u2211Msub/M200. 3 CONVERGENCE RESULTS 3.1 Convergence of median halo properties In this subsection, we study the convergence of median halo properties from simulations starting with different initial loads. In Figs 2 and 3, we plot the halo properties as a function of halo mass. From top to bottom, we show the halo concentration, spin, Vmax, rmax, axial ratio c/a, velocity dispersion, formation time, and subhalo mass fraction. From left to right columns, we show the results from ALL, MATCHED and MISMATCHED halo samples. For each halo property, in the upper panel, the scatter points show the halo property halo mass relation for all haloes in the sample while the large dots with error bars plot the median relation and its scatters in different mass bins; in the lower panel, we plot the ratio of medians with respect to the glass simulation. Note that, to have a robust estimation of the ratio of medians, we only show the ratios for the mass bins which have more than 20 haloes. The halo numbers in each mass bin are outlined at the top of the \ufb01gures. We use blue, red and green colours to distinguish the results from the grid, glass and CCVT simulations respectively. To compare with the convergence between different realizations of the same load class, we overplot the ratio of medians from the glass-1 versus glass simulations and from the CCVT-1 versus CCVT simulations with grey and light blue colours, respectively. Let us \ufb01rst focus on the left column in Figs 2 and 3 to investigate the impacts of pre-initial conditions on ALL halo sample. It is easy to \ufb01nd that the median relations of halo property \u2013 halo mass converge fairly well among grid, glass and CCVT simulations. Speci\ufb01cally, from the plots for ratios of median relations, both grid and CCVT simulations converge to glass simulation at a level of a few per cent (i.e. \u227210%). The numerical convergences among pre-initial conditions are particularly good forVmax, c/a and \u03c3v, which have convergence levels of \u22722%. Quantitatively, similar convergence results are observed between different realizations of the same load class. From the plots of ALL halo sample, we con\ufb01rm that the results of median halo properties in many previous studies, such as halo concentration mass relations (see e.g. Neto et al. 2007; Macci` o et al. 2007; Dutton & Macci` o 2014), converge at a level of a few per cent among different initial particle loads as well as different realizations of the same particle load class, and we are free to use grid, glass or CCVT loads to perform simulations when studying the median halo properties. In the \ufb01gures, we have also plotted the errors of ratios for different properties x, \u03b4(x/xglass) = q (\u03b4x/xglass)2 +(x\u03b4xglass/x2 glass)2, (9) where \u03b4x and \u03b4xglass denote the errors of median which are estimated by bootstrap resampling. The \ufb02uctuations of x/xglass in different mass bins are within the range speci\ufb01ed by these error bars, we therefore conclude that in general, the convergences of median halo properties do not depend on halo mass for our halo sample. We further separate the whole ALL halo sample into MATCHED and MISMATCHED sub-samples, and plot their results in the middle and right columns in Figs 2 and 3. We can easily \ufb01nd that, for all median halo properties, the convergences are better for the MATCHED halo sample. For example, for median halo concentrations, the convergences among grid, glass and CCVT are better than \u223c5% for MATCHED haloes, while the convergence level exceeds 10% in the third mass bin for MISMATCHED haloes. This indicates that overall the haloes which converge better in centre positions and virial masses tend to converge better in other halo properties. For the subhalo mass fractions shown in the bottom panels of Fig. 3, we can see that the median fsub in different mass bins for MISMATCHED haloes tend to be signi\ufb01cantly larger than those of MATCHED haloes. This is due to the fact that MISMATCHED haloes are usually merging haloes or haloes which have experienced recent major mergers, as we discussed in Section 2.2 and Appendix A. As the median halo properties are fairly well converged among different simulations, we move on to look at the convergence of properties for individual haloes. To this end, in the following subsections, we will focus on the MATCHED halo sample consisting of 1192 haloes that are well one-to-one matched across three simulations. 3.2 Convergence on properties for MATCHED individual haloes In this subsection, we compare directly the halo properties of every matched halo pairs in the MATCHED halo sample. In Fig. 4, we compute the ratio of each property, x/xglass, for every grid-glass and CCVT-glass matched halo pair, and plot their PDFs. To better quantify their differences, we also \ufb01t each PDF with a Gaussian distribution, P(x/xglass) = 1 \u221a 2\u03c0\u03c3 exp\u2212(x/xglass \u2212\u00b5)2 2\u03c32 , (10) with \u00b5 being the mean (or median) of the distribution and \u03c3 being the dispersion. The best-\ufb01t \u00b5 and \u03c3 are outlined in the upper-right corner of each panel. In the last panel, we summarise |\u00b5 \u22121| and \u03c3 for different halo properties. We \ufb01nd that all PDFs can be well \ufb01tted with Gaussian distributions. All best-\ufb01t values of \u00b5 are close to one (i.e. \u227210%), indicating that the median halo properties are well converged among different simulations. This is also the conclusion in the last subsection. We also note that the best-\ufb01t values of \u03c3 are non-zero. Especially, the best-\ufb01t \u03c3 of some PDFs, such as concentrations, spins, rmax and subhalo mass fractions, are larger than 10%. This indicates that although the median values converge at a level of a few per cent among different simulations, the relative differences for some individual haloes can be several tens of per cent or even larger. To \ufb01nd out what happens for those extreme outliers whose properties converge poorly among different simulations, we look at MATCHED haloes with ratios deviating from \u00b5 larger than 2\u03c3. In Fig. 5, we choose a typical example to illustrate why some haloes converge poorly in subhalo mass fractions which have the largest \u03c3 among all properties discussed in this work. In the \ufb01gure, we plot Halo #1064 and Halo #2878, which have similar masses (\u223c1014.5 h\u22121M\u2299) at z = 0, from the glass simulation and their MNRAS 000, 000\u2013000 (0000) \f6 Zhang et al. Figure 2. Halo properties as a function of halo mass at z = 0 for simulations with different initial loads. The grid, glass and CCVT simulations are plotted with blue, red and green colours. From top to bottom rows, we show halo concentrations, spins, Vmax and rmax and their ratios of median values with respect to the glass simulation. From left to right columns, we show the results for haloes from ALL, MATCHED and MISMATCHED samples. In each panel, the scatter points mark all haloes from the sample, while the dots with error bars show the median values and the 16th and 84th percentiles in each mass bin. The grey horizontal lines in each ratio panel mark the 10% convergence level. The errors of ratios are computed from the errors of median according to Eq. (9). The numbers at the top of each column indicate the number of haloes within each mass bin. For comparison, in the ratio panels, we overplot the ratios of different median halo properties from glass-1 versus glass (CCVT-1 versus CCVT) simulations with grey (light blue) color. MNRAS 000, 000\u2013000 (0000) \fConvergence of pre-ICs 7 Figure 3. Continued to Fig. 2, for halo shape, velocity dispersion, formation time and subhalo mass fraction at z = 0. MNRAS 000, 000\u2013000 (0000) \f8 Zhang et al. Figure 4. Distributions of halo property ratios with respect to the glass simulation for MATCHED haloes at z = 0. Grid and CCVT haloes are shown with blue and green colours respectively. Smooth curves are the best-\ufb01t Gaussian distribution functions, and the corresponding best-\ufb01t \u00b5 and \u03c3 are given on the upper right corner of each panel. In the last panel, the best-\ufb01t |\u00b5 \u22121| (solid, left y-axis) and \u03c3 (dashed, right y-axis) are plotted versus different halo properties. To compare with the convergence between different realizations of the same load class, we overplot the results from glass-1 versus glass (CCVT-1 versus CCVT) simulations with grey (light blue) lines in the last panel. Note that the order of halo properties has been sorted according to the magnitude of \u03c3 in the last panel. The error bars show the 16th and 84th percentiles estimated with the bootstrap resampling. matched counterparts in the grid and CCVT simulations. At z = 0, the former halo has its subhalo mass fraction converged fairly well ( fsub/fsub,glass \u22481), while the subhalo mass fraction of the latter converges poorly ( fsub/fsub,glass \u224810). From top to bottom panels, we have plotted the time-evolution of their M200, M200/M200,glass, fsub and fsub/fsub,glass. We can clearly see from both haloes that if a halo experiences a major merger event, its subhalo mass fraction will increase signi\ufb01cantly when the merging halo becomes a subhalo3. However, the time when this merger event happens may be slightly different in simulations with different initial loads, and this leads both M200/M200,glass and fsub/fsub,glass deviate from 1 temporarily. Such behaviours can be observed almost in every major merger event in the formation history of both haloes. The reason 3 The subhalo mass fraction then decreases gradually as the subhalo is tidally stripped by the host halo. MNRAS 000, 000\u2013000 (0000) \fConvergence of pre-ICs 9 1 Figure 5. Evolution of virial mass and subhalo mass fraction for Halo #1064 (left) and Halo #2878 (right) from MATCHED sub-sample. From top to bottom panels, we plot the time-evolution of virial masses, ratios of virial masses with respect to the glass halo, subhalo mass fraction, and ratios of subhalo mass fraction with respect to the glass halo. The grid, glass and CCVT simulations are plotted with blue, red and green lines respectively. The dashed lines in the bottom panels mark fsub/fsub,glass = \u00b5 +2\u03c3. Note that the halo IDs mentioned here are from the glass simulation. Grid Glass CCVT Figure 6. Visualisation of z = 0 void regions in simulations starting from grid, glass and CCVT particle loads (from left to right). In each panel, we project the particles within a 25 h\u22121Mpc\u00d725 h\u22121Mpc\u00d75 h\u22121Mpc slice onto the xy-plane. The colours denote the local density with black (yellow) colour representing low (high) density regions. In the grid simulation, we can clearly see some regular structures (i.e. particles like beads on a string) in the low density region. MNRAS 000, 000\u2013000 (0000) \f10 Zhang et al. for Halo #2878 to have a very large fsub/ fsub,glass at z = 0 is because it happens to experience a major merger event recently and its fsub/fsub,glass is still in the temporarily deviating process. Note that at z = 0, the ratios of M200/M200,glass in both grid and CCVT simulations for this halo have already fallen below 1.15 and thus it is classi\ufb01ed as a MATCHED halo. Although we only illustrate one example here, similar behaviours can be seen in other haloes which have their subhalo mass fractions poorly converged at z = 0. For other halo properties, we also observe that when a merger event happens, and if this merger event happens in an out-ofsync manner in different simulations, the convergence can become poorer temporarily. Therefore, those haloes with their properties poorly converged at z = 0 usually are experiencing merger events or experienced merger events recently and are still in the process of relaxation; see Appendix B for more details. From the last panel of Fig. 4, we can also \ufb01nd that comparing to grid simulations, CCVT simulations converge slightly better to glass simulations, and the convergence between CCVT and glass simulations is almost indistinguishable from the convergence between different realizations of their own. In general, the best-\ufb01t \u00b5 for different halo properties from CCVT versus glass simulations are more close to 1, and the best-\ufb01t \u03c3 from CCVT versus glass simulations are usually smaller than the ones from grid versus glass simulations. But we stress that their differences are tiny. This slightly better convergence between glass and CCVT is possibly due to the fact that both of them are isotropic while the grid con\ufb01guration is anisotropic. 3.3 Role of environment It has been well known that the memory of pre-initial conditions is preserved in the void region of a simulation even at low redshifts (e.g. Baugh et al. 1995; White 1996). For example, in Fig. 6, we plot the z = 0 particle distributions of void regions from simulations starting with different particle loads. In the left panel, we can clearly see some regular structures (i.e. particles like beads on a string) in low-density regions, which originate from the initial regular grid load. In contrast, we do not see such regular structures in glass and CCVT simulations whose initial particle loads are isotropic. A natural and interesting question is: whether these large-scale environmental dependencies due to pre-initial conditions could affect the numerical convergence on halo properties? To answer this question, for both grid and CCVT simulations, we classify haloes from the MATCHED sample into high-density or low-density environments by computing their environmental number densities (Dressler 1980), \u03c1n = 3n 4\u03c0D3 n , (11) where Dn is the distance to the n-th nearest neighbour. In this work, we adopt n = 5 and consider all isolated haloes containing more than 100 particles within their virial radii when searching for their 5th nearest neighbour. We sort the MATCHED haloes in each simulation according to their \u03c15, and classify the \ufb01rst one-third of haloes (397 haloes) with larger \u03c15 as high-density haloes and the last onethird of haloes (397 haloes) with lower \u03c15 as low-density haloes. For both grid and CCVT simulations, we compute the PDFs of the ratios with respect to the glass simulation for different halo properties. We also \ufb01t the PDFs with Gaussian distributions to obtain the best-\ufb01t \u00b5 and \u03c3. In the left panel of Fig. 7, we show an example of the PDFs of \u03bbCCVT/\u03bbglass for both high-density haloes and low-density haloes in the CCVT simulation. We can clearly see that for halo spins, high-density haloes tend to have their \u00b5 more close to 1 and to have a smaller \u03c3, indicating that high-density haloes have their spins converged better among simulations with different initial loads. We summarise the environmental dependence of |\u00b5 \u22121| and \u03c3 for all halo properties in the middle (right) panel of Fig. 7 for grid (CCVT) haloes. In general, haloes in high-density environments show slightly better convergence in properties (especially for concentrations, spins, rmax, and subhalo mass fractions) among different simulations, i.e. haloes residing in high-density environments tend to have \u00b5 closer to 1 and to have smaller \u03c3. This re\ufb02ects that haloes in high-density environments tend to experience a higher degree of non-linear evolution and thus retain less memory of pre-initial conditions. Again, we stress that the environmental dependence for the convergence is only a weak effect. Note, we have checked that this environmental dependence of convergence can also be seen in the glass-1 versus glass and CCVT-1 versus CCVT simulations. 4"
+                },
+                {
+                    "url": "http://arxiv.org/abs/1810.07055v2",
+                    "title": "The optimal gravitational softening length for cosmological N-body simulations",
+                    "abstract": "Gravitational softening length is one of the key parameters to properly set\nup a cosmological $N$-body simulation. In this paper, we perform a large suit\nof high-resolution $N$-body simulations to revise the optimal softening scheme\nproposed by Power et al. (P03). Our finding is that P03 optimal scheme works\nwell but is over conservative. Using smaller softening lengths than that of P03\ncan achieve higher spatial resolution and numerically convergent results on\nboth circular velocity and density profiles. However using an over small\nsoftening length overpredicts matter density at the inner most region of dark\nmatter haloes. We empirically explore a better optimal softening scheme based\non P03 form and find that a small modification works well. This work will be\nuseful for setting up cosmological simulations.",
+                    "authors": "Tianchi Zhang, Shihong Liao, Ming Li, Liang Gao",
+                    "published": "2018-10-16",
+                    "updated": "2019-05-15",
+                    "primary_cat": "astro-ph.CO",
+                    "cats": [
+                        "astro-ph.CO",
+                        "astro-ph.GA"
+                    ],
+                    "main_content": "INTRODUCTION Cosmological N-body simulations are essential to study the formation of large-scale structures in Universe. In the past decades, with the rapid developments both in the computational power of supercomputers and the numerical techniques, cosmological N-body simulations have played an important role in the studies of hierarchical formation of cold dark matter haloes and the establishment of the standard cosmological model (see Frenk & White 2012, for a review). For a cosmological simulation code, there are usually quite a few parameters to be chosen in order to properly set up it, gravitational softening length is one of the key parameters. In cosmological N-body simulations, in order to avoid close encounters between particles, a small quantity, \u03b5, is introduced in the computation of Newtonian gravity, i.e., the Plummer form, F12 = Gm1m2r12/(r2 12 +\u03b52)3/2. Here, G is the gravitational constant, m1 and m2 are the masses of two particles, r12 is the position vector from particle 1 to particle 2, and \u03b5 is termed as gravitational softening length. In this sense, instead of being a point mass, a particle is treated as a smooth \u201cball\u201d with a volume measured by the softening length. It is not a trivial task to choose an optimal softening length for a numerical simulation in terms of computational cost and force accuracy. In the past decades, many studies have been performed to explore how to choose softening lengths in N-body simulations (see e.g. Thomas & Couchman 1992; Merritt 1996; Romeo 1997, 1998; Moore et al. 1998; Splinter et al. 1998; Athanassoula et al. \u22c6Email: tczhang@nao.cas.cn 2000; Knebe et al. 2000; Dehnen 2001; Fukushige & Makino 2001; Power et al. 2003; Zhan 2006; Price & Monaghan 2007; Iannuzzi & Dolag 2011; van den Bosch & Ogiya 2018). For a uniform mass resolution cosmological simulation, the softening length is usually set to be a fraction of the mean inter-particle separation. However there is no consensus on the choice of the fraction. In literature, the fraction varies from 1/120 (e.g., Klypin et al. 2011) to 1/10 (e.g., Kim et al. 2009). Currently, the most widely adopted setting of the optimal softening length in zoom-in N-body simulations is suggested by Power et al. (2003) (hereafter P03). P03 proposed an optimal choice of softening length based on the argument that the maximum stochastic acceleration caused by close approaching to a single particle, amax = Gm/\u03b52, should be less than the minimum mean-\ufb01eld acceleration in a virial halo, amin \u2248GM200/r2 200. Here, M200 and r200 are the virial mass and virial radius of a simulated halo with its mean density inside r200 being 200 times the critical density. This argument sets a lower limit for the softening length which is needed to avoid strong discreteness effects, \u03b5 > \u03b5acc \u2248r200/\u221aN200, where N200 is the number of particles within the virial radius. P03 further empirically proposed that an optimal softening length is \u03b5opt,P03 \u22484\u03b5acc = 4r200 \u221aN200 , (1) which tends to describe their numerical results well. With this optimal softening, the circular velocity pro\ufb01le of a halo can converge at the radius rconv at a level of better than 10 percent (Navarro et al. 2004). Here, the convergence radius is estimated by requiring the collisional relaxation time at the convergence radius, trelax(rconv), equals to the circular orbital time at the virial radius, tcirc(r200), i.e., c \u20dd0000 The Authors arXiv:1810.07055v2  [astro-ph.CO]  15 May 2019 \f2 Zhang et al. \u03ba(rconv) = trelax(rconv) tcirc(r200) = \u221a 200 8 N(rconv) lnN(rconv) \u0014 \u03c1crit \u00af \u03c1(rconv) \u0015 1 2 = 1, (2) where \u03c1crit is the critical density, and N(rconv) and \u00af \u03c1(rconv) are the enclosed number of particles and mean enclosed density within rconv, respectively. The proposal of P03 optimal softening scheme has been widely adopted in the settings of many zoom-in simulations such as the Phoenix simulations (Gao et al. 2012), Auriga simulations (Grand et al. 2017), AGORA simulations (Kim et al. 2014), FABLE simulations (Henden et al. 2018), etc. Since the proposal of P03 softening scheme, cosmological simulation codes have evolved gradually in recent years, both in force calculation and time integration accuracy. It is interesting to revisit the problem with the most updated codes and with better statistics to see whether P03 optimal softening scheme still holds, and if not, how to improve it. In this paper, we will revise P03 optimal softening scheme with a set of high-resolution simulations. The paper is structured as follows. In Section 2, we describe the details of our simulations and halo samples. In Section 3, we use a series of high-resolution numerical simulations to test the optimal softening scheme advocated in P03 (Section 3.1), and propose an improved optimal softening which can achieve higher spatial resolution (Section 3.2), and discuss the implications of our updated optimal softening length (Section 3.3). Our conclusions are presented in Section 4. 2 NUMERICAL SIMULATIONS We use one of the most widely used cosmological simulation codes, GADGET-3, which is an improved version of GADGET-2 (Springel 2005), to perform all our simulations in this study. The cosmological parameters are \u2126m = 0.3,\u2126\u039b = 0.7,\u03c38 = 0.9,h = 0.65 and ns = 1.0. The initial conditions at z = 100 are generated with the NGENIC code with the linear matter power spectrum given in Eisenstein & Hu (1998). Dark matter haloes in the simulations are identi\ufb01ed with the standard friends-of-friends algorithm with a linking length of 0.2 times the mean particle separation (Davis et al. 1985). In our simulations, the default integration accuracy parameter ErrTolIntAcc is set to 0.025. For the TreePM computation, the force accuracy parameter ErrTolForceAcc is set to 0.0025, and the FFT mesh dimension, PMGRID, is set to be equal to the number of particles in each dimension, Np. Varying these three parameters hardly affect our results present below; see Appendix A for details. Simulation set I. To test the optimal softening scheme in P03, Eq. (1), we perform a set of simulations with varying softening lengths \ufb01xed in comoving coordinates. Each simulation contains N3 p = 2563 dark matter particles in a periodic box with a length Lbox = 10 Mpc/h on a side. We \ufb01rst run a simulation with a softening length following the usual choice, 1/50 of the mean inter-particle separation, i.e., \u03b5use = XLbox/Np with X = 1/50. The value of \u03b5use is 0.78 kpc/h here. Then we select the most massive halo and calculate its optimal softening according to Eq. (1) by using its r200 \u2248330 kpc/h and N200 \u22481.6\u00d7106. The P03 optimal softening length for this halo is \u03b5opt,P03 = 1.0 kpc/h, roughly X = 1/40 of the mean inter-particle separation. Then we re-run the simulation with \u03b5use = \u03b5opt,P03, and a series of softening lengths greater or less than \u03b5opt,P03, i.e., X = 1/10,1/25,1/80,1/100, 1/300 and 1/500. As a \ufb01ducial one to compare with, we also perform a simulation with 8 times better Name \u03b1 mp Nhalo \u00af N200 \u03b5 [M\u2299/h] [kpc/h] Fiducial 4 7.31\u00d7105 164 1285515 0.54 HighRes 1 5.84\u00d7106 167 160860 0.38 2 167 159430 0.76 3 166 162509 1.14 4 163 162216 1.52 MidRes 0.5 4.68\u00d7107 165 19765 0.54 1 165 20059 1.03 2 167 19708 2.06 3 168 19887 3.09 4 168 19580 4.124 LowRes 0.5 3.74\u00d7108 168 2463 1.52 1 170 2440 3.03 2 167 2456 6.06 3 164 2434 9.09 4 165 2418 12.12 Table 1. Details of simulation set II. Here, mp, Nhalo, and \u00af N200 denote the particle mass, number of selected haloes, and the average number of particles inside the selected haloes, respectively. mass resolution with N3 p = 5123 and 2 times better spatial resolution, and use the same random phases as the lower resolution runs to set up the initial conditions. We will use this set of simulations to test whether P03 optimal softening scheme works the best to resolve the inner structures of the most massive halo in Section 3.1. Simulation set II. As we shall see in next section that P03 softening scheme is indeed not most optimal. In order to improve it, we generalize the form of P03 optimal softening scheme by introducing a free parameter, \u03b1 (see Section 3.2 for details). We explore whether or not we can improve P03 softening scheme in a simple way by varying \u03b1 in our following numerical simulations. In order to have better statistics, we perform a set of cosmological simulations with a box size of Lbox = 33Mpc/h, and focus on the galactic haloes with masses M200 = [5 \u00d7 1011,2 \u00d7 1012]M\u2299/h with the corresponding virial radii r200 \u2248150kpc/h. There are about 160 haloes in the halo sample in each simulation, and these haloes are stacked to obtain the stacked density and circular velocity pro\ufb01les. We have performed the simulations with three different resolutions, at each resolution, we run these simulations with \ufb01ve different softening setups, namely \u03b1 = 0.5,1,2,3, and 4. Details of simulations are summarized in Table 1. 3 RESULTS 3.1 Testing P03 optimal softening scheme To test the optimal softening scheme proposed by P03, in Fig. 1, we plot the circular velocity pro\ufb01le, Vc(r) = p GM(r)/r, and density pro\ufb01le, \u03c1(r), of the most massive halo in each Set I simulation, and compare them with those of the \ufb01ducial run. Results for different simulations are distinguished with different colors as labelled in the \ufb01gure. We can clearly see that both circular velocity and density pro\ufb01les in the simulations with X = 1/80 and 1/100 converge to smaller radii when compared with the run using softening length proposed by P03. This suggests that P03 softening scheme may MNRAS 000, 000\u2013000 (0000) \fThe optimal gravitational softening length for Cosmological N-body simulations 3 be too conservative (see Ludlow et al. 2018, for a similar conclusion). However, we shall note that using an over small softening (e.g. the simulation with X = 1/500) overpredicts \u03c1(r) with respect to the \ufb01ducial one as large as \u223c20% at small radii, this is possibly due to two-body effects introduced by over small softening length, or spurious low-mass structures which form at early times, retain their high central densities and later sink into the halo center to arti\ufb01cially boost the central density (see Power et al. 2016, for related discussions). Note that P03 convergence radii (the dotted vertical lines in Fig. 1) are almost independent of the chosen softening lengths. Also we note that, while we only show the results for the most massive halo here, similar results can be found for other haloes with comparable halo mass in the simulations. 3.2 An improved proposal of optimal softening and convergence radius As we see in the above subsection that P03 softening scheme is over conservative, For simplicity, in this subsection we explore to improve it based on the original P03 form. To this end, we generalize the form of P03 optimal softening form into \u03b5opt = \u03b1 r200 \u221aN200 , (3) where \u03b1 is a free parameter to be determined here, and \u03b1 = 4 corresponds to the original P03 optimal softening scheme. To empirically explore the optimal \u03b1, we have performed a set of simulations with softening lengths given by \u03b1 = 0.5,1,2,3, and 4, which are described in detail in Section 2. To reduce noises, we stack the circular velocity and density pro\ufb01les of \u223c160 galactic haloes at z = 0 which have masses in the range from 5\u00d71011 M\u2299/h to 2\u00d71012 M\u2299/h. In Fig. 2, we plot the stacked pro\ufb01les of the simulations with different resolutions and compare them with the \ufb01ducial run. Let us focus on results of MidRes simulations (middle column of Fig. 2) \ufb01rst. Clearly Vc(r) of the simulation using P03 softening scheme (solid red curve) converge to the \ufb01ducial one at convergence radius at 10 percent level, in agreement with studies of Navarro et al. (2004) and others. However the simulations with smaller softening length converge to even smaller radii at a similar error level. Results for density pro\ufb01les are displayed in the lower panels of the same \ufb01gure. Again, the P03 softening scheme does a pretty good job in matching the density pro\ufb01le at the convergence radius at which density pro\ufb01le of the halo in the lower resolution run only deviates from the \ufb01ducial one about few percent. However, similar to the result for the circular velocity pro\ufb01les, using smaller softening length, the density pro\ufb01le can converge to smaller radii, for \u03b1 = 2,3 the spatial resolution for the stacked density pro\ufb01le can be improved by a factor of 1.8 and 1.3, respectively. Note, as we discussed in the last subsection that using an over small softening overpredicts dark matter density at very inner region, one can readily \ufb01nd bumps in the residual plot for the run using \u03b1 = 0.5,1 at \u223c0.04r200. Therefore, according to the above convergence tests, these results suggest the simulations with \u03b1 = 2 works equivalently well as P03 in terms of numerical convergence but at the same time can achieve about 2 times better spatial resolution. Similar conclusions can also be drawn from LowRes and HighRes simulations. A remaining question is that if we choose \u03b1 = 2 in Eq. (3) as a better optimal softening scheme, then is it possible to give an estimation of its convergence radius? In Fig. 2, we plot P03 convergence radii with vertical dotted lines in the residual panels. Similar to previous studies (e.g., Navarro et al. 2004), we \ufb01nd that in the MidRes and HighRes cases, the circular velocity pro\ufb01les with P03 softening (red lines) converge to the \ufb01ducial one roughly at a level of 10 percent at r = rconv,P03. But for the LowRes case, the convergence level at r = rconv,P03 is slightly worse, i.e., \u223c15%. Note that the haloes in LowRes simulations only have \u223c2000 particles, and previous studies (e.g., Navarro et al. 2004) have not tested P03 convergence radius for the haloes with such low number particles. Our LowRes results suggest that in haloes with thousands of particles, the circular velocity pro\ufb01le at the P03 convergence radius converges at a level worse than 10 percent. We also plot the half of P03 convergence radius with blue vertical solid lines in the residual panels in Fig. 2. They offer a rough estimation of the convergence radius of the circular velocity with \u03b1 = 2 at a level of \u223c10%. This means that by reducing the softening length into half of P03 optimal softening scheme, the spatial resolution of a simulation can be two times better. In such a way, we ef\ufb01ciently achieve a spatial resolution which otherwise needs a simulation with eight times more particles and several times more computational cost. We have also looked at a set of simulations targeting cluster haloes, and found similar conclusions for the optimal softening length and convergence radius presented above. Thus, we conclude that an improved proposal for the optimal softening is to set \u03b1 = 2 in Eq. (3), and the corresponding convergence radius can be estimated as rconv,opt = rconv,P03/2, (4) where rconv,P03 can be computed from Eq. (2). 3.3 Discussion An important application of cosmological simulations is to study the halo mass\u2013concentration relation. In order to estimate concentration parameter (c) reliably, simulations need to have enough spatial resolution to well resolve the characteristic radius rs of a halo of given mass (Neto et al. 2007). Based upon our results presented in the last subsection, we can make a rough estimation of the required mass and spatial resolution in order to reliably estimate the concentration parameter of a halo as a function of halo mass. This will be very useful to set up simulation parameters in practice. To answer this question, we notice that the enclosed number of particles and mean density in Eq. (2) can be expressed as N(rconv,opt) = M(rconv,opt) mp , (5) and \u00af \u03c1(rconv,opt) = 3M(rconv,opt) 4\u03c0r3 conv,opt , (6) respectively. Here, mp is the particle mass, and the enclosed mass within rconv,opt is M(rconv,opt) = M200 f(cx) f(c) , (7) where x = rconv,opt/r200, and the function f(y) has the form of f(y) = ln(1+y)\u2212 y 1+y. (8) Considering the relation between M200 and r200, M200 = 800\u03c0 3 \u03c1critr3 200, (9) and putting Eqs (5-6) into Eq. (4), we can \ufb01nd that rconv,opt is a MNRAS 000, 000\u2013000 (0000) \f4 Zhang et al. Figure 1. Circular velocity pro\ufb01les (left panel) and density pro\ufb01les (right panel) for the largest halo in the simulation set I at z = 0. For a direct comparison, the radius has been scaled to r200 for each halo. In each panel, the upper part presents pro\ufb01les, and the bottom shows their residuals from the \ufb01ducial simulation (e.g., \u03b4 lnVc = lnVc \u2212lnVc,Fiducial). The solid vertical lines in the upper parts mark the softening lengths for different simulations, whereas the dotted vertical lines in the bottom parts show P03 convergence radii, rconv, computed from Eq. (2). function of M200, c, and mp. Once c\u2212M200 relation is known (e.g. Dutton & Macci` o 2014), rconv,opt is only a function of M200 and mp. Therefore, for given rconv,opt and M200, it is easy to derive mp and then use Eq. (3) and Eq. (9) to compute \u03b5opt. In Fig. 3, we plot the required mass resolution mp (left axis) and optimal softening length as a function of M200. The optimal softening length derived here assumes spatial resolution 0.5rs of any given mass halo. From the plot, one can easily identify what mass resolution and softening are needed to reliably estimate the concentration parameter of a halo of given mass when using the optimal softening scheme proposed in this study. For example, if we aim to resolve a Milky Way-sized halo (M200 \u223c1012M\u2299/h ), the most economical simulation setup is to use a mass resolution mp \u2248 5\u00d7108M\u2299/h and a softening length 5kpc/h, these are indeed very similar to the corresponding parameters adopted in the Millennium simulation (Springel et al. 2005). 4"
+                }
+            ],
+            "Sheng Liu": [
+                {
+                    "url": "http://arxiv.org/abs/2402.09478v1",
+                    "title": "Data Reconstruction Attacks and Defenses: A Systematic Evaluation",
+                    "abstract": "Reconstruction attacks and defenses are essential in understanding the data\nleakage problem in machine learning. However, prior work has centered around\nempirical observations of gradient inversion attacks, lacks theoretical\ngroundings, and was unable to disentangle the usefulness of defending methods\nversus the computational limitation of attacking methods. In this work, we\npropose a strong reconstruction attack in the setting of federated learning.\nThe attack reconstructs intermediate features and nicely integrates with and\noutperforms most of the previous methods. On this stronger attack, we\nthoroughly investigate both theoretically and empirically the effect of the\nmost common defense methods. Our findings suggest that among various defense\nmechanisms, such as gradient clipping, dropout, additive noise, local\naggregation, etc., gradient pruning emerges as the most effective strategy to\ndefend against state-of-the-art attacks.",
+                    "authors": "Sheng Liu, Zihan Wang, Qi Lei",
+                    "published": "2024-02-13",
+                    "updated": "2024-02-13",
+                    "primary_cat": "cs.CR",
+                    "cats": [
+                        "cs.CR",
+                        "cs.LG"
+                    ],
+                    "main_content": "Introduction Machine learning research has transformed the technical landscape across various domains but also raises privacy concerns potentially (Li et al., 2023; Papernot et al., 2016). Federated learning (Kone\u010dn\u00fd et al., 2016; McMahan et al., 2017), a collaborative multi-site training framework, aims to uphold user privacy by keeping user data local while only exchanging model parameters and updates between a central server and edge users. However, recent studies on reconstruction attacks (Yin et al., 2021; Huang et al., 2021), also known as gradient inversion attacks, highlight privacy vulnerabilities even within federated learning. Attackers can eavesdrop on shared trained models and gradient information and reconstruct training data using them. Even worse, honest but curious servers can inadvertently expose training data by querying designed model parameters. Some defending methods are also proposed and analyzed. Prior data reconstruction attacks have centered around gradient inversion (Zhu et al., 2019), attempting to match gradients generated from dummy and real input variables. Some variants in this line incorporate prior input data knowledge as regularization in the objective function (Yin et al., 2021; Jeon et al., 2021). As illustrated in Fig. 1, the reconstruction attack can be viewed as an inverse problem; from the observations G that is generated from the unknown data and a known function (model\u2019s gradient), the adversary intends to reconstruct the input data, and a defending method is to prevent this from perturbing the observations. To evaluate the effectiveness of a defense is to evaluate how robust it is to the strongest attack within the threat model. However, previous attacks lack strength and theoretical guarantees, making the evaluation of the defense\u2019s strength untrustworthy. Empirical understanding of attacking and defending methods \u2217Equal contribution. 1 arXiv:2402.09478v1  [cs.CR]  13 Feb 2024 \fFigure 1: An illustration of the key components of data reconstruction studied in this paper. is affected by factors like optimization challenges of non-convex objectives. Under the heuristic attacking methods from prior work, it is hard to disentangle the following two possibilities: 1) the algorithmic or computational barrier of the attack, and 2) the success of the defense. In this work, we will investigate the problem by introducing stronger attacks, as well as bringing more theoretical perspectives. A line of theoretical work analyzing privacy attacks is differential privacy (DP) (Dwork, 2006), which guarantees privacy in data re-identification or membership inference. However, there are scenarios when data identity information is not sensitive but data itself is, and DP is not suitable to interpret data reconstruction attacks Guo et al. (2022). As a concrete example, when the observation G is the sum of the samples, it yields no DP guarantee but recovering data from the sum is impossible as long as there are multiple data points. Although there are previous works discussed the reconstruction attack under differential privacy setting (Guo et al., 2022; Stock et al., 2022), their setting is different from federated learning where all samples but one are known and the goal of the attacker is to reconstruct the last data point, which is unrealistic in the federate learning setting. To this end, with DP not applicable in this setting, there is limited theoretical work and it is urgent to call for more fundamental investigations on the data reconstruction problems. Recent work by Wang et al. (2023) introduced a theoretically sound feature reconstruction attack, but lacked practicality as it focused on two-layer fully connected neural networks, while for deep networks it had to manipulate the bottom layers\u2019 weights in a transparently detectable way. We enhance this attack by combining gradient and intermediate layer matching, where we utilize the methodology in (Wang et al., 2023) as a pre-processing step of intermediate layer reconstruction. In the setting of an honest-but-curious server, our stronger attack demonstrates robustness to various defenses through empirical validation. Moreover, the robustness can be theoretically analyzed, differing from previous attacks. Under the framework of this attack, we can conduct a more systematic and scientific evaluation of privacy defenses\u2019 utilities. Our main contributions are the following: \u2022 We propose a new gradient inversion attack method. Leveraging the use of an untrained U-Net as an image prior and intermediate feature matching. The proposed method can recover data from gradients and be robust to a wide range of defense methods. \u2022 We establish theoretical analyses to thoroughly evaluate the effectiveness of a wide range of 2 \fcommon defense strategies against feature recovery, providing a theoretical perspective in reconstruction attack and defense. \u2022 We further conduct extensive experiments on the common defense strategies with the proposed attack method, connecting theoretical principles with practice. 1.1 Related Work In federated learning (Kone\u010dn\u00fd et al., 2016; McMahan et al., 2017), a line of work in gradient inversion aims to reconstruct training data from gradients. An early work by Aono et al. (2017) theoretically showed that reconstruction is possible under a single neuron setting. Following this line, Zhu et al. (2019) proposed the gradient matching framework, where the training data and labels are recovered by minimizing the l2 distance between gradients generated by dummy variables and real data. Instead of using l2 distance, Wang et al. (2020) proposed a Gaussian kernel-based distance function, and Geiping et al. (2020) used cosine similarity. Apart from using different distance measures, recent works introduced image priors to gradient matching. Geiping et al. (2020) added a total variation regularization term since pixels of a real image are usually similar to their neighbor. Wei et al. (2020a) introduced a label-based regularization to fit the prediction results. Balunovic et al. (2021) formulated the gradient inversion attack in a Bayesian framework. Yin et al. (2021) used a batch-normalization regularization to fit the BN statistics and a group consistency regularization to indicate the spatial equivariance of CNN. Instead of using regularization terms, Jeon et al. (2021) represented dummy training data by a generative model to preserve the image prior. In this method, the latent variables and the parameters of the generative model are trained simultaneously. Some recent works investigated new data reconstruction methods outside the framework of gradient matching. Wang et al. (2023) theoretically showed that the training data can be reconstructed from gradients of networks with random weights using tensor decomposition methods, where optimization is not needed. Haim et al. (2022) proposed a reconstruction method using the stationary property for trained neural networks, induced by the implicit bias of training. Defense strategies in this setting, however, are relatively less studied. The original setting of federated learning proposed by McMahan et al. (2017) used local aggregation to update multiple steps instead of gradients directly. Bonawitz et al. (2016, 2017) proposed a secure aggregation that can collect the gradients from multiple clients before updating. Geyer et al. (2017); Wei et al. (2020b) introduced differential privacy into federated learning, perturbing the gradients. Aono et al. (2017) demonstrated an encryption framework in the setting of federated learning. Moreover, many tricks designed to improve the performance of neural networks are effective in defending against privacy attacks, such as Dropout (Hinton et al., 2012), gradient pruning (Sun et al., 2017), and MixUp (Zhang et al., 2017). The effect of defending strategies against gradient matching attacks are discussed in (Huang et al., 2021; Zhu et al., 2019; Geiping et al., 2020). 2 A Stronger Attack for Defense Methods Evaluation Prior research has demonstrated the potential to retrieve input directly from gradient values, specifically for image classification endeavors, by presenting it as an optimization problem: when provided with a neural network characterized by parameters \u03b8 and its associated gradient \u2207\u03b8L(x\u2217, y\u2217) computed with a private data batch (x\u2217, y\u2217) \u2208Rb\u00d7d \u00d7 Rd, b is the batch size, d, for example, is the image 3 \fsize. Attack methods tries to recover x, an estimation of x\u2217: arg min x Lgrad(x; \u03b8, \u2207\u03b8L\u03b8(x\u2217, y\u2217)) + \u03b1Raux(x) (1) The optimization objective is twofold: the initial term Lgrad(x; \u03b8, \u2207\u03b8L\u03b8(x\u2217, y\u2217)) ensures that the gradient of the retrieved batch x aligns with the given gradients. Meanwhile, the regularization term Raux(x) refines the recovered image using established image prior(s) such as total variation. This is because Eq. (1) is non-convex, and inverting gradients is often under-determined, i.e. there exists a pair of different data having the same gradient even when the learning model is large. Meanwhile, a recent work by Wang et al. (2023) introduced a novel tensor-based approach for reconstructing input data from the gradients of two-layer fully connected neural networks. Distinct from traditional optimization-based gradient matching techniques, this tensor-based strategy has been shown, both theoretically and empirically, to offer superior performance. In the pursuit of building a more robust attack method that enhances defense mechanisms evaluation. we explore the integration of this tensor-based methodology with existing optimization-based gradient matching approaches. Specifically, the tensor-based technique is applied to reconstruct intermediate features before the fully connected layers, which commonly serve as classification heads in modern neural network architectures. High-quality reconstruction of these features, as evidenced by (Wang et al., 2023), provides additional information that can be utilized to further regularize the objective equation Eq. (1), thereby making gradient matching more computationally tractable. As we demonstrated in Figure 2 and Table 1, introducing feature matching to gradient matching results in a more potent attack methodology. This integrated approach not only strengthens the attack but also facilitates a more comprehensive theoretical examination of various defense strategies. 2.1 Our attack algorithm In this section, we present a stronger attack algorithm designed to rigorously evaluate various defense mechanisms. The method follows (Geiping et al., 2020) to use the same selection of Lgrad and research (Yin et al., 2021) for regularization grounded in batch normalization. A key innovation of our method is the integration of additional regularizations, inspired by the recent contributions of (Wang et al., 2023). This novel incorporation seeks to strength the attack strategy, ensuring a more precise and efficient evaluation of defense methods. Feature reconstruction with tensor-based method To utilize the feature matching regularization, we have to obtain the intermediate feature as a preprocessing step. Since the federated learning model cannot directly access the intermediate feature, a feature reconstruction with small errors is needed. The setting of recovering the intermediate feature is the same as reconstructing input data from the gradient of a fully connected 2-layer neural network. Specifically, we denote the input dimension by d and the number of classes by K. For a two layer neural network f(x; \u0398) = 1 mA\u03c3(Wx) with m hidden nodes, where W = [w1, . . . , wm] \u2208Rm\u00d7d, A = [a1, . . . , aK]\u22a4\u2208RK\u00d7m and \u03c3 is pointwise, denote zk = a\u22a4 k \u03c3(Wx) and pk = Softmax(zk). Then with cross-entropy loss, for input x we can observe the partial derivative \u2202\u2113 \u2202akj = \u2202\u2113 \u2202zk \u2202zk \u2202akj = 1 m(pk \u2212yk)\u03c3(w\u22a4 j x) from gradient. We adopt the tensor-based reconstruction method proposed by Wang et al. (2023). We can define g(wj) = PK k=1 ck \u2202\u2113 \u2202akj , where ck\u2019s are some constant with carefully chosen such that ri := PK k=1 ck(pki \u2212yki) is a constant. Then compute Pm j=1 g(wj)Hp(wj), where Hp is the p-th Hermite function, and conduct tensor decomposition. See details of the method in Appendix B. 4 \fStrategic weight initialization. In addressing the challenge of integrating a tensor-based method, which requires randomly initialized networks, into gradient inversion processes that typically see improved performance with a few steps of preliminary training, we have designed a strategic approach for weight initialization. Since tensor-based method is only applied to the final fully connected layers, denoted as A\u03c3(Wx), where A \u2208RK\u00d7m, W \u2208Rm\u00d7d, with K representing the number of classes, m the number of hidden nodes, and d the input dimension. We consider the original pre-trained weights to be partitioned into two sets: W = [W1, W2] and A = [A1; A2]. Here, W2 \u2208Rv\u00d7d is initialized as a random Gaussian matrix, essential for the tensor-based method to function effectively. Concurrently, each row i of A2 \u2208RK\u00d7v is initialized to a constant value of i/v, as suggested by the tensor-based approach. The remaining dimensions of the weight matrices, W1 \u2208R(m\u2212v)\u00d7d and A1 \u2208RK\u00d7(m\u2212v), retain their pre-trained weights, aligning with the requirements for successful gradient matching. For all of our experiments, the dimension allocated for gradient matching, m \u2212v, is set as 2048. This strategic initialization approach not only accommodates the prerequisites of the tensor-based method but also maintains the efficacy of the gradient-matching process. Challenges in order recovery of the features. When deploying the tensor-based method for feature recovery, a challenge arises due to the algorithm\u2019s inability to precisely maintain the order and sign of features when dealing with batches larger than a single input. This challenge complicates the task of accurately matching the recovered features to their corresponding inputs within a batch. In theory, one approach to circumvent this issue is to consider every possible permutation of the recovered features against the batch inputs, aiming to identify the correct alignment. However, this method is computationally intensive and impractical for larger batches. To streamline the process, we adopt a more efficient strategy that involves sequentially comparing each recovered feature against the actual input features using cosine similarity. This comparison continues until the most accurate order of features is determined based on their similarity scores. Although a single recovered feature might have high cosine similarity with several features corresponding to different inputs, we empirically observe that this greedy matching method achieves similar performance with the method that considers all possible pairs. Regularization on feature matching. To address the challenge of non-unique solutions in gradient matching, we introduce a regularization term designed to align intermediate network features with those reconstructed via a tensor-based method. This regularization, denoted as Rfeature(x), employs squared cosine similarity to mitigate the issue of sign ambiguity inherent in tensor-based reconstruction: Rfeature(x) = 1 \u2212 \u0012 \u27e8f(x, \u03d5), \u02c6 z\u27e9 \u2225f(x, \u03d5)\u2225\u2225\u02c6 z\u2225 \u00132 , (2) where f(x, \u03d5) are the intermediate features of input x and \u02c6 z are the reconstructed features from the tensor-based method. This approach aims to refine gradient matching by ensuring the generated input x yields intermediate features similar to \u02c6 z, providing a more accurate and specific solution space. Other regularizations. Following (Geiping et al., 2020), we adopt total variation and regularization on batch norm to exploit prior knowledge of natural images and training data. Moreover, inspired by deep image prior (Ulyanov et al., 2018), we employ an untrained Convolutional Neural Network (CNN) to generate an image. This idea is rather similar to (Jeon et al., 2021) where a 5 \fnetwork is pre-trained for image generation. The final objective of the introduced attack method is arg min x Lgrad(x; \u03b8, \u2207\u03b8L\u03b8(x\u2217, y\u2217)) + \u03b1TV RTV + \u03b1BNRBN + \u03b1fRfeature(x). (3) 3 Defense Methods To combat privacy attacks of machine learning, some defenses are proposed to prevent data leakage. Specifically in the setting of data reconstruction attack in federated learning, (Huang et al., 2021; Zhu et al., 2019; Geiping et al., 2020) evaluated the privacy of different defending strategies empirically. These works shed light on choosing appropriate defenses against reconstruction attacks but can be improved in the following sense: (i) the attacks they used to evaluate defenses lack strength. However, the definition of how robust a defense strategy is should be measured on the strongest attack within the threat model; and (ii) previous evaluations are purely empirical without theoretical support. In contrast, our evaluation of defenses is based on a stronger attack we proposed. Moreover, we also provide theoretical analysis from the perspective of feature reconstruction. Our attack is composed of gradient matching and feature matching. Defenses bring both optimization and statistical barriers to the gradient matching component, where the effect is difficult to analyze theoretically. The feature-matching component, on the other hand, can be analyzed quantitatively. The quality of feature matching is not only essential to and correlates strongly with the overall performance of data reconstruction, but the intermediate feature, as well as original data, is also protective information and its leakage should be prevented as well. To this end, we will theoretically analyze the defending effect on feature reconstruction in the following part of this section. With our stronger attack, the feature reconstruction is equivalent to recovering the input of a two-layer neural network. Thus, our theoretical analysis can be based on the results of reconstruction error bounds on two-layer networks in (Wang et al., 2023) but varies among different defenses. On one hand, our theoretical findings overturned some prior empirical observations on the effectiveness of several defense methods. On the other hand, it is generally more convincing to analyze the effect of defenses under a stronger and more robust attacking method. Combined with the experiments in Section 4, our analysis gives a more complete understanding of various defending methods. In the following analysis, our setting conforms to that of Section 2.1 with a main focus on feature reconstruction of fully connected layers. 3.1 No defense Without any defense, we conduct tensor decomposition to Pm j=1 g(wj)Hp(wj) as stated in Section 2.1. Then by the following Stein\u2019s lemma (Stein, 1981; Mamis, 2022): Lemma 3.1 (Stein\u2019s Lemma). Let X be a standard normal random variable. Then for any function g, we have E[g(X)Hp(X)] = E[g(p)(X)], (4) if both sides of the equation exist. Here Hp is the pth Hermite function and g(p) is the pth derivative of g. we have m X j=1 g(wj)Hp(wj) \u2248m Ew\u223cN(0,I)[g(w)Hp(w)] 6 \f= m Ew[\u2207p wg(w)] = B X i=1 riE[\u03c3(p)(w\u22a4xi)x\u2297p i ]. (5) Thus, the result of tensor decomposition is {x1, . . . , xB} and the error bound is \u02dc O(BK q d m) with high probability, where B is the batch size of data. Details of the analysis is in Appendix B. 3.2 Local aggregation In a realistic setting of federated learning, the observed local update may not be a single gradient. Instead, it can be the result of multiple steps of gradient descent. Specifically, under the setting of federated averaging (McMahan et al., 2017), a client with N images trains E epochs for each update, where a single epoch contains N/B gradient descent steps with batch size B. Since the observation is more complicated than a gradient, the difficulty of reconstructing features increases. However, the tensor-based attack can still work under this setting. For an update \u02dc g with multiple steps, we can simply replace the gradient g in the previous attack with \u02dc g and conduct tensor decomposition as normal. Specifically, we will discuss two cases: using the same batch to train multiple steps and using different batches for every gradient step. Multiple steps with the same batch. In this setting, B = N and E > 1. We first consider the case E = 2. According to gradient descent, we have a(t+1) kj = a(t) kj \u2212\u03b7 m PB i=1(p(t) ki \u2212y(t) ki )\u03c3(w(t) j \u00b7 xi) for t = 0, 1, where p(t) ki , y(t) ki , a(t) kj , w(t) j are the values of corresponding parameters after t gradient steps. Since the information from clients are the values of a(2) j , we have from the local update a(2) kj \u2212a(0) kj = \u2212\u03b7 m B X i=1 (p(0) ki \u2212y(0) ki )\u03c3(w(0) j \u00b7 xi) \u2212\u03b7 m B X i=1 (p(1) ki \u2212y(1) ki )\u03c3(w(1) j \u00b7 xi). (6) Under this setting, we can compute Pm j=1 PK k=1 ck(a(2) kj \u2212a(0) kj )Hp(wj) and conduct rank-B tensor decomposition, which is similar to the original problem. For the attack, we can prove that the reconstruction error is bounded by \u02dc O(BK q d m) with high probability. Different batches. In this setting, E = 1 but N > B. We first consider the case with only 2 batches, i.e. B < N \u22642B. Similar to Eq.(6), the local update a(2) kj \u2212a(0) kj = \u2212\u03b7 B X i=1 (p(0) ki \u2212y(0) ki )\u03c3(w\u22a4 j xi) \u2212\u03b7 N X i=B+1 (p(1) ki \u2212y(1) ki )\u03c3(w(1) j \u00b7 xi). (7) The only difference from the case above is that the data used to train \u0398(1) is different from the one in training \u0398(0). Thus, performing our attacking method with N outputs instead of B can reconstruct the original data. We can prove that the reconstruction error is bounded by \u02dc O(NK q d m) with high probability. Conclusion. Note that for both cases, if there are more than 2 gradient steps, we can perform the same tensor decomposition method. Thus, the tensor-based attack can recover features against local aggregation attacks. The proofs of the error bounds above are in Appendix C.1. 7 \f3.3 Differential privacy stochastic gradient descent Differential privacy (Dwork, 2006) algorithms ensure the privacy of data by adding noise to gradient descent steps (Shokri and Shmatikov, 2015; Abadi et al., 2016; Song et al., 2013). In this way, it hides the exact local gradient from the global model. In differential private federated learning (Geyer et al., 2017; Wei et al., 2020b), each client clips the gradient and introduces a random Gaussian noise before updates to the cluster. In the setting of two-layer networks, the update of aj is \u02dc gj = gj/ max \u001a 1, \u2225g\u2225 S \u001b + \u03f5, where \u03f5 \u223cN(0, \u03c32I). Note that under this setting, the information contained in the gradient is disrupted by gradient clipping and random noise. We first analyze the effect of the two strategies separately. For gradient clipping, we conduct our method based on observed clipped gradient \u02dc g. There will be no defensive effect to our attack no matter the clipping threshold and we can prove that the reconstruction error bound \u02dc O(BK q d m) is the same as that with no defense (even for the hidden terms). For noisy gradient g + \u03f5, we have the same order of error bound if the noise level \u03c3 \u2264O( B m) so the defense is not effective. In the defense of differential privacy gradient descent, we combine the two strategies and conduct a tensor method based on \u02dc g + \u03f5. The defense is more effective and has an error bound O(max{1, \u2225g\u2225 S }) times to the bound of gradient noise defense only. Gradient clipping enhances the defensive performance of the gradient noise though itself has no effect in defending the attack. However, our attack method is still enough to recover the feature since we can modify the initial weights to control \u2225g\u2225. Conclusion. The defense of gradient clipping has no effect while gradient noise and differential privacy gradient descent is successful only when the noise level is relatively large. However, the noise variance \u03c32 in the application is usually small since a large random noise will cause bad performance in federated learning (Wei et al., 2020b). We also show some results in Section 4. See detailed proofs of the error bounds in Appendix C.2. 3.4 Secure aggregation In federated learning, local devices update gradients to the server individually. Secure aggregation (Bonawitz et al., 2016, 2017) is a method that clients {u1, . . . , uL} can aggregate their gradients prior to the cluster and the cluster can only access to aggregated gradient: \u02dc G = 1 B PL i=1 glBl, where gl and Bl is the gradient update and batch size for user ul respectively and B = PL i=1 Bl. In this way, the global server is blocked from knowing each individual gradient and then prevents privacy leakage. Even though the server can reconstruct the training data, it cannot identify which user has the data. If we only reconstruct data without identifying its source, the aggregated gradient is equivalent to a gradient step with large batch size B and we can conduct our tensor-based attack on the aggregated gradient. Conclusion. Tensor method will still work when the batch size is not too large. Otherwise, say B > d, feature recovery cannot work since the tensor decomposition is not unique. 8 \f3.5 Dropout Another method to improve the defending effect is dropout (Hinton et al., 2012; Srivastava et al., 2014), which is a mechanism designed to prevent overfitting. It randomly drops nodes in a network with a certain probability 1 \u2212p. In this way, some of the entries in the gradient randomly turn to zero. Since dropout introduces randomness to the gradient, it can be used to defend against privacy attacks in federated learning. The effect of dropout against gradient matching is empirically discussed in (Huang et al., 2021; Zhu et al., 2019). A two-layer fully connected network with a dropout layer can be written as f(x; \u0398) = m X j=1 sjaj\u03c3(wj \u00b7 x) = X j:sj=1 aj\u03c3(wj \u00b7 x), where sj \u223cBernoulli(p). Thus, the model has an effective width equal to the number of nodes m\u2032 that has not been dropped. We can compute the sum 1 m\u2032 P j:sj=1 gjHp(wj) and conduct tensor decomposition. Since the effective width m\u2032 \u2248pm, the defense is not effective when p is not too small. 3.6 Gradient pruning Gradient pruning (Sun et al., 2017; Ye et al., 2020) is a method that accelerates the computation in training by setting the small entries in gradient to zero. Thus, the gradient will be sparse, which is similar to dropout. However, the key difference is that the remaining entries of the gradient in dropout are chosen randomly yet gradient pruning drops small entries making the defending more effective (when a similar level of utility is lost). If we denote the set of entries that is not pruned by S and conduct the tensor-based attack, we have \u02c6 Tp = 1 m\u2032 X j\u2208S gjHp(wj), where gj = \u2207ajL and m\u2032 = |S|. This formula has a similar form to the case in dropout but the key difference is that the remaining wj\u2019s are more likely to make gj larger so they do not follow the normal distribution. In this case, the concentration property P j\u2208S g(wj)Hp(wj) \u2248 m\u2032 Ew\u223cN(0,I)[g(w)Hp(w)] may not hold. Moreover, Lemma 3.1 cannot be applied with wj\u2019s are not normal random vectors so Ew\u223cN(0,I)[g(w)Hp(w)] \u0338= Ew[\u2207p wg(w)]. Thus, the \u02c6 Tp is not a good estimation of the real tensor product, indicating gradient pruning defense is effective against feature reconstruction. 4 Experiments 4.1 Experimental setup Key parameters of defenses. We evaluate defense methods on CIFAR-10 dataset (Krizhevsky et al., 2009) with a ResNet-18 (trained for one epoch), which is the default backbone model for federated learning. For the deep image prior model, we use a U-Net backbone similar to an unmasked PixelCNN++ (Salimans et al., 2017; Ronneberger et al., 2015) and replace the original weight normalization (Salimans and Kingma, 2016) with group normalization (Wu and He, 2018). We use self-attention at the 16 \u00d7 16 feature map resolution (Wang et al., 2018). The details are in the Appendix D. For GradPrune: gradient pruning sets gradients of small magnitudes to zero. We vary 9 \fOurs Geiping et al. (2020) Original p = 0.5 p = 0.7 Gradprune bound = 2 bound = 4 bound = 8 GradClipping p = 0.99  = 0.1  = 0.01 GradNoise Local Agg. step = 3 step = 5 No defense Geiping et al. (2020) Ours Figure 2: Comparison of the reconstruction results from the gradient inversion method (Geiping et al., 2020) and our proposed attack method on different defenses with batch size equal to 4. Our method achieves more robust reconstruction across various defenses. Gradient pruning (p = 0.99) makes reconstructions from both methods almost unrecognizable. Batch Size 16 32 Method Geiping Jeon Ours Geiping Jeon Ours LPIPS \u2193 0.41 (0.09) 0.17 (0.12) 0.14 (0.11) 0.45 (0.11) 0.24 (0.13) 0.15 (0.11) Table 1: Comparison of our methods with other state-of-the-art methods, Geiping, and Jeon refer to (Geiping et al., 2020) and (Jeon et al., 2021) respectively. We highlight the best performances in bold. the pruning ratio p in {0.3, 0.5, 0.7, 0.9, 0.99}. For GradClipping: gradient clipping set gradient to have a bounded norm, which is ensured by applying a clipping operation that shrinks individual model gradients when their norm exceeds a given threshold. We set this threshold as {2, 4, 8}. We also adopt defense by adding noise to gradient, the noise is generated from random Gaussian with different standard deviations {0.001, 0.01, 0.05, 0.1}. Local gradient aggregation aggregates local gradient by performing a few steps of gradient descent to update the model. We locally aggregate 3 or 5 steps. Key experimental setup for the attack. We use a subset of 50 CIFAR-10 images to evaluate the attack performance. To achieve a strong attack, we add reconstructed features (after linear projections to match the dimension) into each residual block of the U-Net. We also assume the batch norm statistics are available following (Geiping et al., 2020). We observe the difficulty of optimization when using cosine-similarity as the gradient inversion loss under our setting, and therefore address this issue by reweighting the gradients by their \u21130 norm. See details in the Appendix D. Zhu et al. (2019); Geiping et al. (2020) have shown that small batch size is vital for the success of the attack. We intentionally evaluate the attack with two small batch sizes 4 and 8 and two small but realistic batch sizes, 16 and 32. Metrics for reconstruction quality. We visualize reconstructions obtained under different defenses. Following (Yin et al., 2021), we also use the RMSE, PSNR, and learned perceptual image patch similarity (LPIPS) score (Zhang et al., 2018) to measure the mismatch between reconstruction and original images. For the evaluation of feature reconstruction, we use the average norm of projection 10 \fGradprune GradClipping GradNoise Local Aggregation Batchsize w/o defense p=0.3 p=0.5 p=0.7 bound=2 bound=4 bound=8 0.001 0.01 0.1 step=3 step=5 1 0.171 0.173 (0.002) 0.173 (0.002) 0.248 (0.006) 0.173 (0.002) 0.173 (0.002) 0.173 (0.002) 0.172 (0.003) 0.174 (0.002) 0.259 (0.012) 0.181 (0.067) 0.213 (0.071) 2 0.171 0.171 (0.003) 0.218 (0.011) 0.443 (0.120) 0.169 (0.003) 0.169 (0.003) 0.170 (0.003) 0.166 (0.003) 0.252 (0.082) 0.850 (0.108) 0.186 (0.127) 0.210 (0.087) 4 0.174 0.186 (0.114) 0.277 (0.106) 0.483 (0.075) 0.174 (0.116) 0.175 (0.127) 0.177 (0.113) 0.190 (0.021) 0.252 (0.106) 0.714 (0.102) 0.192 (0.079) 0.218 (0.081) 8 0.175 0.188 (0.044) 0.266 (0.071) 0.425 (0.043) 0.179 (0.041) 0.179 (0.041) 0.179 (0.041) 0.198 (0.114) 0.499 (0.104) 0.953 (0.108) 0.202 (0.073) 0.223 (0.069) Table 2: Feature reconstruct error under different defenses. When using gradient pruning defense and gradient noise defense with large \u03c3, the feature reconstruction quality degrades significantly. None GradNoise (\u03c3) GradPrune (p) GradClipping (bound) Local Aggregation (step) Parameter 0.001 0.01 0.05 0.1 0.3 0.5 0.7 0.9 0.99 2 4 8 3 5 Attack batch size = 2 RMSE \u2193 0.15(0.04) 0.17 (0.05) 0.22 (0.07) 0.31 (0.06) 0.28 (0.08) 0.16 (0.08) 0.17 (0.07) 0.20 (0.09) 0.26 (0.09) 0.27 (0.10) 0.17 (0.08) 0.17 (0.08) 0.19 (0.08) 0.23 (0.09) 0.25 (0.10) PSNR \u2191 23.69 (5.69) 23.31 (3.04) 21.32 (3.52) 14.58 (1.59) 13.11 (4.26) 22.63 (6.15) 23.33 (6.03) 19.40 (6.02) 16.39 (6.56) 14.72 (6.45) 23.26 (6.10) 23.40 (6.00) 23.01 (6.28) 18.65 (6.75) 18.77 (7.33) Attack batch size = 4 RMSE \u2193 0.15 (0.03) 0.19 (0.07) 0.24 (0.08) 0.29 (0.03) 0.27 (0.07) 0.16 (0.04) 0.16 (0.03) 0.21 (0.04) 0.27 (0.07) 0.27 (0.08) 0.16 (0.03) 0.16 (0.04) 0.16 (0.04) 0.28 (0.08) 0.26 (0.08) PSNR \u2191 23.59 (5.39) 20.12 (3.58) 16.41 (4.64) 11.27 (0.33) 12.28 (4.08) 23.16 (5.48) 24.08 (5.38) 18.73 (5.63) 13.90 (3.77) 12.43 (2.73) 22.88 (5.31) 23.93 (5.55) 24.04 (5.58) 13.84 (5.38) 14.21 (5.41) Attack batch size = 8 RMSE \u2193 0.15 (0.04) 0.19 (0.05) 0.29 (0.05) 0.30 (0.03) 0.30 (0.06) 0.15 (0.03) 0.16 (0.04) 0.20 (0.05) 0.29 (0.05) 0.29 (0.05) 0.16 (0.03) 0.16 (0.04) 0.16 (0.04) 0.29 (0.04) 0.30 (0.04) PSNR \u2191 23.37 (5.42) 20.31 (4.13) 14.56 (0.88) 11.27 (0.89) 11.27 (1.83) 23.74 (5.21) 23.32 (5.13) 18.25 (5.22) 11.30 (2.10) 11.13 (2.15) 23.36 (5.14) 23.59 (5.41) 23.47 (5.23) 11.25 (2.56) 10.82 (2.20) Table 3: Our method evaluated with different defense methods. With feature matching, our method performs well against most defenses. Specifically, gradient pruning shows its effectiveness under this stronger attack as well. from original features to the orthogonal complement of the space spanned by reconstructed features. This metric measures the difference between the two spaces spanned by original and reconstructed features. Compared with the average cosine similarity between features, this metric is more robust when some features are similar. 4.2 Experiment results Results of the proposed attack method. Our method can be easily added to previous methods (Zhu et al., 2019; Geiping et al., 2020). In Table 1, we compare the state-of-the-art methods with the proposed attacking method, our method outperforms previous methods. We visualize reconstructed images in Figure 2. Without any defense, both (Geiping et al., 2020) and our attack method can recover images well from the gradient, and our method produces higher-quality images. Increasing the batch size makes all methods more difficult to recover well. With defenses, our method shows better robustness \u2013 the recovered images are visually similar to the original image. This result shows that our attack is a stronger attack under these defense methods. Figure 3b suggests that the feature matching loss is the main reason behind such robustness, showing that the analysis of feature reconstruction is reasonable. See Table 3 and Table 5 in Appendix E for summary of reconstruction results. Comparison of defense methods in feature recovery. For feature recovery, we compared the reconstruction error under different defending strategies, and the results are shown in Table 2. We also use the final training loss of the federated learning model to measure the level of interference from defenses toward the training (details see Table 6 in Appendix E). For an effective defense, it should increase the feature reconstruction error while disturbing little to the training. We show the relation between reconstruction error and final training loss with different defenses in Figure 3a. Gradient pruning has a large reconstruction error without increasing training loss too much so it has the best defending effect under this criteria. Adding noise also prevents feature leakage when noise is large enough but it will affect training. Gradient clipping is barely effective for defending feature recovery while dropout has a mild effect but it is harmful to training. The feature reconstruction 11 \f(a) Feature reconstruction error vs final training loss. None GradNoise GradPrune GradClipping Defense method 0 5 10 15 20 25 30 Average PSNR w/ feature matching w/o feature matching (b) PSNR of our method against different defenses. Figure 3: The results of defenses against our attack. (a) The final training loss measures the level of interference with the training of defenses. The relation between feature error and interference reflects the effect of defenses. (b) PSNR of reconstructed data using the method with and without feature matching. The difference indicates that feature matching improves robustness against defenses. errors are consistent with the theoretical analysis in Section 3. Comparison of defense methods in inputs reconstruction. According to 3, data reconstructed by our method with defense gradient pruning and gradient noise has the smallest average PSNR, indicating that these two defenses are effective against our attack. However, according to Figure 3a, the final training loss of gradient pruning is smaller than that of gradient noise even when the pruning parameter p is very large. Therefore, gradient pruning is the best defense that prevents data leakage and maintains training utility at the same time. It is also shown in Figure 2 that gradient pruning with p = 0.9 has the best defensive effect. Gradient noise with \u03c3 = 0.1 also works but the final training loss is large, showing its interference towards training. We also compared between our attack method and the method without feature matching against different defenses in Figure 3b to show the effect of feature matching. Here we choose the batch size B = 8 and defenses gradient noise with \u03c3 = 0.001, gradient pruning with p = 0.9, and gradient clipping with threshold 4. It is shown that feature matching improves the robustness of our attack against gradient noise and gradient clipping defenses. This can be explained by our analysis in Section 3 that feature recovery works badly against gradient pruning and feature matching regularization has no effect with inaccurate features. See the quantified effect of defenses with and without feature matching in Table 3 and Table 5 in Appendix E. 5"
+                }
+            ],
+            "Hong Guo": [
+                {
+                    "url": "http://arxiv.org/abs/2401.09846v3",
+                    "title": "Phase structure of holographic superconductors in an Einstein-scalar-Gauss-Bonnet theory with spontaneous scalarization",
+                    "abstract": "Holographic superconductor phase transition and spontaneous scalarization are\ntriggered by the instability of the underlying vacuum black hole spacetime.\nAlthough both hairy black hole solutions are closely associated with the\ntachyonic instability of the scalar degree of freedom, they are understood to\nbe driven by distinct causes. It is, therefore, interesting to explore the\ninterplay between the two phenomena in the context of a scenario where both\nmechanisms are present. To this end, we investigate the\nEinstein-scalar-Gauss-Bonnet theory in asymptotically anti-de Sitter spacetime\nwith a Maxwell field. On the one hand, the presence of the charged scalar and\nMaxwell fields in anti-de Sitter spacetime furnishes the celebrated framework\nfor a holographic superconductor. On the other hand, the non-minimal\nGauss-Bonnet coupling between the scalar field and the gravitational sector\ntriggers spontaneous scalarization. However, near the transition curve, the two\nphases are found to be largely indistinguishable regarding both the radial\nprofile and effective potential. This raises the question of whether the hairy\nblack holes triggered by different mechanisms are smoothly joined by a phase\ntransition or whether these are actually identical solutions. To assess the\ntransition more closely, we evaluate the phase diagram in terms of temperature\nand chemical potential and discover a smooth but first-order transition between\nthe two hairy solutions by explicitly evaluating Gibbs free energy and its\nderivatives. In particular, one can elaborate a thermodynamic process through\nwhich a superconducting black hole transits into a scalarized one by raising or\ndecreasing the temperature. Exhausting the underlying phase space, we analyze\nthe properties and the interplay between the two hairy solutions.",
+                    "authors": "Hong Guo, Wei-Liang Qian, Bean Wang",
+                    "published": "2024-01-18",
+                    "updated": "2024-05-15",
+                    "primary_cat": "gr-qc",
+                    "cats": [
+                        "gr-qc"
+                    ],
+                    "main_content": "INTRODUCTION As an enigmatic prediction of General Relativity, the black hole is an extreme manifestation of the spacetime curvature. In the past millennium, owing to the continuous endeavor in astrophysics regarding observation associated with both electromagnetic and gravitational wave channels, the black hole is arguably the most notable astrophysical object [1, 2]. Specifically, recent decades have witnessed unprecedented advances in gravitational wave detection, achieved by LIGO-Virgo Collaboration, which involves more than one hundred black hole binary mergers [3\u20136]. These prominent astrophysical events provide a crucial means to investigate extreme gravitational phenomena. In particular, the most complex dynamics and extreme gravitational conditions occur in the vicinity of the black hole\u2019s horizon. As it plays a pivotal role by connecting theoretical speculations with astrophysical observations, the relevant studies have triggered much attention in the literature [7\u20139]. One pertinent topic in black hole physics concerns a series of \u201cno-hair\u201d theorems and their evasion [10\u201312]. These theorems state that all the information about a black hole is determined by its mass, charge, and angular momentum. On the other hand, substantial insights can also obtained by exploring the scenarios when the prior condition of such theorems becomes invalid. The latter might give rise to hairy black hole solutions owing to various mechanisms [13\u201315]. The celebrated holographic superconductor is primarily owing to the tachyonic instability in the asymptotically anti-de Sitter (AdS) spacetime, complemented with the presence of a Maxwell field and a charged scalar [16, 17]. In this framework, the asymptotic AdS spacetime is crucial to evading the prerequisite of no-hair theorems in asymptotically flat spacetimes [18]. More recently, an alternative mechanism for hairy black holes, known as black hole spontaneous scalarization, has been proposed. In its original form, it refers to the scenario where the scalar degree of freedom is nonminimally coupled to the Gauss-Bonnet curvature in an asymptotically Minkowski spacetime, giving rise to the emergence of hairy black hole solutions [19\u201321]. In this regard, one pivotal feature of the theory is its ability to evade the no-hair theorem in asymptotically flat spacetimes. In the literature, the notion of black hole spontaneous scalarization quickly garnered significant attention. It was observed that black hole spontaneous scalarization may take place in a more general context where the scalar field is nonminimallly coupled to source terms furnished by various types of matter fields, inclusively the Maxwell invariant [22], Chern-Simons invariant [23], and the Ricci scalar [24]. Further developments on spontaneous scalarization in2 \fvolve spin-induced [25\u201328], nonlinear [29\u201332], and dynamical descalarization scenarios [33\u201338]. This mechanism is also extendable to cases with a cosmological constant [39\u201345], contributing to its prominence. A comprehensive survey of recent progress can be found in the review [46]. Notably, spontaneous scalarization is also attributed to the instability of the underlying hairfree black hole solution. The latter is demonstrated as an effective tachyonic mass in the master equation governing the linearized scalar perturbations. In particular, the stability of the corresponding \u201cbald\u201d black hole solution can be analyzed by explicitly evaluating the quasinormal frequencies [19, 47, 48]. In Refs. [47, 48], the onset of spontaneous scalarization is recognized as when the purely imaginary quasinormal modes touch the origin. More specifically, bound state solutions of the scalar field were derived in [20, 49, 50], for which the occurrence of spontaneous scalarization is shown to coincide with that for the marginally stable quasinormal mode encountered in [47, 48]. A sufficient condition for the tachyonic instability is attained when the effective potential for the scalar perturbations Veff can be essentially viewed as a potential well, namely, R +\u221e \u2212\u221edr\u2217Veff(r\u2217) < 0. This condition guarantees [51] at least one bound state, indicating the instability of a bald black hole, which typically occurs as the coupling exceeds a critical value. It is noteworthy to point out that the occurrence of superluminal propagation in the system with a substantial Gauss-Bonnet term is known in the literature and has been explored in the context of the AdS/CFT correspondence [52\u201357]. In the present scenario, such an effect becomes \u201cdynamic\u201d as it is nonlinearly coupled to a scalar field. Subsequently, rather than a \u201cstatic\u201d bound for metric parameters, one acquires a physical instability associated with the scalar degree of freedom that eventually gives rise to a scalarized hairy black hole. As discussed in [47], it is also essential to note that the tachyonic instability, being a sufficient condition, does not always align with the onset of marginally stable quasinormal modes. Nonetheless, the instability of the bald black hole solution is ascertained by the unstable quasinormal modes, while the subsequent transition to a hairy black hole can be confirmed by explicitly deriving the non-vanishing bound state solution [20, 49, 50] and evaluating the entropies of the scalarized black hole and compare it against that of its bald counterpart [19]. Given that the occurrence of unstable quasinormal modes is a weaker condition whose onset does not always warrant tachyonic instability, it was argued in [48] that spontaneous scalarization is caused by the GregoryLaflamme instability [58]. In other words, another mechanism might trigger scalarization before the effective potential eventually becomes a potential well. The present study is motivated by the above consideration to explore further the properties 3 \fand relation between the two mechanisms for hairy black holes. To this end, we employ the Einstein-scalar-Gauss-Bonnet theory in asymptotically AdS spacetime, a scenario where both relevant mechanisms are present. Specifically, a charged scalar field is coupled to the Gauss-Bonnet invariant in such a framework. On the one hand, the minimal coupling between the scalar field and the Maxwell field leads to a tachyonic instability, forming a s-wave holographic superconductor [59]. On the other hand, the scalar field is coupled to the Gauss-Bonnet curvature, giving rise to spontaneous scalarization [19]. Although both instabilities imply a transition to the hairy black hole, it is not entirely clear whether the hairy black hole are equivalent, given that the resulting profiles of the fields are largely indistinguishable near the transition point. We scrutinize this point by evaluating the phase diagram in terms of temperature and chemical potential, and explicitly calculating the Gibbs free energy and its derivatives. In particular, we identify a rather smooth but first-order transition between the two hairy solutions. By exhausting the parameter space of the underlying black hole metric, we analyze the properties and the interplay between the two hairy solutions. The holographic superconductor phase is found to flip over to the other side of the transition curve when the temperature drops below the critical value corresponding to vanishing Gauss-Bonnet coupling. Moreover, it is pointed out that the two mechanism can also be distinguished by their specific shapes of the effective potentials. The remainder of the paper is organized as follows. In the following section, we elaborate on the Einstein-scalar-Gauss-Bonnet model, the relevant equations of motion, and the corresponding boundary conditions. The numerical scheme is presented in Sec. III, which is then used to derive the hairy black hole solutions and subsequently the phase diagram. We explore the properties of the obtained solutions associated with the holographic superconductor and spontaneous scalarization. Furthermore, the phase diagram of the model is presented in terms of temperature and chemical potential. We analyze the specific shapes of the effective potentials reflecting the underlying instabilities of the underlying gravitational system. The last section is devoted to further discussions and concluding remarks. II. EINSTEIN-SCALAR-GAUSS-BONNET MODEL In this section, we elaborate on the Einstein-scalar-Gauss-Bonnet model employed in the present study. The action consists of a charged massive scalar field \u03c8 nonminimally coupled to the Gauss-Bonnet invariant with the presence of a Maxwell field in an asymptotically AdS 4 \fspacetime [60, 61] S = 1 16\u03c0GN Z d4x \u221a\u2212g \" R + 6 L2 \u22121 4F\u00b5\u03bdF\u00b5\u03bd \u2212|D\u00b5\u03c8|2 \u2212m2|\u03c8|2 + f(\u03c8)R2 GB # , (1) where the Gauss-Bonnet curvature R2 GB = R2 \u22124R\u00b5\u03bdR\u00b5\u03bd + R\u00b5\u03bd\u03b1\u03b2R\u00b5\u03bd\u03b1\u03b2, f(\u03c8) describes the nonminimal coupling between the scalar and the spacetime curvature. The covariant derivative is defined by D\u00b5 = \u2207\u00b5 \u2212iqA\u00b5, where the scalar\u2019s electric charge q measures its coupling to the Maxwell field. Also, GN is Newton\u2019s constant, and L represents the curvature radius of the AdS spacetime. On the one hand, as the charge q vanishes, the action falls back to a more straightforward case that furnishes spontaneous scalarization [19]. On the other hand, if one assumes f(\u03c8) = 0, the model is essentially a s-wave holographic superconductor [59]. We note that to guarantee that the coupling function f(\u03c8) can induce the spontaneous scalarization, the following specific form is adopted [19] f(\u03c8) = \u03bb2 2 \u0010 1 \u2212e\u2212\u03c82\u0011 . (2) where the strength \u03bb is a constant, so that f \u2032(0) = 0 and f \u2032\u2032(0) > 0 [19]. In the asymptotically AdS spacetime, we consider the following metric ansatz ds2 = \u2212g(r)dt2 + 1 g(r)dr2 + r2 \u0010 dx2 + dy2\u0011 , (3) where g(r) = r2 L2 \u2212M r , (4) and the Hawking temperature reads T = g\u2032(rh) 4\u03c0 . (5) In the probe limit, by varying the action Eq. (1) w.r.t. the scalar and electromagnetic degrees of freedom, one finds the following equations of motion \u2207\u00b5\u2207\u00b5\u03c8 \u2212 \u0010 m2 + q2A\u00b5A\u00b5\u0011 \u03c8 + 1 2 f \u2032(\u03c8)R2 GB = 0 , (6) \u2207\u03b1F\u03b1\u00b5 = 2q2A\u00b5\u03c82 . (7) By considering spherically symmetric case where A\u00b5dx\u00b5 = \u03d5(r)dt, \u03c8 = \u03c8(r), the equations are further simplified to read \u03d5\u2032\u2032(r) + 2 r \u03d5\u2032(r) \u22122q2\u03c8(r)2 g(r) \u03d5(r) = 0 , (8) \u03c8\u2032\u2032(r) +  2 r + g\u2032(r) g(r) ! \u03c8\u2032(r) + q2\u03d5(r)2 \u2212m2g(r) g(r)2 \u03c8(r) + R2 GB 2g(r) f \u2032(\u03c8) = 0 , (9) 5 \fwhere the Gauss-Bonnet curvature is evaluated as R2 GB = 4 r2 h g\u2032(r)2 + g(r)g\u2032\u2032(r) i . Using the tortoise coordinate dr\u2217= dr g(r) and denoting \u03c8 = \u03c6 r , the Klein-Gordon equation (9) can be brought into a Schrodinger-like form as \u22022\u03c6(r) \u2202r2 \u2217 \u2212Veff(r)\u03c6(r) = 0 , (10) where the effective potential of the scalar field is Veff(r) = g(r)  g\u2032(r) r + m2 \u2212q2 g(r)\u03d5(r)2 \u2212\u03bb2 2 R2 GB ! . (11) To derive Eqs. (10) and (11), it is noted that the scalar and electromagnetic fields are treated as perturbations and in particular, we have only kept the leading term in the expansion d f(\u03c8) d\u03c8 \u2243 \u03c8 \u0012 1 \u2212\u03c82 + 1 2\u03c84 + O(\u03c86) \u0013 . We proceed to discuss the boundary conditions for the above equations of motion. It is important to note that the boundary conditions are derived based on generic requirements for the fields to be regular and the asymptotical forms of the equations of motion. These conditions are universal for distinct hairy black hole solutions associated with different physical natures. At the event horizon, r = rh, the scalar and Maxwell field must be regular. From Eq. (8), the last term on the l.h.s. indicates \u03d5(rh) = 0. (12) By substituting it into Eq. (9), we have \u03c8\u2032(rh) = L2 3rh \uf8eb \uf8ec \uf8ec \uf8ec \uf8ec \uf8edm2 \u221218\u03bb2e\u2212\u03c8(rh)2 L4 \uf8f6 \uf8f7 \uf8f7 \uf8f7 \uf8f7 \uf8f8\u03c8(rh) . (13) At spatial infinity, by analyzing the leading contributions, the asymptotical behaviors of scalar and Maxwell fields are found to be \u03d5(r) = \u00b5 \u2212\u03c1 r , (14) \u03c8(r) = \u03c81 r\u2206\u2212+ \u03c82 r\u2206+ , (15) where \u2206\u00b1 = 3\u00b1\u221a 9+4m2 eL2 2 and the effective scalar mass is defined as m2 e = m2 \u221212 \u03bb2 L4. One enforces the condition \u03c82 = 0, (16) so that the condensation is turned on without a source on the AdS boundary. 6 \fIn the framework of the holographic principle, \u00b5 is the chemical potential, and \u03c1 describes the charge density of the field theory. The condensate of the scalar operator O in the field theory dual to the field \u03c8 is given by < O1 >= \u221a 2\u03c81. (17) The asymptotical behavior of Eq. (14) can be used to extract the density and chemical potential. It is not difficult to observe that there is a scaling symmetry in the model; namely, a hairy black hole solution continues to be valid under the following scaling transform r \u2192ar, (t, x, y, ) \u2192(t, x, y)/a, (18) accompanied by M \u2192a3M, L \u2192L, rh \u2192arh, g \u2192a2g, (19) and \u03d5(r) \u2192a\u03d5(r/a), \u03c8(r) \u2192\u03c8(r/a), RGB \u2192RGB, (20) q \u2192q, m \u2192m, \u03bb \u2192\u03bb. (21) In this regard, we redefine temperature and chemical potential in a scaling transform invariant fashion, namely, \u02dc T = T Tc and \u02dc \u00b5 = \u00b5 Tc, where Tc is the transition temperature at vanishing GaussBonnet coupling. III. TWO TYPES OF HAIRY BLACK HOLE SOLUTIONS In this section, we demonstrate that two distinct types of hairy black hole solutions associated with, respectively, holographic superconductor and scalarization, coexist in the model. Using the numerical scheme presented in Sec. III A, the phase diagram will be evaluated and presented in terms of temperature and Gauss-Bonnet coupling shown in Fig. 1. The system comprises three phases: thermalized vacuum represented by a phase of bald black hole solutions, holographic superconductor, and scalarization phases indicated by hairy black hole solutions. As will be validated in Sec. III B, to identify and explore the transition between the two hairy black hole phases, one may also present the phase diagram in terms of temperature and chemical potential, shown in Fig. 2. We note that the latter two thermodynamic quantities are independent ones not constrained by scaling laws, while they facilitate the study of phase transition\u2019s order. Moreover, the 7 \fthermodynamic properties of their interpretation in the dual field theory are then elaborated, and in particular, the free energy of obtained spacetime configurations are evaluated. We relegate the stability analysis of the underlying bald black hole solutions to Sec. III C. Holographic Superconductor Bald Black Hole Spontaneous Scalarization 0.0 0.2 0.4 0.6 0.8 1.0 1.2 1.4 0 1 2 3 4 5 \u03bb T \uf02d FIG. 1. The phase diagram shown in terms of temperature \u02dc T and Gauss-Bonnet coupling \u03bb. The blue region represents the holographic superconductor phase, and the solid black curve indicates the boundary where the transition to a bald black hole occurs. The red region corresponds to the spontaneous scalarization phase, so the black dashed line represents the critical value of the Gauss-Bonnet coupling. The calculations have been carried out by adopting rh = L = 1, q = 1 and m2 e = \u22122. FIG. 2. The phase diagram shown in terms of temperature \u02dc T and chemical potential \u02dc \u00b5. The conventions introduced in Fig. 1 have been adopted, and the calculations have been carried out using the same parameters. The left panel shows the phase diagram in the high temperature and small chemical potential region. The middle panel corresponds to the low temperature and large chemical potential region. The right panel shows the region where the holographic superconductor phase flips to the other side of the spontaneous scalarization one. 8 \fA. Numerical procedure The hairy black hole solutions are derived numerically using the shooting method. The scalar and Maxwell fields are evaluated by the equations of motion Eqs. (8) and (9) using numerical integration. As mentioned above, the two types of hairy black holes are encountered by adopting the same boundary conditions discussed in the last section. Besides, from a mathematical perspective, although they originated from different physical mechanisms and reside in different regions of the parameter space, the algorithm to derive these solutions is mainly identical, specified as follows. One starts the numerical integration at the horizon r = rh where the two lowest Taylor expansion coefficients are determined by assuming the values of \u03c8(rh) and \u03d5\u2032(rh) and using Eqs. (12) and (13). The shooting procedure is accomplished by enforcing the condition Eq. (16) at the boundary. As for the one-dimensional Schrodinger-like equation, the number of nodes corresponds to the energy level. In the present study, we will focus on the ground state by only considering the solution without any node, as shown in Fig. 3. For simplicity, the numerical calculations are carried out using rh = L = 1 and q = 1. In particular, following [17, 59, 62\u201364], we set the effective mass to m2 e = \u22122, which is above the Breitenlohner-Freedman bound for stability. By comparing the obtained radial profiles \u03c8(r) and \u03d5(r) to the asymptotical form Eq.(15), the values of \u00b5 and \u03c1 are extracted. The resulting family of solutions is characterized by two variables, namely, the coupling \u03bb and \u03c8(rh). One then employs the system\u2019s scaling invariance by using Eqs. (18)-(21) to cover the remainder of the parameter space. When the Gauss-Bonnet coupling \u03bb is sufficiently tiny, specifically \u03bb < \u03bbc \u22480.6339, it is shown that a holographic superconductor phase is encountered featuring a transition at specific value of \u03d5\u2032(rh) [60], which can be effectively viewed to occur at a specific temperature employing the scaling Eqs. (18)-(21). In particular, it would be the only relevant mechanism in the present model to form a hairy black hole if one takes the limit \u03bb \u21920. On the other hand, hairy solutions due to spontaneous scalarization can be obtained by employing the same numerical scheme at larger Gauss-Bonnet coupling. Unlike a holographic superconductor, such a solution persists even when the charge of the scalar vanishes. To explore the phase structure of the system, one may first derive the above solutions in the specific region of the phase space and then continuously vary the parameters to the region of interest where both mechanisms are potentially relevant. Starting from a hairy black hole solution 9 \fassociated with a holographic superconductor, one explores the solution space by continuously increasing the Gauss-Bonnet coupling. As demonstrated in Fig. 1, it turns out that the transition at the critical temperature diverges as \u03bb \u2192\u03bbc from below. Both mechanisms persist for finite charge q and coupling \u03bb. As an illustration, the radial profiles of the scalar and Maxwell fields are shown in Fig. 3 in blue and red curves. The solid curves represent the numerical results for a holographically superconducting black hole with the metric parameters \u03c8(rh) = 0.1, \u03d5\u2032(rh) = 0.38, and \u03bb = 0.63. The dashed lines show the radial profiles of a spontaneous scalarization black hole with the parameters \u03c8(rh) = 0.112, \u03d5\u2032(rh) = 0.36, and \u03bb = 0.64. It is observed that the condensation of the scalar field while the temporal component of the electromagnetic field vanishes at the horizon. As the fundamental states, the obtained radial profiles do not contain any nodes. Notably, the two distinct types of hairy black holes somehow bear a strong resemblance if they are near the critical coupling \u03bbc. As the fields\u2019 radial profiles of the two cases are largely indistinguishable, it is not entirely clear whether the hairy black hole solutions residing on the two sides of \u03bb = \u03bbc are different ones and, even if they are potentially triggered by different mechanisms. In this regard, it is interesting to analyze the properties of the two phases and the transition between them further in the context of the system\u2019s phase structure. \u03c8 (r) \u03d5 (r) 0 20 40 60 80 100 -0.10 -0.05 0.00 0.05 0.10 r FIG. 3. Radial profiles of the scalar(blue) and Maxwell fields(red). The solid lines represent the holographc superconductor solution with \u03bb = 0.63, \u03c8(rh) = 0.1, \u03d5\u2032(rh) = 0.38, and the dashed lines are the spontaneous scalarization solution with \u03bb = 0.64, \u03c8(rh) = 0.112, \u03d5\u2032(rh) = 0.36. Numerically, one may ascertain that the two types of hairy black holes are indeed distinct when they are further apart in the parameter space. This can be demonstrated, for instance, by examining the scalar condensation near the horizon \u03c8(rh) as a function of the temperature for different Gauss10 \fBonnet coupling constants. The results are presented in Fig. 4. In the left panel, for a holographic superconductor, the results indicate how the system undergoes a phase transition. The scalar condensation merges as the system cools down and reaches the transition temperature represented by the solid black curve in Fig. 1. It rapidly grows as the temperature further decreases. However, as the coupling approaches the critical value \u03bbc, the transition temperature increases and eventually diverges. The dependence of the condensation on temperature becomes less drastic, and the overall shape of the curve approaches that of the spontaneous scalarization, as shown on the right panel of Fig. 4. The latter features distinctive patterns in two temperature regimes. At elevated temperatures, the scalar condensation converges to a constant magnitude that increases with increasing Gauss-Bonnet coupling. As temperature decreases, a surge of scalar condensation is observed. This behavior differs from spontaneous scalarization in the absence of an electromagnetic field due to an interplay between the two instabilities. \u03bb =0 \u03bb =0.4 \u03bb =0.5 \u03bb =0.6 \u03bb =0.6339 0 2 4 6 8 0.0 0.2 0.4 0.6 0.8 1.0 T \uf02d \u03c8 (rh) \u03bb =0.634 \u03bb =0.8 \u03bb =1.0 \u03bb =1.5 \u03bb =1.8 0 2 4 6 8 10 12 14 0.0 0.2 0.4 0.6 0.8 T \uf02d \u03c8 (rh) FIG. 4. Scalar condensation at the horizon \u03c8(rh) as the function of temperature with different Gauss-Bonnet coupling \u03bb in the situation of holographic superconductor (left) and spontaneous scalarization (right), respectively. However, the above analysis, and the phase diagram Fig. 1, are primarily based on the coupling constant \u03bb, which does not possess a straightforward thermodynamic interpretation. It is still not entirely clear whether there is a phase transition from a superconductor phase to the spontaneous scalarization one. In particular, it seems not straightforward to elaborate a thermodynamic process through which a superconducting black hole transits into a scalarized one by raising or decreasing the temperature. Regarding the AdS/CFT dictionary, it is more meaningful to present the results in terms of intensive thermodynamic quantities such as temperature and chemical potential. Such an approach is carried out in the following subsection. Moreover, we evaluate the system\u2019s free 11 \fenergy and elaborate further on the properties of the phase transition. B. Transitions among the black holes The phase diagram presented in Fig. 1 is closely related to the numerical employed scheme, which is standard in the literature. However, to explore the underlying phase transition between the two hairy black holes, it is meaningful to show the phase diagram in terms of thermodynamic variables such as temperature and chemical potential. Using the AdS/CFT dictionary, one can reiterate the phase diagram shown in Fig. 1 in terms of intensive quantities, namely, temperature and chemical potential. The results are presented in Fig. 2. It is noted that the chemical potential does not remain constant when the system evolves along a vertical line with given \u03bb, as shown in the bottom row of Fig. 5. When comparing Fig. 2 against Fig. 1, one observes a few intriguing features of the phase structure of the system. The solid black curve bridges the transition between the holographically superconducting black hole and a hairless one, as shown in the left panel of Fig. 2. The latter corresponds to the region of elevated temperature and lower chemical potential. A dashed black curve indicates the transition between the holographic superconductor and spontaneous scalarization, which will be elaborated further by evaluating the free energy. In this region, one may consider the following process with given chemical potential for an initially thermalized bald black hole with elevated temperature. As the temperature gradually decreases, the scalar field will condensate and form a holographic supercondutor via a second-order phase transition by tranversing the solid black curve. Subsequently, as the temperature further decreases, the system transits into a scalarized black hole through a first-order transition by crossing the dashed black curve. However, the above qualitative properties regarding the phase division does not change as one goes to higher-temperature region. In other words, even though the solid black curve and dashed black one asymptotically approach each other in Fig. 1 at the high-temperature limit, the two-phase transitions do not actually intersect in the phase space presented in terms of temperature and chemical potential. Moreover, the spontaneous scalarization phase does not extend and occupies the remainder of the phase space. It can be verified numerically that the temperature and chemical potential remain finite even at the limit \u03bb \u2192+\u221e. Also, a background hairless RN black hole spans the entire parameter space. The middle panel of Fig. 2 shows a similar transition, but the positions of the two phases are exchanged. It is also noted that the superconducting black hole cannot transit to a hairless 12 \f0.6 0.7 0.8 0.9 1.0 1.1 1.2 2.12 2.14 2.16 2.18 2.20 2.22 \u03bb \u03bc \uf02d T \uf02d=1.5 0.0 0.5 1.0 1.5 2.0 8 10 12 14 16 18 \u03bb \u03bc \uf02d T \uf02d=0.5 \u03bb =0 \u03bb =0.2 \u03bb =0.4 \u03bb =0.5 \u03bb =0.6 0.2 0.4 0.6 0.8 1.0 1.2 1.4 1.6 5 10 15 20 25 30 35 T \uf02d \u03bc \uf02d \u03bb =0.7 \u03bb =0.8 \u03bb =1.0 \u03bb =1.5 \u03bb =2.0 0 2 4 6 8 10 0 10 20 30 40 T \uf02d \u03bc \uf02d FIG. 5. The top row shows the chemical potential as a function of the Gauss-Bonnet coupling in the high temperature (top-left) and low temperature (top-right) regions, where the blue curves represent the holographic superconductors while the red curves describe the spontaneous scalarization, and the vertical gray dashed line is the critical coupling \u03bbc. The bottom row shows the chemical potential as a function of temperature for different Gauss-Bonnet couplings. counterpart in this region. This is because the solid black curve terminates at \u02dc T = 1 in Fig. 1 as such a transition is confined in the region T > Tc. The results in the left and middle panels imply that the two phases successively flip to the other side of the transition curve in a narrow region of the phase diagram, as shown in the right panel of Fig. 2. Such an intriguing phenomenon can be attributed to the non-monotonic behavior of chemical potential as a function of Gauss-Bonnet coupling at different temperatures. At an elevated temperature related to the left panel of Fig. 2, the chemical potential decreases as the coupling constant increases. Conversely, at a lower temperature corresponding to the middle panel of Fig. 2, the chemical potential increases monotonically with increasing coupling. The above results are explicitly shown in the top-left and top-right panels of Fig. 5. 13 \fTo provide a more comprehensive analysis of the transition between the holographic superconductor and spontaneous scalarization phases, we evaluate the on-shell Gibbs free energy of the system by following [65, 66], which reads F = F\u2126 V2 = \u22121 2\u00b5\u03c1 \u2212\u03c81\u03c82 + Z 1 0 dz \u0012q2\u03d5(z)2\u03c8(z)2 z2g(z) \u2212\u03bb2R2 GB 2z4 \u03c8(z)4\u0013 , (22) with z = rh r here and elaborate on the Gibbs condition. 1.165 1.170 1.175 1.180 1.185 1.190 1.195 -0.1 0.0 0.1 0.2 0.3 T \uf02d F \u03bc \uf02d=3.5 0.80 0.85 0.90 0.4 0.6 0.8 1.0 1.2 1.4 T \uf02d F \u03bc \uf02d=5.5 0.968 0.970 0.972 0.974 0.976 0.978 0.980 0.982 0.2 0.3 0.4 0.5 0.6 0.7 T \uf02d F \u03bc \uf02d=5 1.165 1.170 1.175 1.180 1.185 0.190 0.192 0.194 0.196 0.198 0.200 T \uf02d \u2202F \u2202\u03bc \uf02d \u03bc \uf02d=3.5 0.80 0.85 0.90 0.5 1.0 1.5 T \uf02d \u2202F \u2202\u03bc \uf02d \u03bc \uf02d=5.5 0.968 0.970 0.972 0.974 0.976 0.28 0.30 0.32 0.34 0.36 0.38 T \uf02d \u2202F \u2202\u03bc \uf02d \u03bc \uf02d=5 FIG. 6. The free energy and its first-order derivative w.r.t. the chemical potential as functions of temperature for different chemical potentials. The blue curves represent the holographic superconductors while the red curves describe the spontaneous scalarization, and the vertical gray dashed line indicates the transition point. The results are shown in Figs. 6 and 7. The three plots on the first row of Fig. 6 demonstrate the Gibbs conditions for, respectively, typical scenarios corresponding to the left, middle, and right panels of Fig. 2. Gibbs condition dictates that a phase transition occurs with equalized temperature, pressure, and chemical potential. When there is competition between the two mechanisms for hairy black holes, the surviving state corresponds to the one with less free energy. The magnified sections of the plots indicate that the transition is of first order for the first two plots since the free energy shot above the other phase after the transition point. The latter is also confirmed by explicitly showing that the first-order derivatives of the free energy are discontinuous, as given in the second row of Fig. 6. We therefore confirm that one can elaborate a thermodynamic process through which a superconducting black hole transits into a scalarized one by raising or decreasing the temperature. The purple region in the bottom panel of Fig. 2 indicates an intriguing scenario. 14 \fThere, the two phases directly compete in the purple region of the right panel of Fig. 2. According to the free energy evaluated and presented in the last plot on the first row of Fig. 6, a scalarized black hole possesses a smaller free energy and, therefore, is favorable. FIG. 7. The system\u2019s free energy as a function of chemical potential and temperature. In Fig. 7, we present the free energy landscape from a three-dimensional perspective. It illustrates how the transition takes place in a more intuitive fashion. The two free-energy surfaces intersect at a dashed black curve. When comparing the left and middle panels, one observes that the two phases switch their positions with respect to the transition curve. This occurs near the critical temperature \u02dc T \u22731. There, the free-energy surface of the spontaneous scalarization is found to swing from one side to the other through the vertical direction, while the superconducting phase\u2019s surface varies moderately, and the slope remains essentially unchanged. For the superconducting phase, the phase transition to bald black hole does not occur for \u02dc T < 1, and subsequently, the transition curve represented by the solid black curves ends at \u02dc T = 1. The latter region \u02dc T < 1 bounded by \u03bb = 0 also flips to the other side of the transition curve. These characteristics lead to the exchange of the two phases, as discussed in Fig. 6. Also, as mentioned above, for the region where the two phases coexist, a scalarized black hole always possesses a smaller free energy than the superconducting one and, therefore, is more favorable. C. Instability analysis using effective potential In this subsection, we complement our analysis by studying the tachyonic instability of the effective potentials. On the one hand, for a holographic superconductor, it is understood that the coupling between the scalar and Maxwell field in asymptotic AdS spacetime leads to tachyonic instability [17]. On the other hand, the coupling between the scalar field and the Gauss-Bonnet curvature also gives rise to tachyonic instability [20, 49, 50], and it has been argued that the origin 15 \fof the instability is Gregory-Laflamme type [48]. This section delves into the effective potential Eq. (11) of the scalar perturbations regarding the underlying instabilities. In literature, the tachyonic instability is primarily attributed to a negative effective mass extracted from examining the master equation of scalar perturbations. For a holographic superconductor, a negative effective scalar mass arises from the non-vanishing the Maxwell field (electrostatic potential) in AdS spacetime. For spontaneous scalarization, this is due to the contribution coming from the non-vanishing coupling between the scalar and higher curvature term. In what follows, the numerical results of the effective potential Eq. (11) are obtained by solving the system of equations, Eqs. (8) and (9), for given \u03bb, q, and \u03d5\u2032(rh) = 0.5 instead of \u03c8(rh). In Fig. 8, we present the effective potentials and the corresponding profiles of the scalar field, evaluated for various metric parameters. As pointed out in [48], the effective potential of tachyonic instability in AdS spacetime is featured by a positive barrier near the event horizon that smoothly converges to a given value at infinity. In the top-left panel of Fig. 8, the resulting effective potentials of a pure holographic superconductor agree with such a behavior. In the present model, this can be achieved by assuming \u03bb = 0. We note that the effective potential asymptotically approaches Veff \u2192\u2212q2\u03d5(r)2 at spatial infinity for the given metric parameters. The different curves in the plot are obtained by taking different values for the charge q. A positive potential barrier is formed near the event horizon for all the cases. An increase of the charge q causes the potential barrier to dissipate less rapidly as the radial coordinate increases. The negative values of the effective potential are attributed to the condensation of the Maxwell field, giving rise to tachyonic instability in scalar perturbations. Also, a more significant coupling between the scalar and Maxwell fields leads to a higher transition temperature for holographic superconductivity [17]. Conversely, a pure spontaneously scalarized black hole metric can be obtained in the present model by taking q = 0. The corresponding effective potentials are evaluated and shown in the top-right panel of Fig. 8, where one varies the Gauss-Bonnet coupling \u03bb. One observes that the obtained effective potential\u2019s main feature differs from that of a holographic superconductor. In particular, a potential well is formed near the event horizon, and the depth of this well gradually increases as the Gauss-Bonnet coupling \u03bb grows. Therefore, the potential well close to the horizon caused by the Gauss-Bonnet coupling is primarily understood to cause the tachyonic instability. Such a characteristic of the effective potential has been extensively discussed in the literature of spontaneous scalarization [20, 47], which was attributed to the Gregory-Laflamme instability in Ref. [48]. The above discussions further confirm the distinct nature of the holographic super16 \fq=0 q=0.5 q=1 q=1.25 q=1.5 1 5 10 50 100 -3.0 -2.5 -2.0 -1.5 -1.0 -0.5 0.0 0.5 r Veff \u03bb =0 \u03bb =0 \u03bb =0.5 \u03bb =0.75 \u03bb =1 \u03bb =1.25 1 5 10 50 100 -1.5 -1.0 -0.5 0.0 0.5 r Veff q=0 q=0 q=0.5 q=1 q=1.25 q=1.5 1 5 10 50 100 0 1 2 3 4 r \u03c8 (r) \u03bb =0 \u03bb =0 \u03bb =0.5 \u03bb =0.75 \u03bb =1 \u03bb =1.25 1 5 10 50 100 0.0 0.1 0.2 0.3 0.4 r \u03c8 (r) q=0 FIG. 8. The top row shows the calculated effective potentials for different model parameters. Top-left: The effective potential for the holographic superconductors with \u03bb = 0, evaluated for different charges q. Topright: The effective potential for the spontaneously scalarized black hole with q = 0, evaluated for different values of \u03bb. The bottom row shows the corresponding profiles of the scalar field \u03c8(r). conductivity and spontaneous scalarization phases, which are substantially triggered by entirely distinct mechanisms. Besides the thermodynamic quantities, such as the free energy, the difference is also manifested by the effective potential. The effective potentials are further explored in Fig. 9 for different values of the charge q. It is found that a more significant Gauss-Bonnet coupling \u03bb deepens the potential well near the horizon without affecting its behavior at infinity. Also, a more significant value of q causes the value of the effective potential to become more negative at infinity while not influencing the potential well near the event horizon. Therefore, one concludes that both mechanisms play a role in the present model rather independently. Subsequently, it is interesting to explore the properties of the hairy black hole in the region where the two mechanisms compete. In the preceding subsections, we elaborated on a scenario where both phases are present and 17 \f\u03bb =0 \u03bb =0.5 \u03bb =0.6 \u03bb =0.7 \u03bb =1 1 5 10 50 100 -0.8 -0.6 -0.4 -0.2 0.0 0.2 0.4 r Veff q=0.2 \u03bb =0 \u03bb =0.5 \u03bb =0.6 \u03bb =0.7 \u03bb =1 1 5 10 50 100 -1.0 -0.5 0.0 0.5 r Veff q=1 FIG. 9. The calculated effective potential with different couplings between the scalar and Maxwell fields. The calculations are carried out for different charges q. Left: The effective potential for a smaller coupling q = 0.2. Right: The effective potential for a more significant coupling q = 1. q=0 q=1.7 q=1.8 q=1.9 q=2 1 5 10 50 100 -6 -4 -2 0 r Veff \u03bb =0.3 q=0 q=1.7 q=1.8 q=1.9 q=2 1 5 10 50 100 -2.0 -1.5 -1.0 -0.5 0.0 r Veff \u03bb =1 FIG. 10. The calculated effective potential near the transition curve between a holographic superconductor and spontaneous scalarization. The calculations are carried out for different charges q. Left: The effective potential for the holographic superconductor with \u03bb \u2272\u03bbc. Right: The effective potential for the spontaneously scalarized black hole with \u03bb \u2273\u03bbc. explored the transition between them. It is, therefore, also interesting to study the effective potentials in the phase transition region. This analysis is presented in Fig. 10, showing the calculated effective potential near the transition curve. The calculations are carried out for different charges q. In the left panel of Fig. 10, the behavior of the effective potential closely resembles that of a pure holographic superconductor. In other words, the obtained effective potential clearly demonstrates the physical mechanism that gives birth to a holographic superconductor. On the other hand, in the right panel of Fig. 10, where the Gauss-Bonnet coupling surpasses the critical value \u03bb > \u03bbc, 18 \fthe effective potential forms a well outside the event horizon. While the presence of the potential well does not affect its asymptotical form at large radial coordinates, it suffices for the tachyonic instability to trigger the scalarization. It is observed that varying q does not alter the depth of the potential well near the horizon, as such instability is irrelevant to the Maxwell field. Notably, when comparing the left and right panels of Fig. 10, one observes that the resulting effective potentials are pretty similar, which further gives rise to similar profiles as discussed in Fig. 4. To distinguish the two phases, we have to resort to explicit calculations of the free energy. IV. FURTHER DISCUSSIONS AND CONCLUDING REMARKS We employed a model that unites both mechanisms based on existing studies on holographic superconductors and spontaneous scalarization [41, 44, 60, 63, 67]. The system\u2019s phase space is scrutinized numerically by developing a high-precision shooting method. The spontaneous scalarization phase always prevails as long as the Gauss-Bonnet coupling exceeds the critical value \u03bb > \u03bbc. The phase diagram is shown in Fig. 1 in terms of ( \u02dc T, \u03bb). Although the transition from a bald black hole to a superconductor is well-established and is of second-order phase transition, it is somehow obscure to us whether there is a well-defined phase transition from the superconductor to a scalarized black hole, given that both the radial profile and effective potential between the two phases are somehow indistinguishable. Also, it needs to be clarified if the system transits from one phase to another by simply raising or decreasing the temperature. This seeming ambiguity is further explored by examining the phase diagram in terms of temperature and chemical potential ( \u02dc T, \u02dc \u00b5), as shown in Fig. 2. By explicitly evaluating the Gibbs free energy and its derivatives, it is shown that such a phase transition is well-defined and of first order. Moreover, the phase diagram indicates a non-trivial feature as the two phases flip over to the other side along the transition curve. These results reinforced that the spontaneous scalarization and holographic superconductor do not transit smoothly between one another and are potentially induced by different instabilities. Last but not least, we mention a few potentially related topics to the present work. In our calculations, we have only considered the fundamental modes. The scalar perturbations have been shown [20] to possess further excited states in the decoupling limit. Also, spontaneous scalarization induced by other matter sources, such as the Einstein-Maxwell-scalar theory [42, 68], is also a worthy possibility. We have focused on a minimal toy model that comprises both phases, and a more generic background black hole metric further spans the model\u2019s parameter space while 19 \freflecting a more realistic scenario. Regarding thermal properties, we elaborated on the complexity during the transition between these two phases, and it is interesting to probe such properties at zero temperature [45]. The relation between the quasinormal modes and instability has been extensively explored in the literature. Such analysis in the context of phase transition is also relevant to the present model. Given that the present study primarily adopts the probe limit, it is imperative to consider numerical calculations involving backreaction. Relevant studies regarding holographic superconductor have been carried out [17], and a generalization of the present scheme will provide further insights beyond the linearized theory. Moreover, a study of the dual phase of scalarization was performed in [41]. Further generalization is an intriguing direction. Applications of the present findings to the strongly coupled quantum system and condensed matter physics might be beneficial. ACKNOWLEDGMENTS This research is supported by the financial support from Brazilian agencies Funda\u00e7\u00e3o de Amparo \u00e0 Pesquisa do Estado de S\u00e3o Paulo (FAPESP), Funda\u00e7\u00e3o de Amparo \u00e0 Pesquisa do Estado do Rio de Janeiro (FAPERJ), Conselho Nacional de Desenvolvimento Cient\u00edfico e Tecnol\u00f3gico (CNPq), and Coordena\u00e7\u00e3o de Aperfei\u00e7oamento de Pessoal de N\u00edvel Superior (CAPES). [1] V. P. Frolov and I. D. Novikov, Black Hole Physics: Basic Concepts and New Developments. Kluwer Academic, 1998, 10.1007/978-94-011-5139-9. [2] E. Berti et al., Testing General Relativity with Present and Future Astrophysical Observations, Class. Quant. Grav. 32 (2015) 243001, [1501.07274]. [3] LIGO Scientific, Virgo collaboration, B. P. Abbott et al., Properties of the Binary Black Hole Merger GW150914, Phys. Rev. Lett. 116 (2016) 241102, [1602.03840]. [4] LIGO Scientific, Virgo collaboration, B. P. Abbott et al., GWTC-1: A Gravitational-Wave Transient Catalog of Compact Binary Mergers Observed by LIGO and Virgo during the First and Second Observing Runs, Phys. Rev. X 9 (2019) 031040, [1811.12907]. [5] LIGO Scientific, Virgo collaboration, B. P. Abbott et al., Tests of General Relativity with the Binary Black Hole Signals from the LIGO-Virgo Catalog GWTC-1, Phys. Rev. D 100 (2019) 104036, 20 \f[1903.04467]. [6] LIGO Scientific, VIRGO, KAGRA collaboration, R. Abbott et al., GWTC-3: Compact Binary Coalescences Observed by LIGO and Virgo During the Second Part of the Third Observing Run, 2111.03606. [7] L. Barack et al., Black holes, gravitational waves and fundamental physics: a roadmap, Class. Quant. Grav. 36 (2019) 143001, [1806.05195]. [8] C. P. L. Berry, S. A. Hughes, C. F. Sopuerta, A. J. K. Chua, A. Heffernan, K. Holley-Bockelmann et al., The unique potential of extreme mass-ratio inspirals for gravitational-wave astronomy, 1903.03686. [9] S. Babak, J. Gair, A. Sesana, E. Barausse, C. F. Sopuerta, C. P. L. Berry et al., Science with the space-based interferometer LISA. V: Extreme mass-ratio inspirals, Phys. Rev. D 95 (2017) 103012, [1703.09722]. [10] R. Ruffini and J. A. Wheeler, Introducing the black hole, Phys. Today 24 (1971) 30. [11] P. T. Chrusciel, J. Lopes Costa and M. Heusler, Stationary Black Holes: Uniqueness and Beyond, Living Rev. Rel. 15 (2012) 7, [1205.6112]. [12] B. Carter, Axisymmetric Black Hole Has Only Two Degrees of Freedom, Phys. Rev. Lett. 26 (1971) 331\u2013333. [13] C. A. R. Herdeiro and E. Radu, Asymptotically flat black holes with scalar hair: a review, Int. J. Mod. Phys. D 24 (2015) 1542014, [1504.08209]. [14] T. P. Sotiriou, Black Holes and Scalar Fields, Class. Quant. Grav. 32 (2015) 214002, [1505.00248]. [15] C. A. R. Herdeiro and E. Radu, Kerr black holes with scalar hair, Phys. Rev. Lett. 112 (2014) 221101, [1403.2757]. [16] S. S. Gubser, Breaking an Abelian gauge symmetry near a black hole horizon, Phys. Rev. D 78 (2008) 065034, [0801.2977]. [17] S. A. Hartnoll, C. P. Herzog and G. T. Horowitz, Holographic Superconductors, JHEP 12 (2008) 015, [0810.1563]. [18] D. Sudarsky and J. A. Gonzalez, On black hole scalar hair in asymptotically anti-de Sitter space-times, Phys. Rev. D 67 (2003) 024038, [gr-qc/0207069]. [19] D. D. Doneva and S. S. Yazadjiev, New Gauss-Bonnet Black Holes with Curvature-Induced Scalarization in Extended Scalar-Tensor Theories, Phys. Rev. Lett. 120 (2018) 131103, [1711.01187]. 21 \f[20] H. O. Silva, J. Sakstein, L. Gualtieri, T. P. Sotiriou and E. Berti, Spontaneous scalarization of black holes and compact stars from a Gauss-Bonnet coupling, Phys. Rev. Lett. 120 (2018) 131104, [1711.02080]. [21] G. Antoniou, A. Bakopoulos and P. Kanti, Evasion of No-Hair Theorems and Novel Black-Hole Solutions in Gauss-Bonnet Theories, Phys. Rev. Lett. 120 (2018) 131102, [1711.03390]. [22] C. A. R. Herdeiro, E. Radu, N. Sanchis-Gual and J. A. Font, Spontaneous Scalarization of Charged Black Holes, Phys. Rev. Lett. 121 (2018) 101102, [1806.05190]. [23] Y. Brihaye, C. Herdeiro and E. Radu, The scalarised Schwarzschild-NUT spacetime, Phys. Lett. B 788 (2019) 295\u2013301, [1810.09560]. [24] C. A. R. Herdeiro and E. Radu, Black hole scalarization from the breakdown of scale invariance, Phys. Rev. D 99 (2019) 084039, [1901.02953]. [25] A. Dima, E. Barausse, N. Franchini and T. P. Sotiriou, Spin-induced black hole spontaneous scalarization, Phys. Rev. Lett. 125 (2020) 231101, [2006.03095]. [26] C. A. R. Herdeiro, E. Radu, H. O. Silva, T. P. Sotiriou and N. Yunes, Spin-induced scalarized black holes, Phys. Rev. Lett. 126 (2021) 011103, [2009.03904]. [27] E. Berti, L. G. Collodel, B. Kleihaus and J. Kunz, Spin-induced black-hole scalarization in Einstein-scalar-Gauss-Bonnet theory, Phys. Rev. Lett. 126 (2021) 011104, [2009.03905]. [28] D. D. Doneva, L. Arest\u00e9 Sal\u00f3, K. Clough, P. Figueras and S. S. Yazadjiev, Testing the limits of scalar-Gauss-Bonnet gravity through nonlinear evolutions of spin-induced scalarization, Phys. Rev. D 108 (2023) 084017, [2307.06474]. [29] D. D. Doneva and S. S. Yazadjiev, Beyond the spontaneous scalarization: New fully nonlinear mechanism for the formation of scalarized black holes and its dynamical development, Phys. Rev. D 105 (2022) L041502, [2107.01738]. [30] M.-Y. Lai, D.-C. Zou, R.-H. Yue and Y. S. Myung, Nonlinearly scalarized rotating black holes in Einstein-scalar-Gauss-Bonnet theory, Phys. Rev. D 108 (2023) 084007, [2304.08012]. [31] D. D. Doneva, L. G. Collodel and S. S. Yazadjiev, Spontaneous nonlinear scalarization of Kerr black holes, Phys. Rev. D 106 (2022) 104027, [2208.02077]. [32] A. M. Pombo and D. D. Doneva, Effects of mass and self-interaction on nonlinear scalarization of scalar-Gauss-Bonnet black holes, 2310.08638. [33] H. O. Silva, H. Witek, M. Elley and N. Yunes, Dynamical Descalarization in Binary Black Hole Mergers, Phys. Rev. Lett. 127 (2021) 031101, [2012.10436]. 22 \f[34] H.-J. Kuan, D. D. Doneva and S. S. Yazadjiev, Dynamical Formation of Scalarized Black Holes and Neutron Stars through Stellar Core Collapse, Phys. Rev. Lett. 127 (2021) 161103, [2103.11999]. [35] C.-Y. Zhang, P. Liu, Y. Liu, C. Niu and B. Wang, Dynamical charged black hole spontaneous scalarization in anti\u2013de Sitter spacetimes, Phys. Rev. D 104 (2021) 084089, [2103.13599]. [36] C.-Y. Zhang, P. Liu, Y. Liu, C. Niu and B. Wang, Dynamical scalarization in Einstein-Maxwell-dilaton theory, Phys. Rev. D 105 (2022) 024073, [2111.10744]. [37] C.-Y. Zhang, Q. Chen, Y. Liu, W.-K. Luo, Y. Tian and B. Wang, Critical Phenomena in Dynamical Scalarization of Charged Black Holes, Phys. Rev. Lett. 128 (2022) 161105, [2112.07455]. [38] Y. Liu, C.-Y. Zhang, Q. Chen, Z. Cao, Y. Tian and B. Wang, Critical scalarization and descalarization of black holes in a generalized scalar-tensor theory, Sci. China Phys. Mech. Astron. 66 (2023) 100412, [2208.07548]. [39] A. Bakopoulos, G. Antoniou and P. Kanti, Novel Black-Hole Solutions in Einstein-Scalar-Gauss-Bonnet Theories with a Cosmological Constant, Phys. Rev. D 99 (2019) 064003, [1812.06941]. [40] Y. Brihaye, C. Herdeiro and E. Radu, Black Hole Spontaneous Scalarisation with a Positive Cosmological Constant, Phys. Lett. B 802 (2020) 135269, [1910.05286]. [41] Y. Brihaye, B. Hartmann, N. P. Aprile and J. Urrestilla, Scalarization of asymptotically anti\u2013de Sitter black holes with applications to holographic phase transitions, Phys. Rev. D 101 (2020) 124016, [1911.01950]. [42] G. Guo, P. Wang, H. Wu and H. Yang, Scalarized Einstein\u2013Maxwell-scalar black holes in anti-de Sitter spacetime, Eur. Phys. J. C 81 (2021) 864, [2102.04015]. [43] C. Promsiri, T. Tangphati, E. Hirunsirisawat and S. Ponglertsakul, Scalarization of planar anti\u2013de Sitter charged black holes in Einstein-Maxwell-scalar theory, Phys. Rev. D 108 (2023) 024015, [2302.04654]. [44] D.-C. Zou, B. Meng, M. Zhang, S.-Y. Li, M.-Y. Lai and Y. S. Myung, Analytical approximate solutions for scalarized AdS black holes, Universe 9 (2023) 26, [2301.04784]. [45] A. Marrani, O. Miskovic and P. Q. Leon, Spontaneous scalarization in (A)dS gravity at zero temperature, JHEP 07 (2022) 100, [2203.14388]. [46] D. D. Doneva, F. M. Ramazano\u02d8 glu, H. O. Silva, T. P. Sotiriou and S. S. Yazadjiev, Scalarization, 2211.01766. [47] J. L. Bl\u00e1zquez-Salcedo, D. D. Doneva, J. Kunz and S. S. Yazadjiev, Radial perturbations of the 23 \fscalarized Einstein-Gauss-Bonnet black holes, Phys. Rev. D 98 (2018) 084011, [1805.05755]. [48] Y. S. Myung and D.-C. Zou, Gregory-Laflamme instability of black hole in Einstein-scalar-Gauss-Bonnet theories, Phys. Rev. D 98 (2018) 024030, [1805.05023]. [49] H. O. Silva, C. F. B. Macedo, T. P. Sotiriou, L. Gualtieri, J. Sakstein and E. Berti, Stability of scalarized black hole solutions in scalar-Gauss-Bonnet gravity, Phys. Rev. D 99 (2019) 064011, [1812.05590]. [50] G. Antoniou, A. Leh\u00e9bel, G. Ventagli and T. P. Sotiriou, Black hole scalarization with Gauss-Bonnet and Ricci scalar couplings, Phys. Rev. D 104 (2021) 044002, [2105.04479]. [51] W. F. Buell and B. Shadwick, Potentials and bound states, American Journal of Physics 63 (1995) 256\u2013258. [52] M. Brigante, H. Liu, R. C. Myers, S. Shenker and S. Yaida, The Viscosity Bound and Causality Violation, Phys. Rev. Lett. 100 (2008) 191601, [0802.3318]. [53] M. Brigante, H. Liu, R. C. Myers, S. Shenker and S. Yaida, Viscosity Bound Violation in Higher Derivative Gravity, Phys. Rev. D 77 (2008) 126006, [0712.0805]. [54] A. Buchel and R. C. Myers, Causality of Holographic Hydrodynamics, JHEP 08 (2009) 016, [0906.2922]. [55] D. M. Hofman and J. Maldacena, Conformal collider physics: Energy and charge correlations, JHEP 05 (2008) 012, [0803.1467]. [56] D. M. Hofman, Higher Derivative Gravity, Causality and Positivity of Energy in a UV complete QFT, Nucl. Phys. B 823 (2009) 174\u2013194, [0907.1625]. [57] X. O. Camanho and J. D. Edelstein, Causality constraints in AdS/CFT from conformal collider physics and Gauss-Bonnet gravity, JHEP 04 (2010) 007, [0911.3160]. [58] R. Gregory and R. Laflamme, Black strings and p-branes are unstable, Phys. Rev. Lett. 70 (1993) 2837\u20132840, [hep-th/9301052]. [59] S. A. Hartnoll, C. P. Herzog and G. T. Horowitz, Building a Holographic Superconductor, Phys. Rev. Lett. 101 (2008) 031601, [0803.3295]. [60] H. Guo, S. Kiorpelidi, X.-M. Kuang, E. Papantonopoulos, B. Wang and J.-P. Wu, Spontaneous holographic scalarization of black holes in Einstein-scalar-Gauss-Bonnet theories, Phys. Rev. D 102 (2020) 084029, [2006.10659]. [61] H. Guo, X.-M. Kuang, E. Papantonopoulos and B. Wang, Horizon curvature and spacetime structure influences on black hole scalarization, Eur. Phys. J. C 81 (2021) 842, [2012.11844]. 24 \f[62] S. Franco, A. Garcia-Garcia and D. Rodriguez-Gomez, A General class of holographic superconductors, JHEP 04 (2010) 092, [0906.1214]. [63] Y. Bao, H. Guo and X.-M. Kuang, Excited states of holographic superconductor with scalar field coupled to Gauss-Bonnet invariance, Phys. Lett. B 822 (2021) 136646. [64] J. Pan, X. Qiao, D. Wang, Q. Pan, Z.-Y. Nie and J. Jing, Holographic superconductors in 4D Einstein-Gauss-Bonnet gravity with backreactions, Phys. Lett. B 823 (2021) 136755, [2109.02207]. [65] S. Basak, P. Chaturvedi, P. Nandi and G. Sengupta, Thermodynamic geometry of holographic superconductors, Phys. Lett. B 753 (2016) 493\u2013499, [1509.00826]. [66] D. Ghorai and S. Gangopadhyay, Holographic free energy and thermodynamic geometry, Eur. Phys. J. C 76 (2016) 702, [1607.05187]. [67] Q. Chen, Z. Ning, Y. Tian, B. Wang and C.-Y. Zhang, Descalarization by quenching charged hairy black hole in asymptotically AdS spacetime, JHEP 01 (2023) 062, [2210.14539]. [68] Q. Chen, Z. Ning, Y. Tian, B. Wang and C.-Y. Zhang, Nonlinear dynamics of hot, cold, and bald Einstein-Maxwell-scalar black holes in AdS spacetime, Phys. Rev. D 108 (2023) 084016, [2307.03060]. 25"
+                }
+            ],
+            "Curtis Bright": [
+                {
+                    "url": "http://arxiv.org/abs/2012.04715v1",
+                    "title": "A SAT-based Resolution of Lam's Problem",
+                    "abstract": "In 1989, computer searches by Lam, Thiel, and Swiercz experimentally resolved\nLam's problem from projective geometry$\\unicode{x2014}$the long-standing\nproblem of determining if a projective plane of order ten exists. Both the\noriginal search and an independent verification in 2011 discovered no such\nprojective plane. However, these searches were each performed using highly\nspecialized custom-written code and did not produce nonexistence certificates.\nIn this paper, we resolve Lam's problem by translating the problem into Boolean\nlogic and use satisfiability (SAT) solvers to produce nonexistence certificates\nthat can be verified by a third party. Our work uncovered consistency issues in\nboth previous searches$\\unicode{x2014}$highlighting the difficulty of relying\non special-purpose search code for nonexistence results.",
+                    "authors": "Curtis Bright, Kevin K. H. Cheung, Brett Stevens, Ilias Kotsireas, Vijay Ganesh",
+                    "published": "2020-12-08",
+                    "updated": "2020-12-08",
+                    "primary_cat": "cs.DM",
+                    "cats": [
+                        "cs.DM",
+                        "cs.AI",
+                        "cs.LO",
+                        "cs.SC",
+                        "math.CO"
+                    ],
+                    "main_content": "Introduction Projective geometry was developed in the 1600s by renaissance artists and mathematicians in order to describe how to project a three dimensional scene onto a two dimensional canvas. Projective geometry has the counter-intuitive property that any two lines must meet. For example, a pair of train tracks (parallel lines in three dimensions) when projected onto two dimensions will meet on the horizon. Despite an intensive amount of study for over 200 years some basic questions about projective geometry remain unsettled. For example\u2014how many points can a projective geometry have? A geometry is said to be \ufb01nite if it contains a \ufb01nite number of points and a \ufb01nite geometry is said to have order n if every line contains n+1 points (Dembowski 1968). All \ufb01nite projective geometries have been classi\ufb01ed with the exception of those having exactly two dimensions\u2014the projective planes. The \ufb01rst order for which it is theoretically uncertain if a projective plane exists is n = 10. Determining if such a projective plane exists has become known as Lam\u2019s problem after the work of (Lam, Thiel, and Swiercz 1989) experimentally showed that such a plane does not exist\u2014 work that was later independently veri\ufb01ed by (Roy 2011). As pointed out by (Heule, Kullmann, and Marek 2017) there are currently three kinds of solvers that are used to Copyright \u00a9 2021, Association for the Advancement of Arti\ufb01cial Intelligence (www.aaai.org). All rights reserved. solve large but \ufb01nite decision problems like Lam\u2019s problem: special purpose solvers, constraint satisfaction solvers, and satis\ufb01ability (SAT) solvers. They note that recently SAT solvers have become so strong that they are \u201cthe best solution in most cases\u201d. Even still, they note that some problems such as Lam\u2019s problem have only been solved by specialpurpose means: An example where only a solution by [special purpose solvers] is known is the determination that there is no projective plane of order 10.. . We remedy this situation by using a SAT solver to resolve the most challenging subcase of Lam\u2019s problem. Together with the recent SAT-based results of (Bright et al. 2020a,b) this provides a complete resolution of Lam\u2019s problem with all of the exhaustive search work completed by SAT solvers. The previous searches done in Lam\u2019s problem remain fantastic achievements, but a SAT-based resolution has two primary advantages. First, it is more veri\ufb01able: a third party can check the nonexistence certi\ufb01cates for themselves and (once they believe in the encoding) be convinced in the nonexistence of a projective plane of order ten without having to trust a search procedure. Second, using well-tested SAT solvers to perform the search is less error-prone than writing special-purpose search code\u2014a reality of developing software for computer-assisted proofs is that it is extremely dif\ufb01cult to make custom-written code both correct and ef\ufb01cient (Lam 1990). Indeed, our results uncover discrepancies with both the original 1989 search and its 2011 independent veri\ufb01cation. As we detail in section 2, the \ufb01rst two steps of Lam et al.\u2019s search are to enumerate what are known as A1s and A2s. Our work agrees with the previous searches that up to isomorphism there are 66 possibilities for the A1s. However, our count for the A2 possibilities disagrees with both of the counts of (Lam, Thiel, and Swiercz 1989) and (Roy 2011)\u2014works which differ between themselves as well (see Section 5). We generate certi\ufb01cates that demonstrate our A2 search is complete (see Section 4) and verify the certi\ufb01cates with a proof veri\ufb01er. These certi\ufb01cates were generated with the assistance of the symbolic computation library Traces (McKay and Piperno 2014)\u2014but we describe how one can verify the certi\ufb01cates without needing to trust the output of the library. Our work does not provide a completely formal proof of arXiv:2012.04715v1  [cs.DM]  8 Dec 2020 \fthe nonexistence of a projective plane of order ten because we rely on results that currently have no formal computerveri\ufb01able proofs. In particular, we rely on a result of (Carter 1974) that the error-correcting code associated with a hypothetical projective plane of order ten must contain words that are referred to as weight 15, weight 16, or \u2018primitive\u2019 weight 19 words. The former two cases were \ufb01rst ruled out by the searches of (MacWilliams, Sloane, and Thompson 1973) and (Lam, Thiel, and Swiercz 1986) and were recently settled via SAT-based nonexistence certi\ufb01cates (Bright et al. 2020a,b). The primitive weight 19 search is by far the most challenging\u2014it was ruled out by (Lam, Thiel, and Swiercz 1989) and it is the case that we consider in our work. Our work does provide a possible avenue for constructing a formal proof: by deriving our SAT encoding and the mathematical results that we rely on inside a formal proof system. This would be a signi\ufb01cant undertaking but is in principle possible with current tools. In fact, results that were recently proven using SAT solvers such as the resolution of the Boolean Pythagorean triples problem (Heule, Kullmann, and Marek 2016) and a case of the Erd\u02dd os discrepancy conjecture (Konev and Lisitsa 2014) have since had formal proofs generated based on the SAT encoding (Cruz-Filipe, Marques-Silva, and Schneider-Kamp 2018; Keller 2019). 2 Background We now provide the necessary background in order to understand our results. In particular, we outline the cubeand-conquer satis\ufb01ability solving paradigm, describe Lam\u2019s problem from projective geometry, describe the subcase for which we provide nonexistence certi\ufb01cates, and outline the symmetry breaking methods exploited by the nonexistence certi\ufb01cates. 2.1 Cube-and-conquer The cube-and-conquer satis\ufb01ability solving paradigm was developed by (Heule et al. 2011) for solving hard combinatorial problems. The method uses two kinds of SAT solvers in two stages: First, a \u201ccubing solver\u201d splits a satis\ufb01ability instance into a large number distinct subproblems speci\ufb01ed by cubes\u2014formulas of the form l1 \u2227\u00b7 \u00b7 \u00b7 \u2227ln where li are variables or negated variables. Second, for each cube a \u201cconquering solver\u201d solves the original instance under the assumption that the cube is true. The cube-and-conquer method tends to be effective at quickly solving large satis\ufb01ability instances when the cubing solver can generate many cubes encoding subproblems of approximately equal dif\ufb01culty. It has since been applied to solve huge combinatorial problems such as the Boolean Pythagorean triples problem (Heule, Kullmann, and Marek 2017) and the computation of the \ufb01fth Schur number (Heule 2018). 2.2 Lam\u2019s problem Projective geometry was formalized by mathematicians in the 1600s though its roots date back to the work of Pappus of Alexandria in the 4th century. In the 1800s projective geometry became extensively studied\u2014including projective geometries that contain only a \ufb01nite number of points (von Staudt 1856). The only \ufb01nite projective geometries that remain to be classi\ufb01ed are those in two dimensions and such objects are known as projective planes. Projective planes consist of an incidence relationship between points and lines such that any two distinct lines intersect in a unique point and any two distinct points are on a unique line. To avoid trivial cases we also require that not all (or all but one) of the points lie on the same line. These axioms imply that all lines contain the same number of points and the plane contains the same number of points and lines. If each line has n+1 points then the projective plane said to be of order n and it will contain exactly n2+n+1 points and the same number of lines. If A is the {0, 1} incidence matrix with a 1 in entry (i, j) exactly when line i contains point j then the projective plane axioms imply that the off-diagonal entries of the matrices AAT and AT A are exactly 1. Two vectors are said to intersect if they share a 1 in the same position and therefore the projective plane axioms imply that any two rows or columns of A must intersect. Projective planes are known to exist in all orders that are prime powers but despite extensive study no projective planes in any other orders are known and it has been conjectured that the order of a projective plane must be a prime power (Weisstein 2002). Certain orders including six have been theoretically ruled out (Bruck and Ryser 1949) leaving n = 10 as the \ufb01rst uncertain order\u2014until the computational search of (Lam, Thiel, and Swiercz 1989) did not \ufb01nd a plane of order ten. Lam et al.\u2019s search was based on properties of the incidence matrix A of a hypothetical projective plane of order ten. In particular, the results of (Carter 1974) and (MacWilliams, Sloane, and Thompson 1973) imply that the words of Hamming weight 19 in the rowspace of A (mod 2) are of three possible forms (called oval, 16-type, and primitive) and there must exist some 16-type or primitive words. However, the searches of (Lam, Thiel, and Swiercz 1986) ruled out the existence of 16-type words and (Lam, Thiel, and Swiercz 1989) ruled out the existence of primitive words. 2.3 Primitive weight 19 words The most challenging case in the resolution of Lam\u2019s problem is to show the nonexistence of primitive weight 19 words. The existence of such words greatly constrains the structure of the 111 \u00d7 111 incidence matrix A of a projective plane of order ten\u2014in particular, A can be decomposed into a 3 \u00d7 2 collection of submatrices as shown in Figure 1. The row sums of the submatrices were derived in (Carter 1974) and the column sums (that depend on a parameter k counting how many 1s appear in the \ufb01rst six rows of a column) were derived in (Lam, Cross\ufb01eld, and Thiel 1985). We follow the labelling scheme that appears in the latter work. Once A1 has been \ufb01xed this uniquely determines A3 and A4 without loss of generality (Lam, Cross\ufb01eld, and Thiel 1985). There are typically a large number of possibilities for A2, though this number can be reduced by only considering nonisomorphic A2s under the symmetry group of A1 (see Section 2.4). Once all the possible A2s have been determined the search of Lam et al. continued by attempting \f19 92 6 \" A1 A4 # 37 A2 A5 68 A3 labels 19 92 \" 5 6 # 3 8 1 10 row sums 19 92 \" k k # 9 \u22122k 4 \u22122k k + 2 k + 7 column sums Figure 1: Structure of the incidence matrix of a projective plane of order ten containing a primitive weight 19 word. The numbers outside the matrices count the number of rows or columns in each submatrix. to extend each A2 into the A5 submatrix. In no case was a completion of A5 found, thereby disproving the existence of the complete matrix A. 2.4 Symmetry groups Two incidence matrices are said to be isomorphic if one can be transformed into the other through row or column permutations. The symmetry group of a matrix is the set of row and column permutations that \ufb01x all entries of the matrix. When the symmetry group of a submatrix of A (such as A1 in Figure 1) is large the search starting from that submatrix tends to include a lot of isomorphic matrices. To avoid searching through a space containing many isomorphic matrices an important optimization is to detect and remove as many symmetries as early in the search as possible. (Lam, Cross\ufb01eld, and Thiel 1985) found that up to isomorphism there are exactly 66 possible ways of completing the submatrix A1; an explicit list containing each possible case is available in (Kaski and \u00d6sterg\u00e5rd 2006). Lam et al. show how to remove 21 of those possibilities by various argumentation. Computational searches performed for each of the remaining 45 possibilities (Lam, Thiel, and Swiercz 1989) found 639,624 nonisomorphic ways of extending these A1s to A2s. Our count differs from that of Lam et al.\u2014see Section 5 for details. 3 SAT encoding We now describe the SAT encoding used in our instances in three parts\u2014corresponding to the three steps of Lam et al.\u2019s search. First, a single SAT instance determines the possibilities for the A1s (i.e., the upper left 6 \u00d7 19 matrix in Figure 1). Second, for each possible A1 a new instance determines the possibilities for the A2s. Third, for each possible A2 a new instance determines that the matrix cannot be completed to a full incidence matrix A. For ef\ufb01ciency reasons many constraints are dropped from the third set of instances. This results in a small number of solutions to these instances which are then shown to not complete by adding back in some of the constraints (see Section 4.3). In each of these instances we use the Boolean variable ai,j to represent that entry (i, j) of A contains a 1. Note that since A de\ufb01nes a projective plane none of its rows intersect twice; in other words, for every pair of distinct indices (i, i\u2032) there do not exist another pair of distinct indices (j, j\u2032) such that all the variables {ai,j, ai,j\u2032, ai\u2032,j, ai\u2032,j\u2032} are true. 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 1 0 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 7 8 11 18 25 Figure 2: On the left the A1 of the \ufb01rst case is shown. On the right the upper-left 25 \u00d7 5 submatrix of its associated A2 is shown with some of its row numbers in A\u2014this submatrix is completely determined under the assumption that its rows are lexicographically ordered. Thus, each of our SAT instances include clauses of the form \u00acai,j \u2228\u00acai,j\u2032 \u2228\u00acai\u2032,j \u2228\u00acai\u2032,j\u2032 where i and i\u2032 are indices of the rows under consideration and j and j\u2032 are indices of the columns under consideration. 3.1 A1 encoding An A1 is a 6 \u00d7 19 matrix with {0, 1} entries containing exactly \ufb01ve 1s in each row and no two rows having more than a single 1 in the same position. Furthermore, the rows and columns of an A1 may be lexicographically ordered without loss of generality (Knuth 2015, cf. exercise 495). Moreover, lexicographic constraints can simply be encoded into Boolean logic (Knuth 2015, cf. equation 169). To enforce the fact that the row sum of each row is 5 we use the sequential counter cardinality encoding (Sinz 2005)\u2014cf. exercise 30 (Knuth 2015). In order to \ufb01nd all possible A1s we exhaustively search for solutions of the above SAT instance. Whenever a solution S is found the blocking clause W S| =p \u00acp (where S | = p means the variable p is true in S) is added to the SAT instance and the solver is restarted; this produces 3,366 solutions. To check the A1s for equivalence we construct the incidence graph of the matrix (Kaski and \u00d6sterg\u00e5rd 2006) and use the library Traces (McKay and Piperno 2014) to discard the A1s whose incidence graphs are isomorphic to those of previously found A1s. 3.2 A2 encoding An A2 is a 37\u00d719 matrix with {0, 1} entries containing exactly three 1s in each row and no two rows having more than a single 1 in the same location. Furthermore, in the complete incidence matrix A the A2 appears directly below an A1 and this completely determines the number of 1s that appear in each column (see Figure 1). Because the rows of A2 may be permuted freely without loss of generality we assume that the rows of A2 are lexicographically sorted. The row sum, column sum, and lexicographic constraints are each encoded in the same way as in the A1 encoding. The A2 SAT instances may now be exhaustively solved similar to how the A1 SAT instance is solved and this produces over 56 million solutions. Due to the large number of solutions it is much more ef\ufb01cient to employ symmetry removal during the solving process. To this end we adapt \fthe \u201crecorded objects\u201d method of isomorph-free exhaustive generation (Kaski and \u00d6sterg\u00e5rd 2006) to the SAT context. In order to do this we \ufb01rst split the A2 search space into a number of successive levels, where each level successively \ufb01lls in more of the A2 matrix. Note that the \ufb01rst row of A1 is 15014 (as a binary vector) because its columns are lexicographically ordered. Thus the \ufb01rst \ufb01ve columns pairwise intersect in A1 and so will not intersect at all in A2. It follows that the column sum and lexicographic constraints completely \ufb01x the \ufb01rst \ufb01ve columns of A2. For example, Figure 2 contains one possible A1 and the \ufb01rst \ufb01ve columns of the A2 generated by this A1. The set of rows of A2 can be split into levels based on which rows are identical in the \ufb01rst \ufb01ve columns. For example, the levels of the A2 in Figure 2 consist of row 7 and then the rows 8\u201310, 11\u201317, 18\u201324, 25\u201331, and the remaining rows 32\u201343 (consisting of zeros in the \ufb01rst \ufb01ve columns). Our exhaustive search proceeds by \ufb01nding completions of the entries in each successive level. At each level isomorphism removal is performed on the completions found at that level. When multiple completions are isomorphic to each other only a single one of those completions is used for the purposes of completing the next level. When a completion of a level is found, the incidence graph of the A1 and A2 (up to the given level) is formed and passed to the Traces library. Traces generates a certi\ufb01cate of the incidence graph and if the certi\ufb01cate is new the completion is recorded as a new solution of the current level. If the certi\ufb01cate has been previously seen, the incidence graph is compared to the incidence graphs of the previously found completions to verify that it is indeed isomorphic to one of them. Once it has been veri\ufb01ed that the completion is isomorphic to a previously found completion the new completion is discarded. Formally, a blocking clause W S| =p \u00acp is added to the SAT instance, where S consists of the assignment formed by the completion to be discarded (up to the given level). The solver is then resumed\u2014the blocking clause being added to the SAT instance on-the-\ufb02y, i.e., programmatically (Ganesh et al. 2012). This procedure requires keeping track of the nonisomorphic completions (and their certi\ufb01cates) that are found at each level as the search is progressing but its advantage is that symmetries are detected and removed much earlier than they would otherwise be if isomorphism removal was only performed at the \ufb01nal level. Moreover, the search is still exhaustive in the sense that all nonisomorphic A2s will be found. Formally, we state the following theorem whose proof appears in the online appendix. Theorem 1. If the A2 SAT instances are solved with isomorphism removal performed after the completion of each level then the solver will record exactly one representative from each equivalence class of A2 completions. 3.3 Main encoding We now describe our main encoding of determining the nonexistence of A containing a given A1 and A2. First, there is a unique way of completing A3 (assuming a lexicographic ordering of its rows) because its row sums are 1. Similarly, 20 24 29 34 39 44 48 52 Figure 3: The A1 of case 66 (upper left) and its associated A4 (upper right). One particular row of an A2 is shown (lower left) and the form of its completion in A5 is shown (lower right). Each of the gray rectangles contain a single 1 and there are another \ufb01ve 1s on the row\u2014ordered here to appear as soon as possible. there is a unique way of completing A4 because its columns have at most two 1s (having k \u22653 in the rightmost column of Figure 1 is impossible). We complete the columns of A4 with column sum 2 \ufb01rst (adding a single column of this form for each pair of lines that do not already intersect in the \ufb01rst 19 columns) and assume a lexicographic ordering of the remaining columns. Figure 3 shows one possible A1 and its associated A4. There are six blocks appearing in an A4 where block i consists of the columns containing a 1 in the ith row. The columns not incident to any of the blocks are called outside columns. For example, in Figure 3 the \ufb01rst block consists of column 20 with columns 24\u201328, and the outside columns are columns 52\u201356. The columns of A5 that are identical in A4 can be taken to appear in lexicographic order without loss of generality\u2014in other words, we assume that the columns within each block (except for those with column sum 2 in A4) are lexicographically sorted. Similarly, the rows in A5 that are identical in A3 are assumed to appear in lexicographic order. At this point we could simply encode the row sums, column sums, and lexicographic constraints using the same encoding that was used in the A1 and A2 encodings. The work of Lam et al. imply these instances are unsatis\ufb01able, but we optimized the encoding in order to reduce the amount of computational resources required to prove unsatis\ufb01ability. In particular, we did not use all 92 columns of A5 because this resulted in an excessive number of constraints. Instead, we selected between 4 and 6 blocks (see Section 3.4) from each instance and only used the constraints appearing in those blocks. In this context the row sum constraints no longer apply and we ignore the column sum constraints in the bottom (last 68 rows) of A5. Instead, we use an alternative encoding that directly enforces incidences that the \ufb01rst 19 columns have in A5. We also use an improved lexicographic encoding taking into account the form of the rows or columns being ordered. Incidence constraints The \ufb01rst 19 columns of A are known in each SAT instance; say Cj denotes the set of row indices of the 1s in column j with 1 \u2264j \u226419. The axioms of a projective plane imply that any two columns intersect\u2014 thus for each pair of column indices (j, k) with 1 \u2264j \u226419 and k in the blocks we are completing we include the clause W i\u2208Cj ai,k. Similarly, if Ri denotes the set of column indices of the 1s in row i we include clauses of the form W j\u2208Ri ak,j where 7 \u2264k \u2264111 and block i is selected. \fLexicographic constraints Consider the columns of a block that have a single 1 in A4 (e.g., columns 24\u201328 in Figure 3). By Figure 1 we know there are exactly three 1s in the \ufb01rst 43 rows of these columns (two of which appear in A5). If i and i\u2032 are the row indices of the 1s in column j that is not the \ufb01nal column in a block then the lexicographic ordering of the columns implies that Ai\u2217,j+1 = 0 for all 7 \u2264i\u2217< min(i, i\u2032). Translating this into conjunctive normal form, we include the clauses \u00acai,j \u2228\u00acai\u2032,j \u2228\u00acai\u2217,j+1 for all 7 \u2264i\u2217< i\u2032 < i \u226443 and all columns j that have a single 1 in A4 (except for the \ufb01nal column in a block). This generalizes the lexicographic encoding of (Bright et al. 2020b); and we encoded the row lexicographic constraints in a similar way. These constraints uniquely \ufb01x certain entries. For example, if the bottom row of Figure 3 was the \ufb01rst row in A2 then the leftmost entry in each gray rectangle would have to be 1. In our main instances we reorder the rows of A2 to maximize the number of mutually intersecting rows at the top in order to \ufb01x as many entries as possible. Partial isomorphism removal constraints These constraints are optional and tend to only apply in the easiest cases, though when they do apply they effectively constrain the search. They encode the \u201cextra partial isomorphism testing\u201d condition of (Lam, Thiel, and Swiercz 1989). Brie\ufb02y, if two of the \ufb01rst six rows intersect after the \ufb01rst 19 columns then the vector formed by adding (mod 2) these rows to 119092 (as a binary vector) forms a new vector that intersects six rows of A \ufb01ve times each. The speci\ufb01c six rows vary between cases but may quickly be determined in each case by examining A1 and A2. There are only a small number of ways of completing those six rows and each way must be isomorphic to one of the 66 possibilities for A1. If the completion corresponds to a case that has already been solved then a clause blocking that completion can be included in the SAT instance as it cannot lead to a solution. If the A1 cases are ordered so that those with the fewest number of A2s are solved \ufb01rst then about 22% of A2s have all of their completions isomorphic to previously solved cases. 3.4 Block selection Each of our SAT instances used the columns from 4 to 6 blocks. We used two different methods of selecting the blocks: a simple method which was used in the easiest cases and a more involved method which was used in the hardest cases and which we experimentally found was about 4 to 5 times faster in those cases. Inside block method This method was used on the cases with two or more columns with column sum 2 in A4\u2014these tend to be the easiest cases. This method simply selects \ufb01ve blocks (i.e., ignores a single block) chosen to maximize the number of intersections that occur in the \ufb01rst six rows of the selected blocks. For example, in Figure 3 blocks 5 and 6 have the most intersections in A4 so they are chosen. Additionally, blocks 1 and 2 are chosen since they intersect blocks 5 and 6. If possible, the block that is ignored is a block that has no intersections in A4; otherwise, one of the remaining blocks with a single intersection in A4 is ignored (e.g., block 3 in Figure 3). Outside block method This method was used on the cases with at most a single column with column sum 2 in A4\u2014 these tend to be the hardest cases because of the lack of intersections between blocks in A4 (which tend to produce con\ufb02icts leading to quick proofs of unsatis\ufb01ability). Thus, in these cases we used a seventh \u201coutside\u201d block that shares columns with as many of the \ufb01rst six (or inside) blocks as possible. First, we choose a \u201cspecial\u201d line in the \ufb01rst 37 rows of A5 which includes points in as many inside blocks as possible. For example, in Figure 3 the line at the bottom includes points from the blocks 1, 3, and 6, though in some cases a line can be found that is incident to all six inside blocks. The remaining points on the special line become the outside block. For example, in Figure 3 the outside block would include the last \ufb01ve columns of the diagram if the bottom line was selected as the special line. The SAT instance only uses blocks incident to the special line and the blocks (if any) that intersect in the \ufb01rst six rows. Additionally, in order to reduce the number of constraints one inside block is dropped from the instance (so long as at least four blocks in total are selected). The dropped block is selected to have the fewest number of rows with unassigned entries in common with the other blocks. Such a block is the least likely to produce con\ufb02icts\u2014since con\ufb02icts between two blocks occur in rows where both blocks have unassigned entries. 4 Certi\ufb01cates In this section we describe the certi\ufb01cates from our resolution of Lam\u2019s problem and how a third party can verify them. We use several kinds of certi\ufb01cates based on the different parts of the search. First, we provide a certi\ufb01cate which speci\ufb01es the possible cases for A1. For each A1 we provide another certi\ufb01cate specifying each of the ways (if any) of extending that A1 to A2, and similarly for each A2 we provide a certi\ufb01cate specifying each of the ways (if any) of extending that A2 to the selected blocks (as described in Section 3.4) of A5. Finally, we provide certi\ufb01cates showing all completions of the selected blocks do not extend to a complete A and thereby resolve Lam\u2019s problem. Our certi\ufb01cates are based on the DRAT (deletion resolution asymmetric tautology) format (Wetzler, Heule, and Hunt Jr. 2014) which is a standard format used for verifying the unsatis\ufb01ability of SAT instances. 4.1 A1 certi\ufb01cate The A1 certi\ufb01cate consists of a DRAT proof that the A1 SAT instance adjoined with 3,366 blocking clauses (one for each solution of the original instance) is unsatis\ufb01able, thus providing all solutions of the original instance. Furthermore, a separate certi\ufb01cate (produced by the library Traces) contains an explicit permutation of the rows and columns of each solution that produces a unique canonical form in each case. Using these permutations one can verify each solution is isomorphic to one of 66 A1s, providing an upper bound on the \fnumber of A1s that need to be considered\u2014all that is strictly necessary to verify the resolution of Lam\u2019s problem. Traces also provides the elements of the symmetry group of each A1. One can verify this output without needing to trust Traces\u2019 implementation; it is straightforward to verify that the permutations produced by Traces do in fact \ufb01x the entries of A1 and one can independently check (e.g., by hand) that the size of the symmetry group is correct. 4.2 A2 certi\ufb01cates The A2 certi\ufb01cates consist of DRAT proofs of unsatis\ufb01ability for each A2 SAT instance adjoined with blocking clauses for every solution found and blocking clauses for every (possibly partial) completion that is isomorphic to a recorded completion (as described in Section 3.2). Accompanying each solution and partial completion is a set of row and column permutations (provided by Traces) for translating the solution or partial completion into a canonical form. In order to verify one of the certi\ufb01cates, one needs to verify that (1) the DRAT proof does indeed show the unsatis\ufb01ability of the augmented SAT instance, and (2) the canonical form of each (partial or complete) solution is equal to the canonical form of one of the recorded nonisomorphic completions. By Theorem 1 this shows that the set of solutions consists of exactly one solution from each equivalence class of solutions to the original SAT instance. Moreover, each blocked clause is independently justi\ufb01ed (without trusting Traces) to block one of the recorded solutions or to block a partial completion isomorphic to a recorded partial completion. The fact that each of the recorded solutions are nonisomorphic to each other does rely on trusting Traces\u2019 canonical form. In order to verify the resolution of Lam\u2019s problem it is not strictly necessary to verify the recorded A2s are nonisomorphic\u2014however, in order to verify (without trusting Traces) that our A2 counts did not include extraneous cases we also performed a veri\ufb01cation that all recorded solutions were nonisomorphic of each other. Note that all A2s that are isomorphic to a given A2 can be generated through the symmetry group of its associated A1; up to row permutations any two isomorphic A2s must be isomorphic to each other via a permutation in the symmetry group of A1. Additionally, as mentioned in Section 4.1, the symmetry group of each A1 can be veri\ufb01ed without trusting Traces. No two recorded A2s are isomorphic to each other under the symmetries of their associated A1, thereby showing each of the recorded A2s are indeed mutually nonisomorphic. This can be exhaustively veri\ufb01ed by applying every A1 symmetry group permutation to every recorded A2. 4.3 Main certi\ufb01cates The main certi\ufb01cates consist of DRAT proofs of unsatis\ufb01ability for each of the SAT instances described in Section 3.3 adjoined with blocking clauses for the completions (if any) of the blocks selected to appear in the SAT instance. The majority of SAT instances had no completions but in about 3% of them completions were found\u2014see the online appendix for one explicit such completion. An individual certi\ufb01cate for each completion can be generated showing that the completion does not extend to a complete incidence matrix A. Alternatively, it is more ef\ufb01cient to generate one certi\ufb01cate for each case A1 showing that none of the completions found in that case can be extended. In order to do this, we generate a SAT instance for each A1 that includes the variables and constraints from all six inside blocks and those from the outside block columns appearing in each completion. Each completion C found for that A1 is speci\ufb01ed as a set of incremental assumption unit clauses (Audemard, Lagniez, and Simon 2013). Once the solver \ufb01nds no solutions while assuming V C| =p p it moves on to the next set of assumptions. This \u201cincremental\u201d solve produces a single DRAT certi\ufb01cate which proves the clause W C| =p \u00acp for each completion C under consideration\u2014 thereby demonstrating that these completions C cannot be extended to all six inside blocks. This veri\ufb01es that a full completion of A cannot in fact exist. 5 Results Our SAT instances are generated by Python scripts that are freely available as a part of the \u201cMathCheck\u201d project. The code, along with Bash scripts to generate and check the certi\ufb01cates, is available from uwaterloo.ca/mathcheck. Unless otherwise speci\ufb01ed we solve the SAT instances using MapleSAT (Liang et al. 2016) and verify the certi\ufb01cates using GRATgen (Lammich 2017). The computations were performed on a cluster of Intel E5 cores at 2.1 GHz running Linux and using at most 4GB of memory. 5.1 A1 and A2 results The A1 instance can be generated and solved in a few seconds. The resulting certi\ufb01cate (about 1MB) shows that there are 3,366 total solutions of the SAT instance and 3,300 of them are isomorphic to one of the remaining 66 A1s. We label these A1s using the case numbers given in (Kaski and \u00d6sterg\u00e5rd 2006). The A2 instances are generated and solved in about 25 minutes and produce a total of 650,370 nonisomorphic A2s. The resulting certi\ufb01cates along with the canonical form labellings provided by Traces total about 7GB. Fifteen cases (4, 10, 14, 19, 28\u201331, 35, 40, 44, 45, 59, 61, and 62) are found to have no A2s. Five cases (32, 38, 54, 57, and 64) imply the existence of a word of weight 16 in A\u2019s rowspace (Lam, Cross\ufb01eld, and Thiel 1985) and previous searches (Carter 1974; Lam, Thiel, and Swiercz 1986) and certi\ufb01cates (Bright et al. 2020b) demonstrates the nonexistence of such a word. Case 52 is eliminated by a theoretical argument (Lam, Cross\ufb01eld, and Thiel 1985), leaving 45 cases remaining. Our counts for the number of nonisomorphic A2s in the remaining 45 cases match those of (Lam, Thiel, and Swiercz 1989) in all but the eight cases shown in Table 1. The independent veri\ufb01cation (Roy 2011) does not provide the number of A2s found in each case but their total A2 count is inconsistent with both the counts of Lam et al. and the counts provided by our certi\ufb01cates. It is unclear what caused the discrepancy between these searches\u2014the previous searches \fCase Lam Our Work Case Lam Our Work 11 7,397 7,059 39 1,010 505 12 10,966 10,635 56 1,554 794 16 5,958 8,040 58 4,329 4,188 23 8,033 7,971 66 662 168 Table 1: The A2 counts given by (Lam, Thiel, and Swiercz 1989) that differ with the counts given by our work. did not produce certi\ufb01cates and by personal communication we have been informed that the code and data from the previous searches are no longer available. The method described in Section 4.2 of checking that the generated A2s are mutually nonisomorphic generates 56,157,420 total A2s; complete counts for each case is available in the online appendix. Adding these A2s as blocking clauses to the original A2 instances (without using symmetry removal) produces unsatis\ufb01able instances that provide a second veri\ufb01cation that no A2s were missed\u2014and without relying on Theorem 1. However, the instances generated in this way took about 150 times longer to solve. 5.2 Main results The 45 remaining cases have a total of 639,075 nonisomorphic A2s between them. SAT instances are generated for each of these and are simpli\ufb01ed using the solver CADICAL (Biere 2019) run for 20,000 con\ufb02icts. In total this simpli\ufb01cation uses about 400 hours and determines that 166,408 of the instances are unsatis\ufb01able. The remaining simpli\ufb01ed instances are processed using the \u201ccubing\u201d solver March_cu (Heule et al. 2011). We disabled the default cubing cutoff of this solver in favour of a cutoff based on the number of free variables in the subproblems speci\ufb01ed by each cube. More precisely, when the number of free variables in a subproblem drops below a provided bound no more cubing occurs in that subproblem. The cubing bound is controlled by March_cu\u2019s -n parameter, but we modi\ufb01ed March_cu so that the auxiliary variables from the cardinality constraints are not considered free. The cutoff bound was experimentally chosen by randomly selecting up to several hundred instances from each case and determining a bound that minimizes the sum of the cubing and conquering times. Ultimately, the cubing solver produces over 312 million cubes and uses about 1,200 hours. The simpli\ufb01ed SAT instances are solved using the conquering solver MapleSAT with the cubes produced by March_cu. This requires about 15,000 total core hours or about 16 hours of real time when simultaneously distributed across 30 machines with 32 cores each. In each instance the DRAT proof produced by MapleSAT is concatenated with the simpli\ufb01cation proof produced by CADICAL. The combined proofs total about 110 tebibytes in a binary format and are used to verify that each of the original SAT instances (after adding blocking clauses for each solution found by MapleSAT) are unsatis\ufb01able; GRATgen checked the proofs in about 33,000 core hours. It is possible that each solution found by MapleSAT leads to more than one solution of the original SAT instance because variables are eliminated during the simpli\ufb01cation process. Regardless, the DRAT proofs show that the solutions found by MapleSAT are exhaustive in the sense that any satisfying assignment of the original SAT instance must extend a solution found by MapleSAT. MapleSAT \ufb01nds 24,882 partial solutions and these are all shown to not extend to a full incidence matrix in a total of about 6 minutes. These certi\ufb01cates are about 4GB and are checked with DRAT-trim (Wetzler, Heule, and Hunt Jr. 2014) in forward checking mode. The default backward checking mode can not be used as these certi\ufb01cates are generated using incremental assumptions and therefore prove the negation of each set of assumptions rather than an empty clause. 6"
+                },
+                {
+                    "url": "http://arxiv.org/abs/2001.11973v2",
+                    "title": "Unsatisfiability Proofs for Weight 16 Codewords in Lam's Problem",
+                    "abstract": "In the 1970s and 1980s, searches performed by L. Carter, C. Lam, L. Thiel,\nand S. Swiercz showed that projective planes of order ten with weight 16\ncodewords do not exist. These searches required highly specialized and\noptimized computer programs and required about 2,000 hours of computing time on\nmainframe and supermini computers. In 2011, these searches were verified by D.\nRoy using an optimized C program and 16,000 hours on a cluster of desktop\nmachines. We performed a verification of these searches by reducing the problem\nto the Boolean satisfiability problem (SAT). Our verification uses the\ncube-and-conquer SAT solving paradigm, symmetry breaking techniques using the\ncomputer algebra system Maple, and a result of Carter that there are ten\nnonisomorphic cases to check. Our searches completed in about 30 hours on a\ndesktop machine and produced nonexistence proofs of about 1 terabyte in the\nDRAT (deletion resolution asymmetric tautology) format.",
+                    "authors": "Curtis Bright, Kevin K. H. Cheung, Brett Stevens, Ilias Kotsireas, Vijay Ganesh",
+                    "published": "2020-01-31",
+                    "updated": "2020-05-01",
+                    "primary_cat": "cs.DM",
+                    "cats": [
+                        "cs.DM",
+                        "cs.LO",
+                        "cs.SC",
+                        "math.CO"
+                    ],
+                    "main_content": "Introduction Geometry is one of the oldest branches of mathematics, being \ufb01rst axiomatically studied by Euclid in the 3rd century BC. Given a line and a point not on it, Euclid\u2019s \u201cparallel postulate\u201d implies that there exists exactly one line through the point and parallel to the given line. For 2000 years mathematicians tried in vain to prove this axiom but eventually geometries that did not satisfy the parallel postulate were discovered. For example, in the early seventeenth century G. Desargues studied projective geometry where parallel lines do not exist. Projective geometry became widely studied in the nineteenth century, leading to the discovery of projective geometries containing a \ufb01nite number of points. Despite a huge amount of study for over 200 years, some basic questions about \ufb01nite projective geometries remain open\u2014 for example, how many points can a \ufb01nite projective plane contain? It is known [K\u00e5hrstr\u00f6m, 2002] that this number must be of the form n2+n+1 for some natural number n (known as the order of the plane) and certain orders such as n = 6 have been ruled out by theoretical arguments. For every other n up to ten a \ufb01nite projective plane of order n can be shown to exist through an explicit construction. No theoretical explanation is known that answers the question if a projective plane of order ten exists and answering this question has since become known as Lam\u2019s problem. In the 1970s and 1980s an enormous amount of computing was used to show that no such plane exists [Lam, 1991]. The computations were based on the existence of codewords in the error-correcting code generated by a projective plane of order ten. It was shown [Carter, 1974] that such a code must contain codewords of weights 15, 16, or 19\u2014but exhaustive searches showed that such codewords do not exist. Each search required more advanced search techniques and orders of magnitude more computational power than the previous search\u2014the weight 15 search being the easiest and the weight 19 search being the most challenging. In this paper we focus on the weight 16 search that originally required about 2,000 hours on supercomputers and a VAX-11 supermini machine. Additionally, in 2011, using an optimized C implementation the weight 16 search was veri\ufb01ed in 16,000 core hours split across \ufb01fteen desktop machines [Roy, 2011]. We provide a reduction of the weight 16 codeword existence problem to the Boolean satis\ufb01ability problem (SAT) and a SAT certi\ufb01cation that the resulting instances are unsatis\ufb01able. This is done using the cube-and-conquer SAT solving paradigm [Heule et al., 2011] and uses functionality from the computer algebra system Maple for the purposes of symmetry breaking. See Section 2 for background on the cube-andconquer paradigm and Section 3 for a description of our SAT encoding and symmetry breaking methods. Our search completed in about 30 hours on a desktop machine, signi\ufb01cantly faster than any previous search. Furthermore, no previous search was able to provide any kind of a certi\ufb01cate following a successful completion. Thus, an independent party had to take on faith that the searches did in fact complete. In contrast, our search produces unsatis\ufb01ability certi\ufb01cates that an independent party can use to verify that our searches were successfully run to completion. The proofs of nonexistence generated by the SAT solver amounted to about 1 terabyte in the uncompressed DRAT (deletion resolution asymmetric tautology) format [Wetzler et al., 2014]. See Section 4 for details on our implementation and results. We do not claim our search is a formal veri\ufb01cation because our encoding relies on many mathematical properties that were not derived in a computer-veri\ufb01able form, such as arXiv:2001.11973v2  [cs.DM]  1 May 2020 \fthe result that there are ten nonisomorphic cases that need to be considered [Carter, 1974] in addition to the correctness of our encoding and implementation. However, we now have a potential method for producing a formal proof: by formally deriving our SAT encoding from the projective plane axioms. This would require expertise in both projective geometry and a formal proof system and would be a signi\ufb01cant undertaking. However, the tools to do this already exist and have been used to formally verify other results derived using SAT certi\ufb01cates [Cruz-Filipe et al., 2018; Keller, 2019]. 2 Background We now describe the background necessary to understand the nonexistence results of this paper, including the method that we used to solve the SAT instances and the mathematical background on projective planes and their symmetry groups that is necessary to understand our SAT reduction. The cube-and-conquer paradigm. The cube-and-conquer paradigm was \ufb01rst developed by Heule, Kullmann, Wieringa, and Biere [Heule et al., 2011] for computing van der Waerden numbers, a notoriously dif\ufb01cult computational problem from combinatorics. In recent years the cube-and-conquer method has been used to resolve long-standing combinatorial problems such as the Boolean Pythagorean triples problem [Heule et al., 2017] and computing the \ufb01fth Schur number [Heule, 2018]. The idea behind the cube-and-conquer method is to split a SAT instance into subproblems de\ufb01ned by cubes (propositional formulae of the form l1 \u2227\u00b7 \u00b7 \u00b7 \u2227ln where li are literals). Each cube de\ufb01nes a single subproblem\u2014generated by assuming the cube is true\u2014and each subproblem is then solved or \u201cconquered\u201d either in parallel or in sequence. Projective planes. A projective plane is a collection of points and lines that satisfy certain axioms, for example, in a projective plane any two lines intersect at a unique point. Finite projective planes can be de\ufb01ned in terms of incidence matrices that have a 1 in the (i, j)th entry exactly when the jth point is on the ith line. In this framework, a projective plane of order n is a square {0, 1}-matrix of order n2 + n + 1 where any two rows or any two columns intersect exactly once (where two rows or columns intersect when they share a 1 in the same position). To avoid degenerate cases we also require that each row contains at least two zeros or equivalently that each row contains exactly n + 1 ones. Two projective planes are said to be isomorphic if one can be transformed into the other via a series of row or column permutations. Projective planes are known to exist in all orders that are primes or prime powers and the prime power conjecture is that they exist in no other orders. Some orders such as n = 6 have been ruled out on theoretical grounds making n = 10 the \ufb01rst uncertain case. This stimulated a massive computer search for such a plane [Lam, 1991] based on the form such a plane must have assuming certain codewords exist. A codeword is a {0, 1}-vector in the rowspace (mod 2) of a {0, 1}-matrix and the weight of a codeword is the number of 1s that it contains. It is known [Carter, 1974; Hall, 1980] that a projective plane of order ten must generate codewords of weight 15, 16, or 19, thus dramatically shrinking the search space and naturally Case Symmetries Group Size Initial Cols. 1a S4 \u2240S2 1152 28 1b S4 \u00d7 S4 576 23 1c S4 \u2240S2 1152 18 2 S4 \u00d7 S2 48 28 3 D8 16 28 4 D4 \u00d7 S2 16 28 5 S3 \u00d7 S2 12 28 6a S2 \u00d7 S2 4 28 6b S2 2 26 6c S2 \u00d7 S2 4 24 Table 1: The ten possible cases for the \ufb01rst eight rows of a projective plane of order ten generating a weight 16 codeword and the symmetries in the initial columns (see below). Here Sn denotes the symmetric group of order n!, Dn denotes the dihedral group of order 2n, and \u2240denotes the wreath product. splitting the search into three cases. As shown by [Carter, 1974], up to isomorphism there are ten possibilities for the \ufb01rst eight rows of the planes that generate weight 16 codewords. Five of these possibilities (cases 2 to 6a in Table 1) were eliminated by the searches of [Carter, 1974] and the other \ufb01ve were eliminated by the searches of [Lam et al., 1986]. Incidence matrix structure. Carter derived numerous properties that the structure of a projective plane generating a weight 16 codeword must satisfy. In particular, the projective plane can be decomposed into a 3 \u00d7 2 grid of submatrices as follows: 16 95 8  2 k ! 72 9 8 \u22122k 31 0 k + 3 Here the numbers outside the matrix denote the number of rows or columns in that part of the submatrix. The numbers inside the matrix denote how many 1s there are in each column in that part of the submatrix; certain columns depend on a parameter k that differs between columns. Additionally, Carter showed that every entry in the \ufb01rst 16 columns is uniquely speci\ufb01ed by the starting case. We call the columns incident with at least two of the \ufb01rst eight rows the initial columns and the columns incident with at least one of the \ufb01rst eight rows the inside columns. Full starting matrices for each case are available at uwaterloo.ca/mathcheck/w16. Symmetry groups. A projective plane (or partial projective plane) may be symmetric in nontrivial ways, in other words, there may exist row or column permutations that \ufb01x the entries of the plane. Such symmetries are important to detect because they can dramatically reduce the search space\u2014and therefore the running time\u2014of any search that makes use of them [Aloul et al., 2003; Heule et al., 2015]. For example, Figure 1 shows the initial con\ufb01guration (the \ufb01rst eight rows and initial columns) from case 1c. This matrix is \ufb01xed by the permutation that swaps the \ufb01rst two rows and column k with column k + 4 for 1 \u2264k \u22644. The set of all row and column permutations that \ufb01x the entries of a matrix forms a group known as the symmetry group of the matrix. \f1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 0 1 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 1 Figure 1: The upper-left 8 \u00d7 18 submatrix from case 1c. In the matrix of Figure 1 any permutation of the \ufb01rst four rows, any permutation of the last four rows, and the permutation that swaps row i and row i + 4 for 1 \u2264i \u22644 occur (with appropriate column permutations) in the symmetry group. The size of this permutation group is 4!2 \u00b7 2 = 1152 and the group is isomorphic to the group of symmetries of a pair of tetrahedrons. Up to isomorphism, the symmetry groups for each of the ten possible initial con\ufb01gurations are given in Table 1. 3 SAT Encoding We now describe the encoding that we use to prove that projective planes of order ten with weight 16 codewords do not exist. Although SAT solvers have been widely used in searching for combinatorial designs [Zhang, 2009] they have only recently been applied to projective planes [Bright et al., 2020]. Our encoding that an incidence matrix de\ufb01nes a projective plane is described in Section 3.1, although we do not encode the entire matrix\u2014we choose the number of rows and columns to use based on the structure of the starting cases and in an attempt to minimize the number of variables and constraints necessary. Sections 3.2 and 3.3 describe the methods that we use to reduce the symmetries present in the search. 3.1 Incidence Constraints First, we describe how we encode the property that the incidence matrix de\ufb01ned by Boolean variables pi,k (representing that the (i, k)th entry of the matrix contains a 1) satisfy the properties of a projective plane. In particular, we encode the property that any two rows or columns of the projective plane intersect exactly once by encoding that any two rows or columns intersect (a) at most once and (b) at least once. In fact, we only encode intersections occurring in the \ufb01rst 80 rows\u2014our searches \ufb01nd no satisfying assignments of even this strictly smaller set of constraints. For (a), the constraints V111 k,l=1(\u00acpi,k\u2228\u00acpi,l\u2228\u00acpj,k\u2228\u00acpj,l) say that row i and row j do not intersect twice. We include these constraints for each distinct pair of indices (i, j) with 1 \u2264i, j \u226480 and ignore the constraints where k or l is larger than the last column used (which varied between cases). For (b), the constraint W111 k=1(pi,k \u2227pj,k) says that row i and row j intersect at least once. However, this constraint is not in conjunctive normal form so it can\u2019t directly be used with a typical SAT solver. Instead, we use this constraint in the form W k\u2208S(i) pj,k where S(i) is the set of indices k such that pi,k is true. The \ufb01rst eight rows of the projective plane are completely known beforehand in each starting case, so S(i) is well-de\ufb01ned for 1 \u2264i \u22648. We include these constraints for all 1 \u2264i \u22648 and 9 \u2264j \u226480. Figure 2: The upper-left 8 \u00d7 62 submatrix in case 6c where black squares represent 1s and white squares represent 0s. The \ufb01rst 24 columns form the initial con\ufb01guration and without loss of generality the remaining inside columns are taken in lexicographic order. Similarly, we include constraints that say that column k and column l intersect at least once. These constraints are of the form W i\u2208T (k) pi,l where T(k) is the set of indices i such that pi,k is true. We used these constraints for all k between 1 and 16 and for all l > 16 up to the last column used. In order to use these constraints we require at least 80 rows and all inside columns because the indices in the set S(i) for 1 \u2264i \u22648 are from the inside columns, and the indices in the set T(k) for 1 \u2264k \u226416 are from the \ufb01rst 80 rows. Experimentally we \ufb01nd that only using inside columns produces satis\ufb01able instances\u2014to make all instances unsatis\ufb01able we use \ufb01ve additional \u2018outside\u2019 columns (selected to be incident to a row needing another \ufb01ve points to contain eleven 1s). 3.2 Breaking Column Symmetries Consider the starting matrix shown in Figure 2 (the \ufb01rst eight rows of case 6c). This matrix has a symmetry group containing 5!6 \u00b7 4!2 \u00b7 22 permutations. The factor of 22 arises from symmetries that involve row permutations and we discuss how we handle those in Section 3.3. The larger 5!6 \u00b7 4!2 factor arises from column permutations of the last 38 columns which can be split into six blocks of \ufb01ve columns and two blocks of four columns. We break these symmetries by enforcing a lexicographic ordering on certain submatrices of the columns. For example, consider the \ufb01nal block of case 6c (the last four columns shown in Figure 2). By the de\ufb01nition of a projective plane each of these columns must intersect the \ufb01rst column somewhere in the matrix. An examination of the full matrix shows there are exactly six rows where this intersection could happen. Figure 3 shows the case when the rows of the matrix are ordered so that the six rows occur adjacent to each other\u2014 so that the intersections must occur in a 6 \u00d7 4 submatrix. We break the column symmetries by lexicographically ordering the columns in this submatrix. Each row of the submatrix contains at most a single 1 or we would have a pair of columns that intersect each other twice. Thus, lexicographically ordering the columns of the submatrix ensures that a 1 cannot be in the upper-right or lower-left corners of the submatrix as displayed by the 0s in Figure 3. Similarly, each column of the submatrix contains at most a single 1 (in fact it must contain exactly a single 1 since the \ufb01rst column must intersect each of the other columns in the submatrix). Consider the entry marked x in Figure 3. If this entry contains a 1 then all entries in the next column that are above it must be 0 for the columns to be correctly ordered. Thus, considering the variables labelled x and y in Figure 3, we include the clause \u00acx \u2228\u00acy in our encoding. We include similar clauses for each unknown entry in the submatrix. The remaining satisfying assignments are exactly those whose columns are in lexicographic order, therefore enforcing \f1 1 1 1 1 0 0 0 1 0 0 1 y 0 1 0 x 1 0 0 1 0 0 0 . . . \u00b7 \u00b7 \u00b7 Figure 3: A 6 \u00d7 4 submatrix demonstrating our column symmetry breaking encoding. The 0s that appear are known under the assumption that the submatrix\u2019s columns are lexicographically ordered. This also implies that the entry marked y is 0 if the entry marked x contains a 1. a unique ordering on columns which are otherwise identical. By using this method on each block of column symmetries this decreases the search space size by a factor of 5!6 \u00b7 4!2 \u22481015 in the case of Figure 2. Each block is independent of the others and will have its symmetries broken in a different submatrix. 3.3 Breaking Initial Symmetries In Section 3.2 we described how we break most of the symmetries in our instances. However, it remains to break the initial symmetries involving both row and column permutations (i.e., those described in Table 1). We used two methods of breaking these symmetries. One method was particularly effective when the size of the symmetry group was not too large and was used in the cases 2 to 6c. The second method took advantage of the speci\ufb01c form of the symmetry group of the cases 1a\u2013c. Lex method. In addition to the column symmetries of the last 38 columns of the matrix in Figure 2 there are an additional two generators \u03d51 and \u03d52 of the symmetry group of this matrix. These generators involve both row and column permutations. In cycle notation the row permutations are (1, 5)(2, 6)(3, 4) and (1, 2)(3, 4)(5, 6)(7, 8) and the column permutations are completely determined by these row permutations. For example, after swapping rows 1 and 5 and rows 2 and 6, the \ufb01rst column (containing 1s in rows 1 and 2) becomes the 14th column (containing 1s in rows 5 and 6), so \u03d51 must send column 1 to column 14. Similarly, permutations of the \ufb01rst eight rows can be extended to permutations of the entries in the submatrix P consisting of the \ufb01rst 80 rows and the initial columns\u2014the extension uniquely determined by the restriction that the initially known entries remain \ufb01xed. We now consider the action of these permutations on the submatrix P. For example, in case 6c the \ufb01rst 24 columns form the initial columns and the lex symmetry breaking method focuses on the unknown entries in the upper-left 80 \u00d7 24 submatrix P. In particular, we \ufb01x an ordering on the variables in the submatrix P whose values are undetermined. For example, one possible ordering of these variables is left-to-right and top-to-bottom, i.e., LP := [p9,17, p9,18, p9,19, . . . , p80,22, p80,23, p80,24]. Under the symmetry \u03d51 this ordering becomes [p56,19, p56,22, p56,17, . . . , p17,18, p17,20, p17,24] which we denote by \u03d51(LP ). If P is a 80 \u00d7 24 partial projective plane then \u03d51(P) is also a 80 \u00d7 24 partial projective plane. It follows that any partial projective plane of this form can be transformed into an isomorphic partial projective plane with LP \u2264lex \u03d51(LP ). Similarly, up to equivalence we can assume that LP \u2264lex \u03d5(LP ) (\u2217) where \u03d5 is any symmetry of P. In the example of Figure 2 we take \u03d5 to be \u03d51, \u03d52, and \u03d51 \u25e6\u03d52 (there is no need to take \u03d5 to be the identity symmetry since then (\u2217) is trivial). It remains to describe how we encode the lexicographic constraint (\u2217) in conjunctive normal form. We express the general lexicographic constraint [x1, . . . , xn] \u2264lex [y1, . . . , yn] using 3n \u22122 clauses and n \u22121 new variables [Knuth, 2015]. Denoting the new variables by a1, . . . , an\u22121, the clauses are \u00acxk \u2228yk \u2228\u00acak\u22121, \u00acxk \u2228ak \u2228\u00acak\u22121, yk \u2228ak \u2228\u00acak\u22121 for k = 1, . . . , n\u22121 (with \u00aca0 omitted) along with the clause \u00acxn \u2228yn \u2228\u00acan\u22121. In practice this method breaks almost all of the symmetries of the search space that exist in the initial columns, though it is not guaranteed to break them all. This is because for certain instantiations of the variables of P it may be the case that (\u2217) does not remove any isomorphic solutions. This occurs when P is unchanged under all symmetries \u03d5 of the symmetry group (i.e., when LP = \u03d5(LP ) for all symmetries \u03d5). However, this did not occur very often in practice. Similar to the work [Crawford et al., 1996] this method uses constraints of the form (\u2217) for every nontrivial symmetry. Because of this, it worked best when the symmetry group was relatively small. We used this symmetry breaking method on the starting cases 2\u20136c. Block method. Consider the starting matrix given in Figure 1 (case 1c). Since each row contains eleven 1s in total and there are \ufb01ve 1s per row in the initial columns, there are another six 1s in each row. Furthermore, since the rows are already pairwise intersecting in the initial columns, none of the rows intersect following the initial columns. In other words, each row contains six 1s on columns that are not incident with the other rows. We call the columns that contain those six 1s a block of 1s. Without loss of generality we may assume that the \ufb01rst block occurs on columns 19\u201324, the second block occurs on columns 25\u201330, the third block on columns 31\u201336, etc. By exhaustive search, we \ufb01nd that there are 49,472 solutions of the SAT instance that uses the \ufb01rst 80 rows, the columns up to and including the \ufb01rst block, and the lexicographic column ordering clauses described in Section 3.2. Our symmetry breaking method now uses the following properties of the symmetry group of case 1c: 1. The symmetry group \ufb01xing the \ufb01rst row (i.e., the symmetries that do not move the \ufb01rst block) is isomorphic to S4 \u00d7 S3. It has a set of generators {\u03d52, \u03d53, \u03d55, \u03d56, \u03d57} where \u03d5i is a permutation that swaps rows i and i + 1 (and appropriate columns) but \ufb01xes each of the other \ufb01rst eight rows. 2. The action of the symmetry group on the set of blocks is transitive, i.e., for each pair of blocks there exists a \fsymmetry that sends one block to another block. For example, \u03d51 sends block 1 to block 2. We use the \ufb01rst property to show that of the 49,472 possibilities for the \ufb01rst block, only 469 possibilities are nonisomorphic under the symmetries that \ufb01x the \ufb01rst row. These numbers agree with those reported by [Lam et al., 1986]. This splits the search into 469 distinct cases, one for each nonequivalent possibility of the \ufb01rst block. Additionally, we now use the second property to remove further symmetries within these cases. We label each of the 49,472 possibilities for the \ufb01rst block with a label between 1 and 469 and let t be the labelling function that when given an instantiation of the \ufb01rst block returns its label. Furthermore, let Bi denote the submatrix consisting of the ith block where 1 \u2264i \u22648 and let \u03c8i denote a symmetry that sends block i to block 1 where 2 \u2264i \u22648. With \u03d5i de\ufb01ned as above, we can take \u03c82 := \u03d51, \u03c85 := (1, 5)(2, 6)(3, 7)(4, 8) (as row permutations in cycle notation), and \u03c8i := \u03d5i\u22121 \u25e6\u03c8i\u22121 for all other i. We extend the labelling function t by giving an instantiation B of an arbitrary block Bi the same label as \u03c8i(B). Up to isomorphism we can assume that any partial projective plane in case 1c must satisfy t(B1) \u2264t(Bi) for 2 \u2264i \u22648. (\u2217\u2217) In other words, we can assume that the \ufb01rst block has the minimum label of all the blocks 1\u20138. For suppose a partial projective plane did not satisfy this condition: then there must be an index m such that block m has the minimum label. Applying \u03c8m to this partial projective plane permutes the block labels and produces an isomorphic partial projective plane such that block 1 has the minimum label. To encode the constraint (\u2217\u2217) in our SAT instances we use a series of blocking clauses. In each SAT instance the left-hand side of (\u2217\u2217) is known in advance, since each instance contains a \ufb01xed instantiation of the \ufb01rst block. In the \ufb01rst SAT instance the label of the \ufb01rst block is 1. In this case (\u2217\u2217) is trivial and does not block any solutions. In the second SAT instance we need to block all solutions where t(Bi) = 1 for 2 \u2264i \u22648. To do this, suppose B is an instantiation of the \ufb01rst block that is labelled 1. We generate \u03c8\u22121 i (\u03d5(B)) for all 2 \u2264i \u22648 and all \u03d5 in the symmetry group \ufb01xing the \ufb01rst line. This gives us an explicit collection of instantiated blocks that we want to ignore. If B\u2032 is one of these blocks and B\u2032 | = p means that variable p is assigned true in the assignment de\ufb01ned by B\u2032 then the clause W B\u2032| =p \u00acp prevents B\u2032 from occurring in the solution of the SAT instance. We include such clauses in the SAT instance for all B\u2032 of the form \u03c8\u22121 i (\u03d5(B)). Similarly, in the kth SAT instance we include clauses of this form for all B\u2032 of the form \u03c8\u22121 i (\u03d5(B)) where B is an instantiation of the \ufb01rst block whose label is strictly less than k. The above description speci\ufb01cally applies to case 1c, but cases 1a and 1b can be handled in a similar way. In case 1a the main difference is that each block consists of seven columns and some columns are shared between blocks. However, the same method applies because the two properties of the symmetry group that we used in 1c also hold in this case (cases 1a and 1c have an isomorphic symmetry group). In case 1a we \ufb01nd 21,408 solutions of the SAT instance using the \ufb01rst 80 rows and the columns up to and including the \ufb01rst block (the block containing 1s on the \ufb01rst row). Using the symmetries that \ufb01x the \ufb01rst row we \ufb01nd that only 275 of the 21,408 solutions are nonisomorphic, thus naturally splitting the problem into 275 SAT instances that we solve in the same way as we solve the instances from case 1c. We solve case 1b in a similar way, but in this case four of the blocks contain seven columns and the other four blocks contain six columns. We order the blocks such that the \ufb01rst four blocks contain seven columns and the last four blocks contain six columns. The \ufb01rst block coincides with the \ufb01rst block in case 1a and the symmetry group that \ufb01xes the \ufb01rst row is the same as in case 1a, so we also have 275 nonisomorphic solutions of the \ufb01rst block in case 1b. In case 1b the symmetry group does not act transitively on the blocks because there are no symmetries that send blocks with seven columns to blocks with six columns. However, the symmetry group does act transitively on the \ufb01rst four blocks. Thus we use the same symmetry breaking condition given in (\u2217\u2217) except replacing the condition on i with 2 \u2264i \u22644. 4 Implementation and Results The ten starting matrices were constructed following [Carter, 1974] who provides the \ufb01rst 8 rows and 16 columns of each case. The symmetry groups in each case were computed using the computer algebra system Maple 2019 which uses the library nauty [McKay and Piperno, 2014]. A complete collection of the row and column permutations in each group were saved so that they could be later used in the symmetry breaking method. A Python script of about 250 lines was written to generate the constraints (a) and (b) from Section 3.1, the column symmetry breaking constraints from Section 3.2, and for cases 2\u20136c the symmetry breaking constraints from the lex method in Section 3.3. As input it took the case for which to generate constraints and the number of rows and columns to use (though we used 80 rows in all cases). The script required the starting matrix as well as the permutations necessary for breaking the initial symmetries to be explicitly provided. Cases 2\u20136c. For these cases the lex symmetry breaking method described in Section 3.3 was used. Our Python script was used to generate a single SAT instance for each case using all inside columns and an additional \ufb01ve columns. The cube-and-conquer SAT solving paradigm [Heule et al., 2017] was then used to show that each instance was unsatis\ufb01able. The preprocessor of the SAT solver Lingeling [Biere, 2017] (at optimization level 5) simpli\ufb01ed the instances prior to cubing, the lookahead SAT solver March_cu [Heule et al., 2011] generated the cubes, and an incremental version of MapleSAT [Liang et al., 2018] solved the instances and generated proofs of unsatis\ufb01ability. In each case the proofs from the simpli\ufb01cation and conquering steps were combined into a single proof by concatenation and the combined proof was veri\ufb01ed using the proof checker DRAT-trim [Wetzler et al., 2014] as well as the GRAT toolchain [Lammich, 2020]. These cases took about 10 total hours to generate seven proofs whose size together totalled about 300 gigabytes in the plain uncompressed DRAT format. \fCases 1a\u2013c. In these cases the block symmetry breaking method described in Section 3.3 was used. To begin, we generated SAT instances without the initial symmetry breaking clauses and using the columns up to and including the \ufb01rst block. In order to \ufb01nd all nonisomorphic solutions of the \ufb01rst block we use a \u201cprogrammatic\u201d (see [Ganesh et al., 2012]) version of the MapleSAT solver [Bright et al., 2018]. Whenever a solution is found we record the solution and then programmatically learn clauses that block the solution in addition to all solutions isomorphic to the found solution (using the symmetry group \ufb01xing the \ufb01rst block as computed by Maple). In this way, only the nonisomorphic solutions are recorded. For every nonisomorphic solution a SAT instance is generated (by another Python script) that includes unit clauses completely specifying the \ufb01rst block and the symmetry breaking clauses from the block method in Section 3.3. The cube-andconquer method then solves these instances similar to how the previous cases are solved, though cases 1a\u2013c generated 1019 individual proofs (469 in case 1c and 275 for each case 1a and 1b). The fact that these cases are exhaustive relies on nontrivial symmetry group computations, so we did not attempt to combine these proofs together. These instances use \ufb01ve outside columns and all inside columns with the exception of the noninitial columns in block 5 (in cases 1a\u2013b) and blocks 2 and 3 (in case 1c)\u2014 removing these columns generates a strictly smaller set of constraints that increases the performance of the SAT solver. Similarly, [Lam et al., 1986] ignored the columns in blocks 2 and 3 of case 1c and found no solutions. We veri\ufb01ed their result, though this depends on the choice of representatives chosen for the nonisomorphic solutions of the \ufb01rst block\u2014some choices of the representatives do in fact lead to satis\ufb01able instances. Interestingly, the performance in cases 1a and 1c improves if the initial symmetry breaking clauses are left out of the instances provided to the cubing solver, as the cubes generated in this manner are still effective in the conquering phase. In case 1b this causes some cubes to have dramatically unbalanced dif\ufb01culties, so in this case we include the initial symmetry breaking clauses in the cubing instances. Following [Lam et al., 1986], the nonisomorphic solutions of the \ufb01rst block are ordered in increasing size of their stabilizer group. In other words, the solutions that are isomorphic to many other solutions are given small labels and the solutions that are isomorphic to few other solutions are given large labels. Results. The computations were run on a desktop machine with an Intel i7 CPU at 2.7 GHz. A summary of our results is presented in Table 2. In particular, this table speci\ufb01es the total number of cubes used in each case, the proportion of the running time spent running the cubing solver, the total running time (in hours) of the SAT solvers, and the size of the proofs produced. The scripts used to generate and solve the SAT instances are available at uwaterloo.ca/mathcheck and the proofs are archived at zenodo.org/record/3767062. The amount of cubing was controlled by the cubing cutoff -n parameter of March_cu (replacing the default heuristic cutoff). This cutoff method stops cubing once the number of Case Cubes Cubing Time Time (h) Proof size 1a 222310 4.9% 2.61 82.0G 1b 379969 15.1% 2.58 89.1G 1c 1300912 3.6% 13.98 551.5G 2 4486 2.0% 1.82 18.4G 3 36388 7.1% 1.39 37.6G 4 1529 8.8% 0.03 1.0G 5 4582 1.4% 0.42 9.7G 6a 8109 1.9% 0.53 13.3G 6b 91448 3.6% 2.21 76.3G 6c 224942 4.6% 3.26 141.5G Table 2: Summary of the results of our implementation applied to all weight 16 cases. free variables drops below the given bound. We attempted to perform an amount of cubing that would minimize the total solve time of each case, but we do not claim we used an exactly optimal amount. Typically starting with a cubing cutoff bound equal to about 75% of the free variables in the instance worked well and we tuned the bound higher or lower based on the solver performance. The cubing process was done once for each SAT instance and the cubes were incrementally solved by MapleSAT (which was used because it performed better than the default cube-and-conquer solvers). 5"
+                },
+                {
+                    "url": "http://arxiv.org/abs/1907.11981v1",
+                    "title": "Complex Golay Pairs up to Length 28: A Search via Computer Algebra and Programmatic SAT",
+                    "abstract": "We use techniques from the fields of computer algebra and satisfiability\nchecking to develop a new algorithm to search for complex Golay pairs. We\nimplement this algorithm and use it to perform a complete search for complex\nGolay pairs of lengths up to 28. In doing so, we find that complex Golay pairs\nexist in the lengths 24 and 26 but do not exist in the lengths 23, 25, 27, and\n28. This independently verifies work done by F. Fiedler in 2013 and confirms\nthe 2002 conjecture of Craigen, Holzmann, and Kharaghani that complex Golay\npairs of length 23 don't exist. Our algorithm is based on the recently proposed\nSAT+CAS paradigm of combining SAT solvers with computer algebra systems to\nefficiently search large spaces specified by both algebraic and logical\nconstraints. The algorithm has two stages: first, a fine-tuned computer program\nuses functionality from computer algebra systems and numerical libraries to\nconstruct a list containing every sequence which could appear as the first\nsequence in a complex Golay pair up to equivalence. Second, a programmatic SAT\nsolver constructs every sequence (if any) that pair off with the sequences\nconstructed in the first stage to form a complex Golay pair. This extends work\noriginally presented at the International Symposium on Symbolic and Algebraic\nComputation (ISSAC) in 2018; we discuss and implement several improvements to\nour algorithm that enabled us to improve the efficiency of the search and\nincrease the maximum length we search from length 25 to 28.",
+                    "authors": "Curtis Bright, Ilias Kotsireas, Albert Heinle, Vijay Ganesh",
+                    "published": "2019-07-27",
+                    "updated": "2019-07-27",
+                    "primary_cat": "cs.SC",
+                    "cats": [
+                        "cs.SC",
+                        "cs.LO",
+                        "math.CO"
+                    ],
+                    "main_content": "Introduction The sequences that are now referred to Golay sequences or Golay pairs were \ufb01rst introduced by Golay (1949) in a groundbreaking paper on multislit spectrometry. Later, Golay (1961) made a detailed study of their elegant mathematical properties and in this paper he referred to them as complementary series: Regardless of past or possible future applications, the writer has found these complementary series mathematically appealing... Since then, Golay pairs and their generalizations have been widely studied and applied to a huge and surprisingly varied number of problems in engineering. For example, they To appear in the Journal of Symbolic Computation July 27, 2019 arXiv:1907.11981v1  [cs.SC]  27 Jul 2019 \fhave been applied to encoding acoustic surface waves (Tseng, 1971), spread-spectrum systems (Krone and Sarwate, 1984), optical time domain re\ufb02ectometry (Nazarathy et al., 1989), CDMA networks (Seberry et al., 2002), medical ultrasounds (Nowicki et al., 2003), train wheel detection (Donato et al., 2004), radar systems (Li et al., 2008), and wireless networks (Lomayev et al., 2017). Golay pairs consist of two sequences and the property that de\ufb01nes them (roughly speaking) is the fact that one sequence\u2019s \u201ccorrelation\u201d with itself is the inverse of the other sequence\u2019s \u201ccorrelation\u201d with itself; see De\ufb01nition 2 in Section 2 for the formal de\ufb01nition. Although Golay de\ufb01ned his complementary series over an alphabet of {\u00b11}, later authors have generalized the alphabet to include nonreal roots of unity such as the fourth root of unity i B \u221a \u22121. In this paper, we focus on the case where the alphabet is {\u00b11, \u00b1i}. In this case the resulting sequence pairs are sometimes referred to as quadriphase, 4-phase, or quaternary Golay pairs though we will simply refer to them as complex Golay pairs. If a complex Golay pair of length n exists then we say that n is a complex Golay number. Complex Golay pairs have been extensively studied by many authors in several different contexts. Initially they were studied in the context of signal processing where some researchers ran searches for \u201cpolyphase complementary codes\u201d in the process of studying signal encoding methods. In particular, Sivaswamy (1978) found a complex Golay pair of length 3 and Frank (1980) found complex Golay pairs of length 5 and 13 and stated that 7, 9, 11, 15, and 17 were not complex Golay numbers. Complex Golay pairs were also introduced by Craigen (1994) (independently of the above works) in order to expand the orders of Hadamard matrices attainable via ordinary Golay pairs\u2014 that are only known to exist in the lengths 2a+b+c \u00b75b \u00b713c for integers a, b, c \u22650. Craigen also proved that if m and n are complex Golay numbers then 2mn is a complex Golay number. An exhaustive search for complex Golay pairs up to length 13 was performed by Holzmann and Kharaghani (1994). This search veri\ufb01ed the remark of Frank (1980) that 7 and 9 are not complex Golay numbers but found that 11 is in fact a complex Golay number (the cause of the mistaken claim is unknown since it was based on computer programs that were never published). Later, an exhaustive search up to length 19 was performed by Craigen, Holzmann, and Kharaghani (2002), showing that 14, 15, 17, and 19 are not complex Golay numbers. In addition, they reported that 21 was not a complex Golay number and conjectured that 23 was not a complex Golay number based on a partial search for complex Golay pairs of length 23. Another line of research is to provide explicit constructions for complex Golay pairs and a number of results of this form have been published as well. Fiedler, Jedwab, and Parker (2008a,b) provide a construction that explains the existence of all known complex Golay pairs whose lengths are a power of 2, including complex Golay pairs of length 16 discovered by Li and Chu (2005) to not \ufb01t into a construction given by Davis and Jedwab (1999). Gibson and Jedwab (2011) provide a construction that explains the existence of all complex Golay pairs up to length 26 and give a table that lists the total number of complex Golay pairs up to length 26. This table was produced by the mathematician Frank Fiedler, who describes his enumeration method in a subsequent paper (Fiedler, 2013) where he also reports that 27 and 28 are not complex Golay numbers. In this paper we give an enumeration method that can be used to verify Fiedler\u2019s 2 \ftable giving the total number of complex Golay pairs up to length 28. We implemented our method and obtained counts up to length 28 after about 8.5 months of CPU time. The counts we obtain match those in Fiedler\u2019s table in each case, increasing the con\ufb01dence that the enumeration was performed without error. In addition, we also provide counts for the total number of complex Golay pairs up to well-known equivalence operations and explicitly publish the sequences on our website uwaterloo.ca/mathcheck. To our knowledge, this is the \ufb01rst time that explicit complex Golay pairs (and their counts up to equivalence) have been published for lengths larger than 19. Lastly, we publicly release our code for enumerating complex Golay pairs so that others may verify and reproduce our work; we were not able to \ufb01nd any other code for enumerating complex Golay pairs that was publicly available. Our result is of interest not only because of the veri\ufb01cation we provide but also because of the method we use to perform the veri\ufb01cation. The method proceeds in two stages. In the \ufb01rst stage, a \ufb01ne-tuned computer program performs an exhaustive search among all sequences that could possibly appear as the \ufb01rst sequence in a complex Golay pair of a given length (up to the equivalence de\ufb01ned in Proposition 8 of Section 2). Several \ufb01ltering theorems that we describe in Section 2 allow us to discard almost all sequences from consideration. To apply these \ufb01ltering theorems we use functionality from the computer algebra system MAPLE (Monagan et al., 2005) and the mathematical library FFTW (Frigo and Johnson, 2005) as we describe in Section 3. After this \ufb01ltering is completed we have a list of sequences of a manageable size such that the \ufb01rst sequence of every complex Golay pair of a given length (up to equivalence) appears in the list. In the second stage, we use the programmatic SAT solver MAPLESAT developed by Liang et al. (2017) to determine the sequences from the \ufb01rst stage (if any) that can be paired up with another sequence to form a complex Golay pair. A programmatic SAT instance is constructed from each sequence found in the \ufb01rst stage such that the instance is satis\ufb01able if and only if the sequence is part of a complex Golay pair. Furthermore, when the instance is satis\ufb01able the assignment produced by the SAT solver determines the second sequence of a complex Golay pair. The \u201cSAT+CAS\u201d method that we use is of interest in its own right because it links the two previously separated \ufb01elds of symbolic computation and satis\ufb01ability checking. Recently there has been interest in combining methods from both \ufb01elds to solve computational problems as outlined in the invited talk at ISSAC by \u00c1brah\u00e1m (2015) and demonstrated by the SC2 (satis\ufb01ability checking + symbolic computation) project initiated by \u00c1brah\u00e1m et al. (2016). Our work \ufb01ts into this paradigm and to our knowledge is the \ufb01rst application of a SAT solver to search for complex Golay pairs, though previous work exists that uses a SAT solver to search for other types of complementary sequences like those de\ufb01ning Williamson matrices (Bright et al., 2016; Zulkoski et al., 2017; Bright, 2017). A preliminary version of our algorithm and results was presented at the conference ISSAC (Bright et al., 2018b). We have since made several improvements to our algorithm that allow us to extend our exhaustive search from all lengths n \u226425 to all lengths n \u226428. We describe our implementation, give timings for our searches, and compare the timings with those of our previous algorithm in Section 4. The new timings are about an order of magnitude faster on the same hardware, demonstrating the effectiveness of our improvements. In particular, our new algorithm incorporates the following updates: 3 \fMore ef\ufb01cient \ufb01ltering. The preprocessing stage of our algorithm uses a \ufb01ltering condition (Corollary 14 of Section 2) to remove a large number of sequences from consideration. In our original algorithm we applied this condition using a large number of equally-spaced points z along the unit circle. In our new algorithm we apply this condition signi\ufb01cantly less often but \ufb01lter approximately the same number of sequences (and sometimes even more) by showing how to only use the condition for the z that are the most likely to work. More ef\ufb01cient joining. The \ufb01rst stage of our algorithm requires searching through two lists and \ufb01nding elements of the \ufb01rst that can be joined with elements of the second. In our previous algorithm this was done in a totally brute-force manner, i.e., every item in the \ufb01rst list was paired with every item of the second list to see if they could be joined. In our new algorithm we sort the lists using a custom ordering and show how to \ufb01nd the elements that can be joined via a number of linear scans through the sorted lists (see Section 3.2), thereby eliminating the need to consider all possible pairs. Increased \ufb01ltering. Because the improved \ufb01ltering method outlined above is so much faster than the previous \ufb01ltering method we were able to add another round of \ufb01ltering just before generating the SAT instances (see Section 3.5). The result is that approximately 40% of the SAT instances generated by our previous algorithm are now quickly \ufb01ltered before even calling a SAT solver. Additionally we include more background details in this version of the paper. For example, we add Section 2.1 that gives an alternative de\ufb01nition of complex Golay pairs that is often useful and we show that this de\ufb01nition is equivalent with the \ufb01rst de\ufb01nition. 2. Background on Complex Golay Pairs In this section we present the background necessary to describe our method for enumerating complex Golay pairs. First, we require some preliminary de\ufb01nitions to de\ufb01ne what complex Golay pairs are. We let z denote the complex conjugate of z (which is just the multiplicative inverse of z for z on the unit circle) and if A is a sequence we let A denote the sequence containing the conjugates of A. De\ufb01nition 1 (cf. Kotsireas (2013)). The nonperiodic autocorrelation function of a sequence A = [a0, . . . , an\u22121] of length n is NA(s) B n\u2212s\u22121 X k=0 akak+s for s = 0, . . . , n \u22121. De\ufb01nition 2. A pair of sequences (A, B) with A and B in {\u00b11, \u00b1i}n are called a complex Golay pair if the sum of their nonperiodic autocorrelations is a constant zero for s , 0, i.e., NA(s) + NB(s) = 0 for s = 1, . . . , n \u22121. Note that if A and B are in {\u00b11, \u00b1i}n (as we assume throughout this paper) then NA(0) + NB(0) = 2n by the de\ufb01nition of the nonperiodic autocorrelation function and the fact that zz = 1 if z is \u00b11 or \u00b1i, explaining why s , 0 in De\ufb01nition 2. 4 \fExample 3. ([1, 1, \u22121], [1, i, 1]) is a complex Golay pair of length 3 since the \ufb01rst sequence A has autocorrelations NA(1) = 0 and NA(2) = \u22121 and the second sequence B has autocorrelations NB(1) = 0 and NB(2) = 1. 2.1. Alternative de\ufb01nition Instead of viewing complex Golay pairs as pairs of sequences it is also possible to view them as pairs of polynomials. If A is the sequence [a0, . . . , an\u22121] we let A(z) denote the Hall polynomial a0 + a1z + . . . + an\u22121zn\u22121 which can be viewed as the \ufb01nite generating function of A. This leads to the following alternative de\ufb01nition of complex Golay pairs. De\ufb01nition 4. A pair of polynomials (A(z), B(z)) that have degrees n \u22121 and coef\ufb01cients in {\u00b11, \u00b1i} are called a complex Golay pair if |A(z)|2 + |B(z)|2 = 2n for all z on the unit circle. Example 5. (1 + z \u2212z2, 1 + iz + z2) is a complex Golay pair of length 3 since \f \f \f1 + z \u2212z2\f \f \f2 + \f \f \f1 + iz + z2\f \f \f2 = 6 for all z on the unit circle. These two de\ufb01nitions can be seen to be equivalent using the following lemma that expresses the squared absolute values of a polynomial evaluated on the unit circle in terms of the autocorrelations of the sequence formed by the polynomial\u2019s coef\ufb01cients. Lemma 6. Let A be a complex sequence of length n. Then |A(z)|2 = NA(0) + 2 Re \u0012n\u22121 X s=1 NA(s)z\u2212s\u0013 . for all z on the unit circle. Proof. Since z is on the unit circle we have z = z\u22121, so |A(z)|2 = A(z)A(z) = A(z)A(z\u22121). Expanding this, we obtain that |A(z)|2 is equal to n\u22121 X k=0 n\u22121 X l=0 akalzk\u2212l. Collecting terms of zs together for s from \u2212n + 1 to n \u22121 this becomes n\u22121 X s=0 \u0012n\u22121 X j=s a jaj\u2212s \u0013 zs + n\u22121 X s=1 \u0012n\u22121 X j=s aj\u2212saj \u0013 z\u2212s so the coef\ufb01cient of zs for positive s is NA(s) and for negative s is NA(s). Using the fact that NA(s)zs = NA(s)z\u2212s this becomes NA(0) + n\u22121 X s=1 \u0012 NA(s)z\u2212s + NA(s)z\u2212s\u0013 . The desired result now follows from the fact that z + z = 2 Re(z) for all complex z. 5 \fFor completeness we now demonstrate the equivalence of De\ufb01nitions 2 and 4. Theorem 7. A pair (A, B) is a complex Golay pair in the sense of De\ufb01nition 2 if and only if (A(z), B(z)) is a complex Golay pair in the sense of De\ufb01nition 4. Proof. If (A, B) is a complex Golay pair in the sense of De\ufb01nition 2 then by Lemma 6 |A(z)|2 + |B(z)|2 = NA(0) + NB(0) + 2 Re \u0012n\u22121 X s=1 (NA(s) + NB(z))z\u2212s\u0013 = 2n for all z on the unit circle, as required. Conversely, if (A(z), B(z)) is a complex Golay pair in the sense of De\ufb01nition 4 then by Lemma 6 and subtracting off NA(0) + NB(0) = 2n we have n\u22121 X s=1 \u0010 NA(s)z\u2212s + NA(s)zs + NB(z)z\u2212s + NB(s)zs\u0011 = 0 for all z on the unit circle. Since any nonzero rational function has a \ufb01nite number of zeros in C the function given on the left hand side must be identically zero. In particular, the coef\ufb01cients of z\u2212s for s = 1, . . . , n \u22121 must be zero and we derive NA(s) + NB(s) = 0 for s = 1, . . . , n \u22121 as required. 2.2. Equivalence operations There are certain invertible operations that preserve the property of being a complex Golay pair when applied to a sequence pair (A, B). These are summarized in the following proposition. Proposition 8 (cf. Craigen et al. (2002)). Let ([a0, . . . , an\u22121], [b0, . . . , bn\u22121]) be a complex Golay pair. Then the following are also complex Golay pairs: E1. (Reversal) ([an\u22121, . . . , a0], [bn\u22121, . . . , b0]). E2. (Conjugate Reverse A) ([an\u22121, . . . , a0], [b0, . . . , bn\u22121]). E3. (Swap) ([b0, . . . , bn\u22121], [a0, . . . , an\u22121]). E4. (Scale A) ([ia0, . . . , ian\u22121], [b0, . . . , bn\u22121]). E5. (Positional Scaling) (i \u22c6A, i \u22c6B) where c \u22c6A denotes the sequence of coef\ufb01cients of the polynomial A(cz), i.e., [a0, ca1, c2a2, . . . , cn\u22121an\u22121]. Proof. Suppose (A, B) is a complex Golay pair and let z be on the unit circle. E1. Note that the reverse of A(z) is zn\u22121A(z\u22121) and |zn\u22121| = 1. Then |zn\u22121A(z\u22121)|2 + |zn\u22121B(z\u22121)|2 = |A(z\u22121)|2 + |B(z\u22121)|2 = 2n since (A, B) is a complex Golay pair and z\u22121 is on the unit circle. E2. The conjugate reverse of A(z) is zn\u22121A(z\u22121) and |zn\u22121A(z\u22121)| = |A(z)| = |A(z)|. E3. |B(z)|2 + |A(z)|2 = |A(z)|2 + |B(z)|2 = 2n. E4. A(z) scaled by i is iA(z) and |iA(z)| = |A(z)|. 6 \fE5. |A(iz)|2 + |B(iz)|2 = 2n since (A, B) is a complex Golay pair and iz is on the unit circle. De\ufb01nition 9. We call two complex Golay pairs (A, B) and (A\u2032, B\u2032) equivalent if (A\u2032, B\u2032) can be obtained from (A, B) using the transformations described in Proposition 8. The next lemma provides some normalization conditions that can be used when searching for complex Golay pairs up to equivalence. Since all complex Golay pairs (A\u2032, B\u2032) which are equivalent to a complex Golay pair (A, B) can easily be generated from (A, B), it suf\ufb01ces to search for complex Golay pairs up to equivalence. Lemma 10 (cf. Fiedler (2013)). Let (A\u2032, B\u2032) be a complex Golay pair. Then (A\u2032, B\u2032) is equivalent to a complex Golay pair (A, B) with a0 = a1 = b0 = 1 and a2 \u2208{\u00b11, i}. Proof. We will transform a given complex Golay sequence pair (A\u2032, B\u2032) into an equivalent normalized one using the equivalence operations of Proposition 8. To start with, let A B A\u2032 and B B B\u2032. First, we ensure that a0 = 1. To do this, we apply operation E4 (scale A) enough times until a0 = 1. Second, we ensure that a1 = 1. To do this, we apply operation E5 (positional scaling) enough times until a1 = 1; note that E5 does not change a0. Third, we ensure that a2 , \u2212i. If it is, we apply operation E1 (reversal) and E2 (conjugate reverse A) which has the effect of keeping a0 = a1 = 1 and setting a2 = i. Last, we ensure that b0 = 1. To do this, we apply operation E3 (swap) and then operation E4 (scale A) enough times so that a0 = 1 and then operation E3 (swap) again. This has the effect of not changing A but setting b0 = 1. 2.3. Filtering properties We now prove some useful properties that all complex Golay pairs satisfy and that will be exploited by our algorithm for enumerating complex Golay pairs. The properties will be used as \ufb01ltering criteria: if a sequence does not satisfy them then we know it cannot possibly be part of a complex Golay pair and may therefore be \ufb01ltered away. The next well-known lemma is one of the most powerful results of this form. Lemma 11 (cf. Popovi\u00b4 c (1991)). Let A be a complex sequence of length n. If |A(z)|2 > 2n for some z on the unit circle then A is not a member of a complex Golay pair. Proof. Suppose the sequence A was a member of a complex Golay pair whose other member was the sequence B. Since |B(z)|2 \u22650, we must have |A(z)|2 + |B(z)|2 > 2n, in contradiction to De\ufb01nition 4. Example 12. The sequence A B [1, 1, 1] cannot be a member of a complex Golay pair since |A(1)|2 = 9 is larger than 2n = 6. Fiedler (2013) derives a variation of Lemma 11 that is useful because it can be applied knowing only around half of the entries of A. It is derived using the following variation of Lemma 6. Let Aeven be identical to A with the entries of odd index replaced by zeros and let Aodd be identical to A with the entries of even index replaced by zeros. 7 \fLemma 13 (cf. Fiedler (2013)). Let A be a complex sequence of length n. Then |Aeven(z)|2 + |Aodd(z)|2 = NA(0) + 2 Re  n\u22121 X s=1 s even NA(s)z\u2212s ! . Proof. The proof proceeds like in the proof of Lemma 6 and we derive |Aeven(z)|2 + |Aodd(z)|2 = n\u22121 X k,l=0 k, l even akalzk\u2212l + n\u22121 X k,l=0 k, l odd akalzk\u2212l = n\u22121 X k,l=0 k\u2212l even akalzk\u2212l. From this we see that the coef\ufb01cient on zs for odd s is zero and the coef\ufb01cient on zs for even s is the same as in Lemma 6 from which the result follows. Corollary 14. Let A be a complex sequence of length n. If |Aeven(z)|2 or |Aodd(z)|2 is strictly larger than 2n for some z on the unit circle then A is not a member of a complex Golay pair. Proof. If (A, B) is a complex Golay pair then by Lemma 13 we have |Aeven(z)|2 + |Aodd(z)|2 + |Beven(z)|2 + |Bodd(z)|2 = 2n but if either |Aeven(z)|2 > 2n or |Aodd(z)|2 > 2n then this cannot hold. Example 15. The sequence A B [1, x, 1, y, 1, z, 1] cannot be a member of a complex Golay pair (regardless of the values of x, y, and z) since |Aeven(1)|2 = 16 is larger than 2n = 14. 2.4. Sum-of-squares decomposition types The next lemma is useful because it allows us to write 2n as the sum of four integer squares. It is stated by Holzmann and Kharaghani (1994) using a different notation; we use the notation resum(A) and imsum(A) to represent the real and imaginary parts of the sum of the entries of A. For example, if A B [1, i, \u2212i, i] then resum(A) = imsum(A) = 1. Lemma 16 (cf. Holzmann and Kharaghani (1994)). If (A, B) is a complex Golay pair then resum(A)2 + imsum(A)2 + resum(B)2 + imsum(B)2 = 2n. Proof. Using De\ufb01nition 4 with z = 1 we have |resum(A) + imsum(A)i|2 + |resum(B) + imsum(B)i|2 = 2n. Since |resum(X) + imsum(X)i|2 = resum(X)2 + imsum(X)2 the result follows. A consequence of Lemma 16 is that every complex Golay pair generates a decomposition of 2n into a sum of four integer squares. In fact, it typically generates several decompositions of 2n into a sum of four squares. Recall that i \u22c6A denotes positional scaling by i (operation E5) on the sequence A. If (A, B) is a complex Golay pair then 8 \fapplying operation E5 to this pair k times shows that (ik \u22c6A, ik \u22c6B) is also a complex Golay pair. By using Lemma 16 on these complex Golay pairs one obtains the fact that 2n can be decomposed as the sum of four integer squares as resum(ik \u22c6A)2 + imsum(ik \u22c6A)2 + resum(ik \u22c6B)2 + imsum(ik \u22c6B)2. For k > 3 this produces no new decompositions but in general for k = 0, 1, 2, and 3 this produces four distinct decompositions of 2n into a sum of four squares. With the help of a computer algebra system (CAS) one can enumerate every possible way that 2n may be written as a sum of four integer squares. For example, when n = 23 one has 02 +12 +32 +62 = 2\u00b723 and 12 +22 +42 +52 = 2\u00b723 as well as all permutations of the squares and negations of the integers being squared. During the \ufb01rst stage of our enumeration method only the \ufb01rst sequence of a complex Golay pair is known, so at that stage we cannot compute its whole sums-of-squares decomposition. However, it is still possible to \ufb01lter some sequences from consideration based on analyzing the two known terms in the sums-of-squares decomposition. For example, say that A is the \ufb01rst sequence in a potential complex Golay pair of length 23 with resum(A) = 0 and imsum(A) = 5. We can immediately discard A from consideration because there is no way to chose the resum and imsum of B to complete the sums-of-squares decomposition of 2n, i.e., there are no integer solutions (x, y) of 02 + 52 + x2 + y2 = 2n. 3. Enumeration Method In this section we describe in detail the method we used to perform a complete enumeration of all complex Golay pairs up to length 28. Given a length n our goal is to \ufb01nd all {\u00b11, \u00b1i} sequences A and B of length n such that (A, B) is a complex Golay pair. 3.1. Preprocessing: Enumerate possibilities for Aeven and Aodd The \ufb01rst step of our method uses Fiedler\u2019s trick of considering the entries of A of even index separately from the entries of A of odd index. There are approximately n/2 nonzero entries in each of Aeven and Aodd and there are four possible values for each nonzero entry. Therefore there are approximately 2 \u00b7 4n/2 = 2n+1 possible sequences to check in this step. Additionally, by Lemma 10 we may assume the \ufb01rst nonzero entry of both Aeven and Aodd is 1 and that the second nonzero entry of Aeven is not \u2212i, decreasing the number of sequences to check in this step by more than a factor of 4. It is quite feasible to perform a brute-force search through all such sequences when n \u224830. We apply Corollary 14 to every possibility for Aeven and Aodd. There are an in\ufb01nite number of z on the unit circle so it is not possible to apply Corollary 14 using all such z. One simple approach is to try a suf\ufb01ciently large number of points z so that when a point exists with |A\u2032(z)|2 > 2n (where A\u2032 is either Aeven or Aodd) such a point is usually discovered. For example, Bright et al. (2018b) tested Corollary 14 for 214 equally-spaced points z around the unit circle. Instead, in our implementation we use a nonlinear programming method to estimate the maximum of |A\u2032(z)|2 for z on the unit circle. This can be done with the NLPSOLVE command of the computer algebra system MAPLE though for ef\ufb01ciency we use a custom 9 \fC implementation of a variant of the quadratic interpolation method described by Sun and Yuan (2006). We write |A\u2032(z)|2 in terms of the real variable \u03b8 by using the substitution z = ei\u03b8 and de\ufb01ne f(\u03b8) B |A\u2032(ei\u03b8)|2. The quadratic interpolation method to estimate the maximum of f(\u03b8) over 0 \u2264\u03b8 < 2\u03c0 proceeds as follows: 1. Evaluate f at the 27 points \u03b80, . . . , \u03b8127 where \u03b8k B 2\u03c0k 128 and let fk B f(\u03b8k). If fk > 2n for some k we can immediately \ufb01lter A\u2032 by Corollary 14. 2. For every value of f that is larger than its neighbours (i.e., values of fk that satisfy fk\u22121 \u2264fk and fk \u2265fk+1) we use interpolation to \ufb01nd the quadratic polynomial that passes through the points (\u03b8k\u22121, fk\u22121), (\u03b8k, fk), and (\u03b8k+1, fk+1). Let \u03b8\u2217be the value of \u03b8 that maximizes the quadratic polynomial; this can be computed to be exactly 1 2 \u00b7 fk\u22121(\u03b82 k \u2212\u03b82 k+1) + fk(\u03b82 k+1 \u2212\u03b82 k\u22121) + fk+1(\u03b82 k\u22121 \u2212\u03b82 k) fk\u22121(\u03b8k \u2212\u03b8k+1) + fk(\u03b8k+1 \u2212\u03b8k\u22121) + fk+1(\u03b8k\u22121 \u2212\u03b8k) and let f \u2217B f(\u03b8\u2217). 3. Note that f \u2217is often a better approximation to a local maximum of f than fk was, and if f \u2217> 2n then we can \ufb01lter A\u2032 by Corollary 14. Otherwise we can use the point (\u03b8\u2217, f \u2217) to derive a tighter interval in which a local maximum of f must lie. For example, if \u03b8k < \u03b8\u2217< \u03b8k+1 and f \u2217> fk then we can repeat the previous step except using the points (\u03b8k, fk), (\u03b8\u2217, f \u2217), and (\u03b8k+1, fk+1). One can use this method to derive more and more accurate approximations to the local maxima of f though this is mostly unnecessary for our purposes as we only care about \ufb01nding a single value for \u03b8 with f(\u03b8) > 2n. A good approximation to a local maximum was usually found after a single interpolation step so in our implementation we would move on to looking for another local maximum of f after repeating the interpolation step three times. If all values of fk were examined and no points \u03b8 were found with f(\u03b8) > 2n then we save A\u2032 as a sequence that could not be \ufb01ltered. At the conclusion of this step we have two lists: one list Leven of the Aeven that were not discarded and one list Lodd of the Aodd that were not discarded. 3.2. Stage 1: Enumerate possibilities for A We now enumerate all possibilities for A by joining all possibilities for Aeven with all possibilities for Aodd. The most straightforward way of doing this would be to simply try all A1 \u2208Lodd and A2 \u2208Leven; this was done by Bright et al. (2018b). However, because both Leven and Lodd can contain millions of sequences it can be inef\ufb01cient to try all possible pairings (A1, A2). However, many pairings can be eliminated by using the conditions implied by Lemma 16; we now show how to \ufb01nd all possible pairings that satisfy these conditions without needing to try all A1 \u2208Lodd and A2 \u2208Leven. Let (u0, u1, u2, u3) be an arbitrary quadruple of integers. We will describe how to ef\ufb01ciently \ufb01nd all A whose entries of odd index are in Lodd, whose entries of even index are in Leven, and that satisfy resum(A) = u0, imsum(A) = u1, resum(i \u22c6A) = u2, imsum(i \u22c6A) = u3. (1) 10 \fFor each A1 \u2208Lodd we form the vector V1 B (resum(A1), imsum(A1), resum(i \u22c6A1), imsum(i \u22c6A1)) and for each A2 \u2208Leven we form the vector V2 B (u0 \u2212resum(A2), u1 \u2212imsum(A2), u2 \u2212resum(i \u22c6A2), u3 \u2212imsum(i \u22c6A2)). We now show that the A that satisfy relationship (1) are exactly those formed by the A1 and A2 with V1 = V2. Lemma 17. Let A1 \u2208Lodd and A2 \u2208Leven and let A be the sequence that satis\ufb01es the relationship A(z) = A1(z) + A2(z), i.e., A is a sequence of length n with {\u00b11, \u00b1i} entries. Then A satis\ufb01es (1) if and only if the vectors V1 and V2 de\ufb01ned as above satisfy V1 = V2. Proof. Consider the \ufb01rst entry of V1 and V2. If they are equal, we have resum(A1) = u0 \u2212resum(A2). This implies that resum(A) = u0 since resum(A) = resum(A1) + resum(A2). Similarly, we derive imsum(A) = u1, resum(i \u22c6A) = u2, and imsum(i \u22c6A) = u3, as required. Conversely, resum(A) = u0 implies that the \ufb01rst entries of V1 and V2 are equal and the other equations from (1) imply that their other entries are also equal. Therefore we have translated the problem of \ufb01nding the sequences A that satisfy (1) into the problem of \ufb01nding A1 \u2208Lodd and A2 \u2208Leven that have matching vectors V1 and V2. We can ef\ufb01ciently solve this problem using a string sorting algorithm as described by (for example) Kotsireas, Koukouvinos, and Seberry (2009). First, we sort the list Lodd so that the vectors V1 formed above appear in lexicographically increasing order when iterating through L1 \u2208Lodd. Similarly, we sort Leven in the same way so that the V2 appear in lexicographically increasing order. We can then \ufb01nd all V1 that match with V2 by a linear scan through the lists L1 and L2 and this requires only one pass through each list. For example, if at some point we \ufb01nd that V1 is lexicographically greater than V2 then we try the next L2 in the list Leven and if we instead \ufb01nd that V2 is lexicographically greater than V1 then we try the next L1 in the list Lodd. If instead we \ufb01nd V1 = V2 we iterate through the L1 and L2 that share the same value of V1 and V2 and save the A formed by joining all such A1 and A2 in a new list LA. It remains to determine the appropriate values of (u0, u1, u2, u3) to use in (1). To do this we use a quadratic Diophantine equation solver and \ufb01nd all solutions of the Diophantine equation u2 + v2 + x2 + y2 = 2n in integers u, v, x, y. Let U be the set of all pairs (u, v) for which this equation is solvable. By Lemma 16 and operation E5 we know that if A is a complex Golay pair then (resum(A), imsum(A)) and (resum(i \u22c6A), imsum(i \u22c6A)) must be members of U. Therefore, we apply the above joining procedure for all ((u0, u1), (u2, u3)) \u2208U2. 11 \fAt the conclusion of this stage we will have a list of sequences LA that could potentially be a member of a complex Golay pair. By construction, the \ufb01rst member of all complex Golay pairs (up to the equivalence described in Lemma 10) of length n will be in LA. To decrease the size of LA even further we perform additional \ufb01ltering before adding sequences into LA, for example, we ensure that \u0000resum(\u22121 \u22c6A), imsum(\u22121 \u22c6A)\u0001 and \u0000resum(\u2212i \u22c6A), imsum(\u2212i \u22c6A)\u0001 are both in U for each A added to LA. We also \ufb01lter those A with |A(z)|2 > 2n for some z on the unit circle (see Section 3.5 for optimization details). 3.3. Stage 2: Construct the second sequence B from A In the second stage we take as input the list LA generated in the \ufb01rst stage, i.e., a list of the sequences A that were not \ufb01ltered by any of the \ufb01ltering theorems we applied. For each A \u2208LA we attempt to construct a second sequence B such that (A, B) is a complex Golay pair. We do this by generating a SAT instance that encodes the property of (A, B) being a complex Golay pair where the entries of A are known and the entries of B are unknown and encoded using Boolean variables. Because there are four possible values for each entry of B we use two Boolean variables to encode each entry. Although the exact encoding used is arbitrary, we \ufb01xed the following encoding in our implementation, where the variables v2k and v2k+1 represent bk, the kth entry of B: v2k v2k+1 bk F F 1 F T \u22121 T F i T T \u2212i To encode the property that (A, B) is a complex Golay pair in our SAT instance we add the conditions that de\ufb01ne (A, B) to be a complex Golay pair, i.e., NA(s) + NB(s) = 0 for s = 1, . . . , n \u22121. These equations could be encoded using clauses in conjunctive normal form (for example by constructing logical circuits to perform complex multiplication and addition and then converting those circuits into CNF clauses). However, we found that a much more ef\ufb01cient and convenient method was to use a programmatic SAT solver. The concept of a programmatic SAT solver was \ufb01rst introduced by Ganesh et al. (2012) where a programmatic SAT solver was shown to be more ef\ufb01cient than a standard SAT solver when solving instances derived from RNA folding problems. More recently, a programmatic SAT solver was also shown to be useful when searching for Williamson matrices and good matrices by Bright et al. (2018a, 2019). Generally, programmatic SAT solvers perform well when there is additional domain-speci\ufb01c knowledge known about the problem being solved. Often this knowledge cannot easily be encoded into a SAT instance directly but can be given to a programmatic SAT solver to help guide the solver in its search. 12 \fConcretely, a programmatic SAT solver is compiled with a piece of code that encodes a property any solution must satisfy. Periodically the SAT solver will run this code while performing its search, and if the current partial assignment violates a property that is expressed in the provided code then a con\ufb02ict clause is generated encoding this fact. The con\ufb02ict clause is added to the SAT solver\u2019s database of learned clauses where it is used to increase the ef\ufb01ciency of the remainder of the search. The reason that these clauses can be so useful is because they can encode facts that the SAT solver would have no way of learning otherwise, since the SAT solver has no knowledge of the domain of the problem. Not only does this paradigm allow the SAT solver to perform its search more ef\ufb01ciently, it also allows instances to be much more expressive. Under this framework SAT instances do not have to consist solely of Boolean formulas in conjunctive normal form (the typical format of SAT instances) but can consist of clauses in conjunctive normal form combined with a piece of code that programmatically expresses clauses. Increased expressiveness is also a feature of SMT (SAT modulo theories) solvers, though SMT solvers typically require additional overhead and only support a \ufb01xed number of theories such as those speci\ufb01ed in the SMT library (Barrett et al., 2016). Additionally, one can compile instance-speci\ufb01c programmatic SAT solvers that are tailored to perform searches for a speci\ufb01c class of problems. For our purposes we use a programmatic SAT solver tailored to search for sequences B that when paired with a given sequence A form a complex Golay pair. Each instance will contain the 2n variables v0, . . . , v2n\u22121 that encode the entries of B as previously speci\ufb01ed. In detail, the code given to the SAT solver does the following: 1. Compute and store the values NA(k) for k = 1, . . . , n \u22121. 2. Initialize s to n \u22121. This will be a variable that controls which autocorrelation condition we are currently examining. 3. Examine the current partial assignment to v0, v1, v2n\u22122, and v2n\u22121. If all these values have been assigned then we can determine the values of b0 and bn\u22121. From these values we compute NB(s) = b0bn\u22121. If NA(s) + NB(s) , 0 then (A, B) cannot be a complex Golay pair (regardless of the values of b1, . . . , bn\u22122) and therefore we learn a con\ufb02ict clause saying that b0 and bn\u22121 cannot both be assigned to their current values. More explicitly, if vcur k represents the literal vk when vk is currently assigned to true and the literal \u00acvk when vk is currently assigned to false we learn the clause \u00acvcur 0 \u2228\u00acvcur 1 \u2228\u00acvcur 2n\u22122 \u2228\u00acvcur 2n\u22121 that says that at least one of {v0, v1, v2n\u22122, v2n\u22121} must have their value changed. 4. Decrement s by 1 and repeat the previous step, computing NB(s) if the all the bk that appear in its de\ufb01nition have known values. If NA(s) + NB(s) , 0 then learn a clause preventing the values of bk that appear in the de\ufb01nition of NB(s) from being assigned the way that they currently are. Continue to repeat this step until s = 0. 5. If all values of B are assigned but no clauses have been learned in steps 3\u20134 then output the complex Golay pair (A, B). If an exhaustive search is desired, learn a clause preventing the values of B from being assigned the way they currently are; otherwise learn nothing and return control to the SAT solver. 13 \fFor each A in the list LA from stage 1 we run a SAT solver with the above programmatic code. The list of all outputs (A, B) in step 5 shown above now form a complete list of complex Golay pairs of length n up to the equivalence given in Lemma 10. In fact, since Lemma 10 says that we can set b0 = 1 we can assume that both v0 and v1 are always set to false. In other words, we can add the two unit clauses \u00acv0 and \u00acv1 into our SAT instance without omitting any complex Golay pairs up to equivalence. 3.4. Postprocessing: Enumerating all complex Golay pairs At the conclusion of the second stage we have obtained a list of complex Golay pairs of length n such that every complex Golay pair of length n is equivalent to some pair in our list. However, because we have not accounted for all the equivalences in Section 2.2 some pairs in our list may be equivalent to each other. In some sense such pairs should not actually be considered distinct, so to count how many distinct complex Golay pairs exist in length n we would like to \ufb01nd and remove pairs that are equivalent from the list. Additionally, to verify the counts given by Gibson and Jedwab (2011) it is necessary to produce a list that contains all complex Golay pairs. We now describe an algorithm that does both, i.e., it produces a list of all complex Golay pairs as well as a list of all inequivalent complex Golay pairs. In detail, our algorithm performs the following steps: 1. Initialize \u2126all to be the empty set. This variable will be a set that will be populated with and eventually contain all complex Golay pairs of length n. 2. Initialize \u2126inequiv to be the empty set. This variable will be a set that will be populated with and eventually contain all inequivalent complex Golay pairs of length n. 3. For each (A, B) in the set of complex Golay pairs generated in stage 2: (a) If (A, B) is already in \u2126all then skip this (A, B) and proceed to the next pair. (b) Initialize \u0393 to be the set containing (A, B). This variable will be a set that will be populated with and eventually contain all complex Golay pairs equivalent to (A, B). (c) For every \u03b3 in \u0393 add E1(\u03b3), . . . , E5(\u03b3) to \u0393. Continue to do this until every pair in \u0393 has been examined and no new pairs are added to \u0393. (d) Add (A, B) to \u2126inequiv and add all pairs in \u0393 to \u2126all. Additionally, pseudocode for this algorithm is given in Algorithm 3.1. Algorithm 3.1 Pseudocode for our postprocessing algorithm. Note that the sets being iterated through will update during each iteration. 1: \u2126all B \u2205, \u2126inequiv B \u2205 2: for \u03c9 \u2208{ list of generated complex Golay pairs } \\ \u2126all do 3: \u0393 B {\u03c9} 4: for \u03b3 \u2208\u0393 do 5: \u0393 B \u0393 \u222a{E1(\u03b3), . . . , E5(\u03b3)} 6: \u2126inequiv B \u2126inequiv \u222a{\u03c9} 7: \u2126all B \u2126all \u222a\u0393 14 \fAfter running this algorithm listing the members of \u2126all gives a list of all complex Golay pairs of length n and listing the members of \u2126inequiv gives a list of all inequivalent complex Golay pairs of length n. At this point we can also construct the complete list of sequences that appear in any complex Golay pair of length n. To do this it suf\ufb01ces to add A and B to a new set \u2126seqs for each (A, B) \u2208\u2126all. 3.5. Optimizations Although the method described will correctly enumerate all complex Golay pairs of a given length n, for the bene\ufb01t of potential implementors we mention a few optimizations that we found helpful. In the preprocessing step and stage 1 it is necessary to evaluate a polynomial at points on the unit circle and determine its squared absolute value. The fastest way we found to do this used the discrete Fourier transform (DFT). For example, let A\u2032 be the sequence Aeven, Aodd, or A under consideration but padded with trailing zeros so that A\u2032 is of length N. By de\ufb01nition of the discrete Fourier transform we have that the jth entry of DFT(A\u2032) is exactly A\u2032(zj) where z j B exp(2\u03c0ij/N). Thus, we determine the values of |A\u2032(z j)|2 by taking the squared absolute values of the entries of DFT(A\u2032). If |A\u2032(z)|2 > 2n for some z then by Lemma 11 or Corollary 14 we can discard A\u2032 from consideration. To guard against potential inaccuracies introduced by the algorithms used to compute the DFT we actually ensure that |A\u2032(z)|2 > 2n + \u03f5 for some tolerance \u03f5 that is small but larger than the accuracy of the DFT (e.g., \u03f5 = 10\u22123). In stage 1 we solve the quadratic Diophantine equation u2 + v2 + x2 + y2 = 2n in integers u, v, x, y. In fact, we can also add the constraints u + v \u2261n (mod 2) and x + y \u2261n (mod 2) (the second is unnecessary, being implied by the \ufb01rst) because of the following lemma. Lemma 18. Suppose R and I are the resum and imsum of a sequence A \u2208{\u00b11, \u00b1i}n. Then R + I \u2261n (mod 2). Proof. Let #c denote the number of entries in A with value c. Then R + I = (#1 \u2212#\u22121) + (#i \u2212#\u2212i) \u2261#1 + #\u22121 + #i + #\u2212i (mod 2) since \u22121 \u22611 (mod 2). The quantity on the right is n since there are n entries in A. In the \ufb01nal \ufb01ltering step of stage 1 we ensure that Diophantine equations of the form R2 + I2 + x2 + y2 = 2n are solvable in integers (x, y) where R and I are given. This can be ef\ufb01ciently done by precomputing a Boolean two dimensional array D such that D|R|,|I| is true if and only if this equation has a solution, making the check for solvability a fast lookup. At this point we also check if we can \ufb01nd a z on the unit circle with |A(z)|2 > 2n. Because the joining process is the bottleneck of our algorithm it is important to make this \ufb01ltering step as ef\ufb01cient as possible; we did this by computing the values of |A(z)|2 via the expression |A1(z) + A2(z)|2 and precomputing the values of A1(z) and A2(z) for A1 \u2208Lodd and A2 \u2208Leven on points of the form z = exp(2\u03c0ij/32) with j = 0, . . . , 31. We found that it was more ef\ufb01cient to not check the condition for each j in ascending order (i.e., for each z in ascending complex argument) but to \ufb01rst perform the check 15 \fon points z with larger spacing between them. In our implementation we checked the condition for z of the form exp(2\u03c0ij/N) with j odd and N = 8, 16, and 32 in that order. (This ignores checking the condition when z \u2208{\u00b11, \u00b1i} but that is desirable since |A(ik)|2 = resum(ik \u22c6A)2 +imsum(ik \u22c6A)2 and the sums-of-squares condition is a strictly stronger \ufb01ltering method.) The downside of precomputing the values of A1(z) and A2(z) for A1 \u2208Lodd and A2 \u2208Leven is that when the lists Lodd and Leven are large this requires a signi\ufb01cant amount of memory. In our implementation storing the values of A2(z) for all A2 \u2208Leven in the lengths 27 and 28 each required about 8GB of RAM, the searches in lengths 25 and 26 each required about 2GB of RAM, and the searches in lengths 23 and 24 each required about 0.5GB of RAM. However, the amount of precomputation could be increased or decreased depending on the amount of memory available. In stage 1 we make a pass through the lists Lodd and Leven for each valid possibility of the values (u0, u1, u2, u3). However, it is possible to reuse some work between passes. For example, it is only necessary to sort the lists Lodd and Leven once. Even though the values of V2 depend on the values (u0, u1, u2, u3) the relative ordering of Leven is unaffected since all V2 are shifted by the same amount in each pass. It is even possible to do some parts of the passes simultaneously: for example, if the \ufb01rst coordinate of V1 is greater than the \ufb01rst coordinate of V2 for some u0 then V1 is lexicographically greater than V2 in all passes with that value of u0 and so we can iterate to the next L2 in all such passes. At the conclusion of stage 1 we added an additional round of \ufb01ltering to the sequences in LA that was not in our previous work. Since this step was not a bottleneck we used a more involved \ufb01ltering process here; in our implementation we ensured that |A(z)|2 \u22642n for the 210 points of the form z j = exp(2\u03c0ij/210). Additionally, we keep track of the local maxima found by this process and use the quadratic interpolation method described in Section 3.1 to \ufb01nd more accurate approximations to the local maxima of |A(z)|2. In stage 2 one can also include properties that complex Golay sequences must satisfy in the SAT instances. As an example of this, we state the following proposition that was published by Bright et al. (2018b) at ISSAC 2018. Proposition 19. Let (A, B) be a complex Golay pair. Then akan\u2212k\u22121bkbn\u2212k\u22121 = \u00b11 for k = 0, . . . , n \u22121. To prove this, we use the following simple lemma. Lemma 20. Let ck \u2208Z4 for k = 0, . . . , n \u22121. Then n\u22121 X k=0 ick = 0 implies n\u22121 X k=0 ck \u22610 (mod 2). Proof. Let #c denote the number of ck with value c. Note that the sum on the left implies that #0 = #2 and #1 = #3 because the 1s must cancel with the \u22121s and the is must cancel with the \u2212is. Then Pn\u22121 k=0 ck = #1 + 2#2 + 3#3 = 4#1 + 2#2 \u22610 (mod 2). We now prove Proposition 19. 16 \fProof. Let ck, dk \u2208Z4 be such that ak = ick and bk = idk. Using this notation the multiplicative equation from Proposition 19 becomes the additive congruence ck + cn\u2212k\u22121 + dk + dn\u2212k\u22121 \u22610 (mod 2). (2) Since (A, B) is a complex Golay pair, the autocorrelation equations give us n\u2212s\u22121 X k=0 \u0010 ick\u2212ck+s + idk\u2212dk+s\u0011 = 0 for s = 1, . . . , n \u22121. Using Lemma 20 and the fact that \u22121 \u22611 (mod 2) gives n\u2212s\u22121 X k=0 \u0000ck + ck+s + dk + dk+s \u0001 \u22610 (mod 2) for s = 1, . . . , n \u22121. With s = n \u22121 (or s = 1) one immediately derives (2) for k = 0. Adding together these congruences for s = n \u22121 and s = n \u22122 derives (2) for k = 1. The congruences for s = n \u22122 and s = n \u22123 give (2) for k = 2 and proceeding in this manner one derives (2) for all k. In short, Proposition 19 tells us that an even number of ak, an\u2212k\u22121, bk, and bn\u2212k\u22121 are real for each k = 0, . . . , n \u22121. For example, if exactly one of ak and an\u2212k\u22121 is real then exactly one of bk and bn\u2212k\u22121 must also be real. In this case, using our encoding from Section 3.3 we add the two binary clauses v2k \u2228v2(n\u2212k\u22121) and \u00acv2k \u2228\u00acv2(n\u2212k\u22121) to our SAT instance. These clauses say that exactly one of v2k and v2(n\u2212k\u22121) is true. Conversely, if an even number of ak and an\u2212k\u22121 are real then an even number of bk and bn\u2212k\u22121 must also be real. In this case we add the two binary clauses v2k \u2228\u00acv2(n\u2212k\u22121) and \u00acv2k \u2228v2(n\u2212k\u22121) to our SAT instance. 4. Results In order to provide a veri\ufb01cation of the counts given by Fiedler (2013), Gibson and Jedwab (2011), and Craigen, Holzmann, and Kharaghani (2002) we implemented the enumeration method described in Section 3. The preprocessing step was performed by a C program and used the mathematical library FFTW by Frigo and Johnson (2005) for computing the values of f0, . . . , f127 as described in Section 3.5. Stage 1 was performed by a C++ program, used FFTW for computing the values of A1(z) and A2(z), and a MAPLE script by Riel (2006) for determining the solvability of the Diophantine equations given in Section 3.3. Stage 2 was performed by the programmatic SAT solver MAPLESAT by Liang et al. (2017). The postprocessing step was performed by a Python script. 17 \fTotal CPU Time in hours n Preproc. Stage 1 Stage 2 17 0.00 0.00 0.00 18 0.00 0.01 0.01 19 0.00 0.01 0.01 20 0.00 0.08 0.04 21 0.00 0.71 0.13 22 0.00 0.88 0.15 23 0.01 4.67 0.19 24 0.01 7.09 1.24 25 0.03 97.86 1.37 26 0.06 234.43 4.72 27 0.12 3255.56 49.56 28 0.22 2543.34 25.73 Table 1: The time used to run the various stages of our algorithm in lengths 17 \u2264n \u226428. We ran our implementation on a cluster of machines running CentOS 7 and using Intel Xeon E5-2683V4 processors running at 2.1 GHz and using at most 8.5GB of RAM. The lengths up to 22 were run on a single core, the lengths 23 and 24 were run on 10 cores, the lengths 25 and 26 were run on 100 cores, and the lengths 27 and 28 were run on 1000 cores. The work was parallelized across N cores by partitioning the list Lodd into N sublists of approximately equal size. Everything in the stages proceeded exactly as before except that in stage 1 the list Lodd was about N times shorter than it would have been otherwise. In practice, this allowed us to complete the search nearly N times faster; for example, our search in length 28 required about 3.5 months of CPU time but completed in about 3 hours when distributed across 1000 cores. The timings for the preprocessing step and the two stages of our algorithm are given in Table 1; the timings for the postprocessing step were negligible. The times are given as the total amount of CPU time used across all cores. Our code is available online as a part of the MATHCHECK project (see uwaterloo.ca/mathcheck) and the resulting enumeration of complex Golay pairs is available from https://doi.org/10.5281/ zenodo.1246337. The sizes of the lists Leven and Lodd computed in the preprocessing step and the size of the list LA computed in stage 1 are given in Table 2 for all lengths n \u226428. Without applying any \ufb01ltering LA would have size 4n so Table 2 demonstrates the power of the criteria we used to perform \ufb01ltering; for example in length 28 less than 10\u22128% of the possible sequences A were added to LA. A result of Gersho et al. (1979) implies that for z on the unit circle the maximum value of |A(z)|2 is n log n+O(n log log n) for almost all {\u00b11, \u00b1i}-polynomials A of degree n. In particular, the number of polynomials that do not satisfy this is at most 4n/(log n)4, implying that the size of LA will be o(4n) though in practice we even have |LA| \u22642n. The generated SAT instances had 2n variables (encoding the entries b0, . . . , bn\u22121), two unit clauses (encoding b0 = 1), 2\u230an/2\u230bbinary clauses (encoding Proposition 19), 18 \fand n \u22121 programmatic constraints (encoding De\ufb01nition 2). Once the values of bk are known for k = 0, . . . , \u230an/2\u230b, the programmatic constraints uniquely determine the remaining values of bk. Thus 4n/2 is a crude upper bound on the number of possible assignments to the values of b0, . . . , bn\u22121. We now give an upper bound on the complexity of the parts of our algorithm that do not run in polynomial time. The preprocessing and postprocessing costs are dominated by the costs of stage 1 and 2. The cost of stage 1 is at most 4n, an upper bound on the number of generated SAT instances. The cost of stage 2 is dif\ufb01cult to specify rigorously since it may depend on the speci\ufb01c SAT solver that is used. However, there are at most 4n/2 possible assignments for each instance, so using a solver that checks each assignment once gives an overall cost of 43n/2. The running time is better in practice, though seemingly still exponential. Finally, we provide counts of the total number of complex Golay pairs of length n \u226428 in Table 3. The sizes of \u2126seqs match those given by Fiedler (2013) in all cases, the sizes of \u2126all match those given by Gibson and Jedwab (2011) for all n \u226426 (the largest length they included) and the sizes of \u2126inequiv match those given by Craigen et al. (2002) for all n \u226419 (the largest length they exhaustively solved). Because Fiedler (2013), Gibson and Jedwab (2011), and Craigen et al. (2002) do not provide implementations or timings for the enumerations they completed it is not possible for us to compare the ef\ufb01ciency of our algorithm to previous algorithms. However, in Table 4 we compare our implementation\u2019s timings to the timings we previously presented (Bright et al., 2018b). Table 4 shows that the improved version of our algorithm performs about an order of magnitude faster in general. 5. Future Work Besides increasing the length to which complex Golay pairs have been enumerated there are a number of avenues for improvements that could be made in future work. As one example, we remark that we have not exploited the algebraic structure of complex Golay pairs revealed by Craigen, Holzmann, and Kharaghani (2002). In particular, their work contains a theorem implying that if p \u22613 (mod 4) is a prime dividing n and A is a member of a complex Golay pair of length n then A(z) is not irreducible over Fp(i). Ensuring that this property holds could be added to the \ufb01ltering conditions used in stage 1. In fact, the authors relate the factorization of A(z) over Fp(i) to the factorization of B(z) over Fp(i) for any complex Golay pair (A, B). This factorization could potentially be used to perform stage 2 more ef\ufb01ciently, possibly supplementing or replacing the SAT solver entirely, though it is unclear if such a method would perform better than our method in practice. In any case, it would not be possible to apply their theorem in all lengths since the length n might only be divisible by primes p = 2 or p \u22611 (mod 4). A second possible improvement could be to use the symbolic form of f(\u03b8) de\ufb01ned in Section 3.1 to help \ufb01nd the maximum of f(\u03b8). For example, a consequence of Lemma 6 and Euler\u2019s identity is that f(\u03b8) = NA\u2032(0) + 2 n\u22121 X s=1 Re(NA\u2032(s)) cos(s\u03b8) + 2 n\u22121 X s=1 Im(NA\u2032(s)) sin(s\u03b8) 19 \fn |Leven| |Lodd| |LA| 1 1 \u2212 1 2 3 1 3 3 3 1 1 4 3 4 3 5 12 4 5 6 12 16 14 7 39 16 12 8 48 64 36 9 153 64 44 10 153 204 118 11 561 252 99 12 645 860 445 13 2121 884 279 14 2463 3284 294 15 8340 3572 1650 16 9087 12116 829 17 31275 12824 3233 18 34560 46080 11159 19 117597 50944 10918 20 130215 173620 26876 21 446052 194004 81941 22 500478 667304 90163 23 1694871 732232 118747 24 1886562 2515416 200138 25 6447250 2727452 709584 26 7183879 9578506 737891 27 24426370 10591928 7618474 28 27265578 36354113 3687209 Table 2: The number of sequences Aeven, Aodd, and A that passed the \ufb01ltering conditions of our algorithm in lengths up to 28. 20 \fn |\u2126seqs| |\u2126all| |\u2126inequiv| 1 4 16 1 2 16 64 1 3 16 128 1 4 64 512 2 5 64 512 1 6 256 2048 3 7 0 0 0 8 768 6656 17 9 0 0 0 10 1536 12288 20 11 64 512 1 12 4608 36864 52 13 64 512 1 14 0 0 0 15 0 0 0 16 13312 106496 204 17 0 0 0 18 3072 24576 24 19 0 0 0 20 26880 215040 340 21 0 0 0 22 1024 8192 12 23 0 0 0 24 98304 786432 1056 25 0 0 0 26 1280 10240 16 27 0 0 0 28 0 0 0 Table 3: The number complex Golay pairs in lengths up to 28. The table counts the number of individual sequences, the number of pairs, and the number of pairs up to equivalence. 21 \fTotal CPU Time in hours n ISSAC\u201918 This paper 17 0.07 0.00 18 0.27 0.02 19 0.26 0.02 20 0.80 0.12 21 3.86 0.84 22 10.77 1.03 23 45.18 4.87 24 86.97 8.34 25 702.39 99.26 26 \u2212 239.21 27 \u2212 3305.24 28 \u2212 2569.29 Table 4: A comparison between the method presented at ISSAC 2018 (Bright et al., 2018b) and the method used in this paper. The times measure the total amount of computation time that was used to run a complete search in the lengths 17 \u2264n \u226428 when run on the same hardware. showing that f has a simple form as a sum of sines and cosines. Finding the real roots of the derivative of f would reveal the locations of the local maxima and minima of f. However, again it is unclear if this method would perform better than our approximation method in practice. Note that our method is not guaranteed to \ufb01nd the global maximum of f since we only apply the quadratic interpolation optimization method to ranges that we know contain a local maximum by examining the initial sampling of f. With a more careful branch-and-bound algorithm it would be possible to guarantee that the global maximum was found but the approximations that we found were effective enough that we did not pursue this. Another possible improvement could be obtained by deriving further properties like Proposition 19 that complex Golay pairs must satisfy. For example, consider the following property that could be viewed as a strengthening of Proposition 19: akan\u2212k\u22121 = (\u22121)n+1bkbn\u2212k\u22121 for k = 1, . . . , n \u22122. An examination of all complex Golay pairs up to length 28 reveals that they all satisfy this property except for a single complex Golay pair up to equivalence. The only pairs that don\u2019t satisfy this property are equivalent to \u0000[1, 1, 1, \u22121, 1, 1, \u22121, 1], [1, i, i, \u22121, 1, \u2212i, \u2212i, \u22121]\u0001 and were already singled out by Fiedler, Jedwab, and Parker (2008b) for being the only known examples of what they call \u201ccross-over\u201d Golay sequence pairs. Since a counterexample exists to this property there is no hope of proving it in general, but perhaps a suitable generalization could be proven. Lastly, the running time analysis of our algorithm could be improved. We have given a crude upper bound of 43n/2 = 8n for the complexity of the parts of our algorithm 22 \fthat do not run in polynomial time. However, this running time would be improved by tighter bounds on either the size of LA or the number of possible assignments that the SAT solver will try. Acknowledgements This work was made possible by the facilities of the Shared Hierarchical Academic Research Computing Network (SHARCNET) and Compute/Calcul Canada. The authors would also like to thank the anonymous reviewers for their comments on this paper and on our ISSAC 2018 submission. Their careful reviews improved our work\u2019s clarity and presentation."
+                },
+                {
+                    "url": "http://arxiv.org/abs/1907.04408v2",
+                    "title": "SAT Solvers and Computer Algebra Systems: A Powerful Combination for Mathematics",
+                    "abstract": "Over the last few decades, many distinct lines of research aimed at\nautomating mathematics have been developed, including computer algebra systems\n(CASs) for mathematical modelling, automated theorem provers for first-order\nlogic, SAT/SMT solvers aimed at program verification, and higher-order proof\nassistants for checking mathematical proofs. More recently, some of these lines\nof research have started to converge in complementary ways. One success story\nis the combination of SAT solvers and CASs (SAT+CAS) aimed at resolving\nmathematical conjectures.\n  Many conjectures in pure and applied mathematics are not amenable to\ntraditional proof methods. Instead, they are best addressed via computational\nmethods that involve very large combinatorial search spaces. SAT solvers are\npowerful methods to search through such large combinatorial\nspaces---consequently, many problems from a variety of mathematical domains\nhave been reduced to SAT in an attempt to resolve them. However, solvers\ntraditionally lack deep repositories of mathematical domain knowledge that can\nbe crucial to pruning such large search spaces. By contrast, CASs are deep\nrepositories of mathematical knowledge but lack efficient general search\ncapabilities. By combining the search power of SAT with the deep mathematical\nknowledge in CASs we can solve many problems in mathematics that no other known\nmethods seem capable of solving.\n  We demonstrate the success of the SAT+CAS paradigm by highlighting many\nconjectures that have been disproven, verified, or partially verified using our\ntool MathCheck. These successes indicate that the paradigm is positioned to\nbecome a standard method for solving problems requiring both a significant\namount of search and deep mathematical reasoning. For example, the SAT+CAS\nparadigm has recently been used by Heule, Kauers, and Seidl to find many new\nalgorithms for $3\\times3$ matrix multiplication.",
+                    "authors": "Curtis Bright, Ilias Kotsireas, Vijay Ganesh",
+                    "published": "2019-07-09",
+                    "updated": "2019-09-16",
+                    "primary_cat": "cs.LO",
+                    "cats": [
+                        "cs.LO",
+                        "cs.AI",
+                        "cs.SC",
+                        "math.CO"
+                    ],
+                    "main_content": "INTRODUCTION Te development of computer science has transformed the practice of mathematics. Te practical algorithms designed by computer scientists have profoundly changed how many mathematical conjectures are proposed, studied, and resolved. For example, the felds of satisfability checking and symbolic computation have each been paradigm-shifing in this way. Tey have allowed mathematicians the ability to solve problems much larger than ever dreamt of in the past, the ability to pose and solve entirely new kinds of mathematical conjectures, and the ability to verify their solutions to unprecedented levels. Despite a common background and over a hundred years of combined successful progress, these two felds have developed mostly independently of each other and have litle common overlap [1]. It is in the interest of the working mathematician or computer scientist to have familiarity with the techniques of these felds, as they have broad (and ofen surprising) applicability. Tis article provides an overview of these felds with an emphasis on how the techniques of each feld have been applied to resolve mathematical conjectures\u2014and how combining the techniques of each feld has resolved conjectures and solved problems that were out of reach of both felds. Satisfability checking. Te Boolean satisfability (SAT) problem asks if it is possible assign the variables in a Boolean logic expression in such a way that the expression becomes true. In the 1970s, the Cook\u2013Levin theorem demonstrated that the SAT problem is NP-complete resulting in a pessimism that SAT problems are infeasible to solve in practice. Despite this, research in the engineering of SAT solvers has discovered algorithms and heuristics capable of solving enormous SAT instances that cannot currently be solved by any other method. Tis \u201cSAT revolution\u201d has had dramatic consequences for hardware and sofware designers who now use SAT solvers on a daily basis [40]. In fact, SAT solvers have become so successful that Heule, Kullmann, and Marek [28] call them the \u201cbest solution in most cases\u201d for performing large combinatorial searches. Recently SAT solvers have been spectacularly applied to a number of long-standing mathematical problems including the Erd\u02dd os discrepancy conjecture (open for 80 years) [29], the Boolean Pythagorean triples conjecture (open for 30 years) [28], and the determination of the ffh Schur number (open for 100 years) [26]. We briefy outline how SAT solvers were successful on these problems in Section 2.1. Despite these successes, SAT solvers are known to not perform well for all kinds of combinatorial searches such as those that require advanced mathematics. For example, Arunachalam and Kotsireas [2] have shown that searching for mathematical objects arXiv:1907.04408v2  [cs.LO]  16 Sep 2019 \fCASCON\u201919, November 4\u20136, 2019, Toronto, Ontario, Canada Curtis Bright, Ilias Kotsireas, and Vijay Ganesh defned by autocorrelation relationships are hard for current SAT solvers. Similarly, Van Gelder and Spence [39] have shown that proving the nonexistence of certain combinatorial designs (even some that have intuitively very easy nonexistence proofs) produce small but very difcult instances for SAT solvers. Symbolic computation. Symbolic computation or computer algebra is the branch of computer science concerned with manipulating algebraic expressions and other mathematical objects. It has been studied for over sixty years and its successes has lead to the development of computer algebra systems (CASs) that can now automatically solve many theoretical and practical mathematical problems of interest. For example, a modern computer algebra system has functionality for things such as Gr\u00a8 obner bases, cylindrical algebraic decomposition, latice basis reduction, linear system solving, arbitrary and high precision arithmetic, interval arithmetic, linear and nonlinear optimization, Fourier transforms, Diophantine solving, computing automorphism groups, graph algorithms like determining if a graph has a Hamiltonian cycle, and many other basic operations like computing the derivative of a function. Computer algebra is widely used in engineering and science. For example, the 1999 Nobel prize in physics was awarded to Gerardus \u2019t Hoof and Martinus J. G. Veltman for using computer algebra to place particle physics on \u201ca frmer mathematical foundation\u201d. Computer algebra has also been used to resolve a number of long-standing mathematical conjectures. Tree well-known examples of this are the alternating sign matrix conjecture (open for 15 years) [43], the Mertens conjecture (open for 100 years) [34], and the Kepler conjecture (open for nearly 400 years) [25]. We briefy discuss how computer algebra was used to solve them in Section 2.2. Despite these successes, computer algebra systems are not optimized for all types of problems. In particular, they are typically not optimized to perform the kind of general-purpose search with learning that SAT solvers excel at. In other words, problems that require searching through a large combinatorial space will probably not be solved most efectively by a computer algebra system. Te best of both worlds. In this paper we overview the new \u201cSAT+CAS\u201d paradigm that harnesses the search power of SAT solvers and the mathematical abilities of CASs. Tis approach provides the best aspects of both the SAT and CAS approaches while minimizing the weaknesses of each respective tool. For example, one of the primary drawbacks of SAT solvers is that they lack mathematical expressiveness\u2014many mathematical concepts are difcult or even impossible to efciently encode in Boolean logic. On the other hand, a huge variety of mathematical concepts can easily be expressed in a CAS. Tus, the SAT+CAS paradigm combines the search power of a SAT solver with the expressive power of a CAS. Recently the SAT+CAS paradigm has been used to make progress on a number of conjectures from combinatorics, graph theory, and number theory. In particular, it has verifed a conjecture of Craigen, Holzmann, and Kharaghani, found three new counterexamples to the good matrix conjecture, verifed the smallest counterexample of the Williamson conjecture, and is responsible for the current best known results in the even Williamson, Ruskey\u2013Savage, Norine, and best matrix conjectures. We give an overview of these conjectures and how our SAT+CAS system MathCheck (available at uwaterloo. SAT encoding that Williamson matrices of order n exist Split into subproblems CAS SAT solver CAS Williamson matrices or counterexample SAT instances inequivalent instances partial satisfying assignment confict clause Figure 1: A diagram outlining how the SAT+CAS paradigm is applied to the Williamson conjecture. ca/mathcheck) was used to produce these results in Section 3. A high-level diagram of how MathCheck combines SAT solvers with CASs is shown in Figure 1. We also briefy discuss how Heule, Kauers, and Seidl have recently used the SAT+CAS paradigm to fnd numerous new ways of multiplying 3 \u00d7 3 matrices [27]. Finally, we summarize the kinds of problems for which individually the SAT and CAS paradigms are insufcient but for which the SAT+CAS paradigm has been successful in Section 4. 2 PRIOR WORK In this section we overview the felds of satisfability checking, symbolic computation, and the kinds of conjectures resolved using the tools of these felds. As we will see, these felds have been applied to resolve an impressive variety of conjectures. Satisfability checking is particularly good at solving conjectures that can be expressed only using simple constraints but require an enormous search, while symbolic computation is particularly good at solving conjectures that require a lot of complicated mathematical calculations but not a lot of search. 2.1 SAT solving Te techniques developed by the feld of satisfability checking has recently allowed SAT solvers to resolve mathematical conjectures requiring enormous searches. In this section we discuss three of these conjectures. Erd\u02dd os discrepancy conjecture. In the 1930s, the prolifc mathematician Paul Erd\u02dd os conjectured that for any infnite {\u00b11}-sequence X = (x1,x2, . . . ) the quantity DX (n,k) B \f \f\u00cdn i=1 xki \f \f can be made arbitrarily large by choosing appropriate n and k. In 2010, the Polymath project studied the conjecture and discovered many sequences X of length 1124 with DX (n,k) at most 2 for all choices of n and k for which this quantity is defned. Te sequences were found using a custom computer program and despite expending a lot of computing efort no longer sequences with this property were found. Fields medalist Timothy Gowers would later say \u201cTat \fSAT+CAS: A Powerful Combination for Mathematics CASCON\u201919, November 4\u20136, 2019, Toronto, Ontario, Canada was enough to convince me that 1124 was the correct bound [for the length of sequences X with DX (n,k) at most 2].\u201d In 2014, Konev and Lisitsa [29] showed that 1124 was not the correct bound by using a SAT solver to fnd a sequence of length 1160 with DX (n,k) at most 2 for all n and k. Furthermore, they showed that such a sequence of length 1161 could not exist, thereby resolving the smallest open case of the Erd\u02dd os discrepancy conjecture. Te full conjecture was resolved the next year by Terence Tao [38], building on results of the Polymath project. Boolean Pythagorean triples conjecture. In the 1980s, mathematician Ronald Graham ofered a $100 prize for an answer to the Boolean Pythagorean triples problem: Is it possible to split the natural numbers {1, 2, . . . } into two parts so that all triples (a,b,c) with a2 + b2 = c2 are separated? In 2008, Cooper and Poirel [10] found a partition of the natural numbers up to 1344 into two parts with no Pythagorean triple in the same part\u2014this required a custom computer program and hundreds of hours of computing time. In 2016, Heule, Kullmann, and Marek [28] used a SAT solver to fnd a partition of the natural numbers up to 7824 into two parts that separated all Pythagorean triples. Furthermore, they showed that it was not possible to improve this bound\u2014there is no 2-partition of the natural numbers up to 7825 that separates all Pythagorean triples. Te proof found by the SAT solver was over 200 terabytes and was verifed in about 4 CPU years. Ronald Graham accepted this as a resolution of the Boolean Pythagorean triples conjecture and awarded his $100 prize. Schur number fve. In the 1910s, Issai Schur [36] proved that for any k \u22651 there exists a largest set {1, . . . ,m} that can be partitioned into k parts such that all triples (a,b,c) with a + b = c are separated. Te value of m in the above is known as the Schur number S(k). It is possible to check that S(1) = 1, S(2) = 4, S(3) = 13 by hand, and Baumert and Golomb [23] showed that S(4) = 44 by a computer search in 1965. Furthermore, Exoo [16] showed that S(5) \u2265160 in 1994 using a combinatorial optimization algorithm. In 2017, Heule [26] used a SAT solver to show that any partition of {1, . . . , 161} into 5 parts will not separate all triples (a,b,c) with a +b = c and therefore showed that S(5) = 160. Te proof produced by the SAT solver was two petabytes in size and was verifed by a formally-verifed proof checker using about 36 CPU years. 2.2 Computer algebra Te techniques developed in the feld of computer algebra have been applied to a huge number of engineering, scientifc, and mathematical problems. In this section we discuss three conjectures where techniques from computer algebra were essential in the resolution of the conjecture. Mertens conjecture. In 1885, Tomas Stieltjes conjectured (and later independently by F. Mertens) what is now known as the Mertens conjecture. Te Mertens function is defned by M(x) B \u00cd n\u2264x \u00b5(n) where \u00b5(n) B (\u22121)k if the prime factorization of n consists of k distinct prime factors and \u00b5(n) B 0 if a prime factor appears more than once in the prime factorization of n. Te Mertens conjecture is that |M(x)| < \u221ax for all x > 1. In the 1970s, the Mertens conjecture was shown to hold for all x \u22647.8 \u00b7 109. In 1985, Odlyzko and te Riele [34] showed that the Mertens conjecture was false. Teir method used latice basis reduction and arbitrary-precision arithmetic from the Brent MP package. Te smallest counterexample is still unknown but it is known to be larger than 1014 and smaller than exp(1.59 \u00b7 1040). Alternating sign matrix conjecture. In the 1980s, Mills, Robbins, and Rumsey [33] studied alternating sign matrices\u2014square {0, \u00b11}-matrices whose rows and columns sum to 1 and whose nonzero entries alternate sign in each row and column. Tey noticed that the number of alternating sign matrices of order n \u226410 was \u00cen k=0(3k + 1)!/(n + k)! and conjectured that this relationship held for all n. Te conjecture was proven by Doron Zeilberger [43] in the 1990s, crucially relying on the combinatorial functions of the computer algebra system Maple. In fact, a Maple package was distributed with the paper that empirically (and in some cases rigorously) verifed every nontrivial fact in the paper. Kepler conjecture. In 1661, the astronomer and mathematician Johannes Kepler conjectured that the most efcient way of packing spheres in three dimensions is to stack them in a pyramid shape. It was still unsolved in 1900 and David Hilbert included it in his famous list of unsolved problems. In 1998, the mathematician Tomas Hales and his student Samuel Ferguson [25] proved the Kepler conjecture using a variety of tools such as global optimization, linear programming, and interval arithmetic. Many of the computations in the proof were performed using Mathematica\u2019s arbitrary-precision arithmetic and double-checked using Maple. Because of the complexity of the calculations a team of at least thirteen referees could not be certain of the proof\u2019s correctness afer four years. Tis lead Hales to start a project to complete a formal verifcation of the proof; it completed in 2014 afer a decade of work [24]. 3 SAT+CAS PARADIGM As we saw in Section 2, the satisfability checking and symbolic computation approaches have been applied to resolve a variety of mathematical conjectures\u2014but each approach has its own advantages and disadvantages. On the one hand, satisfability checking is good at solving problems with enormous search spaces and simple constraints. On the other hand, symbolic computation is good at solving problems with sophisticated mathematical calculations. When a search space becomes too large the overhead associated with a computer algebra system becomes more pronounced, necessitating the usage of a more efcient solver. Currently, SAT solvers are probably the best tools currently available for general purpose search; they are very difcult to beat because of the decades of engineering efort that has been aimed at making them efcient. Given this, Zulkoski, Ganesh, and Czarnecki in 2015 proposed [45] (and independently by \u00b4 Abrah\u00b4 am [1]) the SAT+CAS paradigm of combining SAT solvers and CASs to solve conjectures that require both efcient search and advanced mathematics. In this section we overview and explain the major successes of the SAT+CAS paradigm over the last four years. \fCASCON\u201919, November 4\u20136, 2019, Toronto, Ontario, Canada Curtis Bright, Ilias Kotsireas, and Vijay Ganesh 3.1 Williamson conjecture In 1944, the mathematician J. Williamson studied the Hadamard conjecture from combinatorial design theory. Tis conjecture says that square {\u00b11}-matrices with with pairwise orthogonal rows exist in all orders 4n. He defned a new class of matrices now known as Williamson matrices that he used to construct Hadamard matrices of order 4n for certain small values of n. Symmetric {\u00b11}-matrices A, B, C, D form a set of Williamson matrices (each individual matrix itself being Williamson) if they are circulant (each row is a cyclic shif of the previous row) and if A2 + B2 + C2 + D2 is the scalar matrix 4nI. It was once considered likely that Williamson matrices exist for all n and therefore Williamson matrices could provide a route to proving the Hadamard conjecture [22]. Te conjecture that Williamson matrices exist in all orders n has since become known as the Williamson conjecture. Te hopes that Williamson matrices exist in all orders were dashed in 1993, when D. \u02c7 Z. \u00af Dokovi\u00b4 c [14] showed that Williamson matrices of order 35 do not exist by an exhaustive computer search. \u00af Dokovi\u00b4 c noted that this was the smallest odd counterexample of the Williamson conjecture but did not specify if it was truly the smallest counterexample. In 2006, Kotsireas and Koukouvinos [30] found no counterexamples in the even orders n \u226422 using the CodeGeneration package of the computer algebra system Maple. In 2016, using an of-the-shelf SAT solver, Bright et al. [5] found no counterexamples in the even orders n \u226430. Despite these successes, both the SAT-only and CAS-only approaches failed to fnd the smallest counterexample of the Williamson conjecture. Not only did the SAT+CAS approach successfully fnd the smallest counterexample, it blew the other approaches out of the water by exhaustively solving all even orders up to seventy [6, 7]. Te search space up to order 70 is an astronomical twenty-fve orders of magnitude larger than the search space up to order 30 because the search space for Williamson matrices grows exponentially in n. Williamson matrices were found to exist in all even orders n \u226470, leading to the even Williamson conjecture that Williamson matrices exist in all even orders. Te SAT+CAS approach is able to search such large spaces by exploiting mathematical properties of Williamson matrices that dramatically shrink the search space. In particular, the most important known fltering property is the power spectral density (PSD) criterion that says that if A is a Williamson matrix of order n with frst row [a0, . . . ,an\u22121] then PSDA(k) B \f \f \f n\u22121 \u00d5 j=0 aje2\u03c0ijk/n\f \f \f 2 \u22644n for all integers k. Tis is an extremely strong fltering condition; a random circulant and symmetric {\u00b11}-matrix A will almost certainty fail it. Tus, a solver that is able to efectively exploit the PSD criterion will easily outperform a solver that does not know about this property. However, to efectively use it we need (1) an efcient method of computing the PSD values; and (2) an efcient method of searching while avoiding matrices that fail the fltering criteria. Te fundamental reason for the success of the SAT+CAS paradigm in regard to the Williamson and even Williamson conjectures is that CASs excel at (1) and SAT solvers excel at (2). Te manner in which the SAT and CAS are combined is demonstrated in Figure 1. As the SAT solver completes its search it sends to a CAS the matrices A, B, C, D from partial solutions of the SAT instance. Te CAS then ensures that the matrices pass the PSD criterion. If a matrix fails the PSD criterion then a confict clause is generated encoding that fact. Te SAT solver adds the confict clause into its learned clause database, thereby blocking the matrix from being considered in the future. Te search was also parallelized by spliting the search space into many independent subspaces. Each subspace had a separate SAT instance generated for it and the SAT instances were solved in parallel. Te CAS was also useful in the spliting phase by removing instances that were found to be equivalent to other instances under the known equivalence operations of Williamson matrices. In the end, our SAT+CAS system MathCheck found over 100,000 new sets of Williamson matrices among all even orders n \u226470, a new set of Williamson matrices in the odd order 63, and verifed that n = 35 is the smallest counterexample of the Williamson conjecture. 3.2 Good and best matrix conjectures Many variants of Williamson matrices exist; two variants are known as good matrices (introduced by J. Seberry Wallis [41]) and best matrices (introduced by Georgiou, Koukouvinos, and Seberry [20]). Tere are several slightly diferent defnitions for such matrices, but for our purposes we defne them to be circulant matrices A, B, C, D \u2208{\u00b11}n\u00d7n that satisfy AAT +BBT +CCT +DDT = 4nI where A is skew (A+AT = 2I) and D is symmetric (D = DT ). Additionally, B and C are skew (for best matrices) or symmetric (for good matrices). It is known that if good matrices exist of order n exist then n must be of the form 2r + 1 (i.e., odd) and if best matrices of order n exist then n must be of the form r2 +r +1. Te good and best matrix conjectures state that good and best matrices exist in all orders of these forms. In 2002, the good matrix conjecture was shown to hold for all n \u226439 [21] and in 2001 the best matrix conjecture was shown to hold for all n \u226431 [20]. In 2018, the best matrix conjecture was shown to hold for all n \u226443 and the counterexamples n = 41, 47, and 49 were found to the good matrix conjecture [15]. MathCheck has also been applied to the good and best matrix conjectures [3, 4] using a similar method as described in Section 3.1 with some encoding adjustments that are specifc to good or best matrices. For example, if [d0, . . . ,dn\u22121] is the frst row of a symmetric best matrix then it is known that dn/3 = d0 when n is a multiple of 3. MathCheck found two new sets of good matrices (for n = 27 and 57) and three new counterexamples of the good matrix conjecture (n = 51, 63, and 69). MathCheck also found three new sets of best matrices in order 57 and showed that the best matrix conjecture holds for all n \u226457 (the best currently known result). 3.3 Craigen\u2013Holzmann\u2013Kharaghani conjecture In 2002, Craigen, Holzmann, and Kharaghani [11] studied complex Golay pairs which are polynomials f , \u0434 with {\u00b11, \u00b1i} coefcients such that |f (z)|2 + |\u0434(z)|2 is constant on the unit circle. Tis implies that f and \u0434 have the same number of terms and this quantity is known as the length of the polynomial. Craigen, Holzmann, and Kharaghani performed an exhaustive search for all complex \fSAT+CAS: A Powerful Combination for Mathematics CASCON\u201919, November 4\u20136, 2019, Toronto, Ontario, Canada Golay pairs up to length 19 and a partial search up to length 23. Tey found no complex Golay pairs of length 23 and conjectured that they did not exist. An exhaustive search was performed by F. Fiedler in 2013 [18] that did not fnd any complex Golay pairs of length 23, though no implementation was provided making it difcult to verify his search. MathCheck can be used to independently verify the results of Fiedler\u2019s searches [8, 9]. Te frst step is to fnd all single polynomials f that could appear as a member of a complex Golay pair. A number of known properties of complex Golay pairs are used to cut down the search space, the most important one being that |f (z)|2 \u22642n where n is the length of f and z is on the unit circle. Given a potential f we solve the nonlinear optimization problem of maximizing |f (z)|2 subject to |z| = 1 (see Maple\u2019s command NLPSolve) and discard the f whose maximum is greater than 2n. Secondly, we use the known fact that if (f ,\u0434) is a complex Golay pair then N\u0434(s) = \u2212Nf (s) for s = 1, . . . , n \u22121 where N\u0434 is the nonperiodic autocorrelation function of \u0434. Once f is known and enough of \u0434 is known so that N\u0434(s) , \u2212Nf (s) can be determined then a confict clause is learned blocking the partial solution from ever being tried again. Tis fltering theorem is very powerful because it ofen works when only a few coefcients of \u0434 are known. For example, the SAT solver is able to learn to never assign both the frst and last entries of \u0434 to be 1 at the same time. 3.4 Ruskey\u2013Savage conjecture In 1993, Ruskey and Savage [35] asked if every matching (a set of edges without common vertices) of the hypercube graph with 2n vertices can be extended into a Hamiltonian cycle of the graph. In 2007, Fink [19] noted that this property holds in the hypercube graphs for n = 2, 3, and 4 and he proved a weaker form of the conjecture that he atributes to Kreweras [31]. In 2015, MathCheck was used to show for the frst time that the Ruskey\u2013Savage conjecture held for the hypercube graph with 25 = 32 vertices [45]. Tis was accomplished by using a SAT solver to exhaustively enumerate the matchings of the hypercube graph and then verifying with a CAS that each matching extends to a Hamiltonian cycle. Certain kinds of matchings could be ignored; for example, the SAT solver only enumerates maximal matchings (those which cannot be increased in size while remaining matchings) because if a maximal matching extends to a Hamiltonian cycle then so do all subsets of the matching. Once the CAS verifes that a given matching extends to a Hamiltonian cycle, a confict clause is learned that blocks that Hamiltonian cycle (and all subsets of it) from being considered in the search again. Furthermore, it is also efective to have the CAS apply automorphisms of the hypercube graph to the Hamiltonian cycle it fnds to generate additional Hamiltonian cycles to be blocked [44]. 3.5 Norine conjecture Consider a 2-colouring of the edges of a hypercube graph such that edges directly opposite each other have opposite colours. Serguei Norine conjectured that in such a colouring it is always possible to fnd two directly opposite vertices that are joined by a path of edges of a single colour [13]. In 2013, Feder and Subi reported that the conjecture had been verifed for hypercube graphs with n = 2, 3, 4, and 5, and proved the conjecture for a special class of edge colourings [17]. In 2015, MathCheck was used to show for the frst time that the Norine conjecture held for the hypercube graph with 26 = 64 vertices [45]. Tis was accomplished by using a SAT solver to exhaustively enumerate the edge colourings for which the conjecture was not already known to hold. Once an edge colouring was found by the SAT solver it was passed to a CAS to verify that the colouring contains at least two directly opposite vertices that are connected by a path of a single colour. If such vertices do not exist then this colouring forms a counterexample to the conjecture; otherwise, a confict clause is generated that blocks this colouring from appearing in the search again. In fact, any colouring that includes the monochromatic path that was found by the CAS can be blocked, since all such colourings cannot be counterexamples to the Norine conjecture. Similar to in our work on the Ruskey\u2013Savage conjecture, it is also efective to have the CAS apply automorphisms of the hypercube graph to the path that it fnds to generate additional colourings to be blocked [44]. 3.6 3 by 3 matrix multiplication Te classical way of multiplying two 2\u00d72 matrices uses eight scalar multiplications; in 1969, Strassen discovered a way to do it using just seven scalar multiplications [37]. Two years later, Winograd showed that it is not possible to do it with six multiplications [42] and de Groot [12] showed there is essentially one optimal algorithm. Te optimal algorithm for multiplying 3 \u00d7 3 matrices is still unknown and the best known algorithm uses 23 multiplications [32]. Previously, four inequivalent algorithms were known with this complexity. Recently, Heule, Kauers, and Seidl [27] found over 13,000 additional inequivalent algorithms that use 23 multiplications. Tis was achieved using the SAT+CAS paradigm in a multistage process. In the frst stage, they reduce the problem of fnding a matrix multiplication algorithm using 23 scalar multiplications to solving 36 = 729 cubic equations in 23 \u00b7 33 = 621 variables. A SAT instance is generated from these equations by reducing them modulo 2. A solution of the SAT instance then provides a way to multiply 3 \u00d7 3 matrices over the fnite feld F2 = {0, 1}. By using various simplifcations they found over 270,000 solutions of the SAT instance. Tey then used the computer algebra system Mathematica to determine that over 13,000 of those solutions are inequivalent. Finally, they use a Gr\u00a8 obner basis calculation in the computer algebra system Singular to lif the solutions found for the feld F2 to an arbitrary ring. Tey report that a small number of solutions over F2 cannot be lifed in such a way but in most cases each solution provides a new 3 \u00d7 3 matrix multiplication algorithm that works in any ring. None of the algorithms they found could be simplifed to use only 22 multiplications making it tempting to conjecture that such an algorithm does not exist. 4"
+                },
+                {
+                    "url": "http://arxiv.org/abs/1811.05094v1",
+                    "title": "A SAT+CAS Approach to Finding Good Matrices: New Examples and Counterexamples",
+                    "abstract": "We enumerate all circulant good matrices with odd orders divisible by 3 up to\norder 70. As a consequence of this we find a previously overlooked set of good\nmatrices of order 27 and a new set of good matrices of order 57. We also find\nthat circulant good matrices do not exist in the orders 51, 63, and 69, thereby\nfinding three new counterexamples to the conjecture that such matrices exist in\nall odd orders. Additionally, we prove a new relationship between the entries\nof good matrices and exploit this relationship in our enumeration algorithm.\nOur method applies the SAT+CAS paradigm of combining computer algebra\nfunctionality with modern SAT solvers to efficiently search large spaces which\nare specified by both algebraic and logical constraints.",
+                    "authors": "Curtis Bright, Dragomir Z. Djokovic, Ilias Kotsireas, Vijay Ganesh",
+                    "published": "2018-11-13",
+                    "updated": "2018-11-13",
+                    "primary_cat": "cs.LO",
+                    "cats": [
+                        "cs.LO",
+                        "cs.SC",
+                        "math.CO"
+                    ],
+                    "main_content": "Introduction In 2002, circulant \u201cgood\u201d matrices were searched for in all odd orders n with n < 40 (Georgiou, Koukouvinos, and Stylianou 2002) and were found to exist in all such orders. This gave evidence to the conjecture that such matrices actually exist in all odd orders. The mathematician George Szekeres studied circulant good matrices in terms of an equivalent type of object which he termed E-sequences and in his classic paper (Szekeres 1988) he mentioned this hypothesis as being worthwhile to study using computers: ...it is conceivable that E-sequences exist for all n = 2m + 1, m \u22651 and it is worth testing this hypothesis at least for those orders which are accessible to present day computers... Unfortunately, this conjecture was recently shown to be false in (\u00d0okovi\u00b4 c and Kotsireas 2018) where it was shown that the orders n = 41, 47, and 49 are counterexamples, i.e., no circulant good matrices of orders 41, 47, and 49 exist. In this paper we \ufb01nd the additional three larger counterexamples n = 51, 63, and 69. In addition, we verify the claim of \u00d0okovi\u00b4 c and Kotsireas that there are exactly four inequivalent sets of circulant good matrices of order 45 and determine that there is a single set of inequivalent circulant good matrices of order 57. We also \ufb01nd a previously undiscovered set of good matrices of order 27 demonstrating that Szekeres\u2019 claimed exhaustive search (Szekeres 1988) was incomplete. The matrices that are now known as good matrices were \ufb01rst used in the PhD thesis of Jennifer Seberry Wallis (Wallis 1970); we give their formal de\ufb01nition in Section 2. She gave a construction using good matrices that enabled the construction of Hadamard matrices\u2014square matrices with \u00b11 entries and whose rows are pairwise orthogonal. In her thesis she gave examples of good matrices in all odd orders up to 15 as well as order 19 and shortly later gave an example in order 23 (Wallis 1971). Subsequently, (Hunt 1972) ran a complete search in the odd orders up to 21 and gave examples in order 25, (Szekeres 1988) ran a complete search up to order 31, (\u00d0okovi\u00b4 c 1993) gave examples in orders 33 and 35, (Georgiou, Koukouvinos, and Stylianou 2002) ran a complete search up to order 39 and most recently (\u00d0okovi\u00b4 c and Kotsireas 2018) ran a complete search up to order 49. The result of these searches have shown that good matrices exist in all odd orders up to 39 as well as 43 and 45. Additionally, (\u00d0okovi\u00b4 c 1993) gave a construction showing they exist in order 127. In this paper we extend the search to all odd orders divisible by 3 up to order 69. Note that increasing n by 2 increases the size of the search space (at least to a \ufb01rst approximation) by a factor of 16, meaning that the size of the search space in order 69 is an enormous 240 times larger than the search space in order 49, the largest order which has previously been exhaustively searched. There are two primary reasons our approach is able to scale to such orders: 1. We use a number of theoretical mathematical results to cut down the search space, including \ufb01ltering theorems, recently proven compression theorems, and a new product theorem given in this paper. 2. We use state-of-the-art programmatic SAT solvers, computer algebra systems, and mathematical libraries to very ef\ufb01ciently search spaces speci\ufb01ed by both logical and algebraic constraints. This approach of coupling computer algebra systems and SAT solvers was \ufb01rst proposed in 2015 at the conferences CADE and ISSAC (Zulkoski, Ganesh, and Czarnecki 2015; \u00c1brah\u00e1m 2015) and has since appeared in papers at the conferences IJCAI, ISSAC, and the journal of automated reasoning (Zulkoski, Ganesh, and Czarnecki 2016; Bright et al. 2018; Zulkoski et al. 2017) and is the aim of the SC2 project (\u00c1brah\u00e1m et al. 2016). In particular, the SAT+CAS \fmethod in this paper is an adaption of one presented at AAAI (Bright, Kotsireas, and Ganesh 2018). Furthermore, we employ a SAT solver which can learn clauses programmatically, through a piece of code compiled with the SAT solver and which makes calls to an external mathematical library. This approach permits one to ef\ufb01ciently encode constraints that would be much too cumbersome to encode with native SAT clauses, as we will see in Section 3. For example, it is much faster and easier to compute a discrete Fourier transform using a numerical library or computer algebra system than it would be to encode a DFT circuit using logical clauses, the format normally accepted by SAT solvers. A detailed description of our enumeration algorithm will be given in Section 4, followed by our results in Section 5. In particular, we explicitly give two new examples of good matrices, one in order 27 which has gone undetected since 1988 and one in order 57, an order which had previously been out of reach of exhaustive search algorithms; the largest order searched prior to our work was 49. We also provide a table enumerating the number of sets of good matrices in all odd orders divisible by 3 up to 69. These counts are given up to an equivalence which is described, along with the required background on good matrices, in Section 2. 2 Background In this section we de\ufb01ne good matrices and review the properties and theorems of good matrices that we use in our enumeration algorithm. To begin, we recall the de\ufb01nitions of symmetric, skew, and circulant matrices. Let X be a square matrix of order n with entries xi,j with 0 \u2264i, j < n. We say that X is symmetric if all entries satisfy xi,j = xj,i, that X is skew if diagonal entries are 1 and non-diagonal entries satisfy xi,j = \u2212xj,i, and that X is circulant if all entries satisfy xi,j = xi\u22121,j\u22121 with indices taken mod n as necessary. Good matrices De\ufb01nition 1. Four matrices A, B, C, D \u2208{\u00b11}n\u00d7n are known as good matrices if they have the following properties. (a) They are pairwise amicable (XY T is symmetric for X, Y \u2208{A, B, C, D}). (b) A is skew and B, C, D are symmetric. (c) AAT +B2 +C2 +D2 is the identity matrix scaled by 4n. The primary reason that good matrices have attracted sustained interest for almost 50 years is because of the following theorem of (Wallis 1970) which provides a construction for skew Hadamard matrices. Theorem 1. Let A, B, C, D be good matrices of order n. Then \uf8ee \uf8ef \uf8f0 A B C D \u2212B A D \u2212C \u2212C \u2212D A B \u2212D C \u2212B A \uf8f9 \uf8fa \uf8fb is a skew Hadamard matrix of order 4n. Skew Hadamard matrices are conjectured to exist in all orders 4n with n \u22651 and much effort has gone into constructing them in as many orders as possible; the current smallest unknown order is n = 69 and the previous smallest unknown order n = 47 was solved ten years ago by (\u00d0okovi\u00b4 c 2008). From a computational perspective the issue with good matrices is that the search space is too large to effectively search. The standard remedy for this is to focus on circulant matrices for which the search can be performed more effectively. For example, in (Awyzio and Seberry 2015) good matrices are de\ufb01ned as in De\ufb01nition 1 except that condition (a) is replaced with the strictly stronger condition (a\u2032) A, B, C, D are circulant. Technically matrices which satisfy conditions (a\u2032), (b), and (c) are not good matrices but one can recover good matrices from them simply by reversing the order of the rows of B, C, and D (thereby making them amicable with A). Since using (a\u2032) is convenient to state our results we will employ it for the remainder of this paper. We often consider good matrices in terms of their \ufb01rst rows (a0, . . . , an\u22121), (b0, . . . , bn\u22121), (c0, . . . , cn\u22121), and (d0, . . . , dn\u22121) which we call their de\ufb01ning rows. Since A is skew and B, C, and D are symmetric, the de\ufb01ning rows of a set of good matrices must satisfy a0 = 1 and ai = \u2212an\u2212i, bi = bn\u2212i, ci = cn\u2212i, di = dn\u2212i for 1 \u2264i < n/2. Furthermore, we often use A, B, C, and D to denote the de\ufb01ning rows themselves, in which case we say that A is a skew sequence and that B, C, and D are symmetric sequences. Equivalence operations The following three invertible operations are well-known and can be applied to a set of good matrices A, B, C, D to produce another set of good matrices we consider equivalent to A, B, C, D. 1. Reorder B, C, D in any way. 2. Negate any of B, C, D. 3. Apply an automorphism of Zn = {0, . . . , n \u22121} to the indices of the de\ufb01ning rows of each of A, B, C, and D. For example, the negation equivalence operation implies that any set of good matrices is equivalent to one with b0 = c0 = d0 = 1. Filtering theorems The search space for good matrices of order n is enormous. Even if one takes into account the symmetry properties of the de\ufb01ning rows and \ufb01xes the \ufb01rst entries to be positive, each de\ufb01ning row contains \u230an/2\u230bunspeci\ufb01ed entries. Since each unspeci\ufb01ed entry can be one of two values, there are a total of 24\u230an/2\u230b= 4n\u22121 possibilities in the search space. In order to cut down the size of the search space so that we can run exhaustive searches in larger orders we need \ufb01ltering theorems. One of the most powerful \ufb01ltering theorems is based on the following which gives an alternative characterization of good matrices (\u00d0okovi\u00b4 c and Kotsireas 2015). \fTheorem 2. Let A, B, C, D be sequences of length n with A skew and B, C, D symmetric. Then A, B, C, D are the de\ufb01ning rows of a set of good matrices if and only if for all integers k we have PSDA(k) + PSDB(k) + PSDC(k) + PSDD(k) = 4n. Here PSDX(k) := \f \fPn\u22121 j=0 xj\u03c9jk\f \f2 with \u03c9 := exp(2\u03c0i/n) is the power spectral density of X = [x0, . . . , xn\u22121]. This is important because of the following well-known corollary: Corollary 3. Let A, B, C, D be the de\ufb01ning rows of a set of good matrices of order n. If S is a subset of {A, B, C, D} then X X\u2208S PSDX(k) \u22644n for all integers k. For example, this corollary says that if PSDA(k) > 4n for some k then A cannot be part of a set of good matrices. In other words, we can \ufb01lter A and ignore it in our enumeration method. A second well-known corollary of Theorem 2 comes from setting k = 0 in the statement of the theorem: Corollary 4. Let A, B, C, D be the de\ufb01ning rows of a set of good matrices of odd order n. Then sum(B)2 + sum(C)2 + sum(D)2 = 4n \u22121 where sum(X) denotes the sum of entries in X. Since sum(X) is an integer when X has integer entries this corollary tells us that every set of good matrices gives a decomposition of 4n \u22121 into a sum of three integer squares which is a rather restrictive condition. For example, when n is 69 there are only three ways to write 4n \u22121 as a sum of exactly three squares of nonnegative integers, namely, 12 + 72 + 152, 52 + 52 + 152, and 52 + 92 + 132. One must also consider decompositions with squares of negative integers but the negative integers can be found with the following simple (often unstated) lemma. It gives a criterion to determine the signs of sum(B), sum(C), and sum(D). Lemma 5. Let (a0, . . . , an\u22121), (b0, . . . , bn\u22121), (c0, . . . , cn\u22121), (d0, . . . , dn\u22121) be the de\ufb01ning rows of a set of good matrices A, B, C, D of odd order n with b0 = c0 = d0 = 1. Then sum(B) \u2261sum(C) \u2261sum(D) \u2261n (mod 4). Compression Although the \ufb01ltering theorems greatly decrease the number of possibilities for the de\ufb01ning rows of good matrices there are still typically a large number of possibilities which are not \ufb01ltered by Corollaries 3 and 4. An effective way of shrinking the search space even farther is to apply properties that \u201ccompressions\u201d of good matrices must satisfy. Such theorems are only applicable in composite orders; we will assume that the order n is a multiple of 3. To our knowledge this is the \ufb01rst time compression has been used in the search for good matrices and it allows us to search larger orders than other methods. For example, (\u00d0okovi\u00b4 c and Kotsireas 2018) use the aforementioned \ufb01ltering corollaries but do not apply compression and are only able to search orders up to 49. The 3-compression of a sequence X = (x0, . . . , xn\u22121) of length n is the sequence X\u2032 of length m := n/3 whose kth entry is xk + xk+m + xk+2m. Since we are concerned with the case where the entries of X are \u00b11 the entries of X\u2032 are either \u00b11 or \u00b13. Compression is useful because (\u00d0okovi\u00b4 c and Kotsireas 2015) showed that Theorem 2 holds for compressions of the de\ufb01ning rows of good matrices. Theorem 6. Let A, B, C, D be the de\ufb01ning rows of a set of good matrices of order n and let A\u2032, B\u2032, C\u2032, D\u2032 be compressions of those rows. Then for all integers k we have PSDA\u2032(k) + PSDB\u2032(k) + PSDC\u2032(k) + PSDD\u2032(k) = 4n. A new product theorem Our study of good matrices uncovered the following relationship that the entries of good matrices must satisfy. This is an analog of the product theorem that was proven by John Williamson for Williamson matrices (Williamson 1944). Theorem 7. Let (a0, . . . , an\u22121), (b0, . . . , bn\u22121), (c0, . . . , cn\u22121), (d0, . . . , dn\u22121) be the de\ufb01ning rows of a set of good matrices A, B, C, D of odd order n. Then akbkckdk = \u2212a2k mod nb0c0d0 for all 1 \u2264k < n. Let \u00af x := (1 \u2212x)/2, i.e., the mapping x 7\u2192\u00af x is the group isomorphism between Z\u2217 4 = {\u00b11} and Z2 = {0, 1}. Our enumeration method uses Theorem 7 in the following form. Corollary 8. Let (a0, . . . , an\u22121), (b0, . . . , bn\u22121), (c0, . . . , cn\u22121), (d0, . . . , dn\u22121) be the de\ufb01ning rows of a set of good matrices A, B, C, D of odd order n with b0 = c0 = d0 = 1. Then for 1 \u2264k < n/2 we have in Z2 \u00af ak + \u00af a2k + \u00af bk + \u00af ck + \u00af dk = 1 and when n = 3m we have \u00af bm + \u00af cm + \u00af dm = 1. We give proofs of Lemma 5, Theorem 7, and Corollaries 3, 4, and 8 in the appendix. 3 The SAT+CAS paradigm The SAT+CAS paradigm is a new method of solving certain kinds of computational problems which harnesses the power of two \ufb01elds of computer science: satis\ufb01ability checking and symbolic computation. The paradigm is particularly useful for problems that have a signi\ufb01cant search component and a rich mathematical component. Brie\ufb02y, this is due to the fact that modern SAT solvers have extremely ef\ufb01cient search procedures but lack the domain knowledge to effectively deal with rich mathematical concepts. On the other hand, computer algebra systems like MAPLE, MATHEMATICA, and SAGEMATH as well as special-purpose numerical libraries can very effectively deal with rich mathematics. The fact that satis\ufb01ability checking and symbolic computation had great potential synergy was \ufb01rst pointed out by Erika \u00c1brah\u00e1m in an invited talk at the conference ISSAC in 2015 (\u00c1brah\u00e1m 2015). At almost the same time this synergy \fwas demonstrated by the system MATHCHECK presented at the conference CADE (Zulkoski, Ganesh, and Czarnecki 2015). The system MATHCHECK coupled a SAT solver with a computer algebra system and solved open cases of two conjectures in graph theory and was later extended to solve open cases in combinatorial conjectures (Zulkoski et al. 2017). Since then, the SC2 project (\u00c1brah\u00e1m et al. 2016) has organized an annual workshop on this topic for the last three years. To illustrate the usefulness of the SAT+CAS paradigm in the search for good matrices speci\ufb01cally, consider Corollaries 3, 4, and 8 from Section 2. These corollaries all state various properties that good matrices must satisfy but each property arises from a different branch of mathematics. Consequently, each property is best dealt with using systems which have been optimized to deal with that particular branch: \u2022 Corollary 3 is a statement in Fourier analysis and is best checked using a system which has been designed to ef\ufb01ciently compute Fourier transforms. \u2022 Corollary 4 (and Lemma 5) are number theoretic statements and possibilities for the values sum(B), sum(C), and sum(D) can be found by using a system which has been designed to solve quadratic Diophantine systems. \u2022 Corollary 8 is a statement using arithmetic in Z2 and can ef\ufb01ciently be encoded directly in a SAT instance. The programmatic SAT paradigm A programmatic SAT solver, introduced in (Ganesh et al. 2012), is a new kind of SAT solver which allows solving satis\ufb01ability problems with more expressiveness than the kinds of problems that can be solved with a standard SAT solver. Brie\ufb02y, a programmatic SAT solver will use some custom code to examine the current partial assignment and if it cannot be extended into a full assignment (based on some known theorem from the problem domain) a clause will be learned encoding that fact. Because one can think of \u201ccalling\u201d the programmatic SAT solver with the custom code this code is known as a \u201ccallback\u201d function. Programmatic SAT solvers are conceptually similar to SMT (SAT modulo theories) solvers and in some ways could be considered a \u201cpoor man\u2019s SMT\u201d. However, they also differ from SMT solvers in some key ways: Simplicity. SMT solvers are necessarily more complicated than SAT solvers because they solve problems in \ufb01rstorder logic instead of problems in propositional logic. This increase in complexity is justi\ufb01able for many problems but some problems contain mostly just propositional logic with a handful of \u201ctheory lemmas\u201d that are cumbersome to state in propositional logic but can be given to a programmatic SAT solver as necessary to help guide its search. Flexibility. Typically SMT solvers only support theories which are \ufb01xed in advance; for example, the SMT-LIB standard (Barrett, Fontaine, and Tinelli 2016) speci\ufb01es a \ufb01xed number of theories and a common input and output language for those theories. However, not all problems can naturally be expressed in those theories; e.g., the current SMT-LIB standard does not include theories involving Fourier transforms (or transcendental functions or complex numbers). In contrast, a programmatic SAT solver can learn theory lemmas derived using Fourier transforms so long as an appropriate CAS or library can be called. Tailored solving. Programmatic SAT solvers can be tailored to solve speci\ufb01c classes of problems (in addition to using the same state-of-the-art techniques which make modern SAT solving so ef\ufb01cient). For example, in this paper we develop a SAT solver tailored to searching for good matrices. In principle SMT solvers could work in the same way but we are not aware of any SMT solvers that offer a programmatic interface like this. A programmatic SAT encoding of good matrices We now describe how our programmatic SAT solver encoding of good matrices works in detail. We encode the entries of the de\ufb01ning rows of a set of good matrices A, B, C, D of order n using 4n Boolean variables where we let true values denote 1 and false values denote \u22121. By abuse of notation we use the same names for the Boolean variables and the \u00b11 entries that they represent but it will be clear from the context if we are referring to a Boolean or integer value. In fact, using the symmetry constraints from Section 2 we only need to de\ufb01ne the 2(n + 1) variables ai, bi, ci, di that have indices i with 0 \u2264i < n/2. In what follows we implicitly use this whenever necessary; i.e., any variables with indices larger than n/2 are used for clarity only. A programmatic SAT solver includes a callback function that is run whenever the SAT solver\u2019s usual con\ufb02ict analysis fails to \ufb01nd a con\ufb02ict. The callback function examines the current partial assignment and learns clauses that block the current assignment (and extensions of the current assignment) from the search in the future. If x is a variable that appears in the current partial assignment we let xcur denote either the literal x or \u00acx, whichever is true under the current assignment. The callback function used in our encoding of good matrices works by encoding the property given in Corollary 3 and its steps are described in detail below. 1. Let S be a list containing the sequences (a0, . . . , an\u22121), (b0, . . . , bn\u22121), (c0, . . . , cn\u22121), (d0, . . . , dn\u22121) that have all their variables currently assigned. 2. If S is empty then return control to the SAT solver. 3. Let X be the \ufb01rst sequence in S and compute the power spectral density of X. If PSDX(k) > 4n for some k then learn a clause blocking the sequence X from the search in the future. Explicitly, learn the clause \u00acxcur 0 \u2228\u00acxcur 1 \u2228\u00b7 \u00b7 \u00b7 \u2228\u00acxcur n\u22121 and return control to the SAT solver. 4. If S contains at least two sequences then let Y be the second sequence in S and compute the power spectral density of Y . If PSDX(k)+PSDY (k) > 4n for some k then learn a clause blocking the sequences X and Y from occurring together again in the future. Explicitly, learn the \fclause \u00acxcur 0 \u2228\u00b7 \u00b7 \u00b7 \u2228\u00acxcur n\u22121 \u2228\u00acycur 0 \u2228\u00b7 \u00b7 \u00b7 \u2228\u00acycur n\u22121 and return control to the SAT solver. 5. If S contains at least three sequences then let Z be the third sequence in S and compute the power spectral density of Z. If PSDX(k) + PSDY (k) + PSDZ(k) > 4n for some k then learn a clause blocking the sequences X, Y , and Z from occurring together again in the future and return control to the SAT solver. 6. If S contains four sequences then we know every entry of A, B, C, and D. If the relationship in Theorem 2 holds then record A, B, C, and D as rows that de\ufb01ne good matrices. Whether or not the sequences de\ufb01ne good matrices learn a clause blocking these sequences from occurring together again in the future. If only a single instance of good matrices is desired then one can stop searching in Step 6 if a satisfying A, B, C, D is found. However, we learn a blocking clause and continue the search because we want to provide an exhaustive search. The programmatic approach was essential to our algorithm because it allowed us to easily and ef\ufb01ciently apply Corollary 3 which would otherwise be dif\ufb01cult to apply in a SAT instance. Corollary 3 was also extremely effective; the SAT solver was usually able to learn a clause in Step 3 when enough variables were assigned. This enormously cut down the search space\u2014the SAT solver could often learn con\ufb02icts with just n variables instead of con\ufb02icts with all 4n variables and in practice this appeared to give us an exponential speedup in n. However, using this method alone was not suf\ufb01cient for us to derive results beyond order 21 and a more ef\ufb01cient enumeration method (using the programmatic encoding as a subroutine) was required to scale to order 69. We describe this method in the next section. 4 Enumeration algorithm Although SAT solvers are useful tools for searching large spaces they have their limits and the main reason that we were not able to derive any new results only using SAT solvers is because the search space is too large, even using the programmatic \ufb01ltering encoding. One way that the performance of SAT solvers can be improved on instances with large search spaces is by splitting the instance into many smaller instances of approximately equal dif\ufb01culty. The cube-and-conquer paradigm (Heule, Kullmann, and Biere 2018) does this and has achieved some impressive successes such as solving the Boolean Pythagorean triples problem (Heule, Kullmann, and Marek 2016) and determining the \ufb01fth Schur number (Heule 2018). Our enumeration algorithm will use a similar paradigm to cube-and-conquer except that instead of splitting the search space into cubes we split the search space into compressions. Not only does splitting via compressions increase the performance of the SAT solver it also allows for easy parallelization because instances generated in this way are independent. Additionally, we use Theorem 6 to apply \ufb01ltering to the compressions which also has the effect of further decreasing the size of the search space. We now describe our algorithm in four steps followed by some postprocessing. Given an odd order n divisible by 3 our algorithm enumerates all inequivalent circulant good matrices of order n with positive \ufb01rst entries. Each step is designed to search through a larger subspace than the previous step: step 1 \ufb01nds every possible rowsum of a good matrix, step 2 \ufb01nds every possible 3-compressed row of a good matrix, step 3 \ufb01nds every possible 3-compressed quadruple of good matrices, and step 4 \ufb01nds all good matrices up to equivalence. Step 1: Find possible rowsums If A, B, C, D are good matrices then from Corollary 4 and Lemma 5 the rowsums of the matrices B, C, and D must satisfy the quadratic Diophantine system x2 + y2 + z2 = 4n \u22121 x \u2261y \u2261z \u2261n (mod 4) where x, y, and z are the rowsums of B, C, and D. Many computer algebra systems contain number theoretic functions that allow this Diophantine system to be easily solved. For example, the MATHEMATICA function PowersRepresentations or the MAPLE script NSOKS (Riel 2006). Step 2: Find possible compressed rows In this step we will generate sets Ssk and Ssy where Ssk will contain all possible 3-compressions of skew de\ufb01ning rows and Ssy will contain all possible 3-compressions of symmetric de\ufb01ning rows. These sets will be generated by an essentially brute-force enumeration through all skew or symmetric {\u00b11}-sequences of length n, using Corollaries 3 and 4 to \ufb01lter sequences which cannot be a de\ufb01ning row. Let d := \u230an/2\u230b. In detail, we do the following: 1. For all X \u2208{\u00b11}d: (a) Let A be the skew sequence whose \ufb01rst entry is 1 and next d entries are given by X, i.e., A := (1, x0, . . . , xd\u22121, \u2212xd\u22121, . . . , \u2212x0). (b) If PSDA(k) \u22644n for all k then add the 3-compression of A to Ssk. (c) Let B be the symmetric sequence whose \ufb01rst entry is 1 and next d entries are given by X, i.e., B := (1, x0, . . . , xd\u22121, xd\u22121, . . . , x0). (d) If PSDB(k) \u22644n for all k and sum(B) is one of the solutions x, y, z from step 1 then add the 3compression of B to Ssy. Step 3: Find possible compressed quadruples In step 2 we generated all possible 3-compressions of the de\ufb01ning rows of good matrices. However, most quadruples of possible sequences found in step 2 will violate the relationship in Theorem 6 and can therefore be \ufb01ltered. In this step we identify all quadruples of 3-compressions which can\u2019t be \ufb01ltered and store them in a set Sq. We do this by examining all (A\u2032, B\u2032, C\u2032, D\u2032) in Ssk \u00d7 S3 sy and adding the quadruples that satisfy the relationship in Theorem 6 to Sq. \fStep 4: Uncompress via programmatic SAT In step 3 we generated all 3-compressed quadruples (A\u2032, B\u2032, C\u2032, D\u2032) that satisfy the relationship in Theorem 6. Given such a quadruple we need to determine if it is possible to uncompress the quadruple. In other words, we want to \ufb01nd all quadruples (A, B, C, D) of de\ufb01ning rows of good matrices (if any) whose 3-compression is (A\u2032, B\u2032, C\u2032, D\u2032). To do this we formulate the uncompression problem as a programmatic SAT problem. We already discussed our programmatic encoding of the constraint saying that A, B, C, D de\ufb01ne rows of good matrices of order n = 3m. The remaining constraints can easily be expressed in the standard format accepted by SAT solvers (conjunctive normal form). We now discuss how to encode the constraint that they are 3-compressions of A\u2032, B\u2032, C\u2032, and D\u2032. (For simplicity we only consider the compression constraints of A\u2032 = (a\u2032 0, . . . , a\u2032 m\u22121) but the other constraints are analogous.) Consider the entry a\u2032 k = ak + ak+m + ak+2m. There are four possible cases: 1. a\u2032 k = 3. In this case ak = ak+m = ak+2m = 1 which is encoded as the three unit clauses ak, ak+m, ak+2m. 2. a\u2032 k = 1. In this case two of {ak, ak+m, ak+2m} are true and one is false. This is encoded as the four clauses \u00acak \u2228\u00acak+m \u2228\u00acak+2m, ak \u2228ak+m, ak \u2228ak+2m, ak+m \u2228ak+2m. 3. a\u2032 k = \u22121. In this case one of {ak, ak+m, ak+2m} is true and two are false. This is encoded as the four clauses ak \u2228ak+m \u2228ak+2m, \u00acak \u2228\u00acak+m, \u00acak \u2228\u00acak+2m, \u00acak+m \u2228\u00acak+2m. 4. a\u2032 k = \u22123. In this case ak = ak+m = ak+2m = \u22121 which is encoded as the three unit clauses \u00acak, \u00acak+m, \u00acak+2m. Finally, we discuss how to encode Corollary 8. The simplest case of Corollary 8 tells us that an even number of {bm, cm, dm} are true. This is encoded as the four clauses bm \u2228cm \u2228dm, \u00acbm \u2228\u00accm \u2228dm, \u00acbm \u2228cm \u2228\u00acdm, bm \u2228\u00accm \u2228\u00acdm. The general case of Corollary 8 is an XOR constraint of length 5. While SAT solvers are not good with arbitrary XOR constraints we found that these constraints were short enough that they could be effectively encoded as the sixteen clauses with an even number of negated literals, i.e., ak \u2228a2k \u2228bk \u2228ck \u2228dk, . . . , ak \u2228\u00aca2k \u2228\u00acbk \u2228\u00acck \u2228\u00acdk. Postprocessing: Remove equivalent good matrices After all the SAT instances generated in step 4 are solved we will have a list of all circulant good matrices of order n up to equivalence. However, some of them may be equivalent to each other since we have not encoded all of the equivalence operations of Section 2. In order to provide a list which contains only inequivalent good matrices it is necessary to test the matrices for equivalence and remove any that are found to be equivalent to one which has previously been found. To do this, we de\ufb01ne a canonical representative of each equivalence class of de\ufb01ning rows of good matrices. This way, to check if two good matrices are equivalent we compute the canonical representative of each and check if they are equal. First, consider the \ufb01rst two equivalence operations (reorder and negate). Given a quadruple of de\ufb01ning rows (A, B, C, D) we apply the negation operation to set the \ufb01rst entry of each de\ufb01ning row to be positive. Then we apply the reorder operation to sort B, C, D in lexicographically increasing order. This gives us a canonical representative of each equivalence class formed by the \ufb01rst two equivalence operations which we denote by MA,B,C,D. Next, consider the third equivalence operation (permute indices). Let \u03c3 be an automorphism of Zn and let \u03c3 act on (A, B, C, D) by permuting the indices of the de\ufb01ning rows. This operation commutes with the \ufb01rst two operations, so the lexicographic minimum of the set S := { M\u03c3(A,B,C,D) : \u03c3 \u2208Aut(Zn) } is the lexicographic minimum of all quadruples equivalent to (A, B, C, D) and is therefore canonical. We compute this by explicitly generating all elements of S and selecting the lexicographic minimum. Optimizations For the bene\ufb01t of those who would like to implement our algorithm we now discuss some optimizations that we found useful. In the programmatic encoding and in step 2 of our enumeration algorithm we need to check if there exists an integer k such that PSDX(k) > 4n for a given sequence X. We only need to check k with 0 \u2264k < n/2 because the symmetries of the Fourier transform on real input X imply that PSDX(k) = PSDX(\u00b1k mod n). In fact, checking k = 0 is also unnecessary because PSDX(0) = sum(X)2 and step 1 will \ufb01lter any sequences X with sum(X)2 > 4n. Also, when checking the PSD criterion for each k we sort the elements of S so that the sequences with the largest PSD values appear \ufb01rst, making it easier to learn short clauses. In step 3, the matching procedure can be done very ef\ufb01ciently by a string sorting technique similar to the method used in (Kotsireas, Koukouvinos, and Pardalos 2010). First we enumerate all (A\u2032, B\u2032) \u2208Ssk \u00d7 Ssy that satisfy PSDA\u2032(k) + PSDB\u2032(k) \u22644n for all k and all (C\u2032, D\u2032) \u2208S2 sy that satisfy PSDC\u2032(k) + PSDD\u2032(k) \u22644n for all k. At this point we form one list that contains strings that contain the values of PSDA\u2032(k) + PSDB\u2032(k) and another list that contains strings that contain the values of 4n \u2212(PSDC\u2032(k) + PSDD\u2032(k)) and look for strings which occur in both lists. This can be done by sorting the two lists and doing a linear scan through the lists to \ufb01nd duplicates. The fact that PSDs are real numbers can make this tricky, but we can deal solely with integers by applying the inverse \fFourier transform to the PSD values; this produces integer values known as PAF values and the relationship given in Theorem 6 becomes (for 0 < k < n) PAFA\u2032(k) + PAFB\u2032(k) + PAFC\u2032(k) + PAFD\u2032(k) = 0. In fact, since this step was not a bottleneck we computed the PAF values using the slower but more straightforward relationship PAFX(k) = Pn\u22121 j=0 xjxj+k mod n. In step 4, before calling the SAT solver we partition the compressed quadruples into equivalence classes using the reorder and automorphism equivalence operations from Section 2 and keep one quadruple from each equivalence class. If any satis\ufb01able SAT instances are removed by this process they will have equivalent solutions (also with positive \ufb01rst entries) in the instance that was kept. 5 Results In this section we discuss our implementation of our enumeration algorithm, the software and hardware we used to run it, and the results that we achieved. Our code is available from our website uwaterloo.ca/mathcheck. Step 1 of our algorithm was done using NSOKS in MAPLE (Riel 2006). Steps 2 and 3 were done with custom C++ code and the string sorting was done with the GNU core utility SORT. Step 4 was done with the programmatic SAT solver MAPLESAT (Liang et al. 2016) and the PSD values were computed using the library FFTW (Frigo and Johnson 2005). Because FFTW uses \ufb02oating point values which are inherently inaccurate all comparisons were checked to a tolerance of \u01eb = 10\u22122 which is small but larger than the precision of the FFT used. The computations were run on a cluster of 64-bit Opteron 2.2GHz and Xeon 2.6GHz processors running CentOS 6.9 and using 500MB of memory. By far the most computationally expensive step of our algorithm was running the SAT solver. This accounted for 99.9% of the total running time, underscoring the importance of using a state-of-the-art SAT solver such as MAPLESAT. This step was parallelized across 250 cores and completed in about two weeks. Despite step 4 being the bottleneck the other steps were found to be essential could not be removed without signi\ufb01cantly increasing the computation time. The timings for running our implementation in each odd order divisible by 3 up to order 70 are given in Table 1. This table also contains the number of SAT instances generated in each order and the number of inequivalent good matrices found (denoted by #Gn). Our exhaustive search in order 27 produced 13 sets of inequivalent good matrices, though Szekeres\u2019 classic paper (Szekeres 1988) contains only 12 sets of such matrices and Seberry reports that this was checked by at least one other researcher (Seberry 1999). Comparing the matrices generated using our method with those in his paper shows that Szekeres missed a set of good matrices. Furthermore, we found a new set of good matrices of order 57; the two new sets of good matrices produced by our method are given in Figure 1. 6"
+                },
+                {
+                    "url": "http://arxiv.org/abs/1805.05488v2",
+                    "title": "Enumeration of Complex Golay Pairs via Programmatic SAT",
+                    "abstract": "We provide a complete enumeration of all complex Golay pairs of length up to\n25, verifying that complex Golay pairs do not exist in lengths 23 and 25 but do\nexist in length 24. This independently verifies work done by F. Fiedler in 2013\nthat confirms the 2002 conjecture of Craigen, Holzmann, and Kharaghani that\ncomplex Golay pairs of length 23 don't exist. Our enumeration method relies on\nthe recently proposed SAT+CAS paradigm of combining computer algebra systems\nwith SAT solvers to take advantage of the advances made in the fields of\nsymbolic computation and satisfiability checking. The enumeration proceeds in\ntwo stages: First, we use a fine-tuned computer program and functionality from\ncomputer algebra systems to construct a list containing all sequences which\ncould appear as the first sequence in a complex Golay pair (up to equivalence).\nSecond, we use a programmatic SAT solver to construct all sequences (if any)\nthat pair off with the sequences constructed in the first stage to form a\ncomplex Golay pair.",
+                    "authors": "Curtis Bright, Ilias Kotsireas, Albert Heinle, Vijay Ganesh",
+                    "published": "2018-05-14",
+                    "updated": "2018-11-08",
+                    "primary_cat": "cs.LO",
+                    "cats": [
+                        "cs.LO",
+                        "cs.SC",
+                        "math.CO"
+                    ],
+                    "main_content": "INTRODUCTION The sequences which are now referred to Golay sequences or Golay pairs were \ufb01rst introduced by Marcel Golay in his groundbreaking 1949 paper [18] on multislit spectrometry. He later formally de\ufb01ned them in a 1961 paper [17] where he referred to them as complementary series. Since then, Golay pairs and their generalizations have been widely studied for both their elegant theoretical properties and a surprising number of practical applications. For example, they have been applied to radar pulse compression [20], Wi-Fi networks [25], train wheel detection systems [10], optical time domain Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for pro\ufb01t or commercial advantage and that copies bear this notice and the full citation on the \ufb01rst page. Copyrights for components of this work owned by others than the author(s) must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior speci\ufb01c permission and/or a fee. Request permissions from permissions@acm.org. ISSAC \u201918, July 16\u201319, 2018, New York, NY, USA \u00a9 2018 Copyright held by the owner/author(s). Publication rights licensed to ACM. ACM ISBN 978-1-4503-5550-6/18/07...$15.00 https://doi.org/10.1145/3208976.3209006 re\ufb02ectometry [27], and medical ultrasounds [28]. Golay pairs consist of two sequences and the property that makes them special is, roughly speaking, the fact that one sequence\u2019s \u201ccorrelation\u201d with itself is the inverse of the other sequence\u2019s \u201ccorrelation\u201d with itself; see De\ufb01nition 2.2 in Section 2 for the formal de\ufb01nition. Although Golay de\ufb01ned his complementary series over an alphabet of {\u00b11}, later authors have generalized the alphabet to include nonreal roots of unity such as the fourth root of unity i = \u221a \u22121. In this paper, we focus on the case where the alphabet is {\u00b11, \u00b1i}. In this case the resulting sequence pairs are sometimes referred to as 4-phase or quaternary Golay pairs though we will simply refer to them as complex Golay pairs. If a complex Golay pair of length n exists then we say that n is a complex Golay number. Complex Golay pairs have been extensively studied by many authors. They were originally introduced in 1994 by Craigen in order to expand the orders of Hadamard matrices attainable via (ordinary) Golay pairs [7]. In 1994, Holzmann and Kharaghani enumerated all complex Golay pairs up to length 13 [19]. In 2002, Craigen, Holzmann, and Kharaghani enumerated all complex Golay pairs to 19, reported that 21 was not a complex Golay number, and conjectured that 23 was not a complex Golay number [8]. In 2006, Fiedler, Jedwab, and Parker provided a construction which explained the existence of all known complex Golay pairs whose lengths were a power of 2 [12, 13], including complex Golay pairs of length 16 discovered by Li and Chu [23] to not \ufb01t into a construction given by Davis and Jedwab [9]. In 2010, Gibson and Jedwab provided a construction which explained the existence of all complex Golay pairs up to length 26 and gave a table that listed the total number of complex Golay pairs up to length 26 [16]. This table was produced by the mathematician Frank Fiedler, who described his enumeration method in a 2013 paper [11] where he also reported that 27 and 28 are not complex Golay numbers. In this paper we give an enumeration method which can be used to verify the table produced by Fiedler that appears in Gibson and Jedwab\u2019s paper; this table contains counts for the total number of complex Golay pairs and the total number of sequences which appear as a member of a complex Golay pair. We implemented our method and obtained counts up to length 25 after about a day of computing on a cluster with 25 cores. The counts we obtain match those in Fiedler\u2019s table in each case, increasing the con\ufb01dence that the enumeration was performed without error. In addition, we also provide counts for the total number of complex Golay pairs up to well-known equivalence operations [19] and explicitly make available the sequences online [6]. To our knowledge, this is the \ufb01rst time that explicit complex Golay pairs (and their counts up to equivalence) have been published for lengths larger than 19. Lastly, we publicly release our code for enumerating complex Golay pairs \fISSAC \u201918, July 16\u201319, 2018, New York, NY, USA Curtis Bright, Ilias Kotsireas, Albert Heinle, and Vijay Ganesh so that others may verify and reproduce our work; we were not able to \ufb01nd any other code for enumerating complex Golay pairs which was publicly available. Our result is of interest not only because of the veri\ufb01cation we provide but also because of the method we use to performthe veri\ufb01cation. The method proceeds in two stages. In the \ufb01rst stage, a \ufb01netuned computer program performs an exhaustive search among all sequences which could possibly appear as the \ufb01rst sequence in a complex Golay pair of a given length (up to an equivalence de\ufb01ned in Section 2). Several \ufb01ltering theorems which we describe in Section 2 allow us to discard almost all sequences from consideration. To apply these \ufb01ltering theorems we use functionality from the computer algebra system Maple [26] and the mathematical library FFTW [14]. After this \ufb01ltering is completed we have a list of sequences of a manageable size such that the \ufb01rst sequence of every complex Golay pair of a given length (up to equivalence) appears in the list. In the second stage, we use the programmatic SAT solver MapleSAT [24] to determine which sequences from the \ufb01rst stage (if any) can be paired up with another sequence to form a complex Golay pair. A SAT instance is constructed from each sequence found in the \ufb01rst stage such that the SAT instance is satis\ufb01able if and only if the sequence is part of a complex Golay pair. Furthermore, in the case that the instance is satis\ufb01able a satisfying assignment determines a sequence which forms the second half of a complex Golay pair. This method combines both computer algebra and SAT solving and is of interest in its own right because it links the two previously separated \ufb01elds of symbolic computation and satis\ufb01ability checking. Recently there has been interest in combining methods from both \ufb01elds to solve computational problems as demonstrated by the SC2 project [1, 2]. Our work \ufb01ts into this paradigm and to our knowledge is the \ufb01rst application of a SAT solver to search for complex Golay pairs, though previous work exists which uses a SAT solver to search for other types of complementary sequences [3\u2013 5, 31]. 2 BACKGROUND ON COMPLEX GOLAY PAIRS In this section we present the background necessary to describe our method for enumerating complex Golay pairs. First, we require some preliminary de\ufb01nitions to de\ufb01ne what complex Golay pairs are. Let x denote the complex conjugate of x (this is just the multiplicative inverse of x when x is \u00b11 or \u00b1i). De\ufb01nition 2.1 (cf. [22]). The nonperiodic autocorrelation function of a sequence A = [a0, . . . , an\u22121] \u2208Cn of length n \u2208N is NA(s) \u2254 n\u2212s\u22121 \u00d5 k=0 akak+s, s = 0, . . . ,n \u22121. De\ufb01nition 2.2. A pair of sequences (A, B) withAand B in {\u00b11, \u00b1i}n are called a complex Golay pair if the sum of their nonperiodic autocorrelations is a constant zero for s , 0, i.e., NA(s) + NB(s) = 0 for s = 1, . . . ,n \u22121. Note that if A and B are in {\u00b11, \u00b1i}n then NA(0)+NB(0) = 2n by the de\ufb01nition of the complex nonperiodic autocorrelation function and the fact that xx = 1 if x is \u00b11 or \u00b1i, explaining why s , 0 in De\ufb01nition 2.2. Example 2.3. ([1, 1, \u22121], [1,i, 1]) is a complex Golay pair. 2.1 Equivalence operations There are certain invertible operations which preserve the property of being a complex Golay pair when applied to a sequence pair (A, B). These are summarized in the following proposition. Proposition 2.4 (cf. [8]). Let ([a0, . . . , an\u22121], [b0, . . . ,bn\u22121]) be a complex Golay pair. The following are then also complex Golay pairs: E1. (Reversal) ([an\u22121, . . . ,a0], [bn\u22121, . . . ,b0]). E2. (Conjugate Reverse A) ([an\u22121, . . . ,a0], [b0, . . . ,bn\u22121]). E3. (Swap) ([b0, . . . ,bn\u22121], [a0, . . . ,an\u22121]). E4. (Scale A) ([ia0, . . . ,ian\u22121], [b0, . . . ,bn\u22121]). E5. (Positional Scaling) (i \u22c6A,i \u22c6B) where c \u22c6(x0, . . . ,xn\u22121) \u2254 (x0,cx1,c2x2, . . . ,cn\u22121xn\u22121). De\ufb01nition 2.5. We call two complex Golay pairs (A,B) and (A\u2032, B\u2032) equivalent if (A\u2032, B\u2032) can be obtained from (A, B) using the transformations described in Proposition 2.4. 2.2 Useful properties and lemmas In this subsection we prove some useful properties that complex Golay pairs satisfy and which will be exploited by our method for enumerating complex Golay pairs. The \ufb01rst lemma provides a fundamental relationship that all complex Golay pairs must satisfy. To conveniently state it we use the following de\ufb01nition. De\ufb01nition 2.6 (cf. [8]). The Hall polynomial of the sequence A \u2254 [a0, . . . , an\u22121] is de\ufb01ned to be hA(z) \u2254a0 +a1z + \u00b7 \u00b7 \u00b7 +an\u22121zn\u22121 \u2208 C[z]. Lemma 2.7 (cf. [29]). Let (A, B) be a complex Golay pair. For every z \u2208C with |z| = 1, we have |hA(z)|2 + |hB(z)|2 = 2n. Proof. Since |z| = 1 we can write z = ei\u03b8 for some 0 \u2264\u03b8 < 2\u03c0. Similar to the fact pointed out in [21], using Euler\u2019s identity one can derive the following expansion: |hA(z)|2 = NA(0) + 2 n\u22121 \u00d5 j=1 \u0000Re(NA(j)) cos(\u03b8j) + Im(NA(j)) sin(\u03b8j)\u0001. Since A and B form a complex Golay pair, by de\ufb01nition one has that Re(NA(j) + NB(j)) = 0 and Im(NA(j) + NB(j)) = 0 and then |hA(z)|2 + |hB(z)|2 = NA(0) + NB(0) = 2n. \u25a1 This lemma is highly useful as a condition for \ufb01ltering sequences which could not possibly be part of a complex Golay pair, as explained in the following corollary. Corollary 2.8. Let A \u2208Cn, z \u2208C with |z| = 1, and |hA(z)|2 > 2n. Then A is not a member of a complex Golay pair. Proof. Suppose the sequence A was a member of a complex Golay pair whose other member was the sequence B. Since |hB(z)|2 \u2265 0, we must have |hA(z)|2+|hB(z)|2 > 2n, in contradiction to Lemma 2.7. \u25a1 \fEnumeration of Complex Golay Pairs via Programmatic SAT ISSAC \u201918, July 16\u201319, 2018, New York, NY, USA In [11], Fiedler derives the following extension of Lemma 2.7. Let Aeven be identical to A with the entries of odd index replaced by zeros and let Aodd be identical to A with the entries of even index replaced by zeros. Lemma 2.9 (cf. [11]). Let (A, B) be a complex Golay pair. For every z \u2208C with |z| = 1, we have |hAeven(z)|2 + |hAodd(z)|2 + |hBeven(z)|2 + |hBodd(z)|2 = 2n. Proof. The proof proceeds as in the proof of Lemma 2.7, except that one instead obtains that |hAeven(z)|2 + |hAodd(z)|2 is equal to NA(0) + 2 n\u22121 \u00d5 j=1 j even \u0000Re(NA(j)) cos(\u03b8j) + Im(NA(j)) sin(\u03b8j)\u0001. \u25a1 Corollary 2.10. Let A \u2208Cn,z \u2208C with |z| = 1, and |hA\u2032(z)|2 > 2n where A\u2032 is either Aeven or Aodd. Then A is not a member of a complex Golay pair. Proof. If either |hAeven(z)|2 > 2n or |hAodd(z)|2 > 2n then the identity in Lemma 2.9 cannot hold. \u25a1 The next lemma is useful because it allows us to write 2n as the sum of four integer squares. It is stated in [19] using a di\ufb00erent notation; we use the notation resum(A) and imsum(A) to represent the real and imaginary parts of the sum of the entries of A. For example, if A \u2254[1,i, \u2212i,i] then resum(A) = imsum(A) = 1. Lemma 2.11 (cf. [19]). Let (A,B) be a complex Golay sequence pair. Then resum(A)2 + imsum(A)2 + resum(B)2 + imsum(B)2 = 2n. Proof. Using Lemma 2.7 with z = 1 we have |resum(A) + imsum(A)i|2 + |resum(B) + imsum(B)i|2 = 2n. Since |resum(X) + imsum(X)i|2 = resum(X)2 + imsum(X)2 the result follows. \u25a1 The next lemma provides some normalization conditions which can be used when searching for complex Golay pairs up to equivalence. Since all complex Golay pairs (A\u2032, B\u2032) which are equivalent to a complex Golay pair (A,B) can easily be generated from (A, B), it su\ufb03ces to search for complex Golay pairs up to equivalence. Lemma 2.12 (cf. [11]). Let (A\u2032, B\u2032) be a complex Golay pair. Then (A\u2032, B\u2032) is equivalent to a complex Golay pair (A, B) with a0 = a1 = b0 = 1 and a2 \u2208{\u00b11,i}. Proof. We will transform a given complex Golay sequence pair (A\u2032, B\u2032) into an equivalent normalized one using the equivalence operations of Proposition 2.4. To start with, let A \u2254A\u2032 and B \u2254B\u2032. First, we ensure that a0 = 1. To do this, we apply operation E4 (scale A) enough times until a0 = 1. Second, we ensure that a1 = 1. To do this, we apply operation E5 (positional scaling) enough times until a1 = 1; note that E5 does not change a0. Third, we ensure that a2 , \u2212i. If it is, we apply operation E1 (reversal) and E2 (conjugate reverse A) which has the e\ufb00ect of keeping a0 = a1 = 1 and setting a2 = i. Last, we ensure that b0 = 1. To do this, we apply operation E3 (swap) and then operation E4 (scale A) enough times so that a0 = 1 and then operation E3 (swap) again. This has the e\ufb00ect of not changing A but setting b0 = 1. \u25a1 2.3 Sum-of-squares decomposition types A consequence of Lemma 2.11 is that every complex Golay pair generates a decomposition of 2n into a sum of four integer squares. In fact, it typically generates several decompositions of 2n into a sum of four squares. Recall that i \u22c6A denotes positional scaling by i (operation E5) on the sequence A. If (A,B) is a complex Golay pair then applying operation E5 to this pair k times shows that (ik \u22c6A,ik \u22c6B) is also a complex Golay pair. By using Lemma 2.11 on these complex Golay pairs one obtains the fact that 2n can be decomposed as the sum of four integer squares as resum(ik \u22c6A)2 +imsum(ik \u22c6A)2 +resum(ik \u22c6B)2 +imsum(ik \u22c6B)2. For k > 3 this produces no new decompositions but in general for k = 0, 1, 2, and 3 this produces four distinct decompositions of 2n into a sum of four squares. With the help of a computer algebra system (CAS) one can enumerate every possible way that 2n may be written as a sum of four integer squares. For example, whenn = 23 one has 02+12+32+62 = 2 \u00b7 23 and 12 +22 +42 +52 = 2 \u00b7 23 as well as all permutations of the squares and negations of the integers being squared. During the \ufb01rst stage of our enumeration method only the \ufb01rst sequence of a complex Golay pair is known, so at that stage we cannot compute its whole sums-of-squares decomposition. However, it is still possible to \ufb01lter some sequences from consideration based on analyzing the two known terms in the sums-of-squares decomposition. For example, say that A is the \ufb01rst sequence in a potential complex Golay pair of length 23 with resum(A) = 0 and imsum(A) = 5. We can immediately discard A from consideration because there is no way to chose the resum and imsum of B to complete the sumsof-squares decomposition of 2n, i.e., there are no integer solutions (x,y) of 02 + 52 + x2 + y2 = 2n. 3 ENUMERATION METHOD In this section we describe in detail the method we used to perform a complete enumeration of all complex Golay pairs up to length 25. Given a length n our goal is to \ufb01nd all {\u00b11, \u00b1i} sequences A and B of length n such that (A, B) is a complex Golay pair. 3.1 Preprocessing: Enumerate possibilities for Aeven and Aodd The \ufb01rst step of our method uses Fiedler\u2019s trick of considering the entries ofA of even index separately from the entries of A of odd index. There are approximately n/2 nonzero entries in each of Aeven and Aodd and there are four possible values for each nonzero entry. Therefore there are approximately 2 \u00b7 4n/2 = 2n+1 possible sequences to check in this step. Additionally, by Lemma 2.12 we may assume the \ufb01rst nonzero entry of both Aeven and Aodd is 1 and that the second nonzero entry of Aeven is not \u2212i, decreasing the number of sequences to check in this step by more than a factor of 4. It is quite feasible to perform a brute-force search through all such sequences when n \u224830. \fISSAC \u201918, July 16\u201319, 2018, New York, NY, USA Curtis Bright, Ilias Kotsireas, Albert Heinle, and Vijay Ganesh We apply Corollary 2.10 to every possibility for Aeven and Aodd. There are an in\ufb01nite number of possible z \u2208C with |z| = 1, so we do not attempt to apply Corollary 2.10 using all such z. Instead we try a su\ufb03ciently large number of z so that in the majority of cases for which a z exists with |hA\u2032(z)|2 > 2n (where A\u2032 is either Aeven or Aodd) we in fact \ufb01nd such a z. In our implementation we chose to take z to be e2\u03c0ij/N where N \u2254214 and j = 0, . . . , N \u22121. At the conclusion of this step we will have two lists: one list Leven of the Aeven which were not discarded and one list Lodd of the Aodd which were not discarded. 3.2 Stage 1: Enumerate possibilities for A We now enumerate all possibilities forA by joining the possibilities for Aeven with the possibilities for Aodd. For each A1 \u2208Lodd and A2 \u2208Leven we form the sequence A by letting the kth entry of A be either the kth entry of A1 or A2 (whichever is nonzero). Thus the entries of A are either \u00b11 or \u00b1i and therefore A is a valid candidate for the \ufb01rst sequence of a complex Golay pair of length n. At this stage we now use the \ufb01ltering result of Corollary 2.8 and the sums-of-squares decomposition result of Lemma 2.11 to perform more extensive \ufb01ltering on the sequences A which we formed above. In detail, our next \ufb01ltering check proceeds as follows: Let Rk \u2254resum(ik \u22c6A) and Ik \u2254imsum(ik \u22c6A). By using a Diophantine equation solver we check if the Diophantine equations R2 k + I2 k + x2 + y2 = 2n are solvable in integers (x,y) for k = 0, 1, 2, 3. As explained in Section 2.3, if any of these equations have no solutions then A cannot be a member of a complex Golay pair and can be ignored. Secondly, we use Corollary 2.8 with z chosen to be e2\u03c0ij/N for j = 0, . . . , N \u22121 where N \u225427 (we use a smaller value of N than in the preprocessing step because in this case there are a larger number of sequences which we need to apply the \ufb01ltering condition on). If A passes both \ufb01ltering conditions then we add it to a list LA and try the next value of A until no more possibilities remain. At the conclusion of this stage we will have a list of sequences LA which could potentially be a member of a complex Golay pair. By construction, the \ufb01rst member of all complex Golay pairs (up to the equivalence described in Lemma 2.12) of length n will be in LA. 3.3 Stage 2: Construct the second sequence B from A In the second stage we take as input the list LA generated in the \ufb01rst stage, i.e., a list of the sequences A that were not \ufb01ltered by any of the \ufb01ltering theorems we applied. For each A \u2208LA we attempt to construct a second sequence B such that (A, B) is a complex Golay pair. We do this by generating a SAT instance which encodes the property of (A,B) being a complex Golay pair where the entries of A are known and the entries of B are unknown and encoded using Boolean variables. Because there are four possible values for each entry of B we use two Boolean variables to encode each entry. Although the exact encoding used is arbitrary, we \ufb01xed the following encoding in our implementation, where the variables v2k and v2k+1 represent bk, the kth entry of B: v2k v2k+1 bk F F 1 F T \u22121 T F i T T \u2212i To encode the property that (A, B) is a complex Golay pair in out SAT instance we add the conditions which de\ufb01ne (A, B) to be a complex Golay pair, i.e., NA(s) + NB(s) = 0 for s = 1, . . . ,n \u22121. These equations could be encoded using clauses in conjunctive normal form (for example by constructing logical circuits to perform complex multiplication and addition and then converting those circuits into CNF clauses). However, we found that a much more e\ufb03cient and convenient method was to use a programmatic SAT solver. The concept of a programmatic SAT solver was \ufb01rst introduced in [15] where a programmatic SAT solver was shown to be more ef\ufb01cient than a standard SAT solver when solving instances derived from RNA folding problems. More recently, a programmatic SAT solver was also shown to be useful when searching for Williamson matrices [5]. Generally, programmatic SAT solvers perform well when there is domain-speci\ufb01c knowledge about the problem being solved that cannot easily be encoded into SAT instances directly but can be used to learn facts about potential solutions which can help guide the solver in its search. Concretely, a programmatic SAT solver is compiled with a piece of code which encodes a property that a solution of the SAT instance must satisfy. Periodically the SAT solver will run this code while performing its search and if the current partial assignment violates a property that is expressed in the provided code then a con\ufb02ict clause is generated encoding this fact. The con\ufb02ict clause is added to the SAT solver\u2019s database of learned clauses where it is used to increase the e\ufb03ciency of the remainder of the search. The reason these clauses can be so useful is because they can encode facts which the SAT solver would have no way of learning otherwise, since the SAT solver has no knowledge of the domain of the problem. Not only does this paradigm allow the SAT solver to perform its search more e\ufb03ciently, it also allows instances to be much more expressive. Under this framework SAT instances do not have to consist solely of Boolean formulas in conjunctive normal form (the typical format of SAT instances) but can consist of clauses in conjunctive normal form combined with a piece of code that programmatically expresses clauses. This extra expressiveness is also a feature of SMT solvers, though SMT solvers typically require more overhead to use. Additionally, one can compile instance-speci\ufb01c programmatic SAT solvers which are tailored to perform searches for a speci\ufb01c class of problems. For our purposes we use a programmatic SAT solver tailored to search for sequences B that when paired with a given sequence A form a complex Golay pair. Each instance will contain the 2n variablesv0, . . . ,v2n\u22121 that encode the entries of B as previously speci\ufb01ed. In detail, the code given to the SAT solver does the following: (1) Compute and store the values NA(k) for k = 1, . . . , n \u22121. \fEnumeration of Complex Golay Pairs via Programmatic SAT ISSAC \u201918, July 16\u201319, 2018, New York, NY, USA (2) Initialize s to n \u22121. This will be a variable which controls which autocorrelation condition we are currently examining. (3) Examine the current partial assignment tov0,v1,v2n\u22122, and v2n\u22121. If all these values have been assigned then we can determine the values of b0 and bn\u22121. From these values we compute NB(s) = b0bn\u22121. If NA(s) + NB(s) , 0 then (A,B) cannot be a complex Golay pair (regardless of the values of b1, . . . , bn\u22122) and therefore we learn a con\ufb02ict clause which says that b0 and bn\u22121 cannot both be assigned to their current values. More explicitly, if vcur k represents the literal vk when vk is currently assigned to true and the literal \u00acvk when vk is currently assigned to false we learn the clause \u00ac(vcur 0 \u2227vcur 1 \u2227vcur 2n\u22122 \u2227vcur 2n\u22121). (4) Decrement s by 1 and repeat the previous step, computing NB(s) if the all the bk which appear in its de\ufb01nition have known values. If NA(s) + NB(s) , 0 then learn a clause preventing the values of bk which appear in the de\ufb01nition of NB(s) from being assigned the way that they currently are. Continue to repeat this step until s = 0. (5) If all values of B are assigned but no clauses have been learned then output the complex Golay pair (A,B). If an exhaustive search is desired, learn a clause which prevents the values of B from being assigned the way they currently are; otherwise learn nothing and return control to the SAT solver. For each A in the list LA from stage 1 we run a SAT solver with the above programmatic code; the list of all outputs (A, B) in step (5) shown above now form a complete list of complex Golay pairs of length n up to the equivalence given in Lemma 2.12. In fact, since Lemma 2.12 says that we can set b0 = 1 we can assume that both v0 and v1 are always set to false. In other words, we can add the two clauses \u00acv0 and \u00acv1 into our SAT instance without omitting any complex Golay pairs up to equivalence. 3.4 Postprocessing: Enumerating all complex Golay pairs At the conclusion of the second stage we have obtained a list of complex Golay pairs of length n such that every complex Golay pair of length n is equivalent to some pair in our list. However, because we have not accounted for all the equivalences in Section 2.1 some pairs in our list may be equivalent to each other. In some sense such pairs should not actually be considered distinct, so to count how many distinct complex Golay pairs exist in length n we would like to \ufb01nd and remove pairs which are equivalent from the list. Additionally, to verify the counts given in [16] it is necessary to produce a list which contains all complex Golay pairs. We now describe an algorithm which does both, i.e., it produces a list of all complex Golay pairs as well as a list of all inequivalent complex Golay pairs. In detail, our algorithm performs the following steps: (1) Initialize \u2126all to be the set of complex Golay pairs generated in stage 2. This variable will be a set that will be populated with and eventually contain all complex Golay pairs of length n. (2) Initialize \u2126inequiv to be the empty set. This variable will be a set that will be populated with and eventually contain all inequivalent complex Golay pairs of length n. (3) For each (A, B) in \u2126all: (a) If (A, B) is already in \u2126inequiv then skip this (A, B) and proceed to the next pair (A, B) in \u2126all. (b) Initialize \u0393 to be the set containing (A, B). This variable will be a set that will be populated with and eventually contain all complex Golay pairs equivalent to (A, B). (c) For every \u03b3 in \u0393 add E1(\u03b3), . . . , E5(\u03b3) to \u0393. Continue to do this until every pair in \u0393 has been examined and no new pairs are added to \u0393. (d) Add (A, B) to \u2126inequiv and add all pairs in \u0393 to \u2126all. After running this algorithm listing the members of \u2126all gives a list of all complex Golay pairs of length n and listing the members of \u2126inequiv gives a list of all inequivalent complex Golay pairs of length n. At this point we can also construct the complete list of sequences which appear in any complex Golay pair of length n. To do this it su\ufb03ces to add A and B to a new set \u2126seqs for each (A,B) \u2208\u2126all. 3.5 Optimizations Although the method described will correctly enumerate all complex Golay pairs of a given length n, for the bene\ufb01t of potential implementors we mention a few optimizations which we found helpful. In stage 1 we check if Diophantine equations of the form R2 + I2 + x2 + y2 = 2n (\u2217) are solvable in integers (x,y) where R and I are given. CAS functions like PowersRepresentations in Mathematica or nsoks in Maple [30] can determine all ways of writing 2n as a sum of four integer squares. From this information we construct a Boolean two dimensional array D such that D |R |, |I | is true if and only if (\u2217) has a solution, making the check for solvability a fast lookup. In fact, one need only construct the lookup table for R and I with R +I \u2261n (mod 2) as the following lemma shows. Lemma 3.1. Suppose R and I are the resum and imsum of a sequence X \u2208{\u00b11, \u00b1i}n. Then R + I \u2261n (mod 2). Proof. Let #c denote the number of entries in X with value c. Then R + I = (#1 \u2212#\u22121) + (#i \u2212#\u2212i) \u2261#1 + #\u22121 + #i + #\u2212i (mod 2) since \u22121 \u22611 (mod 2). The quantity on the right is n since there are n entries in X. \u25a1 In stage 1 we check if |hA(z)|2 > 2n where z = e2\u03c0ij/N for j = 0, . . . , N \u22121 with N = 27. However, we found that it was more e\ufb03cient to not check the condition for each j in ascending order (i.e., for eachz in ascending complex argument) but to \ufb01rst perform the check on points z with larger spacing between them. In our implementation we \ufb01rst assigned N to be 23 and performed the check for odd j = 1, 3, . . . , N \u22121. Following this we doubled N and again performedthe check for odd j, proceeding in this matter until all pointsz had been checked. (This ignores checking the condition when z = ik for some k but that is desirable since in those cases \fISSAC \u201918, July 16\u201319, 2018, New York, NY, USA Curtis Bright, Ilias Kotsireas, Albert Heinle, and Vijay Ganesh |hA(ik)|2 = resum(ik \u22c6A)2 + imsum(ik \u22c6A)2 and the sums-ofsquares condition is a strictly stronger \ufb01ltering method.) In the preprocessing step and stage 1 it is necessary to evaluate the Hall polynomial hA\u2032 or hA at roots of unity z = e2\u03c0ij/N and determine its squared absolute value. The fastest way we found of doing this used the discrete Fourier transform. For example, let A\u2032 be the sequence Aeven, Aodd, or A under consideration but padded with trailing zeros so that A\u2032 is of length N . By de\ufb01nition of the discrete Fourier transform we have that DFT(A\u2032) = h hA\u2032\u0000e2\u03c0ij/N \u0001iN \u22121 j=0 . Thus, we determine the values of |hA\u2032(z)|2 by taking the squared absolute values of the entries of DFT(A\u2032). If |hA\u2032(z)|2 > 2n for some z then by Corollary 2.8 or Corollary 2.10 we can discard A\u2032 from consideration. To guard against potential inaccuracies introduced by the algorithms used to compute the DFT we actually ensure that |hA\u2032(z)|2 > 2n + \u03f5 for some tolerance \u03f5 which is small but larger than the accuracy that the DFT is computed to (e.g., \u03f5 = 10\u22123). In the preprocessing step before setting N \u2254214 we \ufb01rst set N \u2254n and perform the rest of the step as given. The advantage of \ufb01rst performing the check with a smaller value of N is that the discrete Fourier transform of A\u2032 can be computed faster. Although the check with N = n is a less e\ufb00ective \ufb01lter, it often succeeds and whenever it does it allows us to save time by not performing the more costly longer DFT. In stage 1 our application of Corollary 2.8 requires computing |hA(z)|2 where z = e2\u03c0ij/N for j = 0, . . . , N \u22121. Noting that hA(z) = hAeven(z) + hAodd(z) one need only compute hAeven(z) and hAodd(z) for each each Aeven and Aodd generated in the preprocessing step and once those are known hA(z) can be found by a simple addition. In stage 2 one can also include properties that complex Golay sequences must satisfy in the code compiled with the programmatic SAT solver. As an example of this, we state the following proposition which was new to the authors and does not appear to have been previously published. Proposition 3.2. Let (A, B) be a complex Golay pair. Then akan\u2212k\u22121bkbn\u2212k\u22121 = \u00b11 for k = 0, . . . , n \u22121. To prove this, we use the following simple lemma. Lemma 3.3. Let ck \u2208Z4 for k = 0, . . . , n \u22121. Then n\u22121 \u00d5 k=0 ick = 0 implies n\u22121 \u00d5 k=0 ck \u22610 (mod 2). Proof. Let #c denote the number of ck with value c. Note that the sum on the left implies that #0 = #2 and #1 = #3 because the 1s must cancel with the \u22121s and the is must cancel with the \u2212is. Then \u00cdn\u22121 k=0 ck = #1 + 2#2 + 3#3 \u2261#1 + #3 \u22612#1 \u22610 (mod 2). \u25a1 We now prove Proposition 3.2. Proof. Let ck, dk \u2208Z4 be such that ak = ick and bk = idk . Using this notation the multiplicative equation from Proposition 3.2 Total CPU Time in hours n Preproc. Stage 1 Stage 2 17 0.00 0.01 0.06 18 0.01 0.03 0.23 19 0.01 0.07 0.18 20 0.02 0.35 0.43 21 0.04 1.93 1.89 22 0.08 9.58 1.11 23 0.15 42.01 3.02 24 0.32 81.42 5.23 25 0.57 681.31 20.51 Table 1: The time used to run the various stages of our algorithm in lengths 17 \u2264n \u226425. becomes the additive congruence ck + cn\u2212k\u22121 + dk + dn\u2212k\u22121 \u22610 (mod 2). (\u2217) Since (A, B) is a complex Golay pair, the autocorrelation equations give us n\u2212s\u22121 \u00d5 k=0 \u0010 ick\u2212ck+s + idk \u2212dk+s \u0011 = 0 for s = 1, . . . , n \u22121. Using Lemma 3.3 and the fact that \u22121 \u22611 (mod 2) gives n\u2212s\u22121 \u00d5 k=0 \u0000ck + ck+s + dk + dk+s \u0001 \u22610 (mod 2) for s = 1, . . . , n \u22121. With s = n \u22121 one immediately derives (\u2217) for k = 0. With s = n \u22122 and (\u2217) for k = 0 one derives (\u2217) for k = 1. Working inductively in this manner one derives (\u2217) for all k. \u25a1 In short, Proposition 3.2 tells us that an even number of ak, an\u2212k\u22121, bk, and bn\u2212k\u22121 are real for each k = 0, . . . , n \u22121. For example, if exactly one of ak and an\u2212k\u22121 is real then exactly one ofbk andbn\u2212k\u22121 must also be real. In this case, using our encoding from Section 3.3 we can add the clauses (v2k \u2228v2(n\u2212k\u22121)) \u2227(\u00acv2k \u2228\u00acv2(n\u2212k\u22121)) to our SAT instance. These clauses say that exactly one of v2k and v2(n\u2212k\u22121) is true. 4 RESULTS In order to provide a veri\ufb01cation of the counts from [16] we implemented the enumeration method described in Section 3. The preprocessing step was performed by a C program and used the mathematical library FFTW [14] for computing the values ofhA\u2032(z) as described in Section 3.5. Stage 1 was performed by a C++ program, used FFTW for computing the values of hA(z) and a Maple script [30] for determining the solvability of the Diophantine equations given in Section 3.3. Stage 2 was performed by the programmatic SAT solver MapleSAT [24]. The postprocessing step was performed by a Python script. We ran our implementation on a cluster of machines running CentOS 7 and using Intel Xeon E5-2683V4 processors running at 2.1 GHz and using at most 300MB of RAM. To parallelize the work in each length n we split Lodd into 25 pieces and used 25 cores to \fEnumeration of Complex Golay Pairs via Programmatic SAT ISSAC \u201918, July 16\u201319, 2018, New York, NY, USA n |Leven| |Lodd| |LA| 1 1 \u2212 1 2 3 1 3 3 3 1 1 4 3 4 3 5 12 4 5 6 12 16 14 7 39 16 12 8 48 64 36 9 153 64 44 10 153 204 120 11 561 252 101 12 645 860 465 13 2121 884 293 14 2463 3284 317 15 8340 3572 1793 16 9087 12116 923 17 31275 12824 3710 18 34560 46080 14353 19 117597 50944 10918 20 130215 173620 26869 21 446052 194004 116612 22 500478 667304 67349 23 1694865 732232 182989 24 1886568 2515424 313878 25 6447090 2727452 1211520 Table 2: The number of sequences Aeven, Aodd, and A that passed the \ufb01ltering conditions of our algorithm in lengths up to 25. complete stages 1 and 2 of the algorithm. Everything in the stages proceeded exactly as before except that in stage 1 the list Lodd was 25 times shorter than it would otherwise be, which allowed us to complete the \ufb01rst stages 20.7 times faster and the second stages 23.9 times faster. The timings for the preprocessing step and the two stages of our algorithm are given in Table 1; the timings for the postprocessing step were negligible. The times are given as the total amount of CPU time used across all 25 cores. Our code is available online as a part of the MathCheck project and we have also made available the resulting enumeration of complex Golay pairs [6]. The sizes of the lists Leven and Lodd computed in the preprocessing step and the size of the list LA computed in stage 1 are given in Table 2 for all lengths in which we completed a search. Without applying any \ufb01ltering LA would have size 4n so Table 2 demonstrates the power of the criteria we used to perform \ufb01ltering; typically far over 99.99% of possible sequences A are \ufb01ltered from LA. The generated SAT instances had 2n variables (encoding the entriesb0, . . . , bn\u22121), 2 unit clauses (encoding b0 = 1), 2\u230an/2\u230bbinary clauses (encoding Proposition 3.2), and n \u22121 programmatic clauses (encoding De\ufb01nition 2.2). Finally, we provide counts of the total number of complex Golay pairs of length n \u226425 in Table 3. The sizes of \u2126seqs and \u2126all match those from [16] in all cases and the size of \u2126inequiv matches those from [8] for n \u226419 (the largest length they exhaustively solved). n |\u2126seqs| |\u2126all| |\u2126inequiv| 1 4 16 1 2 16 64 1 3 16 128 1 4 64 512 2 5 64 512 1 6 256 2048 3 7 0 0 0 8 768 6656 17 9 0 0 0 10 1536 12288 20 11 64 512 1 12 4608 36864 52 13 64 512 1 14 0 0 0 15 0 0 0 16 13312 106496 204 17 0 0 0 18 3072 24576 24 19 0 0 0 20 26880 215040 340 21 0 0 0 22 1024 8192 12 23 0 0 0 24 98304 786432 1056 25 0 0 0 Table 3: The number complex Golay pairs in lengths up to 25. The table counts the number of individual sequences, the number of pairs, and the number of pairs up to equivalence. Because [8, 11, 16] do not provide implementations or timings for the enumerations they completed it is not possible for us to compare the e\ufb03ciency of our algorithm to previous algorithms. However, we note that the results in this paper did not require an exorbitant amount of computing resources. If one has access to 25 modern CPU cores then one can exhaustively enumerate all complex Golay pairs up to length 25 using our software in about a day and we estimate that increasing this to length 26 would take another week. We note that Fiedler\u2019s paper [11] enumerates complex Golay pairs to length 28. It is not clear whether this was accomplished using more computing resources or a more e\ufb03cient algorithm, though we note that the preprocessing and stage 1 of our method is similar to Fiedler\u2019s method with some di\ufb00erences in the \ufb01ltering theorems. 5 FUTURE WORK Besides increasing the length to which complex Golay pairs have been enumerated there are a number of avenues for improvements which could be made in future work. As one example, we remark that we have not exploited the algebraic structure of complex Golay pairs revealed by Craigen, Holzmann, and Kharaghani [8]. In particular, those authors prove a theorem which implies that if p \u22613 (mod 4) is a prime which divides n and A is a member of a complex Golay pair of length n then the polynomial hA is not irreducible over Fp(i). Ensuring that this property holds could be \fISSAC \u201918, July 16\u201319, 2018, New York, NY, USA Curtis Bright, Ilias Kotsireas, Albert Heinle, and Vijay Ganesh added to the \ufb01ltering conditions which were used in stage 1. In fact, the authors relate the factorization of hA over Fp(i) to the factorization of hB over Fp(i) for any complex Golay pair (A,B). This factorization could potentially be used to perform stage 2 more e\ufb03ciently, possibly supplementing or replacing the SAT solver entirely, though it is unclear if such a method would perform better than our method in practice. In any case, it would not be possible to apply their theorem in all lengths (for example when n is a power of 2). A second possible improvement could be to symbolically determine the value of z with |z| = 1 which maximizes |hA\u2032(z)|2 in the preprocessing step. Once this value of z is known then A\u2032 can be \ufb01ltered if |hA\u2032(z)|2 > 2n and if not then no other value of z needs to be tried. This would save evaluating hA\u2032(z) at the points z = e2\u03c0ij/N for j = 0, . . . , N \u22121 and would also increase the number of sequences which get \ufb01ltered. However, it is unclear if this method would be bene\ufb01cial in practice due to the overhead of maximizing |hA\u2032(z)|2 subject to |z| = 1. Another possible improvement could be obtained by deriving further properties like Proposition 3.2 that complex Golay pairs must satisfy. We have performed some preliminary searches for such properties; for example, consider the following propertywhich could be viewed as a strengthening of Proposition 3.2: akan\u2212k\u22121 = (\u22121)n+1bkbn\u2212k\u22121 for k = 1, . . . , n \u22122. An examination of all complex Golay pairs up to length 25 reveals that they all satisfy this property except for a single complex Golay pair up to equivalence. The only pair which doesn\u2019t satisfy this property is equivalent to \u0000[1, 1, 1, \u22121, 1, 1, \u22121, 1], [1,i,i, \u22121, 1, \u2212i, \u2212i, \u22121]\u0001 and was already singled out in [13] for being special as the only known example of what they call a \u201ccross-over\u201d Golay sequence pair. Since a counterexample exists to this property there is no hope of proving it in general, but perhaps a suitable generalization could be proven. ACKNOWLEDGEMENTS This work was made possible by the facilities of the Shared Hierarchical Academic Research Computing Network (SHARCNET) and Compute/Calcul Canada. The authors would also like to thank the anonymous reviewers whose comments improved this article\u2019s clarity."
+                },
+                {
+                    "url": "http://arxiv.org/abs/1804.01172v2",
+                    "title": "Applying Computer Algebra Systems with SAT Solvers to the Williamson Conjecture",
+                    "abstract": "We employ tools from the fields of symbolic computation and satisfiability\nchecking---namely, computer algebra systems and SAT solvers---to study the\nWilliamson conjecture from combinatorial design theory and increase the bounds\nto which Williamson matrices have been enumerated. In particular, we completely\nenumerate all Williamson matrices of even order up to and including 70 which\ngives us deeper insight into the behaviour and distribution of Williamson\nmatrices. We find that, in contrast to the case when the order is odd,\nWilliamson matrices of even order are quite plentiful and exist in every even\norder up to and including 70. As a consequence of this and a new construction\nfor 8-Williamson matrices we construct 8-Williamson matrices in all odd orders\nup to and including 35. We additionally enumerate all Williamson matrices whose\norders are divisible by 3 and less than 70, finding one previously unknown set\nof Williamson matrices of order 63.",
+                    "authors": "Curtis Bright, Ilias Kotsireas, Vijay Ganesh",
+                    "published": "2018-04-03",
+                    "updated": "2019-05-14",
+                    "primary_cat": "cs.LO",
+                    "cats": [
+                        "cs.LO",
+                        "cs.SC",
+                        "math.CO"
+                    ],
+                    "main_content": "Introduction In recent years SAT solvers have been used to solve or make progress on mathematical conjectures which have otherwise resisted solution from some of the world\u2019s best mathematicians. Some prominent problems which \ufb01t into this trend include the Erd\u02dd os discrepancy conjecture, which was open for 80 years and had a special case solved by Konev and Lisitsa (2014); the Ruskey\u2013Savage conjecture, which has been open for 25 years and had a special case solved by Zulkoski et al. (2015); the Boolean Pythagorean triples problem, which was open for 30 years and solved by Heule et al. (2016); and the determination of the \ufb01fth Schur number, which was open for 100 years and solved by Heule (2018). Although these are problems which arise in completely separate \ufb01elds and have no obvious connection to propositional satis\ufb01ability checking, nevertheless SAT solvers were found to be extremely effective at pushing the state-of-the-art and sometimes absolutely crucial in the problem\u2019s ultimate solution. In this paper we apply a SAT solver to the Williamson conjecture from combinatorial design theory. Our work is similar in spirit to the aforementioned works but we would like to highlight two main differences. Firstly, we employ an approach inspired by SMT To appear in the Journal of Symbolic Computation March 15, 2019 arXiv:1804.01172v2  [cs.LO]  14 May 2019 \f(SAT modulo theories) solvers and use a SAT solver that is able to learn con\ufb02ict clauses through a piece of code speci\ufb01cally tailored to the problem domain. This code encodes domain-speci\ufb01c knowledge that an off-the-shelf SAT solver would otherwise not be able to exploit. This framework is not limited to any speci\ufb01c domain; any external library or function can be used as long as it is callable by the SAT solver. As we will see in Section 3, the clauses that are learned in this fashion can enormously cut down the search space as well as the solver\u2019s runtime. Secondly, similar in style to (Zulkoski et al., 2015) we incorporate functionality from computer algebra systems to increase the ef\ufb01ciency of the search in what we call the \u201cSAT+CAS\u201d paradigm. This approach of combining computer algebra systems with SAT or SMT solvers was also independently proposed at the conference ISSAC by \u00c1brah\u00e1m (2015). More recently, it has been argued by the SC2 project (\u00c1brah\u00e1m et al., 2016) that the \ufb01elds of satis\ufb01ability checking and symbolic computation are complementary and combining the tools of both \ufb01elds (i.e., SAT solvers and computer algebra systems) in the right way can solve problems more ef\ufb01ciently than could be done by applying the tools of either \ufb01eld in isolation, and our work provides evidence for this view. We describe the Williamson conjecture, its history, and state the necessary properties of Williamson matrices that we require in Section 2. In particular, we derive a new version of Williamson\u2019s product theorem that applies to Williamson matrices of even order (Theorem 15). We give an overview of the SAT+CAS paradigm in Section 3, describe our SAT+CAS method in Section 4, and give a summary of our results in Section 5. The present work is an extension of our previous work (Bright et al., 2018a) that enumerated Williamson matrices of even order up to order 64. The present work extends this enumeration to order 70 and extends the method to enumerate Williamson matrices with orders divisible by 3. In doing so, we \ufb01nd a previously undiscovered set of Williamson matrices of order 63, the \ufb01rst new set of Williamson matrices of odd order discovered since one of order 43 was found over ten years ago by Holzmann et al. (2008). Additionally, we improve our treatment of equivalence checking (see Section 4.6), identify a new equivalence operation that applies to Williamson matrices of even order (see Section 2.2), derive a new doubling construction for Williamson matrices (Theorem 17), and a new construction for 8-Williamson matrices (Theorem 18). Using this construction we construct 8-Williamson matrices in all odd orders n \u2264 35, improving on the result of Kotsireas and Koukouvinos (2009) that constructed 8-Williamson matrices in all odd orders n \u226429. Finally, in Section 6 we use our experience developing systems that combine SAT solvers with computer algebra systems to give some guidelines about the kind of problems for which an approach is likely to be effective. 2. The Williamson conjecture Williamson (1944) introduced the matrices which now bear his name (see Section 2.1) while developing a method of constructing Hadamard matrices. Hadamard matrices are square matrices with \u00b11 entries and pairwise orthogonal rows; they have a long history and many applications such as to error-correcting codes (Bose and Shrikhande, 1959). The Hadamard conjecture states that Hadamard matrices exist 2 \ffor all orders divisible by 4. Williamson\u2019s construction has been extensively used to construct Hadamard matrices in many different orders and the Williamson conjecture states that it can be used to construct a Hadamard matrix of any order divisible by 4; Turyn (1972) states it as follows: Only a \ufb01nite number of Hadamard matrices of Williamson type are known so far; it has been conjectured that one such exists of any order 4t. Williamson matrices have also found use in digital communication systems and this motivated mathematicians from NASA\u2019s Jet Propulsion Laboratory to construct Williamson matrices of order 23 while developing codes allowing the transmission of signals over a long range (Baumert et al., 1962). These Williamson matrices were consequently used to construct a Hadamard matrix of order 4 \u00b7 23 = 92 (Cooper, 2013). (In some older works the Hadamard matrix constructed in this way was itself referred to as a Williamson matrix but we follow modern convention and do not use this terminology.) Williamson matrices are also studied for their elegant mathematical properties and their relationship to other mathematical conjectures (Schmidt, 1999). Although Williamson de\ufb01ned his matrices for both even and odd orders, most subsequent work has focused on the odd case. A complete enumeration of Williamson matrices was completed for all odd orders up to 23 by Baumert and Hall (1965). A enumeration in orders 25 and 27 was completed by Sawade (1977) but this enumeration was later found to be incomplete by \u00d0okovi\u00b4 c (1995), who gave a complete enumeration in the order 25 as well as (in a previous paper) the orders 29 and 31 (\u00d0okovi\u00b4 c, 1992). The orders 33 and 39 were claimed to be completely enumerated by Koukouvinos and Kounias (1988, 1990) but these searches were demonstrated to be incomplete when a complete enumeration of the orders 33, 35, and 39 was completed by \u00d0okovi\u00b4 c (1993). Most recently, all odd orders up to 59 were enumerated by Holzmann et al. (2008) and the order 61 was enumerated by Lang and Schneider (2012). Historically, less attention was paid to the even order cases, although generalizations of Williamson matrices were explicitly constructed in even orders by Wallis (1974) as well as Agayan and Sarukhanyan (1981). Williamson matrices were constructed in all even orders up to 22 by Kotsireas and Koukouvinos (2006), up to 34 by Bright et al. (2016), and up to 42 by Zulkoski et al. (2017). Kotsireas and Koukouvinos (2006) provided a exhaustive search up to order 18 but otherwise these works did not contain a complete enumerations. A complete enumeration in the even orders up to 44 was given by Bright (2017) and this was extended to order 64 by Bright et al. (2018a). One reason why more attention has traditionally been given to the odd order case is due to the fact that if it was possible to construct Williamson matrices in all odd orders this would resolve the Hadamard conjecture. On the other hand, constructing Williamson matrices in all even orders would not resolve the Hadamard conjecture because Hadamard matrices constructed using Williamson matrices of even order have orders which are divisible by 8. However, it is still not even known if Hadamard matrices exist for all orders divisible by 8, so nevertheless studying Williamson matrices of even order has the potential to shed light on the Hadamard conjecture as well. The Williamson conjecture was shown to be false by \u00d0okovi\u00b4 c (1993) who showed that such matrices do not exist in order 35. Later, when an enumeration of Williamson matrices for odd orders n < 60 was completed (Holzmann et al., 2008) it was found that 3 \fWilliamson matrices also do not exist for orders 47, 53, and 59 but exist for all other odd orders under 65 since Turyn\u2019s construction (Turyn, 1972) works in orders 61 and 63. In this paper we provide for the \ufb01rst time a complete enumeration of Williamson matrices in the orders 63, 66, 68, 69, and 70. In particular, we show that Williamson matrices exist in every even order up to 70. This leads us to state what we call the even Williamson conjecture: Conjecture 1. Williamson matrices exist in every even order. The fact that Williamson matrices of even order turn out to be somewhat plentiful gives some evidence for the truth of Conjecture 1. Though we do not know how to prove Conjecture 1 our enumeration could potentially uncover structure in Williamson matrices which might then be exploited in a proof of the conjecture. Additionally, we point out that the existence of Williamson matrices of order 70 = 2 \u00b7 35 is especially interesting since 35 is the smallest order for which Williamson matrices do not exist. Using complex Hadamard matrices, Turyn (1970) showed the existence of Williamson matrices of odd order n implies the existence of Williamson matrices of orders 2kn for k = 1, 2, 3, 4. Since Williamson matrices exist for all odd orders n < 35 Turyn\u2019s result implies that Williamson matrices exist for all even orders strictly less than 70. Since Williamson matrices of order 35 do not exist Turyn\u2019s result cannot be used to show the existence of Williamson matrices of order 70; the question of existence in order 70 was open until this paper. We also determine that there are exactly two sets of Williamson matrices (up to the equivalence given in Section 2.2) of order 63. One of these falls under the aforementioned construction given by Turyn (1972) while the other is new and is the \ufb01rst newly discovered set of Williamson matrices in an odd order since one was found using an exhaustive search in order 43 by Holzmann et al. (2008). In order 69 our enumeration method produced just one set of Williamson matrices and that set falls under the construction given by Turyn. 2.1. Williamson matrices and sequences We now give the background on Williamson matrices and their properties that are necessary to understand the remainder of the paper. The de\ufb01nition of Williamson matrices is motivated by the following theorem used for constructing Hadamard matrices by Williamson (1944). Theorem 2. Let n \u2208N and let A, B, C, D \u2208{\u00b11}n\u00d7n. Further, suppose that 1. A, B, C, and D are symmetric; 2. A, B, C, and D commute pairwise (i.e., AB = BA, AC = CA, etc.); 3. A2 + B2 + C2 + D2 = 4nIn, where In is the identity matrix of order n. Then \uf8ee \uf8ef \uf8ef \uf8ef \uf8ef \uf8ef \uf8ef \uf8ef \uf8ef \uf8ef \uf8ef \uf8ef \uf8ef \uf8f0 A B C D \u2212B A \u2212D C \u2212C D A \u2212B \u2212D \u2212C B A \uf8f9 \uf8fa \uf8fa \uf8fa \uf8fa \uf8fa \uf8fa \uf8fa \uf8fa \uf8fa \uf8fa \uf8fa \uf8fa \uf8fb is a Hadamard matrix of order 4n. 4 \fTo make the search for such matrices more tractable, and in particular to make condition 2 trivial, Williamson also required the matrices A, B, C, D to be circulant matrices, as de\ufb01ned below. De\ufb01nition 3. An n \u00d7 n matrix A = (ai j) is circulant if ai j = a0,(j\u2212i) mod n for all i and j \u2208{0, . . . , n \u22121}. Circulant matrices A, B, C, D which satisfy the conditions of Theorem 2 are known as a quadruple of Williamson matrices in honour of Williamson. Since Williamson matrices are circulant they are de\ufb01ned in terms of their \ufb01rst row [x0, . . . , xn\u22121] and since they are symmetric this row must be a symmetric sequence, i.e., satisfy xi = xn\u2212i for 1 \u2264i < n. Given these facts, it is often convenient to work in terms of sequences rather than matrices. When working with sequences in this context the following function becomes very useful. De\ufb01nition 4. The periodic autocorrelation function of the sequence A = [a0, . . . , an\u22121] is the function given by PAFA(s) B n\u22121 X k=0 aka(k+s) mod n. We also use PAFA to refer to a sequence containing the values of the above function (which has period n), i.e., PAFA B \u0002PAFA(0), . . . , PAFA(n \u22121)\u0003. This function allows us to easily give a de\ufb01nition of Williamson matrices in terms of sequences. De\ufb01nition 5. Four symmetric sequences A, B, C, D \u2208{\u00b11}n are called a Williamson sequence quadruple (or simply Williamson sequences) if they satisfy PAFA(s) + PAFB(s) + PAFC(s) + PAFD(s) = 0 for s = 1, . . . , \u230an/2\u230b. It is straightforward to see that there is an equivalence between such sequences and Williamson matrices (Bright et al., 2016, \u00a73.2) because the \ufb01rst row of the matrix A2 is exactly the sequence PAFA. Therefore, for the remainder of this paper we will work directly with these sequences instead of Williamson matrices. 2.2. Williamson equivalences Given a Williamson sequence quadruple A, B, C, D of order n there are \ufb01ve types of invertible operations which can be applied to produce another set of Williamson sequences, though two of the operations only apply when n is even. These operations allow us to de\ufb01ne equivalence classes of sets of Williamson sequences. If a single Williamson sequence quadruple is known it is straightforward to generate all sets of Williamson sequences in the same equivalence class, so it suf\ufb01ces to search for Williamson sequences up to these equivalence operations. 5 \fE1. (Reorder) Reorder the sequences A, B, C, D in any way. E2. (Negate) Negate all the entries of any of A, B, C, or D. E3. (Shift) If n is even, cyclically shift all the entries in any of A, B, C, or D by an offset of n/2. E4. (Permute entries) Apply an automorphism of the cyclic group Cn to all the indices of the entries of each of A, B, C, and D simultaneously. E5. (Alternating negation) If n is even, negate every second entry in each of A, B, C, and D simultaneously. These equivalence operations are well known (Holzmann et al., 2008) except for the shift and alternating negation operations which have not traditionally been used because they only apply when n is even. In fact, they were overlooked until a careful examination of the sequences produced by our enumeration method. 2.3. Fourier analysis We now give an alternative de\ufb01nition of Williamson sequences using concepts from Fourier analysis. First, we de\ufb01ne the power spectral density of a sequence. De\ufb01nition 6. The power spectral density of the sequence A = [a0, . . . , an\u22121] is the function PSDA(s) B \f \f \fDFTA(s) \f \f \f2 where DFTA is the discrete Fourier transform of A, i.e., DFTA(s) B Pn\u22121 k=0 ake2\u03c0iks/n. Equivalently, we may also consider the power spectral density to be a sequence containing the values of the above function, i.e., PSDA B \u0002PSDA(0), . . . , PSDA(n \u22121)\u0003. It now follows by (\u00d0okovi\u00b4 c and Kotsireas, 2015, Theorem 2) that Williamson sequences have the following alternative de\ufb01nition. Theorem 7. Four symmetric sequences A, B, C, D \u2208{\u00b11}n are Williamson sequences if and only if PSDA(s) + PSDB(s) + PSDC(s) + PSDD(s) = 4n (\u2217) for s = 0, . . . , \u230an/2\u230b. Corollary 8. If PSDA(s) > 4n for any value s then A cannot be part of a Williamson sequence. Proof. Since PSD values are nonnegative, if PSDA(s) > 4n then the relationship (\u2217) cannot hold and thus A cannot be part of a Williamson sequence. Similarly, one can extend this so-called PSD test in Corollary 8 to apply to more than one sequence at a time. Corollary 9. If PSDA(s) + PSDB(s) > 4n for any value of s then A and B do not occur together in a Williamson sequence and if PSDA(s) + PSDB(s) + PSDC(s) > 4n for any value of s then A, B, and C do not occur together in a Williamson sequence. 6 \fAdditionally, a quadruple of sequences A, B, C, D that are not Williamson must necessarily fail the PSD test for some value of s. Corollary 10. If four sequences A, B, C, D \u2208{\u00b11}n are not Williamson sequences then PSDA(s) + PSDB(s) + PSDC(s) + PSDD(s) > 4n for some s. Proof. By Parseval\u2019s theorem the average value of PSDA(s) + PSDB(s) + PSDC(s) + PSDD(s) for s = {0, . . . , n \u22121} is 4n. Thus either this sum is the constant 4n (in which case the sequences are Williamson) or there is some s for which this sum is larger than 4n. 2.4. Compression As in the work by \u00d0okovi\u00b4 c and Kotsireas (2015) we now introduce the notion of compression. De\ufb01nition 11. Let A = [a0, a1, . . . , an\u22121] be a sequence of length n = dm and set a(d) j = aj + aj+d + \u00b7 \u00b7 \u00b7 + a j+(m\u22121)d, j = 0, . . . , d \u22121. Then we say that the sequence A(d) = [a(d) 0 , a(d) 1 , . . . , a(d) d\u22121] is the m-compression of A. From (\u00d0okovi\u00b4 c and Kotsireas, 2015, Theorem 3) we have the following result. Theorem 12. If A, B, C, D are Williamson sequences of order n then PAFA\u2032 + PAFB\u2032 + PAFC\u2032 + PAFD\u2032 = [4n, 0, . . . , 0] and PSDA\u2032 + PSDB\u2032 + PSDC\u2032 + PSDD\u2032 = [4n, . . . , 4n] for any compression A\u2032, B\u2032, C\u2032, D\u2032 of that set of Williamson sequences. Corollary 13. If A, B, C, D are Williamson sequences of order n then R2 A + R2 B + R2 C + R2 D = 4n (\u2217\u2217) where RX denotes the rowsum of X. Proof. Let X\u2032 be the n-compression of X \u2208{\u00b11}n, i.e., X\u2032 is a sequence with one entry whose value is RX. Note that PSDX\u2032 = [R2 X], so the result follows by Theorem 12. 2.5. Williamson\u2019s product theorem Williamson (1944) proved the following theorem: Theorem 14. If A, B, C, D are Williamson sequences of odd order n then aibicidi = \u2212a0b0c0d0 for 1 \u2264i < n/2. We prove a version of this theorem for even n: 7 \fTheorem 15. If A, B, C, D are Williamson sequences of even order n = 2m then aibicidi = ai+mbi+mci+mdi+m for 0 \u2264i < m. Although this theorem is not an essential part of our algorithm it improves its ef\ufb01ciency by allowing us to cut down the size of the search space. Our algorithm uses the theorem in the following form: Corollary 16. If A\u2032, B\u2032, C\u2032, D\u2032 are the 2-compressions of a set of Williamson sequences then A\u2032 + B\u2032 + C\u2032 + D\u2032 \u2261[0, . . . , 0] (mod 4). Proofs of Theorem 15 and Corollary 16 are available in the appendix. 2.6. Doubling construction We now give a simple construction that generates Williamson sequences of order 2n from Williamson sequences of odd order n using the following three operations on sequences A = [a0, . . . , an\u22121] and B = [b0, . . . , bn\u22121]: 1. Negation. Individually negate each entry of A, i.e., \u2212A B [\u2212a0, . . . , \u2212an\u22121]. 2. Shift. Cyclically shift the entries of A by an offset of (n \u22121)/2, i.e., A\u2032 B [a(n\u22121)/2, . . . , an\u22121, a0, a1, . . . , a(n\u22123)/2]. 3. Interleave. Interleave the entries of A and B in a perfect shuf\ufb02e, i.e., A x B B [a0, b0, a1, b1, . . . , an\u22121, bn\u22121]. Our doubling construction is captured by the following theorem. Theorem 17. Let A, B, C, D be Williamson sequences of odd order n. Then A x B\u2032, (\u2212A) x B\u2032, C x D\u2032, (\u2212C) x D\u2032 are Williamson sequences of order 2n. We remark that a single set of Williamson sequences of order n can often be used to generate more than one set of Williamson sequences of order 2n by applying equivalence operations to the quadruple A, B, C, D before using the construction. For example, the single inequivalent set of Williamson sequences of order 5 can be used to generate both inequivalent sets of Williamson sequences of order 10 using this construction with an appropriate reordering of A, B, C, D. We also remark that this doubling construction can be reversed in the sense that if Williamson sequences of order 2n exist for n odd then symmetric sequences X1, . . . , X8 \u2208{\u00b11}n can be constructed that satisfy the Williamson property 8 X i=1 PAFXi(s) = 0 for s = 1, . . . , n \u22121. We call such sequences 8-Williamson sequences because they form the \ufb01rst rows of 8-Williamson matrices as de\ufb01ned by for example Kotsireas and Koukouvinos (2006). Note that the equivalence operations of Section 2.2 also de\ufb01ne an equivalence on 8-Williamson sequences so long as they are written to apply to 8 sequences instead of 4. 8 \fTheorem 18. Let A, B, C, D be Williamson sequences of order 2n with n odd and write A = A1 x A\u2032 2, B = B1 x B\u2032 2, C = C1 x C\u2032 2, D = D1 x D\u2032 2. Then A1, A2, B1, B2, C1, C2, D1, D2 are 8-Williamson sequences of order n. Proofs of Theorems 17 and 18 are available in the appendix. Similar constructions have been described for complementary sets of sequences by Tseng and Liu (1972) but to our knowledge these constructions are new in the context of Williamson sequences. 3. The SAT+CAS paradigm The idea of combining SAT solvers with computer algebra systems originated independently in two works published in 2015: In a paper at the conference CADE entitled \u201cMATHCHECK: A Math Assistant via a Combination of Computer Algebra Systems and SAT Solvers\u201d by Zulkoski et al. (2015) and in an invited talk at the conference ISSAC entitled \u201cBuilding Bridges between Symbolic Computation and Satis\ufb01ability Checking\u201d by \u00c1brah\u00e1m (2015). The paradigm was also anticipated by Jovanovi\u00b4 c and de Moura (2012) who used CAS techniques in SAT-like search algorithms. The CADE paper describes a tool called MATHCHECK that combines the generalpurpose search capability of SAT solvers with the domain-speci\ufb01c knowledge of computer algebra systems. The paper made the case that MATHCHECK ...combines the ef\ufb01cient search routines of modern SAT solvers, with the expressive power of CAS, thus complementing both. As evidence for the power of this paradigm, they used MATHCHECK to improve the best known bounds in two conjectures in graph theory. Independently, the computer scientist Erika \u00c1brah\u00e1m observed that the \ufb01elds of satis\ufb01ability checking and symbolic computation share many common aims but in practice are quite separated, with little communication between the \ufb01elds: ...collaboration between symbolic computation and SMT [SAT modulo theories] solving is still (surprisingly) quite restricted... Furthermore, she outlined reasons why combining the insights from both \ufb01elds had the potential to solve certain problems more ef\ufb01ciently than would be otherwise possible. To this end, the SC2 project (\u00c1brah\u00e1m et al., 2016) was started with the aim of fostering collaboration between the two communities. 3.1. Programmatic SAT and SMT Not all constraints can easily be expressed in SAT instances. To deal with this, sophisticated SMT solvers were developed that can determine the satis\ufb01ability of formulas in \ufb01rst-order logic with respect to certain logical theories (Barrett et al., 2009). SMT solvers are often based on the Davis\u2013Putnam\u2013Logemann\u2013Loveland algorithm (modulo theories) by Ganzinger et al. (2004) denoted DPLL(T) where T is a theory of \ufb01rst-order logic. In this framework SAT solvers handle the Boolean aspects of a formula while T solvers handle the theory aspects of a formula. \u00c1brah\u00e1m (2015) gives 9 \fa number of requirements that a theory solver should satisfy, and the SMT-LIB standard by Barrett et al. (2016) describes many different theories used by SMT solvers along with a common input and output language for those theories. Programmatic SAT solvers were introduced by Ganesh et al. (2012) and are simply a variant of DPLL(T) where the T solvers are replaced by arbitrary user-speci\ufb01ed code. However, programmatic SAT solvers only deal with Boolean logic and not \ufb01rst-order logic, similar to the \u201cSAT modulo SAT\u201d solvers by Bayless et al. (2013). Additionally, the code provided to a programmatic SAT solver can be specialized to individual formulas, while the T solvers in DPLL(T) deal with a speci\ufb01c theory of \ufb01rst-order logic that is typically \ufb01xed in advance. For our purposes in this paper we will use a CAS as a theory solver and therefore our usage of programmatic SAT can be considered an instance of DPLL(CAS). A programmatic SAT solver can generate con\ufb02ict clauses programmatically, i.e., by a piece of code that runs as the SAT solver carries out its search. Such a SAT solver can learn clauses that are more useful than the con\ufb02ict clauses that it learns by default. Not only can this make the SAT solver\u2019s search more ef\ufb01cient, it allows for increased expressiveness as many types of constraints that are awkward to express in a conjunctive normal form format can naturally be expressed using code. Additionally, it allows one to compile instance-speci\ufb01c SAT solvers which are tailored to solving one speci\ufb01c type of instance. In this framework instances no longer have to solely consist of a set of clauses in conjunctive normal form. Instead, instances can consist of both a set of CNF clauses and a piece of code that encodes constraints that are too cumbersome to be written in CNF format. As an example of this, consider the case of searching for Williamson sequences using a SAT solver. One could encode De\ufb01nition 5 in CNF format by using Boolean variables to represent the entries in the Williamson sequences and by using binary adders to encode the summations; such a method was used by Bright et al. (2016). However, one could also use the equivalent de\ufb01nition given in Theorem 7. This alternate de\ufb01nition has the advantage that it becomes easy to apply Corollaries 8 and 9, which allows one to \ufb01lter many sequences from consideration and greatly speed up the search. Because of this, our method will use the constraints (\u2217) from Theorem 7 to encode the de\ufb01nition of Williamson sequences in our SAT instances. However, encoding the equations in (\u2217) would be extremely cumbersome to do using CNF clauses, because of the involved nature of computing the PSD values. However, the equations (\u2217) are easy to express programmatically\u2014as long as one has a method of computing the PSD values. This can be done ef\ufb01ciently using the fast Fourier transform which is available in many computer algebra systems and mathematical libraries. Thus, our SAT instances will not use CNF clauses to encode the de\ufb01ning property of Williamson sequences but instead encode those clauses programmatically. This is done by writing a callback function that is compiled with the SAT solver and programmatically expresses the constraints in Theorem 7 and the \ufb01ltering criteria of Corollaries 8 and 9. 3.2. Programmatic Williamson encoding We now describe in detail our programmatic encoding of Williamson sequences. The encoding takes the form of a piece of code which examines a partial assignment to the 10 \fBoolean variables de\ufb01ning the sequences A, B, C, and D (where true encodes 1 and false encodes \u22121). In the case when the partial assignment can be ruled out using Corollaries 8 or 9, a con\ufb02ict clause is returned which encodes a reason why the partial assignment no longer needs to be considered. If the sequences actually form a Williamson sequence then they are recorded in an auxiliary \ufb01le; at this point the solver would traditionally return SAT and stop, though our implementation continues the search because we want to do a complete enumeration of the space. The programmatic callback function does the following: 1. Initialize S B \u2205. This variable will be a set which contains the sequences whose entries are all currently assigned. 2. Check if all the variables encoding the entries in sequence A have been assigned; if so, add A to the set S and compute PSDA, otherwise skip to the next step. When PSDA(s) > 4n for some value of s then learn a clause prohibiting the entries of A from being assigned the way they currently are, i.e., learn the clause \u00ac(acur 0 \u2227acur 1 \u2227\u00b7 \u00b7 \u00b7 \u2227acur n\u22121) \u2261\u00acacur 0 \u2228\u00acacur 1 \u2228\u00b7 \u00b7 \u00b7 \u2228\u00acacur n\u22121 where acur i is the literal ai when ai is currently assigned to true and is the literal \u00acai when ai is currently assigned to false. 3. Check if all the variables encoding the entries in sequence B have been assigned; if so, add B to the set S and compute PSDB. When there is some s such that P X\u2208S PSDX(s) > 4n then learn a clause prohibiting the values of the sequences in S from being assigned the way they currently are. 4. Repeat the last step again twice, once with B replaced with C and then again with B replaced with D. 5. If all the variables in sequences A, B, C, and D are assigned then record the sequences in an auxiliary \ufb01le and learn a clause prohibiting the values of the sequences from being assigned the way they currently are so that this assignment is not examined again. After the search is completed the auxiliary \ufb01le will contain all sequences that passed the PSD tests and thus all Williamson sequences will be in this list. Verifying a sequence is in fact Williamson can be done using De\ufb01nition 5. (If the PSDs were computed exactly this is not necessary by Corollary 10 but with \ufb02oating-point arithmetic there is a slight chance that a PSD test failure was not detected.) Note that the clauses learned by this function allow the SAT solver to execute the search signi\ufb01cantly faster than would be possible using a brute-force technique. As a rough estimate of the bene\ufb01t, note that there are approximately 2n/2 possibilities for each member A, B, C, D in a set of Williamson sequences. If no clauses are learned in steps 2\u20134 then the SAT solver will examine all 24(n/2) total possibilities. Conversely, if a clause is always learned in step 2 then the SAT solver will only need to examine the 2n/2 possibilities for A. Of course, one will not always learn a clause in steps 2\u20134 but in practice such a clause is learned quite frequently and this more than makes up for the overhead of computing the PSD values (this accounted for about 20% of the SAT solver\u2019s runtime in our experiments). The programmatic approach was essential for the largest orders that we were able to solve; see Table 2 in Section 5 for a comparison between the running times of a SAT solver 11 \fn Driver script Programmatic SAT solver Diophantine solver Fourier transform Fourier transform Partial assignment Con\ufb02ict clause External call Result SAT instances Encoding information Enumeration in order n Figure 1: Outline of our algorithm for enumerating Williamson sequences of order n. The boxes on the left correspond to the preprocessing which encodes and decomposes the original problem into SAT instances. The boxes on the right correspond to an SMT-like setup where the system that computes the discrete Fourier transform takes on the role of the theory solver. using the CNF and programmatic encodings. However, the programmatic encoding was much too slow to be able perform the enumeration by itself and a more sophisticated enumeration algorithm was required (using the programmatic encoding as a subroutine). 4. Our enumeration algorithm A high-level summary of the components of our enumeration algorithm is given in Figure 1. We require two kinds of functions from computer algebra systems or mathematical libraries, namely, one that can solve the quadratic Diophantine equation (\u2217\u2217) and one that can compute the discrete Fourier transform of a sequence. In the following description we have step 1 handled by the Diophantine equation solver, steps 2\u20134 handled by the driver script, and step 5 handled by the programmatic SAT solver. The driver script is responsible for constructing the SAT instances and passing them off to the programmatic SAT solver. It also implicitly passes encoding information to the system responsible for performing the programmatic Williamson encoding described in Section 3.2, i.e., the system needs to know which variables in the SAT instance correspond to which Williamson sequence entries, but this is \ufb01xed in advance. We now give a complete description of our method that enumerates all Williamson sequences of a given order n divisible by 2 or 3. Let m \u2208{2, 3} be the smallest prime divisor of n. 4.1. Step 1: Generate possible sum-of-squares decompositions First, note that by Corollary 13 every set of Williamson sequences gives rise to a decomposition of 4n into a sum of four squares. We query a computer algebra system such as MAPLE or MATHEMATICA to get all possible solutions of the Diophantine equation (\u2217\u2217). Because we only care about Williamson sequences up to equivalence, we add the inequalities 0 \u2264RA \u2264RB \u2264RC \u2264RD 12 \fto the Diophantine equation; it is clear that any Williamson sequence quadruple can be transformed into another quadruple that satis\ufb01es these inequalities by applying the reorder and/or negating equivalence operations. 4.2. Step 2: Generate possible Williamson sequence quadruple members Next, we form a list of the sequences that could possibly appear as a member of a Williamson sequence quadruple of order n. To do this, we examine every symmetric sequence X \u2208{\u00b11}n. For all such X we compute PSDX and ignore those that satisfy PSDX(s) > 4n for some s. We also ignore those X whose rowsum does not appear in any possible solution (RA, RB, RC, RD) of the sum-of-squares Diophantine equation (\u2217\u2217). The sequences X that remain after this process form a list of the sequences that could possibly appear as a member of a set of Williamson sequences. At this stage we could generate all Williamson sequences quadruples of order n by trying all ways of grouping the possible sequences X into quadruples and \ufb01ltering those that are not Williamson. However, because of the large number of ways in which this grouping into quadruples can be done this is not feasible to do except for small n. 4.3. Step 3: Perform compression In order to reduce the size of the problem so that the possible sequences generated in step 2 can be grouped into quadruples we \ufb01rst compress the sequences using the process described in Section 2.4. For each solution (RA, RB, RC, RD) of the sum-of-squares Diophantine equation (\u2217\u2217) we form four lists LA, LB, LC, and LD. The list LA will contain the m-compressions of the sequences X generated in step 2 that have rowsum RA (and the other lists will be de\ufb01ned in a similar manner). Note that the sequences in these lists will be {\u00b12, 0}-sequences if n is even and {\u00b13, \u00b11}-sequences if n is odd since they are m-compressions of the sequences X which are {\u00b11}-sequences. 4.4. Step 4: Match the compressions By construction, the lists LA, LB, LC, and LD contain all possible m-compressions of the members of Williamson sequence quadruples whose sum-of-squares decomposition is R2 A + R2 B + R2 C + R2 D. Thus, by trying all possible sum-of-squares decompositions and all ways of matching together the sequences from the lists LA, LB, LC, LD we can \ufb01nd all m-compressions of Williamson sequence quadruples of order n. By Theorem 12, a necessary condition for A, B, C, D to be Williamson sequences is that PSDA\u2032 + PSDB\u2032 + PSDC\u2032 + PSDD\u2032 = [4n, . . . , 4n] where A\u2032, B\u2032, C\u2032, D\u2032 are the m-compressions of A, B, C, D. Therefore, one could perform this step by enumerating all (A\u2032, B\u2032,C\u2032, D\u2032) \u2208LA \u00d7 LB \u00d7 LC \u00d7 LD and outputting those whose PSDs sum to [4n, . . . , 4n] as a potential m-compression of a Williamson sequence quadruple. However, there will typically be far too many elements of LA \u00d7 LB \u00d7 LC \u00d7 LD to try in a reasonable amount of time. Instead, we will enumerate all (A\u2032, B\u2032) \u2208LA \u00d7 LB and (C\u2032, D\u2032) \u2208LC \u00d7 LD and use a string sorting technique by Kotsireas et al. (2010) to \ufb01nd which (A\u2032, B\u2032) and (C\u2032, D\u2032) can be matched together to form potential m-compressions of Williamson sequences. 13 \fTo determine which pairs can be matched together we use the necessary condition from Theorem 12 in a slightly rewritten form, PAFA\u2032 + PAFB\u2032 = [4n, 0, . . . , 0] \u2212(PAFC\u2032 + PAFD\u2032). Our matching procedure outputs a list of the (A\u2032, B\u2032,C\u2032, D\u2032) which satisfy this condition, and therefore output a list of potential m-compressions of Williamson sequences. In detail, our matching procedure performs the following steps: 1: initialize LAB and LCD to empty lists 2: for (A\u2032, B\u2032) \u2208LA \u00d7 LB do 3: if PSDA\u2032(s) + PSDB\u2032(s) < 4n for all s then 4: add PAFA\u2032 + PAFB\u2032 to LAB 5: for (C\u2032, D\u2032) \u2208LC \u00d7 LD do 6: if PSDC\u2032(s) + PSDD\u2032(s) < 4n for all s then 7: add [4n, 0, . . . , 0] \u2212(PAFC\u2032 + PAFD\u2032) to LCD 8: for each X common to both LAB and LCD do 9: output (A\u2032, B\u2032) and (C\u2032, D\u2032) which X was generated from in an auxiliary \ufb01le Line 8 can be done ef\ufb01ciently by sorting the lists LAB and LCD and then performing a linear scan through the sorted lists to \ufb01nd the elements common to both lists. Line 9 can be done ef\ufb01ciently if with each element in the lists LAB and LCD we also keep track of a pointer to the sequences (A\u2032, B\u2032) or (C\u2032, D\u2032) that the element was generated from in line 4 or 7. Also in line 9 if n is even we only output sequences for which A\u2032 + B\u2032 + C\u2032 + D\u2032 is the zero vector mod 4 as this is an invariant of all 2-compressed Williamson sequences by Corollary 16. 4.5. Step 5: Uncompress the matched compressions It is now necessary to \ufb01nd the Williamson sequences, if any, which when compressed by a factor of m produce one of the sequence quadruples generated in step 4. In other words, we want to \ufb01nd a way to perform uncompression on the matched compressions which we generated. To do this, we formulate the uncompression problem as a Boolean satis\ufb01ability instance and use a SAT solver\u2019s combinatorial search facilities to search for solutions to the uncompression problem. We use Boolean variables to represent the entries of the uncompressed Williamson sequences, with true representing the value of 1 and false representing the value of \u22121. Since Williamson sequence quadruples consist of four sequences of length n they contain a total of 4n entries, namely, a0, . . . , an\u22121, b0, . . . , bn\u22121, c0, . . . , cn\u22121, d0, . . . , dn\u22121. However, because Williamson sequences are symmetric we actually only need to de\ufb01ne the distinct variables a0, . . . , a\u230an/2\u230b, b0, . . . , b\u230an/2\u230b, c0, . . . , c\u230an/2\u230b, d0, . . . , d\u230an/2\u230b. Any variable xi with i > n/2 can simply be replaced with the equivalent variable xn\u2212i; in what follows we implicitly use this substitution when necessary. Thus, the SAT 14 \finstances that we generate will contain 2n + 4 variables when n is even and 2n + 2 variables when n is odd. Say that (A\u2032, B\u2032,C\u2032, D\u2032) is one of the m-compressions generated in step 4. By the de\ufb01nition of m-compression, we have that a\u2032 i = ai + ai+n/2 if n is even and a\u2032 i = ai + ai+n/3 + ai+2n/3 if n is odd. Since \u22123 \u2264a\u2032 i \u22643 there are seven possibilities we must consider for each a\u2032 i. Case 1. If a\u2032 i = 3 then we must have ai = 1, ai+n/3 = 1, and ai+2n/3 = 1. Thinking of the entries as Boolean variables, we add the clauses ai \u2227ai+n/3 \u2227ai+2n/3 to our SAT instance. Case 2. If a\u2032 i = 2 then we must have ai = 1 and ai+n/2 = 1. Thinking of the entries as Boolean variables, we add the clauses ai \u2227ai+n/2 to our SAT instance. Case 3. If a\u2032 i = 1 then exactly one of the entries ai, ai+n/3, and ai+2n/3 must be \u22121. Thinking of the entries as Boolean variables, we add the clauses (\u00acai \u2228\u00acai+n/3 \u2228\u00acai+2n/3) \u2227(ai \u2228ai+n/3) \u2227(ai \u2228ai+2n/3) \u2227(ai+n/3 \u2228ai+2n/3) to our SAT instance. These clauses specify in conjunctive normal form that exactly one of the variables ai, ai+n/3, and ai+2n/3 is false. Case 4. If a\u2032 i = 0 then we must have ai = 1 and ai+n/2 = \u22121 or vice versa. Thinking of the entries as Boolean variables, we add the clauses (ai \u2228ai+n/2) \u2227(\u00acai \u2228\u00acai+n/2) to our SAT instance. These clauses specify in conjunctive normal form that exactly one of the variables ai and ai+n/2 is true. Case 5. If a\u2032 i = \u22121 then exactly one of the entries ai, ai+n/3, and ai+2n/3 must be 1. Thinking of the entries as Boolean variables, we add the clauses (ai \u2228ai+n/3 \u2228ai+2n/3) \u2227(\u00acai \u2228\u00acai+n/3) \u2227(\u00acai \u2228\u00acai+2n/3) \u2227(\u00acai+n/3 \u2228\u00acai+2n/3) to our SAT instance. These clauses specify in conjunctive normal form that exactly one of the variables ai, ai+n/3, and ai+2n/3 is true. Case 6. If a\u2032 i = \u22122 then we must have ai = \u22121 and ai+n/2 = \u22121. Thinking of the entries as Boolean variables, we add the clauses \u00acai \u2227\u00acai+n/2 to our SAT instance. Case 7. If a\u2032 i = \u22123 then we must have ai = \u22121, ai+n/3 = \u22121, and ai+2n/3 = \u22121. Thinking of the entries as Boolean variables, we add the clauses \u00acai \u2227\u00acai+n/3 \u2227\u00acai+2n/3 15 \fto our SAT instance. For each entry a\u2032 i in A\u2032 we add the clauses from the appropriate case to the SAT instance, as well as add clauses from a similar case analysis for the entries from B\u2032, C\u2032, and D\u2032. A satisfying assignment to the generated SAT instance provides an uncompression (A, B,C, D) of (A\u2032, B\u2032,C\u2032, D\u2032). However, the uncompression need not be a set of Williamson sequences. To ensure that the solutions produced by the SAT solver are in fact Williamson sequences we additionally use the programmatic SAT Williamson encoding as described in Section 3.2. For each (A\u2032, B\u2032,C\u2032, D\u2032) generated in step 4 we generate a SAT instance which contains the clauses speci\ufb01ed above. We then solve the SAT instances with a programmatic SAT solver whose programmatic clause generator speci\ufb01es that any satisfying assignment of the instance encodes a set of Williamson sequences and performs an exhaustive search to \ufb01nd all solutions. By construction, every Williamson sequence quadruple of order n will have its m-compression generated in step 4, making this search totally exhaustive (up to the discarded equivalences). 4.6. Postprocessing: Remove equivalent Williamson sequences After step 5 we have produced a list of all the Williamson sequences of order n that have a certain sum-of-squares decompositions. We chose the decompositions in such a way that every Williamson sequence quadruple will be equivalent to at least one decomposition but we have not dealt with all equivalences E1\u2013E5. Therefore some Williamson sequences that we generate may be equivalent to each other. Removing equivalences can be performed in step 5 but since the SAT instances are generally solved in parallel we wait until all SAT instances have been solved for simplicity. For the purpose of counting the total number of inequivalent Williamson sequences that exist in order n it is necessary to examine each quadruple in the list generated in step 5 and determine if it is equivalent to another quadruple in the list. This can be done by repeatedly applying the equivalence operations from Section 2.2 on the quadruples in the list and discarding those which are equivalent to a previously found set of Williamson sequences. However, this can be inef\ufb01cient because there are typically a large number of Williamson sequence quadruples in each equivalence class. Instead, a more ef\ufb01cient way of testing for equivalence is to de\ufb01ne a single representative in each equivalence class that is easy to compute. Then two sets of Williamson sequences can be tested for equivalence by testing that their representatives are equal. As a \ufb01rst step in de\ufb01ning a single representative in each equivalence class of Williamson sequence quadruples we \ufb01rst consider only the equivalence operations E1, E2, and E3 (reorder, negate, and shift). The operations E2 and E3 apply to individual sequences X and there are up to four sequences which could be generated using E2 and E3, namely, X, E2(X), E3(X), and E2(E3(X)). Let MX be the lexicographic minimum of these four sequences. Given a Williamson sequence quadruple (A, B,C, D), we compute (MA, MB, MC, MD) and then use operation E1 on the sequences in the quadruple to sort those sequences in increasing lexicographic order. The resulting quadruple is the lexicographic minimum of all quadruples equivalent to (A, B,C, D) using the operations E1, E2, and E3 and is therefore a unique single representative of the equivalence class which we denote M(A,B,C,D). 16 \fNext, consider the equivalence operation E4 (permute entries). Let \u03c3 be an automorphism of the cyclic group Cn and let \u03c3(X) be the sequence whose ith entry is x\u03c3(i). Then the lexicographic minimum of the set S (A,B,C,D) B \b M(\u03c3(A),\u03c3(B),\u03c3(C),\u03c3(D)) : \u03c3 \u2208Aut(Cn) \t is the lexicographic minimum of all quadruples equivalent to (A, B,C, D) using the operations E1, E2, E3, and E4. (This is due to the fact that E4 commutes with E1, E2, and E3, so it is always possible to \ufb01nd the global lexicographic minimum by \ufb01rst trying all possible ways of applying E4 and only afterwards considering E1, E2, and E3.) Finally, if n is even we consider the equivalence operation E5 (alternating negation). The lexicographic minimum of the set S (A,B,C,D) \u222aS E5(A,B,C,D) will be the lexicographic minimum of all quadruples equivalent to (A, B,C, D) and is therefore a single unique representative of the equivalence class. (Again, this is due to the fact that E5 commutes with the other operations so it is always possible to \ufb01nd the global lexicographic minimum by \ufb01rst trying all possible ways of applying E5 before applying the other operations.) 4.7. Optimizations While the procedure just described will correctly enumerate all Williamson sequences of a given even order n, there are a few optimizations that can be used to improve the ef\ufb01ciency of the search. Note that in step 3 we have not generated all possible m-compression quadruples; we only generate those quadruples that have rowsums (RA, RB, RC, RD) that correspond to solutions of (\u2217\u2217), and we use the negation and reordering equivalence operations to cut down the number of possible rowsums necessary to check. However, there still remain equivalences that can be removed; if \u03c3 is an automorphism of the cyclic group Cn then (A, B,C, D) is a Williamson sequence quadruple if and only if (\u03c3(A), \u03c3(B), \u03c3(C), \u03c3(D)) is a Williamson sequence quadruple (with \u03c3(X) de\ufb01ned so that its ith entry is x\u03c3(i)). Thus if both A and \u03c3(A) are in the list generated in step 2 we can remove one from consideration. Unfortunately, we cannot do the same in the lists for B, C, and D, since it is not possible to know which representatives for B, C, and D to keep, as the representatives must match with the representative for A that was kept. Similarly, in step 5 one can ignore any SAT instance that can be transformed into another SAT instance using the equivalence operations from Section 2.2. In this case the solutions in the ignored SAT instance will be equivalent to those in the SAT instance associated to it through the equivalence transformation. In the programmatic Williamson encoding we can often learn shorter clauses with a slight modi\ufb01cation of the procedure described in Section 3.2. Instead of checking P X\u2208S PSDX(s) > 4n directly we instead \ufb01nd the smallest subset S \u2032 of S such that P X\u2208S \u2032 PSDX(s) > 4n (if such a subset exists). This is done by sorting the values of PSDX(s) and performing the check using the largest values PSDX(s) before considering the smaller values. For example, if PSDB(s) > PSDA(s) then we would check PSDB(s) > 4n before checking PSDA(s) + PSDB(s) > 4n. When n is odd we use Theorem 14 to provide additional information to the SAT solver. For simplicity, suppose we \ufb01x a0 = 1; as shown in (Bright, 2017, \u00a73.1.2) this 17 \fcan be done by \ufb01xing the sign of rowsum(A) to not necessarily be positive but to satisfy rowsum(A) \u2261n (mod 4). Brie\ufb02y, this is because the symmetry of A implies that the rowsum of A will always be congruent to a0 + n \u22121 (mod 4). Also \ufb01xing the values b0 = c0 = d0 = 1, Theorem 14 says that akbkckdk = \u22121 for k = 1, . . . , (n \u22121)/2. Thinking of the entries as Boolean variables, we can encode the multiplicative constraint in conjunctive normal form as (ak \u2228bk \u2228ck \u2228dk) \u2227(\u00acak \u2228\u00acbk \u2228ck \u2228dk) \u2227\u00b7 \u00b7 \u00b7 \u2227(\u00acak \u2228\u00acbk \u2228\u00acck \u2228\u00acdk) (that is, all the clauses on the four variables ak, bk, ck, dk with an even number of negative literals). We add these clauses for k = 1, . . . , (n \u22121)/2 into each SAT instance generated in each odd order n. 5. Results We implemented the algorithm described in Section 4, including all optimizations, and ran it in all orders n \u226470 divisible by 2 or 3. Step 1 was completed using the script NSOKS (Riel, 2006) in the computer algebra system MAPLE 18. Steps 2\u20134 and the postprocessing were completed using C++ code which used the library FFTW 3.3.6-pl2 by Frigo and Johnson (2005) for computing PSD values. Step 5 was completed using MAPLESAT (Liang et al., 2017) modi\ufb01ed to support a programmatic interface and also used FFTW for computing PSD values. Since FFTW introduces some \ufb02oating-point errors in the values it returns, when checking the PSD values of A we actually ensure that PSDA(s) > 4n + \u03f5 for some \u03f5 which is small but larger than the accuracy of the discrete Fourier transform used, e.g., \u03f5 = 10\u22122. Our computations were performed on a cluster of 64-bit Intel Xeon E5-2683V4 2.1 GHz processors limited to 6 GB of memory and running CentOS 7. Timings for running our entire algorithm (in hours) in even orders are given in Table 1, and timings for the running of the SAT solver alone are given in Table 2. The bottleneck of our method for large even n was the matching procedure described in step 4, which requires enumerating and then sorting a very large number of vectors. For example, when n = 64 and RA = RB = 8 there were over 26.6 billion vectors added to LAB. Table 1 also includes the number of SAT instances that we generated in each order, as well as the total number of sets of Williamson sequences that were found up to equivalence (denoted by #Wn). The counts for #Wn are not identical to those given in (Bright et al., 2018a) because that work did not use the equivalence operation E5 (alternating negation) but the results up to order 64 (the largest order previously solved) are otherwise identical. Table 3 contains the same information as Table 1 except in the odd orders. The bottleneck for our algorithm in these orders was the uncompression step (since uncompressing by a factor of 3 is more challenging than uncompressing by a factor of 2), i.e., solving the SAT instances. The counts for #Wn in these cases exactly match those given by Holzmann et al. (2008) up to 59, the largest order they solved. We found one 18 \fn Time (h) # inst. #Wn 2 0.00 1 1 4 0.00 1 1 6 0.00 1 1 8 0.00 1 1 10 0.00 2 2 12 0.00 3 3 14 0.00 3 5 16 0.00 5 6 18 0.00 22 23 20 0.00 14 17 22 0.00 22 15 24 0.00 40 72 26 0.00 24 26 28 0.00 78 83 30 0.00 281 150 32 0.00 70 152 34 0.00 214 91 36 0.00 1013 477 38 0.00 360 50 40 0.01 4032 1499 42 0.02 2945 301 44 0.01 1163 249 46 0.03 1538 50 48 0.09 4008 9800 50 0.45 3715 275 52 0.78 4535 926 54 3.00 25798 498 56 0.98 18840 40315 58 15.97 9908 73 60 27.14 256820 4083 62 64.74 19418 61 64 65.52 34974 69960 66 764.96 109566 262 68 593.77 122150 1113 70 957.96 71861 98 Table 1: A summary of the running time in hours, number of SAT instances used, and number of inequivalent sets of Williamson sequences generated in each even order n \u226470. 19 \fSAT Solving Time (hours) n CNF encoding Programmatic 30 0.01 0.00 32 0.01 0.00 34 0.03 0.00 36 0.36 0.00 38 0.12 0.00 40 2.01 0.01 42 4.31 0.01 44 5.59 0.00 46 8.65 0.01 48 18.78 0.02 50 53.12 0.02 52 \u2212 0.05 54 \u2212 0.18 56 \u2212 0.18 58 \u2212 0.13 60 \u2212 9.56 62 \u2212 0.45 64 \u2212 0.94 66 \u2212 5.14 68 \u2212 17.18 70 \u2212 8.07 Table 2: The total time spent running MAPLESAT in each even order 30 \u2264n \u226470 using the CNF encoding and the programmatic encoding. A timeout of 100 hours was used. 20 \fn Time (h) # inst. #Wn 3 0.00 1 1 9 0.00 3 3 15 0.00 8 4 21 0.00 30 7 27 0.00 172 6 33 0.01 364 5 39 0.05 1527 1 45 1.12 15542 1 51 4.57 17403 2 57 61.26 58376 1 63 1670.95 466561 2 69 8162.50 600338 1 Table 3: A summary of the running time in hours, number of SAT instances used, and number of inequivalent sets of Williamson sequences generated in each odd order n divisible by 3 and less than 70. previously unknown Williamson sequence of order 63 using 466,561 3-compressed quadruples. We give this Williamson sequence here explicitly, with \u2018+\u2019 representing 1, \u2018-\u2019 representing \u22121, and each sequence member on a new line: +----+-+++-+-++++--++--+-----+-++-+-----+--++--++++-+-+++-+---+--++-+-+--++++----+-++-++---+----+---++-++-+----++++--+-+-++-+--++-+++-+++---++-----+-+---+----+---+-+-----++---+++-+++-++-+++++-++----+++-+-++---+-++++-+--+-++++-+---++-+-+++----++-++++ We also used our enumeration of Williamson sequences of order 2n for n \u226435 along with Theorem 18 to explicitly construct 8-Williamson sequences in all odd orders n \u226435. Table 4 contains the counts of how many inequivalent sets of 8-Williamson sequences that can be constructed in this fashion (this does not count the total number of 8-Williamson sequences in order n, only those that can be constructed via the construction of Theorem 18). We explicitly give one example of an 8-Williamson sequence of order 35, with \u2018+\u2019 representing 1 and \u2018-\u2019 representing \u22121: ++++-+++--+-+----++----+-+--+++-+++ +++---+-+++-++--+--+--++-+++-+---++ ++-+-+++-+-----++++++-----+-+++-+-+ ++-+--+--++---+-++++-+---++--+--+-+ ++---++-+-+--+--------+--+-+-++---+ ++---++-+-+--+--------+--+-+-++---+ +--+++-----+---+-++-+---+-----+++-+---++--++++-++-+--+-++-++++--++--These sequences can be used to generate a Hadamard matrix of order 8 \u00b7 35 = 280; for details see Kotsireas and Koukouvinos (2006, 2009). Additionally, our code and an explicit enumeration of all the Williamson sequences and 8-Williamson sequences that we constructed have been made available on our website uwaterloo.ca/mathcheck. 21 \fn 1 3 5 7 9 11 13 15 17 #8Wn \u2265 1 1 1 4 13 10 18 129 79 n 19 21 23 25 27 29 31 33 35 #8Wn \u2265 43 280 48 257 486 71 58 240 78 Table 4: The number of inequivalent sets of 8-Williamson sequences generated using Theorem 18 in each odd order n \u226435 (and therefore a lower bound on #8Wn, the number of inequivalent sets of 8-Williamson sequences in order n). 6."
+                },
+                {
+                    "url": "http://arxiv.org/abs/1803.01480v1",
+                    "title": "A doubling construction for Williamson matrices",
+                    "abstract": "A construction that generates Williamson matrices of order $2n$ from\nWilliamson matrices of odd order $n$ is presented. The construction is\ncompletely constructive and only uses three simple sequence operations.",
+                    "authors": "Curtis Bright",
+                    "published": "2018-03-05",
+                    "updated": "2018-03-05",
+                    "primary_cat": "math.CO",
+                    "cats": [
+                        "math.CO"
+                    ],
+                    "main_content": "Introduction Four square, symmetric, and circulant matrices of order n with \u00b11 entries are known as Williamson matrices if they satisfy A2 + B2 + C2 + D2 = 4nIn where In is the identity matrix of order n. Such matrices were \ufb01rst introduced by Williamson (1944), who proved that such matrices can be used to constuct a Hadamard matrix (a square matrix with \u00b11 entries whose rows are pairwise orthogonal) of order 4n. Since Williamson matrices are circulant they are de\ufb01ned in terms of their \ufb01rst row and so it is convenient to instead think of Williamson matrices in terms of four sequences (a0, . . ., an\u22121), (b0, . . ., bn\u22121), (c0, . . ., cn\u22121), (d0, . . ., dn\u22121). Since Williamson matrices are symmetric these sequences are also symmetric (i.e., xk = xn\u2212k for k = 1, . . . , n \u22121). 2 Preliminaries A doublingconstructionfor Hadamard matriceswas originallygiven by Sylvester(1867) who showed that a Hadamard matrix of order 2n can be constructed from a Hadamard matrix of order n. Baumert and Hall (1965) provided a doubling construction for generalizations of Williamson matrices which are often referred to as Williamson-type matrices (Seberry and Yamada, 1992, Def. 3.3). Using complex Hadamard matrices, Turyn (1970) provided a construction which generates Williamson matrices of order 2kn for k = 1, 2, 3, 4 from Williamson matrices of odd order n. In this paper we provide a simple doubling construction which works directly on the sequences which de\ufb01ne Williamson matrices. 1 \f2.1 Correlation Williamson matrices can also be de\ufb01ned in terms of a correlation function. The periodic cross-correlation function of two sequences X = (x0, . . ., xn\u22121) and Y = (y0, . . ., yn\u22121) is de\ufb01ned to be PCFX,Y(s) \u2254 n\u22121 \u00d5 k=0 xkyk+s mod n and the periodic autocorrelation function of X be a sequence is PAFX(s) \u2254PCFX,X(s). In (Bright, 2017, \u00a73.1.1) it is shown that four symmetric sequences A, B, C, D \u2208{\u00b11}n form the initial rows of a set of Williamson matrices if and only if they satisfy PAFA(s) + PAFB(s) + PAFC(s) + PAFD(s) = 0 for s = 1, . . . , \u230an/2\u230b. We refer to such sequences as Williamson sequences. 2.2 Sequence operations Let A = (a0, . . ., an\u22121) and B = (b0, . . ., bn\u22121) be sequences of order n. Our construction uses the following 3 types of operations. 1. Negation. Individually negate each entry of A, i.e., \u2212A \u2254(\u2212a0, . . ., \u2212an\u22121). 2. Shift. Cyclically shift the entries of A by an o\ufb00set of k, i.e., (ak, ak+1, . . ., ak\u22121) with indices taken modulo n. 3. Interleave. Interleave the entries of A and B in a perfect shu\ufb04e, i.e., A \u0448 B \u2254(a0, b0, a1, b1, . . ., an\u22121, bn\u22121). If n is odd we let A\u2032 denote shifting A by an o\ufb00set of (n \u22121)/2, i.e., A\u2032 \u2254(a(n\u22121)/2, . . ., an\u22121, a0, a1, . . ., a(n\u22123)/2). Note that we have PAF\u2212A(s) = PAFA(s), PAFA\u2032(s) = PAFA(s), and PAFA\u0448B(s) = ( PAFA(s/2) + PAFB(s/2) when s is even, PCFA,B \u0000 s\u22121 2 \u0001 + PCFB,A \u0000 s+1 2 \u0001 when s is odd. 3 Doubling construction Our doubling construction is captured by the following theorem. Theorem 1. Let A, B, C, D be Williamson sequences of odd order n. Then A \u0448 B\u2032, (\u2212A) \u0448 B\u2032, C \u0448 D\u2032, (\u2212C) \u0448 D\u2032 are Williamson sequences of order 2n. 2 \fProof. The fact that the constructed sequences have \u00b11 entries are of length 2n follows directly from the properties of the three types of operations used to generate them. The fact that they are symmetric follows from the fact that the sequences X which appear to the left of \u0448 satisfy xk = xn\u2212k for k = 1, . . . , n\u22121 and the sequencesY which appear to the right of \u0448 satisfy yk = yn\u2212k\u22121 for k = 0, . . . , n \u22121 which are exactly the necessary properties for X \u0448 Y to be symmetric. Let L be the list containing the constructed sequences of order 2n. To show these sequences are Williamson we need to show that \u00d5 X\u2208L PAFX(s) = 0 for s = 1, . . . , n. When s is even and in this range using the properties from Section 2.2 we obtain \u00d5 X\u2208L PAFX(s) = 2 \u00d5 X=A,B,C,D PAFX(s/2) = 0 since A, B, C, D are Williamson. When s is odd we have that PAF(\u2212X)\u0448Y(s) = \u2212PAFX\u0448Y(s) and using this for (X,Y) = (A, B\u2032) and (C, D\u2032) derives the desired property. We remark that unlike the doubling constructions given by Sylvester and Baumert\u2013 Hall our doubling construction cannot be applied repeatedly because it only applies when n is odd. When n is even it is not possible to apply a shift to a symmetric sequence Y of order n to obtain a sequence Y \u2032 which satis\ufb01es y\u2032 k = y\u2032 n\u2212k\u22121 for k = 0, . . . , n \u22121 and this property is necessary to make the constructed sequences symmetric."
+                }
+            ],
+            "Vijay Ganesh": [
+                {
+                    "url": "http://arxiv.org/abs/1502.04023v3",
+                    "title": "The Meaning of Attack-Resistant Systems",
+                    "abstract": "In this paper, we introduce a formal notion of partial compliance, called\nAttack-resistance, of a computer program running together with a defense\nmechanism w.r.t a non-exploitability specification. In our setting, a program\nmay contain exploitable vulnerabilities, such as buffer overflows, but\nappropriate defense mechanisms built into the program or the operating system\nrender such vulnerabilities hard to exploit by certain attackers, usually\nrelying on the strength of the randomness of a probabilistic transformation of\nthe environment or the program and some knowledge on the attacker's goals and\nattack strategy. We are motivated by the reality that most large-scale programs\nhave vulnerabilities despite our best efforts to get rid of them. Security\nresearchers have responded to this state of affairs by coming up with ingenious\ndefense mechanisms such as address space layout randomization (ASLR) or\ninstruction set randomization (ISR) that provide some protection against\nexploitation. However, implementations of such mechanism have been often shown\nto be insecure, even against the attacks they were designed to prevent. By\nformalizing this notion of attack-resistance we pave the way towards addressing\nthe questions: \"How do we formally analyze defense mechanisms? Is there a\nmathematical way of distinguishing effective defense mechanisms from\nineffective ones? Can we quantify and show that these defense mechanisms\nprovide formal security guarantees, albeit partial, even in the presence of\nexploitable vulnerabilities?\". To illustrate our approach we discuss under\nwhich circumstances ISR implementations comply with the Attack-resistance\ndefinition.",
+                    "authors": "Vijay Ganesh, Sebastian Banescu, Mart\u00edn Ochoa",
+                    "published": "2015-02-13",
+                    "updated": "2015-06-11",
+                    "primary_cat": "cs.CR",
+                    "cats": [
+                        "cs.CR"
+                    ],
+                    "main_content": "Introduction In the last several decades there has been impressive progress in the development and application of automated software testing [12, 20, 26, 34] and formal veri\ufb01cation techniques [13, 18, 19, 21]. Despite these gains, establishing trustworthiness of software systems remains a notoriously dif\ufb01cult and expensive problem. Scalably guaranteeing 100% compliance of large software systems w.r.t rich speci\ufb01cations remains an open challenge. In fact, users simply assume that software systems will never be completely free of security vulnerabilities, despite our best efforts. In response to this seeming inevitability of exploitable vulnerabilities in software, security researchers have proposed ingenious defense mechanisms (e.g., address space layout randomization abbreviated as ASLR [40], randomization for a variety of memory protection schemes [7], obfuscations [41], program shepherding [27], use of cryptographic devices [39], and encrypted program execution [14]) that, under suitable assumptions, make it \u201cpractically dif\ufb01cult\u201d for resource-bounded attackers to exploit certain class of vulnerabilities even though vulnerabilities such as buffer over\ufb02ows are present in the system-under-attack. Many of these mechanisms are widely used in practice because of their effectiveness against common attackers. These defense mechanisms are designed to complement traditional approaches such as testing and formal veri\ufb01cation, and provide an additional crucial layer of security. On the other hand, in the past years several attacks have been published against implementation of many of those defense mechanisms: some of these attacks leverage side-channels (i.e. timing side-channels against ASLR [35] and ISR [38]), while others challenge the assumptions made on the attacker\u2019s strategy (i.e. by using ROP or JOP strategies instead of straightforward injections [10, 32]). Defense mechanisms distinguish themselves from formal methods and testing in the following ways: First, they give an \u201cintuitive\u201d yet practically effective partial guarantee of compliance of a software system w.r.t a non-exploitability speci\ufb01cation, even though the system may have vulnerabilities in it. By partial we mean that a resource-bounded attacker can still launch an attack but the probability is vanishingly small, under suitable assumptions. By contrast, the traditional aim of formal veri\ufb01cation is a complete guarantee or establish the absence of vulnerabilities. Testing techniques, on the other hand, are typically incomplete and provide no guarantees of compliance of a large software system w.r.t a speci\ufb01cation. Second, defense mechanisms offer different trade-offs between completeness and scalability, when compared to testing or formal veri\ufb01cation. For example, appropriate use of defense mechanisms may lower the burden of establishing security guarantees on software developers by not requiring them to establish full compliance while giving some measure of security, at the cost of possibly allowing certain hard-to-exploit vulnerabilities. While the inevitability of vulnerabilities in software and the need for effective defense mechanisms has been forcefully made by many researchers in the past, and eloquently captured in a recent paper [6], what seems largely missing is a formal characterization of the security provided by these defenses, and to some extent, a proof strategy or schema for establishing guarantees. Such a formal and precise characterization of security, in terms of a partial compliance guarantee, can be a foundational way of reasoning about and comparing defense mechanisms of all kinds using the same standard approach, just as in the \ufb01eld of cryptography, notions such as \u201csemantic security\u201d are standard ways of comparing encryption schemes. Although in cryptography attackers are usually seen as arbitrary probabilistic algorithms with a certain number of resources (for instance, number of gates which is polynomial in a security parameter), we believe that in the case of vulnerability exploitation and defense this is currently not possible: new attacker models often radically challenge the assumptions made by defenders, as illustrated by ROP, Blind ROP and JOP attacks [9]. However, we believe that making those assumptions explicit, and carefully arguing why certain defense mechanism are secure against explicit attacker classes would substantially improve the ef\ufb01cacy of defense mechaarXiv:1502.04023v3  [cs.CR]  11 Jun 2015 \fnisms, allowing defenders to spot subtle implementations or design errors. In this paper, building on paradigms from cryptography and program analysis, we propose a general and formal de\ufb01nition of partial compliance, we call ATTACK-RESISTANCE, of a software system w.r.t a (non-exploitability) speci\ufb01cation. The key insight of our formal program analysis approach is that a program p \u2208P together with its defense mechanisms d \u2208D (written p + d) is ATTACKRESISTANT against a well-de\ufb01ned attacker (or attack model) A if the code and runtime behavior of p+d is resistant to exploitation by A, and this can be expressed using the complexity-theoretic idea of negligible success probability from cryptography. Informally, we say that p + d is ATTACK-RESISTANT to attacker A if the probability of successfully launching a remote program execution by the attacker is negligible in a suitable security parameter. Based on this de\ufb01nition, we propose a formal analysis framework and a research program whose goal is to analyze the ef\ufb01cacy of defense mechanisms from a variety of contexts. We also discuss building blocks for a proof strategy that can be useful to show ATTACKRESISTANCE in various contexts, and that consists in reducing the attack probability to the likelihood of guessing a random seed, which lies at the heart of most defense mechanisms, in analogy to Kerckhoffs\u2019s principle in cryptography [25]. In sum, we make the following contributions in this \u201cVision and Challenges\u201d paper: Contributions 1. We provide a formal de\ufb01nition of ATTACK-RESISTANCE and discuss a high-level proof strategy for it. 2. We show the utility of this de\ufb01nition and the proof strategy by analyzing and comparing different ISR implementations from the literature. 3. Finally, we suggest that unlike formal veri\ufb01cation of arbitrary programs to establish their non-exploitability (e.g., absence of over\ufb02ow vulnerabilities), in some cases it is possible to show ATTACK-RESISTANCE for a large class of programs by only paying the cost of formally verifying the defense mechanism exactly once. Note that our goal is the quanti\ufb01cation of the effectiveness of probabilistic defenses in a general sense, although in this paper we focus primarily on defenses for memory safety vulnerability exploitation. On the one hand, we do not aim to cover all types of run-time countermeasures to memory safety vulnerabilities, but only the ones in the probabilistic category as de\ufb01ned by Younan et al. [43]. On the other hand, our approach can also be used to analyze probabilistic defense mechanisms beyond memory safety, such as SQLrand [11], which we plan to do as part of future work. 2. Attacker Model The adversary or attacker A is de\ufb01ned as a probabilistic algorithm that has access to a copy of the source code of the program-underattack p \u2208P (e.g., a web server) and is aware of all low-level vulnerabilities contained by p, such as buffer over\ufb02ows, format string vulnerabilities etc. The assumption that the attacker has the source code of p is realistic, given that binary code and obfuscations that are not cryptographically-secure can be easily reverse-engineered by attackers. The attacker is allowed to run any type of program analysis (static and/or dynamic) within a time bounded by a polynomial over the length of a security parameter (a random seed). The attacker\u2019s goal is to learn the vulnerabilities in the program p, construct and launch appropriate exploits. A has remote access to a machine M on which the vulnerable program p is running (e.g., a machine running the Apache Web Server). A can interact with p via a network channel, where it can send multiple messages and observe their respective output. More precisely A can produce k messages: m1, m2, . . . , mk, where mi \u2208I and I is an input message space. Each input message is represented by \ufb01nite bit strings, possibly containing exploits and payloads. A receives k outputs from p, one for each input message: o1, o2, . . . , ok, with oi \u2208O, where O is the output message space. The adversary encodes a malicious program p\u2032 in each input message using a probabilistic function that adaptively takes into account previously received outputs (at most k) e : P \u00d7 Ok \u2192I. The attacker is not allowed side-channel access to the runtime of p (beyond what is leaked through its observations) or physical access to M. Note that although we leave A largely unspeci\ufb01ed to account for adaptation to the interaction with p, we assume that some characteristics of the encoding function e are known (for instance that is tailored for ROP exploit construction, shellcode injection etc.). In the following we will thus denote the adversary as Ae. Note that if this function is completely unknown, it will be practically impossible to show ATTACK-RESISTANCE of a particular defense mechanism, since new attack techniques can easily invalidate certain defense assumptions (as shown by ROP and recently by blind ROP [9]). If p contains a buffer over\ufb02ow vulnerability, it allows uploading the payload into a part of p\u2019s process memory. If the exploit is successful it leads the control \ufb02ow of p to the payload causing it to execute, thus resulting in a control-hijack attack (for further reading, we refer to the rich literature already out there on buffer over\ufb02ow attacks in C/C++ programs [17, 32]). Formally, the attacker Ae wants to remotely execute a malicious program of his choice p\u2032 \u2208S \u2282P on a victim machine M. We de\ufb01ne P to be the set of all programs expressed as machine code runnable on M (for instance x86 machine code), and S is a subset of P, containing malicious programs that are the target of the attacker and not containing p. We leave S unspeci\ufb01ed and strictly smaller than P for two reasons: on the one hand, it does not make sense that S contains p, since this program is being executed on M anyway, on the other hand the notion of malicious can vary from context to context (there are many programs that are harmless if injected). To more precisely de\ufb01ne the goal of the attacker we consider the following event: E(p, p\u2032, Ae) = { p\u2032 runs in process p after interaction with Ae } By p\u2032 runs in process p we mean that there is a sequence of assembly instructions executed in the process memory of p that is semantically equivalent to p\u2032. Note that without loss of generality we can assume that for all p\u2032 \u2208S, S contains all programs semantically equivalent to p\u2032. 3. Attack Resistance In this Section we de\ufb01ne the notion of ATTACK-RESISTANCE more formally. De\ufb01nition 1 We say a defense mechanism d(n) \u2208D, n \u2208N provides attack resistance for a class of victim program C running on a machine M against an attacker Ae and a set of malicious programs S if and only if: \u2200p \u2208C \u2200p\u2032 \u2208S Pr[E(p + d, p\u2032, Ae)] \u2264\u03f5(n), where \u03f5 is a negligible function on n. Clearly C excludes program whose vulnerability free version allow users to execute programs in S (for instance interpreters). However we leave this class of programs unspeci\ufb01ed, since in general it will depend on the defense mechanism and the attacker model considered. \fWe give a few intuitive examples here and a detailed example in Section 4: \u2022 If e is simple code injection (appending malicious code to a message that overwrites a buffer) then some implementantions of ISR [23] provide attack resistance for programs p that do not leak the seed. We will elaborate about this example in the following section. \u2022 If e is ROP, then simple ASLR does not provide attack resistance for many programs, whereas advanced ASLR (where the base address of p is also randomized) or advanced ISR [29] do. \u2022 If e is blind ROP [9] and k is small (or it is not allowed to restart the program enough times by the same attacker), then common ASLR provides attack resistance against a large class of programs, otherwise it does not. 3.1 Proof Strategy for Establishing Attack Resistance Note that in practice most defense mechanisms against memory management exploitability rely on the randomness of a certain runtime transformation. Ideally this randomness should guarantee security and not the complexity of the transformations induced by the defense mechanisms, similarly as secret keys are the security cornerstone of cryptographic guarantees as suggested by Kerckhoffs\u2019s principle [25] or Shannon\u2019s maxim [36]. Therefore, a strategy for establishing ATTACK-RESISTANCE is to prove that the following suf\ufb01cient conditions hold for a program p \u2208C and the defense mechanism d, under the attacker model A: 1. Runtime Secret Seed: A condition for the ef\ufb01cacy of defense mechanisms is the existence of bit sequence s, |s| \u2208O(n) called Runtime Secret Seed in the pair p + d of program and defense mechanism. Note that if the transformation induced by the defense mechanism is not probabilistic, then an attacker could eventually reverse engineer it. 2. Resistance guaranteed by keeping the seed secret: A further condition is a Lemma relating the attack event (remotely executing a malicious program) with the probability of guessing the random seed s. In other words, to show that for each p\u2032 \u2208S, Pr[E(p + d, p\u2032, Ae)] \u2264\u03b1 \u00b7 Pr[{Ae guesses s}] for some constant \u03b1. 3. Bounding the Attacker\u2019s probability of guessing s: A useful formal notion to measure the attacker\u2019s knowledge is to consider the entropy of s. A further condition for the ef\ufb01cacy of the defense mechanism d is thus that the attacker\u2019s a priori knowledge of s must be low, i.e., the a priori entropy of s is high, and that it remains high after static and dynamic analysis of p + d. This notion can be formally captured for instance by quantifying maximal leakage [37], seen as the difference between the a priori and posteriori entropy of s after program analysis and interaction with the victim machine. This condition is important since weak defense mechanisms could have a poor key generation algorithm or some other vulnerability that decreases the ideal (maximal) entropy of the key. In other words to show is that the Pr[{Ae guesses s}] \u2264\u03f5(n) for instance by computing the maximal leakage of s on the network channel (de\ufb01ned as the difference of the entropy of s before executing p and after code analysis and observing the k output messages). In the following section we will discuss some variants of ISR from the point of view of ATTACK-RESISTANCE. 4. Attack-resistance of ISR In the following we discuss and analyze ISR as proposed in [24], which is supposed to be resistant against code-injection attacks. In code-injection attacks a sequence of machine code instructions are written to the stackor heap-memory of a running process by exploiting a buffer over\ufb02ow vulnerability. Additionally, the attacker must overwrite the return address on the current stack frame, using a value that points to the beginning of the injected code. After the current function ends its execution, the overwritten return address is loaded in the instruction pointer register and starts executing the injected code. Figure 1. ISR run-time instruction decoding before execution. The idea behind ISR (illustrated in Figure 1) is to encode the original instructions of a program using a random key and decode them during runtime, right before execution of each instruction. Both RISC (e.g. ARM) and CISC (e.g. Intel x86) architectures use machine code instructions consisting of opcodes followed by zero or more operands. Encoding using a random key maps the values of opcode and operands to a set unknown to a remote attacker which does not have access to the key. Therefore, if the attacker does not guess the correct key, the injected code will be \u201cdecoded\u201d before execution to a different value than intended. Depending on the number of possible instructions for that architecture, their length and the length of the key, the program will either crash or execute a different instruction than intended. We will argue about the probability of each of these outcomes in the following paragraphs. However, since there have been several attacks on ISR [38, 42], which are enabled by the existence of 1 and 2 byte instructions on CISC architectures such as Intel x86, we will assume only 32-bit RISC architectures in the following paragraphs. Moreover, Table 1 shows a broader overview of the previously mentioned attacks (\ufb01rst row) and the assumptions they rely on (\ufb01rst column). We give a few countermeasures on the right-most column which disable the attacks. In the following we will use a combination of some of these countermeasures to build a defense which is ATTACK-RESISTANCE against code-injection attacks. ISR with XOR-ing in ECB mode: Consider a hardware implementation of ISR using a \ufb01xed length n-bit key (stored per process in kernel space), which changes on each process start-up. Furthermore, assume that the Decoder in Figure 1 is a n-bit XOR gate implemented in hardware. Let IS the instruction set for a given RISC architecture. Let |IS| = 2l. Let n be the size in bits of an instruction. Now assume that adversary encodes a program p\u2032 using e. Irrespective of his encoding strategy, the \ufb01rst instruction i1 of p\u2032 must be such that i1 \u2208IS, otherwise the program will crash. If the key s is chosen uniformly at random, and has not been leaked: Pr[{i1 \u2208IS}] \u2264 1 2n\u2212l . because XORing with a random value is basically a random permutation in the set of possible instructions. Since l is costant for a given architecture, this function is negligible in n. For example, the 32-bit ARM architecture has an instruction set consisting of under 27 instructions. Therefore in this case we obtain that the probability that an injected instruction is in IS is less or equal to 1 225 . Otherwise, the program will crash and will use a different key upon restart, provided there is no leakage on the key. \fAssumptions (down) \\Attacks (right) Return attack [38] Jump attack [38] Direct key extraction [42] Known plaintext attack [42] Chosen key attack [42] Key guessing attack [42] Countermeasures Attacker knows address where code is inserted \u00d7 \u00d7 ASLR Same key used after crash and restart \u00d7 \u00d7 \u00d7 Change key upon crash Encoded instruction and decoded instruction pair give the key (e.g. XOR is used for de-/en-coding) \u00d7 \u00d7 \u00d7 \u00d7 Use bit transposition Attacker can distinguish 2 behaviors (e.g. crashed and not crashed) \u00d7 \u00d7 \u00d7 Attacker can distinguish server activity between guessed return instruction and \ufb01rst instruction that would cause the program to crash \u00d7 Attacker can produces in\ufb01nite loops on the target program \u00d7 Key location is \ufb01xed and in program accessible user-space memory \u00d7 Make key location unaccessible via userspace program Format string or buffer over\ufb02ow vulnerability that displays string to end-user \u00d7 \u00d7 Secure MultiExecution Knowledge of the binary executable code (this is the plaintext). It could also be a library if that library is ISRed \u00d7 Secure MultiExecution Key(-generator) of ISR mechanism can be replaced via remote attack (e.g. ret-to-libc) \u00d7 Make key location unaccessible via userspace program Table 1. ISR Attacks versus Assumptions and Countermeasures Preventing leakage: In the event that the program does not crash and the key is wrong, the program will execute some instruction from IS. To avoid that this information or another vulnerability in the program leaks the key such as in direct key extraction and known-plaintext key extraction presented in [42], we propose to combine ISR with secure multi-execution (SME) [16]. In this case, we SME to run two copies of the program in parallel, each randomized with a different key. Both programs receive the same input, however, before outputting anything the SME mechanism checks if the outputs of the two program copies are equal. If so, it forwards the output, otherwise the output is blocked. Under the assumption that the behavior of the program is deterministic, SME guarantees that any of the two keys will not be leaked. Thus, after proving absence of leakage of the key, we can conclude: Pr[E(p + d, p\u2032, Ae)] \u2264Pr[{i1 \u2208IS}] \u2264 1 2n\u2212l \u2264\u03b1 \u00b7 \u03f5(n). for \u03b1 = 2l and \u03f5(n) = 1 2n . ISR with a Stream-cipher: An alternative way to implement ISR is, instead of XOR-ing each instruction in the program with the same key, to use a pseudo-random number generator (PRNG) with a large periodicity, seeded by our n-bit key in order to decode the programs with a stream-cipher. In this case, the length of an instruction is independent of the size of the key, and therefore we denote it with n\u2032. If the malicious program p, which the adversary wants to inject consists of j instructions [i1, i2, \u00b7 \u00b7 \u00b7 , ij], a successful attack requires either guessing j \u00d7 n\u2032-bits or the n bits of the key. Therefore, the probability that the program does not crash and chooses another random key is: Pr[{i1, i2, \u00b7 \u00b7 \u00b7 , ij \u2208IS}] \u2264 1 2min(j(n\u2032\u2212l),n) , which is far less than Pr[{i1 \u2208IS}]. The key-guessing attack presented in [42] shows some examples of the shortest sequences of instructions that cause damage consist of at least 3 instructions. Therefore, if we consider the previous example of a 32-bit ARM architecture and substitute j by 3, we get that the probability of executing a sequence of injected code consisting of 3 instructions without crashing the program is equal to 1 275 . Interestingly, in this case is not suf\ufb01cient to increase the key (seen as the input to the PRNG) size to achieve asymptotic better guarantees, but it is necessary to also increase the size of the instructions. Increasing the instruction size: Note that the effective security parameter in ISR is the instruction size. Usually, the instruction size is determined by the CPU architecture, and therefore to increase it, one would need tailored hardware. Although it might be unpractical (from the ef\ufb01ciency perspective) to increase the instruction size to improve upon the security guarantees, it is possible to achieve this without modi\ufb01cations in hardware by using virtualization. For instance, virtualization obfuscation such as the one provided by Tigress1 allows one to con\ufb01gure the size of the virtualized and randomized instruction set. However note that as discussed before, in practice the probability of code injections attacks for ISR on 1 http://tigress.cs.arizona.edu/ \fRISC (32 bit) based architectures are already vanishingly small, given guarantees on the absence of key leakage. Issues with side channels: Under the assumptions that stackbase address randomization is not employed and that the key is not changed when restarting a program and Sovarel et al. [38] use timing side-channels to determine the key value on Intel x86 architectures. Their technique has a success rate of over 95% and requires less than 1 hour for 4096-byte keys. However, in the previous paragraphs we have assumed that the key changes on each program restart, which is enough to thwart this attack. Partial leakage: Note that the fundamental goal to show ATTACKRESISTANCE is that the bounding probability function \u03f5(n) is negligible. Therefore, it is possible to allow some leakage on the key, if it is possible to show that this will not break the negligibility of the bounding function. This is for instance the case when leakage is constant, independent of the key size, or when it is logarithmic. In future work we plan to explore strategies to account for the possibility of side-channels that have such properties. This is important for ef\ufb01ciency, since for instance resampling a key after every crash is computationally expensive. However, allowing a limited number of crashes with the same key will bound the information that an adversary can gain. For instance, leakage resilient cryptography has been sucessfully applied to real implementations in the case of side-channels caused by CPU caches [5]. Alternatively, bounds on the leakage could be obtained by leveraging on quantitative estimations on implementations using techinques such as [28]. Other attacker models: Note that so far we have focused on common injection attacks. As we have discussed before, ISR together with secure multi-execution, is not resistant against other attack strategies such as ROP [32] attacks. ROP attacks do not inject code in process memory, instead they inject addresses of gadgets, which are not affected by the simple ISR implementation so far. However, to make the program ATTACK-RESISTANCE against ROP, it is possible to extend ISR with defense mechanisms such as kBouncer [30], ASLR (randomizing the program base address), or other mechanisms that invalidate ROP (such as hardware implementations of ISR [29]). However it is not trivial to show that the combination of this strategies provide ATTACK-RESISTANCE: they might use different seeds (of different sizes) to achieve randomness on their own and they might introduce new side-channels or attack vectors. Moreover reasoning about attacks such as ROP is more challenging, since it involves reasoning about the probability that a randomized injected address does not hit a gadget, which will strongly depend on the particular layout of the memory at the time of attack. In the future we plan to analyze this issues more carefully, and to show ATTACK-RESISTANCE of this mechanisms under certain assumptions. 5. Threats to Validity of the Research Program Practical Value of The Proposed Formal Analysis Framework, and its difference with respect to traditional formal veri\ufb01cation: The proposed analysis framework essentially establishes that cryptographic primitives used by the defense mechanism d prevent exploitation by certain attackers, and that the runtime information\ufb02ow leakage technique used by d guarantees a bounded leakage of secret bits. This is a one time cost of analyzing d for a large class C of programs that can be accomplished by using appropriate formal veri\ufb01cation techniques, but leaves open that possibility that other attackers can effectively exploit the program. By contrast, in traditional formal veri\ufb01cation approaches, we have to prove that every program p is completely free of memory safety vulnerabilities, if our goal is a 100% guarantee that p adheres to a non-exploitability speci\ufb01cation. Model-checking is PSPACE-Hard: Model-checking a safety property is known to be PSPACE-Hard and so then exploitconstruction should be equally hard (in general undecidable) from a complexity-theoretic point of view. In what way are the guarantees being proposed here any stronger? Observe that we are not saying anything about the general exploit-construction problem, and instead focus on analysis of a parametric class of programs protected by a defense mechanism. The PSPACE-Hardness result is general, and doesn\u2019t say anything about the hardness of exploiting a given program. We are proposing that given a parametric class of programs, certain defense mechanisms can make it harder to exploit and this guarantee of hardness is captured precisely using the notion of ATTACK-RESISTANCE. The Defense Mechanisms considered are Useful only for Memory Errors: The complex software ecosystem of today is subject to all manner of attacks, not only buffer-over\ufb02ow attacks. Hence, it pays to formally analyze defense mechanisms and distinguish effective ones from the rest. The idea of ATTACK-RESISTANCE can be used to analyze any defense mechanism that relies on proper implementation and use of cryptography and guarantees against remote execution of malicious code, such as SQLrand [11]. Some Defense Mechanisms Shift Attacks on Integrity and/or Con\ufb01dentiality to Attacks on Availability: We have assumed that d detects and prevents all attacks against p. However, in practice it is often the case that an attack is \u201cdetected\u201d by a crash of p, which prevents an attacker from taking over the control-\ufb02ow of p. This is the case for defense mechanisms such as PointGuard or its variant we present here. The threat to validity is that ATTACK-RESISTANCE refers to integrity and/or con\ufb01dentiality attacks, but not availability. Guaranteeing the absence of leakage is hard: Depending on the precise details of a defense mechanism, it can be in general harder to guarantee the absence of leakages (non-interference of the secret random see w.r.t. public outputs) than show the absence of BOFs, since non-interference is not a safety property, i.e., is a 1-hypersafety property. Moreover, there is the side-channel issue discussed before: in general to guarantee the absence of certain side-channels, there is a performance penalty to be paid (such as shutting down CPU caches, constant time cryptography etc.). 6. Related Work There is extensive use of formal methods in the security context, especially for protocol analysis [15]. There is also considerable prior work on dynamic information \ufb02ow leakage [33], and on analysis of implementation of cryptographic primitives [3]. Our work is different in that we propose the combination of such analyses to formally establish the effectiveness of defense mechanisms with respect to clearly speci\ufb01ed attackers. Pucella and Schneider [31] have also formally investigated the effectiveness of randomized defenses in the context of memory safety. Their main result is to characterize such defenses as to be probabilistically equivalent to a strong typing which would guarantee memory safety for buffers, thus reducing the security of the defense mechanism to the strength of strong typing. In particular, they analyze address obfuscation [8], a defense mechanism against memory corruption attacks, that uses a secret key to randomize the offsets of code and data in heap memory. Their idea is to treat address obfuscation as a probabilistic type checker, which has a certain probability p of crashing the program when a buffer over\ufb02ow occurs. Differently from our discussion on the ATTACKRESISTANCE of ISR against code-injection attacks in Section 4, by relating to a type checker that catches out of bound access, they automatically consider a wider range of possible attacks. However, also due to this abstract charachterization, they acknowledge the \fdif\ufb01culty on computing the probability of a successful attack, as we propose to do. We believe that different from [31], the ATTACKRESISTANCE framework proposed in this work can also be used to compute the probability of a successful buffer over\ufb02ow against address obfuscation if we combine this defense technique with other techniques, such as SME or quantitative information \ufb02ow analysis, that prevent substantial leakage of the secret key. Abadi and Plotkin [1] also formally investigate the effectiveness of memory layout randomization in programming language terms. Speci\ufb01cally, they consider layout randomization as part of the low-level implementation of a high-level language. This implementation is analyzed by \u201cmapping low-level attacks against it to context in the high-level programming language\u201d [1]. Their results are phrased as full abstraction theorems that say that \u201ctwo programs are equivalent in the high-level language if and only if their translations are equivalent (in a probabilistic sense) in the lowlevel language. The equivalences capture indistinguishability in the presence of an arbitrary attacker, represented as the context of the programs\u201d [1]. These equivalences are powerful enough to express both secrecy and integrity properties. Jagadeesan et al. [22], extend the work of Abadi and Plotkin by considering return-to-libc attacks as well as dynamic memory allocation features in programming languages. While these are very powerful results, they are less general than our approach because we consider a wider variety of defense mechanisms and attacks, and do not \ufb01x the programming language. By contrast, the results of [1, 22] are restricted to ASLR. On the other hand, if a programmer were to write their programs in the high-level language of [1, 22], then they would get the protection of ASLR for free without having to explicitly prove them. In our setting, someone has to prove for a given class of programs, that the defense mechanism is effective for that class. Agten et al. [2] describe a compiler that implements full abstraction, i.e., the compiler guarantees that standard security features in languages such as Java (e.g., private \ufb01eld) are compiled correctly down to the lower-level language and the security at the low-level is enforced via \ufb01ne-grained access control. This work is orthogonal to ours since, unlike our approach, they don\u2019t analyze probabilistic defense mechanisms. Sovarel et al. [38] and Weiss et al. [42] also perform an analysis of the attacks against ISR presented in Table 1. They compute the probability of a successful code-injection attack on a program protected by the ISR mechanism presented in [4]. Differently from our analysis they only give numeric values for these attacks on Intel x86 architectures under additional assumptions, without offering a more general overview of this probability in terms of the size of the key and the size of the instruction set and instruction sizes. Shacham et al. [35] presented a study regarding the assessment of randomization based software defenses. Their study consisted of a concrete attack on any program containing a buffer over\ufb02ow vulnerability protected by ASLR [40]. Their attacker model was similar to our in the sense that the attacker had knowledge about the vulnerabilities in the target program and only had remote access to the target machine. However, one key factor in their attack was the assumption that the remote machine is running a certain version of an Apache server, whose behavior is used as a side-channel. More speci\ufb01cally, if the correct offset of a libc function is sent to the Apache server, then it has a different behavior than when the guess was incorrect. Of course the attack is not dependent on Apache itself, but on a side-channel which leaks the RSS of ASLR. This attack is highly effective on 32-bit systems where, ASLR only randomizes the base address of memory pages which are 4 KBs in size. Therefore, there are only 20-bits of memory which can be randomized. Brute-forcing a randomization space of this size is practical on current hardware. Therefore, the straightforward solution to this attack is to switch to a 64-bit system. In contrast to [35] we assume that side-channels which leak the RSS do not exist. 7."
+                },
+                {
+                    "url": "http://arxiv.org/abs/1204.2989v1",
+                    "title": "STP/HAMPI and Computer Security",
+                    "abstract": "In the past several years I have written two SMT solvers called STP and HAMPI\nthat have found widespread use in computer security research by leading groups\nin academia, industry and the government. In this brief note I summarize the\nfeatures of STP/HAMPI that make them particularly suited for computer security\nresearch, and a listing of some of the more important projects that use them.",
+                    "authors": "Vijay Ganesh",
+                    "published": "2012-04-12",
+                    "updated": "2012-04-12",
+                    "primary_cat": "cs.CR",
+                    "cats": [
+                        "cs.CR",
+                        "cs.LO"
+                    ],
+                    "main_content": "Introduction SMT solvers [3,4] (Satis\ufb01ability-Modulo-Theories Solvers) are computer programs that decide the satis\ufb01ability problem for rich logics such as the theory of bit-vectors and arrays [10], integers, and datatypes. SMT solvers have recently proven to be particularly useful in \ufb01nding security vulnerabilities, debugging, and program analysis aimed at security. The reason for the success of SMT solvers are threefold: 1) The input logic of SMT solvers is rich enough to capture a wide variety of program behavior easily and compactly, 2) SMT solvers have become very e\ufb03cient at solving such formulas obtained from real-world applications, and 3) there are very e\ufb00ective techniques now available, such as symbolic execution [7,8,11], that convert computation into SMT formulas. My solvers, STP [10] and HAMPI [12], are speci\ufb01cally designed to support computer security applications that perform security analysis aimed at \ufb01nding security vulnerabilities [14], detecting malware [15] and constructing exploits [2,6]. 2 STP STP [10] is a solver for a theory of bit-vectors and arrays. STP\u2019s logic is tailored to capture programs expressions exactly. All modern computer program expressions can be reduced to arithmetic and logic operations over suitably-sized (32 or 64 bit) bit-vectors or read/write operations over memory. STP\u2019s logic of bit-vectors captures program expressions, and STP\u2019s logic of arrays captures memory read/writes. This exact bit-precision allows users to easily encode a variety of security errors (e.g., o\ufb00-by-one errors, memory errors, over\ufb02ow errors). STP has been used in more than 100 research projects, a good number of them are tools that automatically \ufb01nd security errors or perform binary analysis. Important examples include: BitBlaze project [15] from Dawn Song\u2019s group at Berkeley, The BAP system from David Brumley\u2019s group at CMU [5], EXE [8] and KLEE [7] from Dawson Engler\u2019s group at Stanford University, S2E project [9] from George Candea\u2019s group at EPFL, Switzerland, Akamai Inc. for \ufb01nding security errors in mission critical applications (contact: Michael Stone), and governmental agencies. A comprehensive list of projects using STP can be found at the following website: http://sites.google.com/site/stpfastprover/tools-using-stp 1 \f3 HAMPI HAMPI [12] is a solver for a theory of strings that can solve constraints built out of string constants, variables, concatenation, extraction and membership in regular expressions and context-free grammars. HAMPI is explicity aimed at \ufb01nding security vulnerabilities, such as XSS attacks and SQL vulnerabilities, in web applications written in JavaScript, PHP and Python. The big users of HAMPI include: The Ardilla tool [13] from Michael Ernst\u2019s group at MIT and University of Washington Seattle, The WebBlaze project [14] from Dawn Song\u2019s group at Berkeley, and Frank Tip\u2019s group [1] at IBM T.J. Watson center at Hawthorne in New York. A comprehensive list of all the tools using STP and HAMPI can be found by typing my name and following links at the Google Scholar\u2019s page: http://scholar.google.com."
+                }
+            ]
+        },
+        "edge_feat": {}
+    }
+}
\ No newline at end of file