Table fact verification aims to check the correctness of textual statements based on given semi-structured data. Most existing methods are devoted to better comprehending logical operations and tables, but they hardly study generating latent programs from statements, with which we can not only retrieve evidences efficiently but also explain reasons behind verifications naturally. However, it is challenging to get correct programs with existing weakly supervised semantic parsers due to the huge search space with lots of spurious programs. In this paper, we address the challenge by leveraging both lexical features and structure features for program generation. Through analyzing the connection between the program tree and the dependency tree, we define a unified concept, operation-oriented tree, to mine structure features, and introduce Structure-Aware Semantic Parsing to integrate structure features into program generation. Moreover, we design a refined objective function with lexical features and violation punishments to further avoid spurious programs. Experimental results show that our proposed method generates programs more accurately than existing semantic parsers, and achieves comparable performance to the SOTA on the large-scale benchmark TABFACT. With the rise of misleading information on the Internet, such as fake news, rumors and political deceit, fact-checking has been developed as a means of detecting and filtering false information. Table fact verification (TFV) is a specific fact-checking task that requires performing logical operations such as comparison, superlative and aggregation over given tables to verify textual statements. Programs play an important role in TFV. On one hand, correct programs can provide rationales for model decisions, which make reasoning analysis * Corresponding author Season Podiums  1980 9  1981 8  1981 0    ... and failure diagnosis feasible (Zhou et al., 2018). On the other hand, they can be used to fetch the key evidences for verification. Figure 1 gives an example of mainstream methods (Zhong et al., 2020a; Shi et al., 2020b; Yang et al., 2020; Shi et al., 2021) for TFV. It first generates latent programs from statements, then collects evidences from tables by executing the programs over the tables, and finally leverages all information for final predictions. Compared with naive methods(Chen et al., 2020; Zhang et al., 2020a) which simply put statements and linearized tables into language models for verification, the mainstream methods additionally introduce programs to reveal the evidences (e.g., verbalized evidence V1 ) covered by logical operations (e.g., max([row1, row2]], podiums) ) and to fetch the key information from the table (e.g., 8 ). But an incorrect or spurious program may introduce irrelevant or even contradictory evidences. So it is crucial to get correct programs that properly extract evidences from tables, especially when tables are too large to be encoded by neural networks. Despite being important, program generation remains underexplored for TFV. To the best of our knowledge, only LPA (Chen et al., 2020) works on program generation. It first searches programs 7624 with human-designed features, then ranks them with a neural network, and finally uses the execution result of the top program as the prediction. However, it exhibits an unacceptable performance which means it generates incorrect programs. The remaining approaches just predict the correctness of statements but never concern about generating correct programs. In TFV, there is still a need to find better solutions for program generation. Intuitively, we can resort to weakly supervised semantic parsing (Liang et al., 2011) for the program generation, but existing semantic parsers may fail in TFV for the amplified spurious program problem caused by the binary label. Due to the lack of program labels, existing methods will sample label consistent programs for model training. In TFV, any sampled program that outputs a Boolean value has a 50% chance of hitting the correct label; hence there are many label consistent programs, while only a small part of label consistent programs are correct, implying that the rest are all spurious. In this paper, we carefully examine the syntax structures of statements and find that task-related structure features are the key to address the issue mentioned above. We propose a unified operation-oriented tree constructed in three steps. Firstly, we link entities between the table, trigger dictionary and statement. Secondly, we obtain the original tree using a dependency parser with the linked statement as input. Thirdly, the original tree is pruned and merged to a simplified tree that contains only information related to operations. Such a unified tree can provide distant supervision, assisting our model in generating single operations correctly and generating all operations in the correct order. As a result, we have a higher probability of getting correct programs and evading spurious ones. Then we introduce Structure-Aware Semantic Parsing (SASP) by designing a scoring function based on the proposed tree and fusing the sample distributions computed by the scoring function and neural network. At last, we design a refined objective function with lexical features and violation punishments to avoid spurious programs further. Experimental results on Tabfact and Logic2Text show that SASP improves the performance of the baseline model significantly, and achieves comparable performance to the State-Of-The-Art method. Our contributions are as follows:  We propose an operation-oriented tree to provide distant supervision for semantic parsing. We propose SASP which leverages both lexical features and structure features for the serious spurious problem in weakly supervised semantic parsing for TFV. With the proposed method, we can generate more accurate programs which can not only boost existing mainstream methods for TFV, but also provide explanation for verification. Fact Verification Fact verification aims at identifying the truthfulness of online textual statements given different sources of evidences, including document sets (Thorne et al., 2018; Nie et al., 2019; Zhong et al., 2020b; Wan et al., 2021), images (Suhr et al., 2019; Li et al., 2020) and structured tables (Chen et al., 2020; Zhong et al., 2020a; Shi et al., 2020b; Zhang et al., 2020a; Yang et al., 2020; Shi et al., 2021). Despite the sources of evidences used to support the verification vary, the methods for different tasks appear to have the same idea. They first locate the key evidences that will aid in their verification, then fuse the collected key evidences with the original statement to make the final prediction. In this paper, we focus on generating better programs that allow existing methods to get key evidences from tables efficiently, hence benefiting existing methods for TFV. There are also many explainable fact verification works(Kotonya and Toni, 2020a). Attention based methods(Popat et al., 2018; Lu and Li, 2020; Wu et al., 2020) highlight key evidences according to attention weights. Atanasova et al. (2020); Kotonya and Toni (2020b) generate explanations in natural language with text summarization technology. Gad-Elrab et al. (2019); Ahmadi et al. (2020) use horn rules and knowledge graphs to mine explanations. Our work is similar to the third line of works from the perspective of explainability. Semantic Parsing Due to the expensive cost of annotated programs, weakly supervised semantic parsing (Liang et al., 2011; Berant et al., 2013; Artzi and Zettlemoyer, 2013) has been proposed to learn program generation from sentence-label pairs. Compared with full supervision, weak supervision brings spurious problems: there may be spurious programs that accidentally reach the right answer for the wrong reason, and they will provide wrong supervision for model training. Previous work (Pa-supat and Liang, 2016) uses crowd-sourced deno-7625 tations to prune spurious programs. Liang et al. (2018) use both programs inside and outside the memory buffer to compute the expected return objective in case the neural model is misled by spurious programs inside memory. Dasigi et al. (2019); Misra et al. (2018); Agarwal et al. (2019) rely on lexical features to differentiate between spurious and correct programs. Most recently, Cao et al. (2019); Ye et al. (2019); Shao et al. (2021) exploit the semantic correlations between sentences and programs to rule out spurious programs via jointly learning semantic parser and sentence generator. In this paper, we focus on a more complex problem, learning program generation with (sentence, binary label) pairs, in this field, and take the above approaches a step further by leveraging both lexical features and structure features. There already exist many works utilizing the structural correlations between a sentence and its programs. Previous works(Reddy et al., 2016; Hu et al., 2018) directly transform the dependency structure of a sentence into a program, which is not satisfactory on complex sentences. In recent years, some works(Wang et al., 2019; Herzig and Berant, 2021; Li et al., 2021) treat structural constraints as latent variables, then parse a sentence into a program under the constraints. However, it is difficult to learn latent variables in a noisy environment. Simultaneously, modeling structural correlations explicitly requres human annotations.(Sun et al., 2020; Shi et al., 2020a). In this paper, we propose a concise and robust method to integrate the structural correlations into semantic parsing. Structure-Aware Semantic Parsing (SASP) centers around the operation-oriented tree to deconstruct some compositionality of statement and generate program correctly. Figure 3 gives an overview of our proposed SASP. In this section, we will first introduce the task formulation, then describe how to construct the operation-oriented tree, and give the way to generate programs following the well-designed tree at last. Given a table T = { cell i,j | i  R, j  C } with the table header H = { col j | j  C } as evidence, a statement S = { w i | i  W } with W words and a true label y  Y = { T rue, F alse } where T rue means T entails S and F alse means T refutes S , we aim to train a model to do explainable verification. More specifically, we train a model to translate S into an executable program z , then predict a label  y z  Y by accessing the table T with program z such that  y z = y . Different from most existing methods, which just pay attention to predicting a label  y  Y such that  y = y , our model also generates a program as accurate as possible to explain and support the verification. Program A program z can be seen as a set of executable operations  { op i | i  M } . Considering the program example in figure 1, there are six operations in total, and each operation op i = { op i .func, ..., op i .arg j , ..., op i .out } has one operator op i .func (e.g., filter_eq in the figure), multiple operands op i .arg j , 0 < j   relevant to the table T (e.g., all_rows , season and 1981 ) and one output v i = op i .out which may be selected as an operand by subsequent operations. When the whole program is executed by an interpreter, it will be parsed into a tree as shown in figure 1 and executed from bottom to up. According to the execution correctness and the semantic consistency, we divide programs from the executable program set Z into three categories, as shown in figure 2. 3.2 Operation-Oriented Dependency Tree In this part, we first reveal the connection between the program tree and the dependency tree. Then, we design a unified operation-oriented dependency tree for making full use of the connection. Syntactic structures, the organization of tokens in a sentence and how the contexts among them are interrelated, can be revealed by a dependency tree whose nodes and edges correspond to words and grammatical relations in the sentence. We observe that: (1) the operations related to descendants tend to be executed before those related to ancestors in the dependency tree; (2) the operator and operands  The definition of specific operations are listed in Appendix A.1 7626 root In 1981 season, the highest number of podiums was 8 and the lowest was 0 Pruning Irrelevant Info Merging Relevant Nodes [;1981; season] [highest;8;podiums] [lowest;0;podiums/wins] root Operation-oriented tree root [1981] [season] [highest] [podiums] [8] [lowest] [0] In 1981 season, the highest number of podiums was 8 and the lowest was 0 Dependency Parsing neural flow symbolic flow attention function representation column representation cell representation [CLS] Statement [SEP] Table [SEP] BERT + + + LSTM cell _ 1981   Program Interpreter Final Prediction     sample Figure 3: An overview of our proposed approach. within one operation tend to have shorter distances in the dependency tree; in the correct program compared with the incorrect or spurious one. Use the dependency tree in figure 3 and the program in figure 1 as an example. The operation filter_eq related to the child node is executed before the operation eq(v1, 8) corresponding to the father node. What's more, the distance of operands in the incorrect operation filter_eq(all_rows, podiums, 1981) is 6, while that in filter_eq(all_rows, season, 1981) , a correct operation, is just 1. The observations above suggest that there exist some structural correlations between a statement and its programs. We will present how to make use of them in the next section. Before that, we propose an operation-oriented dependency tree to strengthen the above rules in two steps. First, we prune the original dependency tree to focus exclusively on the operation-related structure. Then, we merge the information around every operation to make information in a single operation more com-pact. What's more, it is more convenient to define and calculate the distance in a simplified tree. The left part of figure 3 illustrates how to construct the proposed tree. First of all, we do rule-based entity linking to find potential operators and operands from the statement. For operators detection, we match strings between the statement and the pre-defined trigger words  , and give the matched entities a function type. As for operands, we divide them into two types, cell and column , as they are linked to table cells and the table header respectively (e.g., 1981 has a cell type and season has  All pre-defined trigger words are listed in Appendix A.2 a column type). Then we pass tokens and linked entities with types into a general dependency parser to get a dependency tree  . Every linked entity node n = { n.children, n.type, n.val } , n   has a list type with one type and a list val with one entity. For every token node, its type list and val list are both empty. After that, for every entity node with a cell type value cell i,j , we will add column and col j into its type list and val list respectively. At last, 7627 we call PRUNE in algorithm 1 using  as input and get output   . The nodes left in the tree may contain function info corresponding to the logical operations, cell info and column info from tables. In this section, we will introduce SASP, which unifies both structural features and lexical features with one operation-oriented dependency tree. As shown in the right part of figure 3, we first employ BERT (Devlin et al., 2019) to encode the statement S and the table T following TABERT (Yin et al., 2020). Then we get representations for the statement and entities with different types, which will be fed into the decoder. During decoding, the logits are computed by an LSTM with attention mechanism(Luong et al., 2015): h t = LST M ( h t  1 , x t  1 ) a t = MLP ([ h t ; Attention ( h t , S )]) l t = MatMul ( X t , a t ) (1) where h t is the hidden state, x t  1 is the token generated previously, X t is the candidate token list selected from the vocabulary according to the token type at timestep t (e.g., the type for the second token in the program being predicted is column ), and l t are the logits for the t th token over X t . However, in TFV, it is difficult to find the correct optimization direction with only attention mechanism, especially at the beginning of the training, because of the serious spurious problem. So we bias the logits with our proposed tree additionally. As a result, our model can give the correct program a higher probability, therefore exploring search space efficiently and evading spurious programs. More specifically, we design two scoring mechanisms in line with the two rules found in the previous section. As shown in algorithm 2, given  < 1 , score =  distance means the closer distances, the higher scores. For operator selection, we calculate the average distance from the candidate x  X to its leaves in the tree   , and set the distance to be +  if it is not in the tree. For example, the candidate operator max (triggered by highest ) has a score of  1 . In this way, we give operators closer to leaves higher scores, which leads to operations related to descendants being generated before those related to ancestors. For operand selection, we compute the average distance from the candidate x  X to tokens in the operation op . Use the operation in figure 3 as an example, the score of the Algorithm 2 Scoring function with candidate token list X , operation-oriented tree   and operation being predicted op as input, where  < 1 is a hyper-parameter. candidate 1981 is  0 when the timestep t = 3 . In this way, we prioritize the tokens closed to existing information in the operation being generated, so that the distances inside one operation tend to be shorter in the dependency tree. At last, we combine the scores  t given by algorithm 2 and the logits l t computed by Equation 1 to get the final sample distribution:  t = Score ( X t ,  , op ) P ( X t | S, T, x <t ) = Softmax ( l t +  t ) (2) where  is a hyper-parameter,   is the operation-oriented tree and op is the operation being predicted. After we sample x t  P ( X t | S, T, x <t ) , it will be used to update h t ,   and op . We give more details in Appendix A.3. Previous works(Agarwal et al., 2019; Dasigi et al., 2019) measure the relevance between a sentence and a program by their coverage, and use that lexical coverage to augment the reward function. In a similar spirit, we design the reward based on our proposed tree. Our intuition is that different types of tokens play different roles in the operation-oriented tree, and therefore should be treated under varying degrees. And our reward is defined below. are hyper-parameters, and  y z is the label predicted by accessing the table T with the program z . Since all operation-related tokens of a statement are reserved in the operation-oriented tree, we can calculate the relevance between a statement and a program by r  = (cid:80) n    1 { i, n.type [ i ] =   n.val [ i ]  z } (cid:80) n    1 { i, n.type [ i ] =  } (4) where { n | n    } are nodes of our proposed tree. For further improvement, we modify the generalized update equation in PolicyShaping (Misra et al., 2018) to get Maximum Likelihood Most Violation Reward. The final objective function is: J  = (cid:88) ( S,T )  D (cid:16) (cid:88) z  Z set R ( z )  ( z | S, T )   max z   Z err (  ( z  | S, T )) (cid:17) (5) where D contains all S-T pairs, Z set is the set of sampled executable programs, Z err  Z set is the set of incorrect programs,  is the sample policy,  is a hyper-parameter and  contains all the trainable parameters. We think such an update equation more robust than REINFORCE helps the model learn better with many spurious programs in Z set . Dataset and Evaluation Metrics We conduct experiments on the large-scale dataset TABFACT (Chen et al., 2020), which aims to study fact verification given semi-structured data as evidence. TABFACT contains 16,573 tables and 118,275 statements which are divided into training (80%), validation (10%) and testing (10%) sets. The testing set is further partitioned into simple and complex sets. The statements in the complex set are more complicated in semantic compositionality than those in the simple set. Because there is no program ground-truth provided in TABFACT, we just use the label accuracy as metric for comparison, which is also called execution accuracy (Ex.Acc). We also conduct experiments on WikiTableQues-tion (WTQ) (Pasupat and Liang, 2015), a commonly used weakly supervised semantic parsing dataset, for further evaluation. And we use the same setting as previous works. 10,000 correct statement-table-program tuples, to evaluate parse tree matching accuracy (PT.Match) (Kim et al., 2020) for programs generated by our method and other methods that also provide programs. Because there are only "ENTAILED" statements in Logic2Text, we use the model trained on TABFACT to predict programs without tuning. Implementation Details We use CRF2o (Zhang et al., 2020b) for dependency parsing. For semantic parsing, we use pytorch neural symbolic machine (Liang et al., 2017, 2018; Yin et al., 2020) as our baseline and improve it with the operation-oriented tree. Further, to bootstrap SASP, we use  t in Equation 2 to sample around 10 label consistent programs per example, and load them into memory buffer before training. For BERT parameters, we set the hidden size to 768, and use Adam optimizer with lr 5e-5, warmup step 30k, dropout 0.2. For LSTM parameters, we set hidden size to 200, and use Adam optimizer with lr 3e-3, train step 150k, dropout 0.2. As for hyper-parameters  ,  ,  func ,  cell ,  column and  , we set them to 0.7, 2, 0.2, 0.4, 0.4 and 0.2 respectively. All experiments were conducted on a workstation with 128 GB of RAM and 2 RTX 3090 GPUs. Our source code is available at: https://github.com/ousuixin/SASP . Compared Systems We compare our model with the following baselines, including six that focus on label prediction and two that pay extra attention to program generation. Among the former five methods, Table-BERT (Chen et al., 2020) and SAT (Zhang et al., 2020a) focus on table linearization, so they use different ways to change 2-dimensional tables into 1-dimensional sequences composed of tokens, and then feed them into BERT for label prediction. LFC (Zhong et al., 2020a), HeterTFV (Shi et al., 2020b), ProgVGAT (Yang et al., 2020) and LERGV(Shi et al., 2021) pay attention to comprehending tables and programs. They use different ways to encode programs (generated by LPA-ranking) and tables for verification, although the programs they use are not precise at all. The latter two methods will generate programs and use program execution results as final predictions, including LPA-ranking (Chen et al., 2020) and MAPO (Liang et al., 2018) with BERT. Table 1 gives the overall performance of all eight baselines and our proposed SASP, from which we can observe that: 7629 (1) As a semantic parsing method, our method achieves performance comparable to the State-Of-The-Art method LERGV while maintaining explainability. This is what previous semantic parsers can not do, and shows our superiority in TFV. (2) Our proposed method works better than Table-BERT and SAT, demonstrating the power of the content snapshot proposed by Tabert in catching key information from a table. (3) SASP has a lead of 1.2% on the the complex set compared with ProgVGAT, but falls behind on the simple set. There are two reasons for that. On one hand, mainstream methods like ProgVGAT can fix some errors caused by the symbolic interpreter (e.g., executing eq("USA", "America") to False ). While SASP uses the execution result of the generated program as prediction. Due to the limited expression ability, our interpreter can not cover every statement with a correct program, leading to a lower probability of predicting a correct answer. On the other hand, ProgVGAT can not deal with structural mistakes (e.g., replacing max with min operation) in programs generated by LPA. As a result, ProgVGAT performs worse in complicated semantic environment where LPA has a higher probability of making a structural mistake. Performance on WTQ Table 2 shows the experimental results on WTQ. Our model just has comparable performance with our baseline, MAPO w/ BERT. We give two possible reasons below: Model Dev Test Pasupat and Liang (2015) 37.0 37.1 Dasigi et al. (2019) 43.1 44.3 Agarwal et al. (2019) 43.2 44.1 Wang et al. (2019) 43.7 44.5 MAPO w/ BERT (Yin et al., 2020) 49.6 49.4 SASP 49.3 49.5 Table 2: Performance (execution accuracy) of different methods on WikiTableQuestion. (1) As can be seen in figure 1, the program has more than three operations, which is quite common in TFV, while they use at most three operations to answer a question in previous works (Pasupat and Liang, 2015; Zhong et al., 2017; Liang et al., 2018). Because the compositionality of WTQ is lower than TABFACT, our proposed operation-oriented tree can only provide very limited help. (2) The spurious program problem is further amplified by the binary label in TABFACT. Any program that outputs a Boolean value has a 50% chance of hitting the correct label; hence there are many label consistent programs. While in WTQ, it is not that easy to hit the correct label. Suppose that the vocabulary list has N tokens, but only one token corresponds to the answer. Every executable program in WTQ will output an answer with the string type, so it only has a 1 N probability of hitting the correct label. WTQ has much fewer spurious programs, so lexical features are enough to rule out 7630 Model PT.Match Ex.Acc MAPO w/ BERT 13.4 70.1 LPA 15.6 56.7 SASP 47.9 75.9 Table 3: Performance (matching accuracy and execution accuracy) of different methods on Logic2Text dataset. Performance on Logic2Text Results of different semantic parsing methods are shown in table 3. Our model outperforms other methods with a considerable margin on PT.Match metric. This means SASP can generate more correct programs, which makes it behave well in table fact verification. In program generation for TFV, the search space is too large to be explored completely. To tackle this problem, MAPO w/ refined reward performs systematic search space exploration guided by lexical features in the advanced reward function. It only obtains PT.Match accuracy of 13.4% on Logic2Text. The high Ex.Acc score shows that it just predicts spurious programs executed to "True". For LPA, it first collects all programs under the search space restricted by a lexical feature based algorithm, then ranks these programs with a neural network (BERT). And LPA also has poor behavior in program generation here. The big gaps (more than 40% in MAPO and LPA) between PT.Match and Ex.Acc accuracy suggest that with only lexical features, there are still many spurious programs being explored. Use the spurious program in figure 2 as an example, it conforms to lexical features by making full use of sentence tokens, and would be a promising candidate in MAPO and LPA. However, such kind of programs will differ from the correct ones in the order of operators or the position of operands, so they can be distinguished from correct programs by structure features. Our method captures both lexical and structure features, therefore evading such spurious programs and biasing generated programs from label consistent towards semantic consistent. The smaller gap (28% in SASP) between PT.Match and Ex.Acc accuracy confirms our analysis above. We further conduct an ablation study to evaluate the necessity of leveraging structure information through rules (1) and (2). For rule (1), which defines the operator selection mechanism, we just drop types and values related to function in our proposed tree to see how it influence. For rule (2), which defines the operand selection mechanism, we drop types and values related to cell or column . If we drop all types from the tree, the algorithm degenerates into MAPO w/ BERT refined-reward violation. The experimental results are given in Table 4. We can see that function is the most important type, then is column type, followed by cell type. And all of the types make significant contributions to the final performance. The results above show that both mechanisms associated with the rule (1) and the rule (2) are crucial for our model because both operator and operand selections are crucial for program generation. Effect of Objective Function To evaluate the im-pact of the refined objective function in Equation 5, we conduct another ablation study, and the results are shown in table 5. We change the reward function in Equation 3 with a binary reward function for comparison. The result shows that refined feedback taking lexical features into account plays an essential role in our model. Without the refined reward, some operations may be omitted because the partial programs are already executed to the right label, resulting in a much worse performance. We also remove the violation punishment to investigate the necessity of a conservative update policy. The result shows that the robust update policy 7631 Statement LPA SASP In the 1993 -94 belarusian premier league , the venue with the highest capacity wasminskat41040. makes around 1% improvement. The reward function we designed just prioritizes programs that use tokens related to logical operators or tables as much as possible, leading to label inconsistent programs that meet the condition. Giving such programs a punishment complements the refined reward. In figure 4, we provide two cases to demonstrate the effectiveness of our method for program generation. In both cases, our method generates correct programs that are semantic consistent with the statement, while LPA screws them all up. In the first case, max is the descendant compared with minsk in the dependency tree, so our method uses max before minsk , while LPA gets the wrong order. This confirms that our method generates programs in the correct order with the operator selection mechanism. In the second case, devin has a more close relation to not in the dependency tree, so our method chooses devin as an operand of filter_not_eq , while LPA selects an incorrect operand milwaukee for filter_not_eq . This confirms that our method generates single operations correctly with the operand selection mechanism. To check the generalizability and limitations of our proposed method, we randomly sampled 200 examples from the validation set of TABFACT, and manually inspected the top one program of the beam search using SASP. We found that SASP generated correct programs for 99 examples, spurious programs for 57 examples and incorrect programs for 44 examples. The proportion of correct programs (49.5%) and spurious programs (28.5%) is similar to that in table 3 (47.9% and 28%). This shows the generalizability of SASP and the rationality of using Logic2Text for PT.Match evaluation. What's more, we classified the causes of 101 spurious or incorrect programs into four main categories. Unsupported operations cause 30 error examples. For instance, in "the new york rangers beat the at-lanta flames by 2 points" , the minus operation in a single table cell "4 2" is not supported by our interpreter. The second category of errors occur when the functions or entities can not be detected and added to dependency tree nodes correctly. Use "the maroon played 3 teams located in the united states" as an example, "the united states" can not be linked to "America" in the given table; hence it will not be added to the operation tree. 31 error examples are caused by this reason. The first two categories can not be handled by our proposed method, and we leave the development of powerful interpreter and robust entity linker for future work. The third category is structure error, causing 13 error examples. In other words, the order of operators or the position of operands in the predicted program differs from the correct one. The wrong programs in figure 2 are all this kind of error cases. Underutilized information causes 23 error examples. For the statement in figure 1, "fil-ter_eq(all_rows, season, 1981); max(v0, podiums), eq(v1, 8)" causes this kind of error. In this paper, we have proposed a novel approach to do explainable verification by structure-aware semantic parsing. Firstly, we define a unified operation-oriented tree by entity linking, dependency parsing and tree pruning. Then, we demonstrate how to integrate our proposed tree into semantic parsing with the operator-related and the operand-related principles. At last, we introduce the refined objective function which could reduce the influence of spurious programs. Experimental results confirm that our proposed method can bias program generation from label consistent towards semantic consistent and achieve acceptable performance on the benchmark dataset TABFACT. Future work will collect evidences that are more precise and get better verification performance by replacing LPA with SASP in the first stage of mainstream methods. We appreciate the discussion with Weilin Luo, Weinan He and Yeliang Xiu. We acknowledge support from the Natural Science Foundation of China under Grant No. 62076261.
abstain method abstain abstain method objective objective abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result objective abstain result abstain method result objective objective abstain objective objective objective other other other method other other other other abstain other other other other other other method other other other other other other objective abstain abstain abstain other abstain method method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain other abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain method method abstain abstain abstain abstain method method abstain abstain abstain abstain other abstain abstain abstain abstain abstain abstain abstain method method abstain abstain method method method abstain abstain abstain abstain method abstain other method other abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain abstain abstain abstain other abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method method method abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain objective method objective objective objective abstain other other