Original: FOLD-R++: A Toolset for Automated Inductive Learning of Default Theories from Mixed Data
Revised: FOLD-R++: A Toolset for Automated Inductive Learning of Default Theories from Mixed Data

Original: Abstract
Revised: Abstract

Original: FOLD-R is an automated inductive learning algorithm for learning default rules with exceptions for mixed (numerical and categorical) data.
Revised: FOLD-R is an automated inductive learning algorithm for learning default rules with exceptions for mixed (numerical and categorical) data.

Original: It generates an (explainable) an- swer set programming (ASP) rule set for classification tasks.
Revised: It generates an (explainable) an- swer set programming (ASP) rule set for classification tasks.

Original: We present an improved FOLD-R algorithm, called FOLD-
Revised: We present an improved FOLD-R algorithm, called FOLD-

Original: R++, that significantly increases the efficiency and scalability of FOLD-R. FOLD-R++ improves upon FOLD-R with- out compromising or losing information in the input training data during the encoding or feature selection phase.
Revised: R++, that significantly increases the efficiency and scalability of FOLD-R. FOLD-R++ improves upon FOLD-R with- out compromising or losing information in the input training data during the encoding or feature selection phase.

Original: The FOLD-R++ algorithm is competitive in performance with the widely-used XGBoost algorithm, however, unlike XGBoost, the FOLD-R++ algorithm produces an explainable model.
Revised: The FOLD-R++ algorithm is competitive in performance with the widely-used XGBoost algorithm, however, unlike XGBoost, the FOLD-R++ algorithm produces an explainable model.

Original: Next, we create a powerful tool-set by combining FOLD-
Revised: Next, we create a powerful tool-set by combining FOLD-

Original: R++ with s(CASP)—a goal-directed ASP execution engine— to make predictions on new data samples using the answer set program generated by FOLD-R++.
Revised: R++ with s(CASP)—a goal-directed ASP execution engine— to make predictions on new data samples using the answer set program generated by FOLD-R++.

Original: The s(CASP) system also produces a justification for the prediction.
Revised: The s(CASP) system also produces a justification for the prediction.

Original: Experiments presented in this paper show that our improved FOLD-R++ algorithm is a significant improvement over the original de- sign and that the s(CASP) system can make predictions in an efficient manner as well.
Revised: Experiments presented in this paper show that our improved FOLD-R++ algorithm is a significant improvement over the original de- sign and that the s(CASP) system can make predictions in an efficient manner as well.

Original:  Introduction
Revised:  Introduction

Original: Dramatic success of machine learning has led to a torrent of
Revised: Dramatic success of machine learning has led to a torrent of

Original: Artificial Intelligence (AI) applications.
Revised: Artificial Intelligence (AI) applications.

Original: However, the effectiveness of these systems is limited by the machines’ current inability to explain their decisions and actions to human users.
Revised: However, the effectiveness of these systems is limited by the machines’ current inability to explain their decisions and actions to human users.

Original: That’s mainly because the statistical machine learning methods produce models that are complex algebraic solutions to optimization problems such as risk minimization or geometric margin maximization.
Revised: That’s mainly because the statistical machine learning methods produce models that are complex algebraic solutions to optimization problems such as risk minimization or geometric margin maximization.

Original: Lack of intuitive descriptions makes it hard for users to understand and verify the underlying rules that govern the model.
Revised: Lack of intuitive descriptions makes it hard for users to understand and verify the underlying rules that govern the model.

Original: Also, these methods cannot produce a justification for a prediction they arrive at for a new data sample.
Revised: Also, these methods cannot produce a justification for a prediction they arrive at for a new data sample.

Original: The Explainable AI program (Gunning 2015) aims to create a suite of machine learning techniques that: a) Produce more explainable models, while maintaining a high level of prediction accuracy.
Revised: The Explainable AI program (Gunning 2015) aims to create a suite of machine learning techniques that: a) Produce more explainable models, while maintaining a high level of prediction accuracy.

Original: b) Enable human users to understand, appropriately trust, and effectively manage the emerging generation of artificially intelligent partners.
Revised: b) Enable human users to understand, appropriately trust, and effectively manage the emerging generation of artificially intelligent partners.

Original: Inductive
Revised: Inductive

Original: Logic Programming (ILP) (Muggleton 1991) is one Machine Learning technique where the learned model is in the form of logic programming rules (Horn Clauses) that are comprehensible to humans.
Revised: Logic Programming (ILP) (Muggleton 1991) is one Machine Learning technique where the learned model is in the form of logic programming rules (Horn Clauses) that are comprehensible to humans.

Original: It allows the background knowledge to be incrementally extended without requiring the entire model to be re-learned.
Revised: It allows the background knowledge to be incrementally extended without requiring the entire model to be re-learned.

Original: Meanwhile, the comprehensibility of symbolic rules makes it easier for users to understand and verify induced models and refine them.
Revised: Meanwhile, the comprehensibility of symbolic rules makes it easier for users to understand and verify induced models and refine them.

Original: The ILP learning problem can be regarded as a search problem for a set of clauses that deduce the training examples.
Revised: The ILP learning problem can be regarded as a search problem for a set of clauses that deduce the training examples.

Original: The search is performed either top down or bottom-up.
Revised: The search is performed either top down or bottom-up.

Original: A bottom-up approach builds most-specific clauses from the training examples and searches the hypothesis space by using generalization.
Revised: A bottom-up approach builds most-specific clauses from the training examples and searches the hypothesis space by using generalization.

Original: This approach is not applicable to largescale datasets, nor it can incorporate negation-as-failure into the hypotheses.
Revised: This approach is not applicable to largescale datasets, nor it can incorporate negation-as-failure into the hypotheses.

Original: A survey of bottom-up ILP systems and their shortcomings can be found at (Sakama 2005).
Revised: A survey of bottom-up ILP systems and their shortcomings can be found at (Sakama 2005).

Original: In contrast, top-down approach starts with the most general clause and then specializes it.
Revised: In contrast, top-down approach starts with the most general clause and then specializes it.

Original: A top-down algorithm guided by heuristics is better suited for large-scale and/or noisy datasets (Zeng, Patel, and Page 2014).
Revised: A top-down algorithm guided by heuristics is better suited for large-scale and/or noisy datasets (Zeng, Patel, and Page 2014).

Original: The FOIL algorithm (Quinlan 1990) by Quinlan is a popular top-down inductive logic programming algorithm that generate logic programs.
Revised: The FOIL algorithm (Quinlan 1990) by Quinlan is a popular top-down inductive logic programming algorithm that generate logic programs.

Original: FOIL uses weighted information gain as the heuristics to guide the search for best literals.
Revised: FOIL uses weighted information gain as the heuristics to guide the search for best literals.

Original: The FOLD algorithm by Shakerin (Shakerin 2020;
Revised: The FOLD algorithm by Shakerin (Shakerin 2020;

Original: Shakerin, Salazar, and Gupta 2017) is a new top-down algorithm inspired by the FOIL algorithm.
Revised: Shakerin, Salazar, and Gupta 2017) is a new top-down algorithm inspired by the FOIL algorithm.

Original: It generalizes the
Revised: It generalizes the

Original: FOIL algorithm by learning default rules with exceptions.
Revised: FOIL algorithm by learning default rules with exceptions.

Original: It does so by first learning the default conclusion that covers positive examples while avoiding negative examples, then next it swaps the positive and negative examples and calls itself recursively to learn the exceptions to the default conclusions.
Revised: It does so by first learning the default conclusion that covers positive examples while avoiding negative examples, then next it swaps the positive and negative examples and calls itself recursively to learn the exceptions to the default conclusions.

Original: Both FOIL and FOLD cannot deal with numeric features directly; an encoding process is needed in the preparation phase of the training data that discretizes the continuous numbers into intervals.
Revised: Both FOIL and FOLD cannot deal with numeric features directly; an encoding process is needed in the preparation phase of the training data that discretizes the continuous numbers into intervals.

Original: However, this process not only adds a huge computational overhead to the algorithm but also leads to loss of information in the training data.
Revised: However, this process not only adds a huge computational overhead to the algorithm but also leads to loss of information in the training data.

Original: To deal with the above problems, Shakerin developed an extension of the FOLD algorithm, called FOLD-R, to handle mixed (i.e., both numerical and categorical) features which avoids the discretization process for numerical data (Shakerin 2020; Shakerin, Salazar, and Gupta 2017).
Revised: To deal with the above problems, Shakerin developed an extension of the FOLD algorithm, called FOLD-R, to handle mixed (i.e., both numerical and categorical) features which avoids the discretization process for numerical data (Shakerin 2020; Shakerin, Salazar, and Gupta 2017).

Original: However,
Revised: However,

Original: FOLD-R still suffers from efficiency and scalability issues when compared to other popular machine learning systems for classification.
Revised: FOLD-R still suffers from efficiency and scalability issues when compared to other popular machine learning systems for classification.

Original: In this paper we report on a novel imple- mentation method we have developed to improve the design of the FOLD-R system.
Revised: In this paper we report on a novel imple- mentation method we have developed to improve the design of the FOLD-R system.

Original: In particular, we use the prefix sum technique (Wikipedia contributors 2021) to optimize the process of calculation of information gain, the most time consuming component of the FOLD family of algorithms (Shakerin 2020).
Revised: In particular, we use the prefix sum technique (Wikipedia contributors 2021) to optimize the process of calculation of information gain, the most time consuming component of the FOLD family of algorithms (Shakerin 2020).

Original: Our optimization, in fact, reduces the time complexity of the algorithm.
Revised: Our optimization, in fact, reduces the time complexity of the algorithm.

Original: If N is the number of unique values from a specific feature and M is the number of training examples, then the complexity of classifying all the examples for each split is reduced from O(M*N) for FOLD-R to O(M+N) in FOLD-R++.
Revised: If N is the number of unique values from a specific feature and M is the number of training examples, then the complexity of computing information gain for all the possible literals of a feature is reduced from O(M*N) for FOLD-R to O(M) in FOLD-R++.

Original: Our experimental results indicate that the FOLD-R++ algorithm is comparable to popular machine learning algorithms such as XGBoost wrt various metrics (accuracy, recall, precision, and F1-score) as well as in efficiency and scalability.
Revised: Our experimental results indicate that the FOLD-R++ algorithm is comparable to popular machine learning algorithms such as XGBoost wrt various metrics (accuracy, recall, precision, and F1-score) as well as in efficiency and scalability.

Original: However, in addition, FOLD-R++ produces an explainable and interpretable model in the form of an answer set program.
Revised: However, in addition, FOLD-R++ produces an explainable and interpretable model in the form of an answer set program.

Original: This paper makes the following novel contribution: it presents the FOLD-R++ algorithm that significantly improves the efficiency and scalability of the FOLD-R ILP algorithm without adding overhead during pre-processing or losing information in the training data.
Revised: This paper makes the following novel contribution: it presents the FOLD-R++ algorithm that significantly improves the efficiency and scalability of the FOLD-R ILP algorithm without adding overhead during pre-processing or losing information in the training data.

Original: As mentioned, the new approach is competitive with popular classification models such as the XGBoost classifier (Chen and Guestrin 2016).
Revised: As mentioned, the new approach is competitive with popular classification models such as the XGBoost classifier (Chen and Guestrin 2016).

Original: The FOLD-R++ algorithm outputs an answer set program (ASP) (Gelfond and Kahl 2014) that serves as an explainable/interpretable model.
Revised: The FOLD-R++ algorithm outputs an answer set program (ASP) (Gelfond and Kahl 2014) that serves as an explainable/interpretable model.

Original: This generated answer set program is compatible with s(CASP) (Arias et al. 2018), a goal-directed ASP solver, that can efficiently justify the prediction generated by the ASP model.
Revised: This generated answer set program is compatible with s(CASP) (Arias et al. 2018), a goal-directed ASP solver, that can efficiently justify the prediction generated by the ASP model.

Original:  Inductive Logic Programming
Revised:  Inductive Logic Programming

Original: Inductive Logic Programming (ILP) (Muggleton 1991) is a subfield of machine learning that learns models in the form of logic programming rules (Horn Clauses) that are comprehensible to humans.
Revised: Inductive Logic Programming (ILP) (Muggleton 1991) is a subfield of machine learning that learns models in the form of logic programming rules (Horn Clauses) that are comprehensible to humans.

Original: This problem is formally defined as:
Revised: This problem is formally defined as:

Original: Given
Revised: Given

Original: A background theory B , in the form of an ex-
Revised: A background theory B , in the form of an extended logic

Revised: program

Revised: , i.e., clauses of the form

Original: tended logic program, i.e., clauses of the form h ← l 1 , ..., l m , not l m +1 , ..., not l n , where l 1 , ..., l n are positive literals and not denotes negation-as-failure (NAF) (Baral 2003; Gelfond and Kahl 2014).
Revised: h ← l 1 , ..., l m , not l m +1 , ..., not l n , where l 1 , ..., l n are positive literals and not denotes negation-as-failure (NAF) (Baral 2003; Gelfond and Kahl 2014).

Original: We require that B has no loops through negation, i.e., it is stratified.
Revised: We require that B has no loops through negation, i e., it is stratified.

Original: Two disjoint sets of ground target predicates E + , E − known as positive and negative examples, respectively 3.
Revised: Two disjoint sets of ground target predicates E + , E − known as positive and negative examples, respectively 3.

Original: A hypothesis language of function free predicates L , and a refinement operator ρ under θ − subsumption (Plotkin  that would disallow loops over negation.
Revised: A hypothesis language of function free predicates L , and a refinement operator ρ under θ − subsumption (Plotkin 1971) that would disallow loops over negation.

Original: Find a set of clauses H such that:
Revised: Find a set of clauses H such that:

Original: • ∀ e ∈ E + , B ∪ H | = e • ∀ e ∈ E − , B ∪ H ̸| =
Revised: • ∀ e ∈ E + , B ∪ H | = e • ∀ e ∈ E − , B ∪ H ̸| =

Original: e • B ∧ H is consistent.
Revised: e • B ∧ H is consistent.

Original:  The FOLD-R++ Algorithm
Revised:  The FOLD-R++ Algorithm

Original: The FOLD algorithm (Shakerin 2020; Shakerin, Salazar, and
Revised: The FOLD algorithm (Shakerin 2020; Shakerin, Salazar, and

Original: Gupta 2017) is a top-down ILP algorithm that searches for best literals to add to the body of the clauses for hypothesis,
Revised: Gupta 2017) is a top-down ILP algorithm that searches for best literals to add to the body of the clauses for hypothesis,

Original: H , with the guidance of an information gain-based heuristic.
Revised: H , with the guidance of an information gain-based heuristic.

Original: The FOLD-R++ algorithm 2 refactors the FOLD algorithm and is summarized in algorithm1.
Revised: The FOLD-R++ algorithm 2 refactors the FOLD algorithm and is summarized in algorithm1.

Original: The output of the FOLDR++ algorithm is a set of default rules that include exceptions.
Revised: The output of the FOLDR++ algorithm is a set of default rules that include exceptions.

Original: An example implied by any rule in the set would be classified as positive.
Revised: An example implied by any rule in the set would be classified as positive.

Original: Therefore, the FOLD-R++ algorithm rules out the already covered positive examples in line 5 after learning a new rule.
Revised: Therefore, the FOLD-R++ algorithm rules out the already covered positive examples in line 5 after learning a new rule.

Original: For each rule learning process, a best literal would be selected based on weighted information gain with the current training examples, in line 13, then the examples that cannot be implied by learned default literals would be ruled out for further learning of the current rule.
Revised: For each rule learning process, a best literal would be selected based on weighted information gain with the current training examples, in line 13, then the examples that cannot be implied by learned default literals would be ruled out for further learning of the current rule.

Original: When the information gain becomes zero or the number of negative examples drops below the ratio threshold, the default learning part is done.
Revised: When the information gain becomes zero or the number of negative examples drops below the ratio threshold, the default learning part is done.

Original: Unlike the FOIL algorithm, FOLD-R++ next learns exceptions after first learning default literals.
Revised: Unlike the FOIL algorithm, FOLD-R++ next learns exceptions after first learning default literals.

Original: This is done by swapping the residual positive and negative examples and calling itself recursively in line 29.
Revised: This is done by swapping the residual positive and negative examples and calling itself recursively in line 29.

Original: The remaining positive and negative examples can be swapped again and exceptions to exceptions learned (and then swapped further to learn exceptions to exceptions of exceptions, and so on).
Revised: The remaining positive and negative examples can be swapped again and exceptions to exceptions learned (and then swapped further to learn exceptions to exceptions of exceptions, and so on).

Original: The ratio parameter in Algorithm 1 represents the ratio of training examples that are part of the exception to the examples implied by only the default conclusion part of the rule.
Revised: The ratio parameter in Algorithm 1 represents the ratio of training examples that are part of the exception to the examples implied by only the default conclusion part of the rule.

Original: It will allow us to control the nesting level of exceptions the user wants to permit.
Revised: It will allow us to control the nesting level of exceptions the user wants to permit.

Original: Example 

Revised: Example

Original: In the FOLD-R++ algorithm, the target is to learn rules for fly(X) .
Revised: In the FOLD-R++ algorithm, the target is to learn rules for fly(X) .

Original: B, E + , E − are background knowledge, positive and negative examples, respectively.
Revised: B, E + , E − are background knowledge, positive and negative examples, respectively.

Original: [Equation]
Revised: [Equation]

Original: The target predicate { fly(X) :- true. } is specified when calling the learn rule function at line 4.
Revised: The target predicate { fly(X) :- true. } is specified when calling the learn rule function at line 4.

Original: The function selects the literal bird(X)
Revised: The function selects the literal bird(X)

Original: as result
Revised: as result

Original: and adds it to the clause r = fly(X) :- bird(X) because it has the best information gain among { bird,penguin,cat } .
Revised: and adds it to the clause r = fly(X) :- bird(X) because it has the best information gain among { bird,penguin,cat } .

Original: Then, the training set gets updated to E + =
Revised: Then, the training set gets updated to E + =

Original: { tweety, et } ,
Revised: { tweety, et } ,

Original: E − = { polly } in line 15-16.
Revised: E − = { polly } in line 16-17.

Original: The negative example polly is still implied by the generated clause and so is a false negative classification.
Revised: The negative example polly is still implied by the generated clause and so is a false negative classification.

Original: The default learning of learn rule function is finished because the best information gain of candidate literal is zero.
Revised: The default learning of learn rule function is finished because the best information gain of candidate literal is zero.

Original: Therefore, the FOLD-R++ function is called recursively with swapped positive and negative examples, E + = { polly } , E − =
Revised: Therefore, the FOLD-R++ function is called recursively with swapped positive and negative examples, E + = { polly } , E − =

Original: { tweety, et } , to learn exceptions.
Revised: { tweety, et } , to learn exceptions.

Original: In this case, an abnormal predicate { ab0(X) :- penguin(X) } is generated and returned as the only exception to the previous learned clause as r = fly(X) :- bird(X), ab0(X) .
Revised: In this case, an abnormal predicate { ab0(X) :- penguin(X) } is generated and returned as the only exception to the previous learned clause as r = fly(X) :- bird(X), ab0(X) .

Original: The abnormal rule { ab0(X) :-
Revised: The abnormal rule { ab0(X) :-

Original: Input: target, B, E + , E − , ratio ▷ ratio is the exception ratio
Revised: Input: target, B, E + , E − , ratio ▷ ratio is the exception ratio

Original: Output: R = { r 1 , ..., r n } ▷ R is rule set 1: function FOLD-R++
Revised: Output: R = { r 1 , ..., r n } ▷ R is rule set 1: function FOLD-R++

Original: ( E + , E − , L used ) 2:
Revised: ( E + , E − , L used ) 2:

Original: R ← ∅ 3: while | E + | > 0 do 4: r ← LEARN RULE ( E + , E − , L used ) 5:
Revised: R ← ∅ 3: while | E + | > 0 do 4: r ← LEARN RULE ( E + , E − , L used ) 5:

Original: E + ← E + \ covers ( r, E + , true ) 6:
Revised: E + ← E + \ covers ( r, E + , true ) 6:

Original: R ← R ∪ { r } 7: end while 8: return R 9: end function 10: function LEARN RULE( E + , E − , L used ) 11:
Revised: R ← R ∪ { r } 7: end while 8: return R 9: end function 10: function LEARN RULE( E + , E − , L used ) 11:

Original: L ← ∅ 12: while true do 13: l ← FIND BEST LITERAL ( E + , E − , L used ) 14:
Revised: L ← ∅ 12: while true do 13: l ← FIND BEST LITERAL ( E + , E − , L used ) 14:

Original: L ← L ∪ { l } 15: r ← set default ( r, L ) 16:
Revised: L ← L ∪ { l } 15: r ← set default ( r, L ) 16:

Original: E + ← covers ( r, E + , true ) 17:
Revised: E + ← covers ( r, E + , true ) 17:

Original: E − ← E − \ covers ( r, E − , false ) 18: if l is invalid or | E − | ≤ | E + | ∗ ratio then 19: if l is invalid then 20:
Revised: E − ← E − \ covers ( r, E − , false ) 18: if l is invalid or | E − | ≤ | E + | ∗ ratio then 19: if l is invalid then 20:

Original: L ← L \ { l } 21: r ← set default ( r, L ) 22: else 23: flag ← true 24: end if 25: break 26: end if 27: end while 28: if flag then 29:
Revised: L ← L \ { l } 21: r ← set default ( r, L ) 22: else 23: flag ← true 24: end if 25: break 26: end if 27: end while 28: if flag then 29:

Original: AB ← FOLD - R ++( E − , E + , L used + L ) 30: r ← set exception ( r, AB ) 31: end if 32: return r 33: end function penguin(X) }
Revised: AB ← FOLD - R ++( E − , E + , L used + L ) 30: r ← set exception ( r, AB ) 31: end if 32: return r 33: end function penguin(X) }

Original: is added to the final rule set producing the program below: fly(X) :- bird(X), not ab0(X).
Revised: is added to the final rule set producing the program below: fly(X) :- bird(X), not ab0(X).

Original: ab0(X) :- penguin(X).
Revised: ab0(X) :- penguin(X).

Original: We next give more details of the FOLD-R++ algorithm.
Revised: We next give more details of the FOLD-R++ algorithm.

Original: 3. Literal Selection
Revised: 3. Literal Selection

Original: The literal selection process for Shakerin’s FOLD-R algorithm can be summarized in Algorithm 2.
Revised: The literal selection process for Shakerin’s FOLD-R algorithm can be summarized in Algorithm 2.

Original: The FOLD-R algoirthm (Shakerin 2020; Shakerin,
Revised: The FOLD-R algorithm (Shakerin 2020; Shakerin,

Original: Salazar, and Gupta 2017) selects the best literal based on the weighted information gain for learning defaults, similar to the original FOLD algorithm described in (Shakerin,
Revised: Salazar, and Gupta 2017) selects the best literal based on the weighted information gain for learning defaults, similar to the original FOLD algorithm described in (Shakerin,

Original: Salazar, and Gupta 2017).
Revised: Salazar, and Gupta 2017).

Original: For numeric features, the FOLDR algorithm would enumerate all the possible splits.
Revised: For numeric features, the FOLDR algorithm would enumerate all the possible splits.

Original: Then, it classifies the data and compute information gain for literals for each split.
Revised: Then, it classifies the data and compute information gain for literals for each split.

Original: The literal with the best information gain would be selected as result.
Revised: The literal with the best information gain would be selected as result.

Original: In contrast, FOLD-R++algorithm uses anew, more efficient method employing prefix Algorithm
Revised: In contrast, FOLD-R++ uses a

Original: 1: function SPECIALIZE( c, E + , E − ) 2: while size ( E − ) > 0 do 3: ( c 1 , IG 1 ) ← test categorical ( c, E + , E − ) 4: ( c 2 , IG 2 ) ← test numeric ( c, E + , E − ) 5: if IG 1 = 0 & IG 2 = 

Revised: 1: function SPECIALIZE( c, E + , E − ) 2: while size ( E − ) > 0 do 3: ( c 1 , IG 1 ) ← test categorical ( c, E + , E − ) 4: ( c 2 , IG 2 ) ← test numeric ( c, E + , E − ) 5: if IG 1 = 0 & IG 2 =

Original: then 6: ˆ c ← EXCEPTION ( c, E − , E + ) 7: if ˆ c = null then 8: ˆ c ← enumerate ( c, E + ) 9: end if 10: else 11: if IG 1 ≥ IG 2 then 12: ˆ c ← c13: else 14: ˆ c ← c15: end if 16: end if 17:
Revised: then 6: ˆ c ← EXCEPTION ( c, E − , E + ) 7: if ˆ c = null then 8: ˆ c ← enumerate ( c, E + ) 9: end if 10: else 11: if IG 1 ≥ IG 2 then 12: ˆ c ← c13: else 14: ˆ c ← c15: end if 16: end if 17:

Original: E − ← E − \ covers (ˆ c, E − ) 18: end while 19: end function  sums to calculate the information gain based on the classification categories.
Revised: E − ← E − \ covers (ˆ c, E − ) 18: end while 19: end function new, more efficient method employing prefix sums to calculate the information gain based on the classification categories.

Original: In FOLD-R++, information gain for a given literal is calculated as shown in Algorithm 3.Algorithm
Revised: In FOLD-R++, information gain for a given literal is calculated as shown in Algorithm 3.

Original: 1: function IG( tp, fn, tn, fp ) 2: if fp + fn > tp + tn then 3: return −∞ 4: end if 5: pos, neg ← tp + fp, tn + fn 6: tot ← pos + neg 7: result ← ( tptot log 2 ( tppos ))
Revised: 1: function IG( tp, fn, tn, fp ) 2: if fp + fn > tp + tn then 3: return −∞ 4: end if 5: pos, neg ← tp + fp, tn + fn 6: tot ← pos + neg 7: result ← ( tptot log 2 ( tppos ))

Original: tp> 

Revised: tp>

Original: +( fptot log 2 ( fppos ))
Revised: +( fptot log 2 ( fppos ))

Original: fp>8: result ← result
Revised: fp>8: result ← result

Original: + ( tntot log 2 ( tnneg )) tn> 

Revised: + ( tntot log 2 ( tnneg )) tn>

Original: + ( fntot log 2 ( fnneg ))
Revised: + ( fntot log 2 ( fnneg ))

Original: fn>9: return result 10: end function
Revised: fn>9: return result 10: end function

Original: The variables tp, fn, tn, fp in Algorithm 3 for finding the information gain represent the numbers of true positive, false positive, true negative, and false negative examples, respectively.
Revised: The variables tp, fn, tn, fp in Algorithm 3 for finding the information gain represent the numbers of true positive, false positive, true negative, and false negative examples, respectively.

Original: With the function above, the new approach employs the prefix sum technique to speed up the calculation.
Revised: With the function above, the new approach employs the prefix sum technique to speed up the calculation.

Original: Only one round of classification is needed for a single feature, even with mixed types of values.
Revised: Only one round of classification is needed for a single feature, even with mixed types of values.

Original: The new approach to calculate the best IG and literal is summarized in Algorithm 4.
Revised: The new approach to calculate the best IG and literal is summarized in Algorithm 4.

Original: Example 2 Given positive and negative examples, E + , E − , with mixed type of values on feature i , the target is to find the literal with the best information gain on the given feature.
Revised: Example 2 Given positive and negative examples, E + , E − , with mixed type of values on feature i , the target is to find the literal with the best information gain on the given feature.

Original: There are 8 positive examples, their values on feature i are [1 , 2 , 3 , 3 , 5 , 6 , 6 , b ] .
Revised: There are 8 positive examples, their values on feature i are [1 , 2 , 3 , 3 , 5 , 6 , 6 , b ] .

Original: And, the values on feature i of thenegative examples are [2 , 4 , 6 , 7 , a ] .
Revised: And, the values on feature i of thenegative examples are [2 , 4 , 6 , 7 , a ] .

Original: With the given examples and specified feature, the numbers xs cs ←  values
Revised: xs cs ← unique values

Original: 5: ▷ xs cs lists holds the unique numeric and categorical values 6: xp, xn, cp, cn ← count total ( E +
Revised: 5: ▷ xs cs lists holds the unique numeric and categorical values 6: xp, xn, cp, cn ← count total ( E +

Original: E − i ) 7: ▷ (xp, xn) are the total # of pos / neg examples with numeric value
Revised: E − i ) 7: ▷ (xp, xn) are the total # of pos / neg examples with numeric value

Original: (cp ) are the same categorical
Revised: (cp, cn) are the same categorical

Original: 8: xs ←  sort( xs ) 9: for j ← 1 to size ( xs ) do ▷ compute the prefix sum 10: pos [ xs i ] ← pos [ xs i ] + pos
Revised: 8: xs ← counting sort ) 9: for j ← 1 to size ( xs ) do ▷ compute the prefix sum 10: pos [ xs i ] ← pos [ xs i ] + pos

Original: [ xs i − 1 ] 11: neg [ xs i ] ← neg [ xs i ]
Revised: [ xs i − 1 ] 11: neg [ xs i ] ← neg [ xs i ]

Original: + neg
Revised: + neg

Original: [ xs i − 1 ] 12: end for 13: for x ∈ xs do 14: lit dict [ literal ( i, ≤ , x )]
Revised: [ xs i − 1 ] 12: end for 13: for x ∈ xs do 14: lit dict [ literal ( i, ≤ , x )]

Original: ← IG ( pos [ x ] , xp − pos [ x ] + cp, xn − neg [ x ] + cn, neg [ x ]) 15: lit dict [ literal ( i, >, x )] ←
Revised: ← IG ( pos [ x ] , xp − pos [ x ] + cp, xn − neg [ x ] + cn, neg [ x ]) 15: lit dict [ literal ( i, >, x )] ←

Original: IG ( xp − pos [ x ] , pos [ x ] + cp, neg [ x ] + cn, xn − neg [ x ]) 16: end for 17: for c ∈ cs do 18: lit dict [ literal ( i, = , x )] ← IG ( pos [ c ] , cp − pos [ c ] + xp, cn − neg [ c ] + xn, neg [ c ]) 19: lit dict [ literal ( i, ̸ = , x )] ← IG ( cp − pos [ c ] + xp, pos [ c ] , neg [ c ] , cn − neg [ c ] + xn ) 20: end for 21: best, l ← best pair ( lit dict ) 22: return best, l 23: end function  of positive examples and negative examples for each unique value are counted first, which are shown as pos, neg at right side of Table 1.
Revised: IG ( xp − pos [ x ] , pos [ x ] + cp, neg [ x ] + cn, xn − neg [ x ]) 16: end for 17: for c ∈ cs do 18: lit dict [ literal ( i, = , x )] ← IG ( pos [ c ] , cp − pos [ c ] + xp, cn − neg [ c ] + xn, neg [ c ]) 19: lit dict [ literal ( i, ̸ = , x )] ← IG ( cp − pos [ c ] + xp, pos [ c ] , neg [ c ] , cn − neg [ c ] + xn ) 20: end for 21: best, l ← best pair ( lit dict ) 22: return best, l 23: end function With the given examples and specified feature, the numbers of positive examples and negative examples for each unique value are counted first, which are shown as pos, neg at right side of Table 1.

Original: Then, the prefix sum arrays are calculated for computing heuristic as pos sum, neg sum .
Revised: Then, the prefix sum arrays are calculated for computing heuristic as pos sum, neg sum .

Original: Table 2 show the information gain for each literal, the literal ( i, ̸ = , a ) has been selected with the highest score.
Revised: Table 2 show the information gain for each literal, the literal ( i, ̸ = , a ) has been selected with the highest score.

Original: 3. Justification
Revised: 3. Justification

Original: Explainability is very important for some tasks like loan approval, credit card approval, and disease diagnosis system.
Revised: Explainability is very important for some tasks like loan approval, credit card approval, and disease diagnosis system.

Original: Answer set programming provides explicit rules for how a prediction is generated compared to black box models like those based on neural networks.
Revised: Answer set programming provides explicit rules for how a prediction is generated compared to black box models like those based on neural networks.

Original: To efficiently justify the prediction, the FOLD-R++ outputs answer set programs that are compatible with the s(CASP) goal-directed ASP system (Arias et al. 2018).
Revised: To efficiently justify the prediction, the FOLD-R++ outputs answer set programs that are compatible with the s(CASP) goal-directed ASP system (Arias et al. 2018).

Original: Example 

Revised: Example

Original: The “Titanic Survival Prediction” is a classical classification challenge which contains 891 passengers as training examples and 418 passengers as testing examples and their survival based on features such as sex, age, numexamples ith feature value
Revised: The “Titanic Survival Prediction” is a classical classification challenge which contains 891 passengers as training examples and 418 passengers as testing examples examples ith feature value

Original: E + 1 2 3 3 5 6 6 b
Revised: E + 1 2 3 3 5 6 6 b

Original: E − 2 4 6 7 a value       a b pos         pos sum       na na neg         neg sum       na na
Revised: E − 2 4 6 7 a value       a b pos         pos sum       na na neg         neg sum       na na

Original: Info Gain value ≤ value > value = value ̸ = value −∞ -0.
Revised: Info Gain value ≤ value > value = value ̸ = value −∞ -0.

Original: na na −∞ -0.
Revised: na na −∞ -0.

Original: na na -0.
Revised: na na -0.

Original: −∞ na na -0. −∞ na na -0.
Revised: −∞ na na -0. −∞ na na -0.

Original: −∞ na na -0. −∞ na na -0.
Revised: −∞ na na -0. −∞ na na -0.

Original: −∞ na na a na na −∞ -0.
Revised: −∞ na na a na na −∞ -0.

Original: b na na −∞ -0.
Revised: b na na −∞ -0.

Original: FOLD-R++ generates the following program with onlyrules!:
Revised: FOLD-R++ generates the following program with onlyrules:

Original: [Table]
Revised: [Table]

Original: Note that status(X,0) means that person whose id is X perished, while status(X,1) means that person with id
Revised: Note that status(X,0) means that person whose id is X perished, while status(X,1) means that person with id

Original: X survived.
Revised: X survived.

Original: Note that we don’t have any rules generated for status(X,1) , so we could add a rule: status(X,1) :- not status(X,0).
Revised: Note that we don’t have any rules generated for status(X,1) , so we could add a rule: status(X,1) :- not status(X,0).

Original: The above program achieves 0.94 accuracy, 0.97 precision, 0.93 recall, and 0.95 F 1 score, which is quite remarkable.
Revised: The above program achieves 0.94 accuracy, 0.97 precision, 0.93 recall, and 0.95 F 1 score, which is quite remarkable.

Original: Given a new data sample, the predicted answer for this data sample using the above answer set program can be efficiently produced by the s(CASP) system.
Revised: Given a new data sample, the predicted answer for this data sample using the above answer set program can be efficiently produced by the s(CASP) system.

Original: The s(CASP) system can also produce a justification (a proof tree) for this prediction.
Revised: The s(CASP) system can also produce a justification (a proof tree) for this prediction.

Original: Since s(CASP) is query driven, an example query such as ?- status(926, S) which checks if passenger with id 926 perished or survived, will succeed if status of passenger 926 is indeed predicted as perished ( S is set to 0) by the model represented by the answer set program above.
Revised: Since s(CASP) is query driven, an example query such as ?- status(926, S) which checks if passenger with id 926 perished or survived, will succeed if status of passenger 926 is indeed predicted as perished ( S is set to 0) by the model represented by the answer set program above.

Original: The s(CASP) system can provide a proof for each query.
Revised: The s(CASP) system can provide a proof for each query.

Original: The English description for predicates is also needed to output the proof tree in human readable format.
Revised: The English description for predicates is also needed to output the proof tree in human readable format.

Original: The meaning of predicates in English is given via the #pred declaration, as shown below via examples:
Revised: The meaning of predicates in English is given via the #pred declaration, as shown below via examples:

Original: [Table]
Revised: [Figure]

Revised: age @(Y)

Original: [Figure] [Table]
Revised: [Figure] [Figure]

Revised: pred

Original: [Figure]
Revised: [Figure]

Revised: of

Original: [Table]
Revised: [Figure]

Revised: sibling

Original: [Figure]
Revised: [Figure]

Revised: (X,Y) ::

Original: [Table]
Revised: [Figure] @(X) [Figure] @(Y) siblings or spouses’.

Revised: #pred ab9(X) :: ’abnormal case 9 holds for @(X)’.

Original: The s(CASP) system can even generate this proof in a human understandable form (Arias et al. 2020).
Revised: The s(CASP) system can even generate this proof in a human understandable form (Arias et al. 2020).

Original: For example, here is the justification tree generated for the passenger with id 926: 
Revised: For example, here is the justification tree generated for the passenger with id 926: [Table] [Table] ANSWER

Revised: [Table]

Original: [Table]
Revised: [Table]

Revised: perished, because person 926 is male,

Revised: and

Revised: there

Revised: is

Revised: no evidence that ’ab1’ holds

Revised: for 926)

Revised: , because

Revised: evidence

Revised: that

Revised: person 926 paid Var1 not equal 57.75 for the ticket, and person

Revised: [Table]

Original: With the justification tree, the reason for the prediction can be easily understood by human beings.
Revised: With the justification tree, the reason for the prediction can be easily understood by human beings.

Original: The generated
Revised: The generated

Original: ASP rule-set can also be understood by a human.
Revised: ASP rule-set can also be understood by a human.

Original: In fact, s(CASP) can print the ASP rules in English, given the description of predicates in English via the #pred declaration explained above.
Revised: In fact, s(CASP) can print the ASP rules in English, given the description of predicates in English via the #pred declaration explained above.

Original: If there is any unreasonable logic generated in the rule set, it can also be modified directly by the human without retraining.
Revised: If there is any unreasonable logic generated in the rule set, it can also be modified directly by the human without retraining.

Original: Thus, any bias in the data that is captured in the generated ASP rules can be corrected by the human user, and the updated ASP rule-set used for making new predictions.
Revised: Thus, any bias in the data that is captured in the generated ASP rules can be corrected by the human user, and the updated ASP rule-set used for making new predictions.

Original: An example translation for two of the rules (Rules (1) and (12)) above is shown below:
Revised: An example translation for two of the rules (Rules (1) and (12)) above is shown below:

Original: [Table]
Revised: [Table]

Original: Note that if a data sample is not predicted to hold, because the corresponding query fails on s(CASP), then a justification can be generated by asking the negation of the query.
Revised: Note that if a data sample is not predicted to hold, because the corresponding query fails on s(CASP), then a justification can be generated by asking the negation of the query.

Original: The s(CASP) system supports constructive negation, and thus negated queries can be executed in s(CASP) and their justification/proof generated just as easily as the positive queries.
Revised: The s(CASP) system supports constructive negation, and thus negated queries can be executed in s(CASP) and their justification/proof generated just as easily as the positive queries.

Original:  Experiments and Performance Evaluation
Revised:  Experiments and Performance Evaluation

Original: In this section, we present our experiments on UCI standard benchmarks (Lichman 2013).
Revised: In this section, we present our experiments on UCI standard benchmarks (Lichman 2013).

Original: The XGBoost Classifier is popular classification model and used as a baseline in our experiment.
Revised: The XGBoost Classifier is popular classification model and used as a baseline in our experiment.

Original: We used simple settings for XGBoost classifier without limiting its performance.
Revised: We used simple settings for XGBoost classifier without limiting its performance.

Original: However, XGBoost cannot deal with mixed type (numerical and categorical) of examples directly.
Revised: However, XGBoost cannot deal with mixed type (numerical and categorical) of examples directly.

Original: One-hot encoding has been used for data preparation.
Revised: One-hot encoding has been used for data preparation.

Original: We use precision, recall, accuracy, F 1 score, and execution time to compare the results.
Revised: We use precision, recall, accuracy, F 1 score, and execution time to compare the results.

Original: FOLD-R++ does not requires any encoding before training.
Revised: FOLD-R++ does not require any encoding before training.

Original: The original FOLD-R system used the JPL library with
Revised: The original FOLD-R system used the JPL library with

Original: Java implementation.
Revised: Java implementation.

Original: We implemented FOLD-R++ only with Python.
Revised: We implemented FOLD-R++ only with Python.

Original: To make inferences using the generated rules, we developed a simple ASP interpreter for our application that is part of the FOLD-R++ system.
Revised: To make inferences using the generated rules, we developed a simple ASP interpreter for our application that is part of the FOLD-R++ system.

Original: Note that the generated programs are stratified and predicates contain only variables and constants, so implementing an interpreter for such a restricted class in Python is relatively easy.
Revised: Note that the generated programs are stratified and predicates contain only variables and constants, so implementing an interpreter for such a restricted class in Python is relatively easy.

Original: However, for obtaining the justification/proof tree, or for translating the ASP rules into equivalent English text, one must use the s(CASP) system.
Revised: However, for obtaining the justification/proof tree, or for translating the ASP rules into equivalent English text, one must use the s(CASP) system.

Original: We also compare the FOLD-R++ algorithm with the RIPPER algorithm (Cohen 1995).
Revised: We also compare the FOLD-R++ algorithm with the RIPPER algorithm (Cohen 1995).

Original: RIPPER generates formulas in conjunctive normal form as an explanation of the model.
Revised: RIPPER generates formulas in conjunctive normal form as an explanation of the model.

Original: Table 4 shows the comparison for two datasets from the
Revised: Table 4 shows the comparison for two datasets from the

Original: UCI repository (Adult and Credit Card).
Revised: UCI repository (Adult and Credit Card).

Original: FOLD-R++ outperforms RIPPER on all categories except precision.
Revised: FOLD-R++ outperforms RIPPER on all categories except precision.

Original: Most significantly, FOLD-R++ generates much smaller number of rules.
Revised: Most significantly, FOLD-R++ generates much smaller number of rules.

Original: Computation time for FOLD-R++ is also a lot less.
Revised: Computation time for FOLD-R++ is also a lot less.

Original: As discussed earlier, the time complexity for computing information gain on a feature is significantly reduced in
Revised: As discussed earlier, the time complexity for computing information gain on a feature is significantly reduced in

Original: FOLD-R++ due to the use of prefix-sum.
Revised: FOLD-R++ due to the use of prefix-sum.

Original: Therefore, we obtain a rather large improvements in efficiency.
Revised: Therefore, we obtain a rather large improvements in efficiency.

Original: For the credit
Revised: For the credit

Original: FOLD-R
Revised: -R

Original: +
Revised: +

Original: [Table] [Table]
Revised: [Table] [Table]

Original: dataset, a dataset with only 690 instances, the new FOLDR++ algorithm is hundreds times faster than the original
Revised: dataset, a dataset with only 690 instances, the new FOLDR++ algorithm is hundreds times faster than the original

Original: FOLD-R. All the learning experiments have been conducted on a desktop with Intel i5-10400 CPU @
Revised: FOLD-R. All the learning experiments have been conducted on a desktop with Intel i5-10400 CPU @

Original: 2.9GHz and
Revised: 2.9GHz and

Original: GB ram.
Revised: GB ram.

Original: To measure performance metrics, we conducted 10-fold cross-validation on each dataset and the average of accuracy, precision, recall, F 1 score and execution time have been presented.
Revised: To measure performance metrics, we conducted 10-fold cross-validation on each dataset and the average of accuracy, precision, recall, F 1 score and execution time have been presented.

Original: Table 3 reports the performance metrics and execution time on each dataset compared with the baseline model.
Revised: Table 3 reports the performance metrics and execution time on each dataset compared with the baseline model.

Original: The best performer is highlighted with boldface font.
Revised: The best performer is highlighted with boldface font.

Original: The XGBoost Classifier employs decision tree ensemble method for classification task and provides quite decent performance.
Revised: The XGBoost Classifier employs decision tree ensemble method for classification task and provides quite decent performance.

Original: FOLD-R++ almost always spends less time to finish learning compared to XGBoost classifier, especially for the large dataset Adult income census.
Revised: FOLD-R++ almost always spends less time to finish learning compared to XGBoost classifier, especially for the large dataset Adult income census.

Original: For most of the datasets, FOLD-R++ can achieve equivalent scores.
Revised: For most of the datasets, FOLD-R++ can achieve equivalent scores.

Original: FOLD-R++ achieves much higher scores on e-coli and sonar datasets.
Revised: FOLD-R++ achieves much higher scores on e-coli and sonar datasets.

Original: For the credit card dataset, the baseline XGBoost model failed training due to 32 GB memory limitation, but
Revised: For the credit card dataset, the baseline XGBoost model failed training due to 32 GB memory limitation, but

Original: FOLD-R++ still finished training quite efficiently.
Revised: FOLD-R++ still finished training quite efficiently.

Original:  Related Work
Revised:  Related Work

Original: ALEPH (Srinivasan 2001) is one of the most popular ILP system, which induces theories by using bottom-up generalization search.
Revised: ALEPH (Srinivasan 2001) is one of the most popular ILP system, which induces theories by using bottom-up generalization search.

Original: However, it cannot deal with numeric features and its specialization step is manual, there is no automation option.
Revised: However, it cannot deal with numeric features and its specialization step is manual, there is no automation option.

Original: Takemura and Inoue’s method (Takemura and Inoue 2021) relies on tree-ensembles to generate explainable rule sets with pattern mining techniques.
Revised: Takemura and Inoue’s method (Takemura and Inoue 2021) relies on tree-ensembles to generate explainable rule sets with pattern mining techniques.

Original: Its performance depends on the tree-ensemble model.
Revised: Its performance depends on the tree-ensemble model.

Original: Additionally, it may not be scalable due to its computational time complexity that is exponential in the number of valid rules.
Revised: Additionally, it may not be scalable due to its computational time complexity that is exponential in the number of valid rules.

Original: A survey of ILP can be found in (Muggleton et al. 2012).
Revised: A survey of ILP can be found in (Muggleton et al. 2012).

Original: Rule extraction from statistical Machine Learning models has been a long-standing goal of the community.
Revised: Rule extraction from statistical Machine Learning models has been a long-standing goal of the community.

Original: The rule extraction algorithms from machine learning models are classified into two categories: 1) Pedagogical (i.e., learning symbolic rules from black-box classifiers without opening them) 2)
Revised: The rule extraction algorithms from machine learning models are classified into two categories: 1) Pedagogical (i.e., learning symbolic rules from black-box classifiers without opening them) 2)

Original: Decompositional (i.e., to open the classifier and look into the internals).
Revised: Decompositional (i.e., to open the classifier and look into the internals).

Original: TREPAN (Craven and Shavlik 1995) is a successful pedagogical algorithm that learns decision trees from neural networks.
Revised: TREPAN (Craven and Shavlik 1995) is a successful pedagogical algorithm that learns decision trees from neural networks.

Original: SVM+Prototypes (N ´ u ˜ nez,
Revised: SVM+Prototypes (N ´ u ˜ nez,

Original: Angulo, and Catal ` a 2002) is a decompositional rule extraction algorithm that makes use of KMeans clustering to extract rules from SVM classifiers by focusing on support vectors.
Revised: Angulo, and Catal ` a 2002) is a decompositional rule extraction algorithm that makes use of KMeans clustering to extract rules from SVM classifiers by focusing on support vectors.

Original: Another rule extraction technique that is gaining attention recently is “RuleFit” (Friedman, Popescu, and others 2008).
Revised: Another rule extraction technique that is gaining attention recently is “RuleFit” (Friedman, Popescu, and others 2008).

Original: RuleFit learns a set of weighted rules from ensemble of shallow decision trees combined with original features.
Revised: RuleFit learns a set of weighted rules from ensemble of shallow decision trees combined with original features.

Original: In ILP community also, researchers have tried to combine statistical methods with ILP techniques.
Revised: In ILP community also, researchers have tried to combine statistical methods with ILP techniques.

Original: Support Vector ILP (Muggleton et al. 2005) uses ILP hypotheses as kernel in dual form of the SVM algorithm.
Revised: Support Vector ILP (Muggleton et al. 2005) uses ILP hypotheses as kernel in dual form of the SVM algorithm.

Original: kFOIL (Landwehr et al.
Revised: kFOIL (Landwehr et al.

Original: 2006) learns an incremental kernel for SVM algorithm using a FOIL style specialization.
Revised: 2006) learns an incremental kernel for SVM algorithm using a FOIL style specialization.

Original: nFOIL (Landwehr, Kersting, and Raedt 2005) integrates the Naive-Bayes algorithm with FOIL.
Revised: nFOIL (Landwehr, Kersting, and Raedt 2005) integrates the Naive-Bayes algorithm with FOIL.

Original: The advantage of our research over all of the above mentioned research work is that we generate answer set programs containing negation-as-failure that correspond closely to the human thought process.
Revised: The advantage of our research over all of the above mentioned research work is that we generate answer set programs containing negation-as-failure that correspond closely to the human thought process.

Original: Thus, the descriptions are more concise.
Revised: Thus, the descriptions are more concise.

Original: Second it is scalable thanks to the greedy nature of our clause search.
Revised: Second it is scalable thanks to the greedy nature of our clause search.

Original:  Conclusions and Future Work
Revised:  Conclusions and Future Work

Original: In this paper we presented an efficient and highly scalable algorithm, FOLD-R++, to induce default theories represented as an answer set program.
Revised: In this paper we presented an efficient and highly scalable algorithm, FOLD-R++, to induce default theories represented as an answer set program.

Original: The resulting answer set program has good performance wrt prediction and justification for the predicted classification.
Revised: The resulting answer set program has good performance wrt prediction and justification for the predicted classification.

Original: In this new approach, unlike other methods, the encoding for data is not needed anymore and no information from training data is discarded.
Revised: In this new approach, unlike other methods, the encoding for data is not needed anymore and no information from training data is discarded.

Original: Compared with the popular classification system XGBoost, our new approach has similar performance in terms of accuracy, precision, recall, and F1-score, but better training efficiency.
Revised: Compared with the popular classification system XGBoost, our new approach has similar performance in terms of accuracy, precision, recall, and F1-score, but better training efficiency.

Original: In addition, the FOLD-R++ algorithm produces an explainable model.
Revised: In addition, the FOLD-R++ algorithm produces an explainable model.

Original: Predictions made by this model can be computed efficiently and their justification automatically produced using the s(CASP) system.
Revised: Predictions made by this model can be computed efficiently and their justification automatically produced using the s(CASP) system.

Original: Acknowledgement
Revised: Acknowledgement

Original: Authors gratefully acknowledge support from NSF grants
Revised: Authors gratefully acknowledge support from NSF grants

Original: IIS 1718945, IIS 1910131, IIP and from Amazon Corp, Atos Corp and US DoD. Views expressed are authors’ own and not of the funding agencies.
Revised: IIS 1718945, IIS 1910131, IIP and from Amazon Corp, Atos Corp and US DoD. Views expressed are authors’ own and not of the funding agencies.

Original: We are grateful to Joaquin Arias and the s(CASP) team for their work on providing facilities for generating the justification tree and
Revised: We are grateful to Joaquin Arias and the s(CASP) team for their work on providing facilities for generating the justification tree and

Original: English encoding of rules in s(CASP).
Revised: English encoding of rules in s(CASP).