Original: Truncated Matrix Power Iteration for Differentiable DAG Learning
Revised: Truncated Matrix Power Iteration for Differentiable DAG Learning

Original: Abstract
Revised: Abstract

Original: Recovering underlying Directed Acyclic Graph (DAG) structures from observational data is highly challenging due to the combinatorial nature of the DAGconstrained optimization problem.
Revised: Recovering underlying Directed Acyclic Graph (DAG) structures from observational data is highly challenging due to the combinatorial nature of the DAGconstrained optimization problem.

Original: Recently, DAG learning has been cast as a continuous optimization problem by characterizing the DAG constraint as a smooth equality one, generally based on polynomials over adjacency matrices.
Revised: Recently, DAG learning has been cast as a continuous optimization problem by characterizing the DAG constraint as a smooth equality one, generally based on polynomials over adjacency matrices.

Original: Existing methods place very small coefficients on high-order polynomial terms for stabilization, since they argue that large coefficients on the higher-order terms are harmful due to numeric exploding.
Revised: Existing methods place very small coefficients on high-order polynomial terms for stabilization, since they argue that large coefficients on the higher-order terms are harmful due to numeric exploding.

Original: On the contrary, we discover that large coefficients on higher-order terms are beneficial for DAG learning, when the spectral radiuses of the adjacency matrices are small, and that larger coefficients for higher-order terms can approximate the DAG constraints much better than the small counterparts.
Revised: On the contrary, we discover that large coefficients on higher-order terms are beneficial for DAG learning, when the spectral radiuses of the adjacency matrices are small, and that larger coefficients for higher-order terms can approximate the DAG constraints much better than the small counterparts.

Original: Based on this, we propose a novel DAG learning method with efficient truncated matrix power iteration to approximate geometric series based DAG constraints.
Revised: Based on this, we propose a novel DAG learning method with efficient truncated matrix power iteration to approximate geometric series based DAG constraints.

Original: Empirically, our DAG learning method outperforms the previous state-of-the-arts in various settings, often by a factor of 3 or more in terms of structural Hamming distance.
Revised: Empirically, our DAG learning method outperforms the previous state-of-the-arts in various settings, often by a factor of 3 or more in terms of structural Hamming distance.

Original:  Introduction
Revised:  Introduction

Original: Recovery of Directed Acyclic Graphs (DAGs) from observational data is a classical problem in many fields, including bioinformatics [31, 49], machine learning [19] and causal inference [39].
Revised: Recovery of Directed Acyclic Graphs (DAGs) from observational data is a classical problem in many fields, including bioinformatics [31, 49], machine learning [19] and causal inference [39].

Original: The graphical model produced by a DAG learning algorithm allows one to decompose the joint distribution over the variables of interest in a compact and flexible manner, and under certain assumptions [27, 39], these graphical models can have causal interpretations.
Revised: The graphical model produced by a DAG learning algorithm allows one to decompose the joint distribution over the variables of interest in a compact and flexible manner, and under certain assumptions [27, 39], these graphical models can have causal interpretations.

Original: DAG learning methods can be roughly categorized into constraint-based and score-based methods.
Revised: DAG learning methods can be roughly categorized into constraint-based and score-based methods.

Original: Most constraint-based approaches, e.g. , PC [37], FCI [11, 38], rely on conditional independence test and thus may require a large sample size [33, 43].
Revised: Most constraint-based approaches, e.g. , PC [37], FCI [11, 38], rely on conditional independence test and thus may require a large sample size [33, 43].

Original: The score-based approaches, including exact methods based on dynamic programming [18, 35, 36], A* search [47, 48], and integer programming [13], as well as greedy methods like GES [9], model the validity of a graph according to some score function and are often formulated and solved as a discrete optimization problem.
Revised: The score-based approaches, including exact methods based on dynamic programming [18, 35, 36], A* search [47, 48], and integer programming [13], as well as greedy methods like GES [9], model the validity of a graph according to some score function and are often formulated and solved as a discrete optimization problem.

Original: A key challenge for score-based methods is the combinatorial search space of DAGs [8, 10].
Revised: A key challenge for score-based methods is the combinatorial search space of DAGs [8, 10].

Original: There is a recent interest in developing continuous optimization methods for DAG learning in the past few years.
Revised: There is a recent interest in developing continuous optimization methods for DAG learning in the past few years.

Original: In particular, Zheng et al.
Revised: In particular, Zheng et al.

Original: [50] develops an algebraic characterization of DAG constraint based on a continuous function, specifically matrix exponential, of the weighted adjacency matrix of a graph, and applies it to estimate linear DAGs with equal noise variances using continuous constrained optimization [4, 5].
Revised: [50] develops an algebraic characterization of DAG constraint based on a continuous function, specifically matrix exponential, of the weighted adjacency matrix of a graph, and applies it to estimate linear DAGs with equal noise variances using continuous constrained optimization [4, 5].

Original: The resulting algorithm is called NOTEARS.
Revised: The resulting algorithm is called NOTEARS.

Original: Yu et al.
Revised: Yu et al.

Original: [45] proposes an alternative DAG constraint based on powers of a binomial to improve practical convenience.
Revised: [45] proposes an alternative DAG constraint based on powers of a binomial to improve practical convenience.

Original: Wei et al.
Revised: Wei et al.

Original: [44] unifies these two DAG constraints by writing them in terms of a general polynomial one.
Revised: [44] unifies these two DAG constraints by writing them in terms of a general polynomial one.

Original: These DAG constraints have been applied to more complex settings, e.g. , with nonlinear relationships [20, 25, 45, 51], time series [26], confounders [6], and flexible score functions [53], and have been shown to produce competitive performance.
Revised: These DAG constraints have been applied to more complex settings, e.g. , with nonlinear relationships [20, 25, 45, 51], time series [26], confounders [6], and flexible score functions [53], and have been shown to produce competitive performance.

Original: Apart from the polynomial based constraints, Lee et al.
Revised: Apart from the polynomial based constraints, Lee et al.

Original: [21], Zhu et al.
Revised: [21], Zhu et al.

Original: [52] present alternative formulations of the DAG constraints based on the spectral radius of the weighted adjacency matrix.
Revised: [52] present alternative formulations of the DAG constraints based on the spectral radius of the weighted adjacency matrix.

Original: Instead of solving a constrained optimization problem,
Revised: Instead of solving a constrained optimization problem,

Original: Yu et al.
Revised: Yu et al.

Original: [46] proposes NOCURL which employs an algebraic representation of DAGs such that continuous unconstrained optimization can be carried out in the DAG space directly.
Revised: [46] proposes NOCURL which employs an algebraic representation of DAGs such that continuous unconstrained optimization can be carried out in the DAG space directly.

Original: However, the focus of these works [21, 46, 52] is to improve the scalability, and the performance of the resulting methods may degrade.
Revised: However, the focus of these works [21, 46, 52] is to improve the scalability, and the performance of the resulting methods may degrade.

Original: To avoid potential numeric exploding that may be caused by high-order terms in the polynomial-based
Revised: To avoid potential numeric exploding that may be caused by high-order terms in the polynomial-based

Original: DAG constraints, previous works use very small coefficients for high-order terms in DAG constraints [45, 50].
Revised: DAG constraints, previous works use very small coefficients for high-order terms in DAG constraints [45, 50].

Original: More precisely, the coefficients decrease quickly to very small values for the relatively higher order terms that may contain useful higher-order information.
Revised: More precisely, the coefficients decrease quickly to very small values for the relatively higher order terms that may contain useful higher-order information.

Original: This may cause difficulties for the DAG constraints to capture the higher-order information for enforcing acyclicity.
Revised: This may cause difficulties for the DAG constraints to capture the higher-order information for enforcing acyclicity.

Original: With such DAG constraints, a possible solution to maintain higher-order information for acyclicity is to apply an even larger penalty weight [45, 50], which, however, causes ill-conditioning issues as demonstrated by
Revised: With such DAG constraints, a possible solution to maintain higher-order information for acyclicity is to apply an even larger penalty weight [45, 50], which, however, causes ill-conditioning issues as demonstrated by

Original: Ng et al.
Revised: Ng et al.

Original: Moreover, these small coefficients will be multiplied on the gradients of higher-order terms during the optimization process, leading to gradient vanishing.
Revised: Moreover, these small coefficients will be multiplied on the gradients of higher-order terms during the optimization process, leading to gradient vanishing.

Original: In this paper, we show that, on the contrary, larger coefficients may be safely used to construct more informative higher-order terms without introducing numeric exploding.
Revised: In this paper, we show that, on the contrary, larger coefficients may be safely used to construct more informative higher-order terms without introducing numeric exploding.

Original: The reason is that the weighted adjacency matrix of a DAG must be nilpotent; thus the candidate adjacency matrix often has a very small spectral radius.
Revised: The reason is that the weighted adjacency matrix of a DAG must be nilpotent; thus the candidate adjacency matrix often has a very small spectral radius.

Original: As a result, the higher-order power of the matrix may be very close to zero matrix, and larger coefficients may be safely used without causing numeric exploding.
Revised: As a result, the higher-order power of the matrix may be very close to zero matrix, and larger coefficients may be safely used without causing numeric exploding.

Original: We thus propose to use geometric series-based DAG constraint without small coefficients for more accurate and robust DAG learning.
Revised: We thus propose to use geometric series-based DAG constraint without small coefficients for more accurate and robust DAG learning.

Original: To relieve the computational burden from the geometric series, we propose an efficient
Revised: To relieve the computational burden from the geometric series, we propose an efficient

Original: Truncated Matrix Power Iteration (TMPI) algorithm with a theoretically guaranteed error bound.
Revised: Truncated Matrix Power Iteration (TMPI) algorithm with a theoretically guaranteed error bound.

Original: We summarize our contributions as the following:
Revised: We summarize our contributions as the following:

Original: • We demonstrate that the key challenge for DAG learning is the gradient vanishing issue instead of gradient and numeric exploding.
Revised: • We demonstrate that the key challenge for DAG learning is the gradient vanishing issue instead of gradient and numeric exploding.

Original: For sparse graphs, the gradient vanishing issue can be severe.
Revised: For sparse graphs, the gradient vanishing issue can be severe.

Original: • We design a DAG constraint based on finite geometric series which is an order- d polynomial over adjacency matrices to escape from gradient vanishing.
Revised: • We design a DAG constraint based on finite geometric series which is an order- d polynomial over adjacency matrices to escape from gradient vanishing.

Original: We show that the relatively large coefficients on the higher-order terms would not result in gradient exploding in practice.
Revised: We show that the relatively large coefficients on the higher-order terms would not result in gradient exploding in practice.

Original: • We show that there exists some constant k ⩽ d , s.t.
Revised: • We show that there exists some constant k ⩽ d , s.t.

Original: our order- d polynomial constraint can be reduced to order- k polynomial without expanding its feasible set.
Revised: our order- d polynomial constraint can be reduced to order- k polynomial without expanding its feasible set.

Original: Though finding such value of k requires solving the NP-hard longest simple path problem, we develop a simple heuristic to find such k with bounded error to the exact, order- d , DAG constraint.
Revised: Though finding such value of k requires solving the NP-hard longest simple path problem, we develop a simple heuristic to find such k with bounded error to the exact, order- d , DAG constraint.

Original: Based on this result, we propose a DAG constraint based on efficient Truncated Matrix Power Iteration (TMPI), and conduct experiments to demonstrate that the resulting DAG learning method outperforms previous methods by a large margin.
Revised: Based on this result, we propose a DAG constraint based on efficient Truncated Matrix Power Iteration (TMPI), and conduct experiments to demonstrate that the resulting DAG learning method outperforms previous methods by a large margin.

Original: • We provide a systematical empirical comparison of the existing DAG constraints, including the polynomial and spectral radius based constraints, as well as the algebraic DAG representation of NOCURL.
Revised: • We provide a systematical empirical comparison of the existing DAG constraints, including the polynomial and spectral radius based constraints, as well as the algebraic DAG representation of NOCURL.

Original:  Preliminaries
Revised:  Preliminaries

Original: DAG Model and Linear SEM Given a DAG model (a.k.a.
Revised: DAG Model and Linear SEM Given a DAG model (a.k.a.

Original: Bayesian network) defined over random vector x =
Revised: Bayesian network) defined over random vector x =

Original: [ x 1 , x 2 , . . .
Revised: [ x 1 , x 2 , . . .

Original: , x d ] ⊤ and DAG G , the distribution P ( x ) and DAG G are assumed to satisfy the Markov assumption [27, 39].
Revised: , x d ] ⊤ and DAG G , the distribution P ( x ) and DAG G are assumed to satisfy the Markov assumption [27, 39].

Original: We say that x follows a linear Structural Equation Model (SEM) if
Revised: We say that x follows a linear Structural Equation Model (SEM) if

Original: [Equation]
Revised: [Equation]

Original: where B is the weighted adjacency matrix representing the DAG G , and e = [ e 1 , e 2 , . .
Revised: where B is the weighted adjacency matrix representing the DAG G , and e = [ e 1 , e 2 , . .

Original: . , e d ] ⊤ denotes the exogenous noise vector consisting of d independent random variables.
Revised: . , e d ] ⊤ denotes the exogenous noise vector consisting of d independent random variables.

Original: With slight abuse of notation, we denote by G ( B ) the graph induced by weighted adjacency matrix B .
Revised: With slight abuse of notation, we denote by G ( B ) the graph induced by weighted adjacency matrix B .

Original: Moreover, we do not distinguish between random variables and vertices or nodes, and use these terms interchangeably.
Revised: Moreover, we do not distinguish between random variables and vertices or nodes, and use these terms interchangeably.

Original: Our goal is to estimate the DAG G from n i.i.d.
Revised: Our goal is to estimate the DAG G from n i.i.d.

Original: samples of x , indicated by the matrix X ∈ R n × d .
Revised: samples of x , indicated by the matrix X ∈ R n × d .

Original: In general, the DAG G can only be identified up to its Markov equivalence class under the faithfulness [39] or sparsest Markov representation [30] assumption.
Revised: In general, the DAG G can only be identified up to its Markov equivalence class under the faithfulness [39] or sparsest Markov representation [30] assumption.

Original: It has been shown that for linear SEMs with homoscedastic errors, from which the noise terms are specified up to a constant [22], and for linear non-Gaussian SEMs, from which no more than one of the noise term is Gaussian [34], the true DAG can be fully identified.
Revised: It has been shown that for linear SEMs with homoscedastic errors, from which the noise terms are specified up to a constant [22], and for linear non-Gaussian SEMs, from which no more than one of the noise term is Gaussian [34], the true DAG can be fully identified.

Original: In this work, we focus on the linear SEMs with equal noise variances [28], which can be viewed as an instance of the former.
Revised: In this work, we focus on the linear SEMs with equal noise variances [28], which can be viewed as an instance of the former.

Original: DAG Constraints for Differentiable DAG Learning Recently, Zheng et al.
Revised: DAG Constraints for Differentiable DAG Learning Recently, Zheng et al.

Original: [50] reformulated the
Revised: [50] reformulated the

Original: DAG learning problem as the following continuous optimization problem with convex least-squares objective but non-convex constraint,
Revised: DAG learning problem as the following continuous optimization problem with convex least-squares objective but non-convex constraint,

Original: [Equation]
Revised: [Equation]

Original: subject to h
Revised: subject to h

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: (2) where ∥ · ∥ F and ∥ · ∥ 1 denote the Frobenius norm and elementwise ℓ 1 norm, respectively, η > 0 is the regularization coefficient that controls the sparsity of B , and ⊙ denotes the Hadamard product, which is used to map B to a positive weighted adjacency matrix with the same structure.
Revised: (2) where ∥ · ∥ F and ∥ · ∥ 1 denote the Frobenius norm and elementwise ℓ 1 norm, respectively, η > 0 is the regularization coefficient that controls the sparsity of B , and ⊙ denotes the Hadamard product, which is used to map B to a positive weighted adjacency matrix with the same structure.

Original: Given any ˜
Revised: Given any ˜

Original: B ∈ R d × d ⩾ 0 , the function h exp is defined as
Revised: B ∈ R d × d ⩾ 0 , the function h exp is defined as

Original: [Equation]
Revised: [Equation]

Original: and can be efficiently computed using various approaches [1, 2].
Revised: and can be efficiently computed using various approaches [1, 2].

Original: The key here is that h exp ( ˜ B ) =
Revised: The key here is that h exp ( ˜ B ) =

Original: if and only if G ( ˜ B ) is a DAG.
Revised: if and only if G ( ˜ B ) is a DAG.

Original: The formulation (2) involves a hard constraint, and Zheng et al.
Revised: The formulation (2) involves a hard constraint, and Zheng et al.

Original: [50] adopted the augmented Lagrangian method [4, 5] to solve the constrained optimization problem.
Revised: [50] adopted the augmented Lagrangian method [4, 5] to solve the constrained optimization problem.

Original: Ng et al.
Revised: Ng et al.

Original: [24] demonstrated that the augmented Lagrangian method here behaves similarly to the classical quadratic penalty method [15, 29] in practice, and showed that it is guaranteed to return a
Revised: [24] demonstrated that the augmented Lagrangian method here behaves similarly to the classical quadratic penalty method [15, 29] in practice, and showed that it is guaranteed to return a

Original: DAG under certain conditions.
Revised: DAG under certain conditions.

Original: To improve practical convenience, Yu et al.
Revised: To improve practical convenience, Yu et al.

Original: [45] proposed a similar DAG constraint using an order- d polynomial based on powers of a binomial, given by
Revised: [45] proposed a similar DAG constraint using an order- d polynomial based on powers of a binomial, given by

Original: [Equation]
Revised: [Equation]

Original: where α > 0 is a hyperparameter and is often set to 

Revised: where α > 0 is a hyperparameter and is often set to

Original: /d , e.g. , in the implementation of DAG-GNN [45].
Revised: /d , e.g. , in the implementation of DAG-GNN [45].

Original: This function can be evaluated using O (log d ) matrix multiplications using the exponentiation by squaring algorithm.
Revised: This function can be evaluated using O (log d ) matrix multiplications using the exponentiation by squaring algorithm.

Original: Both h exp ( ˜ B ) and h bin ( ˜ B ) are formulated by Wei et al.
Revised: Both h exp ( ˜ B ) and h bin ( ˜ B ) are formulated by Wei et al.

Original: [44] as a unified one
Revised: [44] as a unified one

Original: [Equation]
Revised: [Equation]

Original:  DAG Learning with Truncated Matrix Power Iteration
Revised:  DAG Learning with Truncated Matrix Power Iteration

Original: In this section, we first show that gradient vanishing is one main issue for previous DAG constraints and propose a truncated geometric series based DAG constraints to escape from the issue in Section 3.1.
Revised: In this section, we first show that gradient vanishing is one main issue for previous DAG constraints and propose a truncated geometric series based DAG constraints to escape from the issue in Section 3.1.

Original: Then in Section 3.2 the theoretical properties of our DAG constraints are analyzed.
Revised: Then in Section 3.2 the theoretical properties of our DAG constraints are analyzed.

Original: In Section 3.3 we provide an efficient algorithm for our DAG constraints.
Revised: In Section 3.3 we provide an efficient algorithm for our DAG constraints.

Original: In Section 3.4, we discuss the relation between our algorithm and previous works.
Revised: In Section 3.4, we discuss the relation between our algorithm and previous works.

Original: 3.1 Gradient Vanishing Issue and Truncated Geometric DAG Constraint
Revised: 3.1 Gradient Vanishing Issue and Truncated Geometric DAG Constraint

Original: Theoretically, any positive values of c i suffice to make the DAG constraint term h poly ( ˜ B ) in Eq.
Revised: Theoretically, any positive values of c i suffice to make the DAG constraint term h poly ( ˜ B ) in Eq.

Original: (5) a valid one, i.e. , it equals zero if and only if the graph G ( ˜ B ) is acyclic.
Revised: (5) a valid one, i.e. , it equals zero if and only if the graph G ( ˜ B ) is acyclic.

Original: Thus previously small
Revised: Thus previously small

Original: [Figure]
Revised: [Figure]

Original: coefficients for higher-order terms are preferred since they are known to have better resistance to numeric exploding of higher-order polynomials [45, 50].
Revised: coefficients for higher-order terms are preferred since they are known to have better resistance to numeric exploding of higher-order polynomials [45, 50].

Original: These small coefficients forbid informative higher-order terms and cause severe gradient vanishing, as nilpotent properties of DAG result in candidate adjacency matrix with very small spectral radius (see empirical analysis in Figure 1 left ).
Revised: These small coefficients forbid informative higher-order terms and cause severe gradient vanishing, as nilpotent properties of DAG result in candidate adjacency matrix with very small spectral radius (see empirical analysis in Figure 1 left ).

Original: In this case, the weight updates during the optimization process can hardly utilize this higher-order information from the vanishingly small gradients.
Revised: In this case, the weight updates during the optimization process can hardly utilize this higher-order information from the vanishingly small gradients.

Original: As a consequence, only lower-order information can be effectively captured, which may be detrimental to the quality of final solution.
Revised: As a consequence, only lower-order information can be effectively captured, which may be detrimental to the quality of final solution.

Original: To avoid the severe vanishing gradient issue in existing DAG constraints ( e.g. , Eq.
Revised: To avoid the severe vanishing gradient issue in existing DAG constraints ( e.g. , Eq.

Original: (3), (4)), we propose to discard the coefficients and use a finite geometric series based function:
Revised: (3), (4)), we propose to discard the coefficients and use a finite geometric series based function:

Original: [Equation]
Revised: [Equation]

Original: The gradient of h geo w.r.t.
Revised: The gradient of h geo w.r.t.

Original: ˜ B denoted by ∇ ˜ B h geo ( ˜ B ) is an order- ( d − 1) polynomial of ˜ B .
Revised: ˜ B denoted by ∇ ˜ B h geo ( ˜ B ) is an order- ( d − 1) polynomial of ˜ B .

Original: Compared to (3) and (4), Eq.
Revised: Compared to (3) and (4), Eq.

Original: (6a) is a more precise DAG constraint escaped from from severe gradient vanishing.
Revised: (6a) is a more precise DAG constraint escaped from from severe gradient vanishing.

Original: Also it is notable that due to the nilpotent properties of weighted adjacency matrices of DAGs, the higher-order terms in (6a) and (6b) often comes with small norms; thus, our
Revised: Also it is notable that due to the nilpotent properties of weighted adjacency matrices of DAGs, the higher-order terms in (6a) and (6b) often comes with small norms; thus, our

Original: DAG constraint may not suffer from numeric exploding in practice, based on the observations in
Revised: DAG constraint may not suffer from numeric exploding in practice, based on the observations in

Original: Section 4.
Revised: Section 4.

Original: In Figure 1 we compared the norm of gradients on higher-order terms of different DAG constraints, where we observe that for previous exponential-based (3) and binomial-based (4) DAG constraints, the gradients of higher-order terms converges to 0 very quickly as the order increases.
Revised: In Figure 1 we compared the norm of gradients on higher-order terms of different DAG constraints, where we observe that for previous exponential-based (3) and binomial-based (4) DAG constraints, the gradients of higher-order terms converges to 0 very quickly as the order increases.

Original: Meanwhile, the gradient of higher-order terms in (6a) converges to 0 with a much slower speed and thus informative higher-order terms are preserved.
Revised: Meanwhile, the gradient of higher-order terms in (6a) converges to 0 with a much slower speed and thus informative higher-order terms are preserved.

Original: We further show that those non-informative higher-order terms that are close to zero in (6a) can be safely dropped to form a more efficient DAG constraint with some k ⩽ d , where we often have k ≪ d in practice:
Revised: We further show that those non-informative higher-order terms that are close to zero in (6a) can be safely dropped to form a more efficient DAG constraint with some k ⩽ d , where we often have k ≪ d in practice:

Original: [Equation]
Revised: [Equation]

Original: Naively, the DAG constraint (7) requires O ( k ) matrix multiplication which is far less than O ( d ) for (6a), and under mild conditions the error of (7) is tightly bounded (see Proposition 3 for details).
Revised: Naively, the DAG constraint (7) requires O ( k ) matrix multiplication which is far less than O ( d ) for (6a), and under mild conditions the error of (7) is tightly bounded (see Proposition 3 for details).

Original: In
Revised: In

Original: Figure 1 right we show that our DAG constraint (7) (named TMPI) attains far better performance than previous ones as it escapes from gradient vanishing.
Revised: Figure 1 right we show that our DAG constraint (7) (named TMPI) attains far better performance than previous ones as it escapes from gradient vanishing.

Original: 3.2 Theoretical Properties of Truncated Geometric DAG Constraint
Revised: 3.2 Theoretical Properties of Truncated Geometric DAG Constraint

Original: We analyze the properties of the power of adjacency matrices, which play an important role in constructing DAG constraints.
Revised: We analyze the properties of the power of adjacency matrices, which play an important role in constructing DAG constraints.

Original: First notice that, for the k th power of an adjacency matrix ˜ B ∈ R d × d ⩾ 0 , its entry ( ˜ B k ) ij is nonzero if and only if there is a length- k path (not necessarily simple) from node
Revised: First notice that, for the k th power of an adjacency matrix ˜ B ∈ R d × d ⩾ 0 , its entry ( ˜ B k ) ij is nonzero if and only if there is a length- k path (not necessarily simple) from node

Original: X i to node X j in graph G ( ˜ B ) .
Revised: X i to node X j in graph G ( ˜ B ) .

Original: This straightforwardly leads to the following property, which is a corollary of [44, Lemma 1].
Revised: This straightforwardly leads to the following property, which is a corollary of [44, Lemma 1].

Original: Proposition 1.
Revised: Proposition 1.

Original: Let ˜ B ∈ R d
Revised: Let ˜ B ∈ R d

Original: ×
Revised: ×

Original: d ⩾ 0 be the weighted adjacency matrix of a graph G with d vertices.
Revised: d ⩾ 0 be the weighted adjacency matrix of a graph G with d vertices.

Original: G is a
Revised: G is a

Original: DAG
Revised: DAG

Original: if and only if ˜ B d = 0 .
Revised: if and only if ˜ B d = 0 .

Original: Proposition 1 can be used to construct a single-term DAG constraint term, given by
Revised: Proposition 1 can be used to construct a single-term DAG constraint term, given by

Original: [Equation]
Revised: [Equation]

Original: where ∥ · ∥ p denotes an elementwise ℓ p norm.
Revised: where ∥ · ∥ p denotes an elementwise ℓ p norm.

Original: However, as the candidate adjacency matrix gets closer to acyclic, the spectral radius of ˜ B d will become very small.
Revised: However, as the candidate adjacency matrix gets closer to acyclic, the spectral radius of ˜ B d will become very small.

Original: As a result, the value h single ( ˜ B ) , as well as its gradient ∇ ˜ B h single ( ˜ B ) may become too small to be represented in limited machine precision.
Revised: As a result, the value h single ( ˜ B ) , as well as its gradient ∇ ˜ B h single ( ˜ B ) may become too small to be represented in limited machine precision.

Original: This suggests the use of the polynomial based constraints for better performance.
Revised: This suggests the use of the polynomial based constraints for better performance.

Original: Without any prior information of the graph, one has to compute the d th power of matrix ˜ B , either using the DAG constraint terms in Eq.
Revised: Without any prior information of the graph, one has to compute the d th power of matrix ˜ B , either using the DAG constraint terms in Eq.

Original: (8) or (5).
Revised: (8) or (5).

Original: However, if the length of the longest simple path in the graph is known, we can formulate a lower-order polynomial based DAG constraint.
Revised: However, if the length of the longest simple path in the graph is known, we can formulate a lower-order polynomial based DAG constraint.

Original: Proposition 2.
Revised: Proposition 2.

Original: Let ˜ B ∈ R d
Revised: Let ˜ B ∈ R d

Original: ×
Revised: ×

Original: d ⩾ 0 be the weighted adjacency matrix of a graph G with d vertices, and k be the length of the longest simple path 1 in graph G .
Revised: d ⩾ 0 be the weighted adjacency matrix of a graph G with d vertices, and k be the length of the longest simple path 1 in graph G .

Original: The following three conditions are equivalent:
Revised: The following three conditions are equivalent:

Original: (1) G is a DAG, (2)
Revised: (1) G is a DAG, (2)

Original: ˜ B k +1 = 0 , and (3) h k trunc
Revised: ˜ B k +1 = 0 , and (3) h k trunc

Original: [Equation]
Revised: [Equation]

Original: The intuition of the above proposition is as follows.
Revised: The intuition of the above proposition is as follows.

Original: For the graph whose largest simple cycle has a length of k , it suffices to compute the k th power of its adjacency matrix, since computing any power larger than k is simply traveling in the cycles repeatedly.
Revised: For the graph whose largest simple cycle has a length of k , it suffices to compute the k th power of its adjacency matrix, since computing any power larger than k is simply traveling in the cycles repeatedly.

Original: Therefore, Proposition 2 suggests that h k trunc ( ˜ B ) =
Revised: Therefore, Proposition 2 suggests that h k trunc ( ˜ B ) =

Original: is a valid DAG constraint.
Revised: is a valid DAG constraint.

Original: Unfortunately, the longest simple path problem for general graphs is known to be NP-hard [32], and thus we have to find an alternative way to seek the proper k .
Revised: Unfortunately, the longest simple path problem for general graphs is known to be NP-hard [32], and thus we have to find an alternative way to seek the proper k .

Original: For a candidate adjacency matrix ˜ B , a simple heuristic is to iterate over the power of matrices to find some k s.t. matrix ˜ B k is close enough to a zero matrix.
Revised: For a candidate adjacency matrix ˜ B , a simple heuristic is to iterate over the power of matrices to find some k s.t. matrix ˜ B k is close enough to a zero matrix.

Original: Recall that Proposition 1 implies that the adjacency matrix of a DAG is nilpotent; therefore, when a candidate adjacency matrix ˜ B is close to being acyclic, its spectral radius would be close to zero, which implies that the ˜ B k would converge quickly to zero as k increases.
Revised: Recall that Proposition 1 implies that the adjacency matrix of a DAG is nilpotent; therefore, when a candidate adjacency matrix ˜ B is close to being acyclic, its spectral radius would be close to zero, which implies that the ˜ B k would converge quickly to zero as k increases.

Original: Thus, if we use the above heuristic to find k , it is highly possible that we find some k ≪ d .
Revised: Thus, if we use the above heuristic to find k , it is highly possible that we find some k ≪ d .

Original: By using an approximate k instead of the exact one, the DAG constraint in Eq.
Revised: By using an approximate k instead of the exact one, the DAG constraint in Eq.

Original: (7) becomes an approximate one with the following bounds.
Revised: (7) becomes an approximate one with the following bounds.

Original: Denoting by ∥ · ∥ ∞ the elementwise infinity norm ( i.e. , maximum norm), we have the following proposition.
Revised: Denoting by ∥ · ∥ ∞ the elementwise infinity norm ( i.e. , maximum norm), we have the following proposition.

Original: Proposition 3.
Revised: Proposition 3.

Original: Given ˜ B ∈ R
Revised: Given ˜ B ∈ R

Original: d
Revised: d

Original: × d ⩾ 0 , if there exists k < d
Revised: × d ⩾ 0 , if there exists k < d

Original: such that ∥ ˜ B k ∥ ∞
Revised: such that ∥ ˜ B k ∥ ∞

Original: ⩽ ϵ < 1 ( k +1)
Revised: ⩽ ϵ < 1 ( k +1)

Original: d , then we have
Revised: d , then we have

Original: [Equation]
Revised: [Equation]

Original: Remark 1.
Revised: Remark 1.

Original: The condition ϵ < 1 ( k +1)
Revised: The condition ϵ < 1 ( k +1)

Original: d in the proposition above is such that the inequalities are non geo ( ˜ B ) − ∇ ˜
Revised: d in the proposition above is such that the inequalities are non geo ( ˜ B ) − ∇ ˜

Original: h k trunc ( ˜ B ) ∥ F / ∥∇ ˜ B
Revised: h k trunc ( ˜ B ) ∥ F / ∥∇ ˜ B

Original: h
Revised: h

Original: geo ( ˜ B ) ∥ F <
Revised: geo ( ˜ B ) ∥ F <

Original: Proposition 3 provides an efficient way to bound the error of truncated constraints h k trunc ( ˜ B ) to the geometric series based DAG constraints h geo ( ˜ B ) .
Revised: Proposition 3 provides an efficient way to bound the error of truncated constraints h k trunc ( ˜ B ) to the geometric series based DAG constraints h geo ( ˜ B ) .

Original: However, it also demonstrates a possible limitation for all polynomial based DAG constraints.
Revised: However, it also demonstrates a possible limitation for all polynomial based DAG constraints.

Original: As we know, when a solution is close to DAG, its spectral radius will be close to zero.
Revised: As we know, when a solution is close to DAG, its spectral radius will be close to zero.

Original: In this situation, if the longest simple path in a graph is long, it is unavoidable to use high-order terms to capture this information while such high-order terms might be close to 0 .
Revised: In this situation, if the longest simple path in a graph is long, it is unavoidable to use high-order terms to capture this information while such high-order terms might be close to 0 .

Original: In the worst case, the higher-order terms may underflow due to limited machine precision.
Revised: In the worst case, the higher-order terms may underflow due to limited machine precision.

Original: Thus some specific numerically stable method may be required, and we leave this for future work.
Revised: Thus some specific numerically stable method may be required, and we leave this for future work.

Original: 3.3 Dynamic Truncated Matrix Power Iteration
Revised: 3.3 Dynamic Truncated Matrix Power Iteration

Original: Proposition 3 indicates that it may be safe to discard those matrix powers with index larger than k .
Revised: Proposition 3 indicates that it may be safe to discard those matrix powers with index larger than k .

Original: In this case, the DAG constraint and its gradient correspond to order- k and order- ( k − 1) polynomials of ˜ B , respectively.
Revised: In this case, the DAG constraint and its gradient correspond to order- k and order- ( k − 1) polynomials of ˜ B , respectively.

Original: A straightforward way to compute the DAG constraint as well as the gradient is provided in Algorithm 1, which we call TMPI.
Revised: A straightforward way to compute the DAG constraint as well as the gradient is provided in Algorithm 1, which we call TMPI.

Original: The general polynomial based DAG constraint in (5) requires O ( d ) matrix multiplication, while Algorithm 1 reduces the number of multiplication to O ( k ) .
Revised: The general polynomial based DAG constraint in (5) requires O ( d ) matrix multiplication, while Algorithm 1 reduces the number of multiplication to O ( k ) .

Original: In practice, k can be much smaller than d ; for example, when recovering 100 -node Erd˝os–Rényi
Revised: In practice, k can be much smaller than d ; for example, when recovering 100 -node Erd˝os–Rényi

Original: DAG with expected degree 4 , k is often smaller than 20 .
Revised: DAG with expected degree 4 , k is often smaller than 20 .

Original: (TMPI)
Revised: (TMPI)

Original: Input: ˜ B ∈ R d × d ⩾ 0 , ϵ
Revised: Input: ˜ B ∈ R d × d ⩾ 0 , ϵ

Original: Output: h (˜ B ) , ∇ ˜ B h (˜ B ) 1: i ← 2 , h (˜ B ) ← tr(˜ B ) , ∇ ˜ B h (˜ B ) ← I 2: while i ⩽ d do 3: ∇ ˜ B h (˜ B ) ← ∇ ˜ B h (˜ B )
Revised: Output: h (˜ B ) , ∇ ˜ B h (˜ B ) 1: i ← 2 , h (˜ B ) ← tr(˜ B ) , ∇ ˜ B h (˜ B ) ← I 2: while i ⩽ d do 3: ∇ ˜ B h (˜ B ) ← ∇ ˜ B h (˜ B )

Original: + i (˜ B i − 1 )
Revised: + i (˜ B i − 1 )

Original: ⊤ 4: ˜ B
Revised: ⊤ 4: ˜ B

Original: i ← ˜ B ˜ B
Revised: i ← ˜ B ˜ B

Original: i −5: h (
Revised: i −5: h (

Original: B ) ← h (˜ B ) + tr(˜ B i ) 6:
Revised: B ) ← h (˜ B ) + tr(˜ B i ) 6:

Original: 8: end while 9:
Revised: 8: end while 9:

Original: B ) , ∇ ˜ B h (˜ B )
Revised: B ) , ∇ ˜ B h (˜ B )

Original: Input: ˜ B ∈ R d × d ⩾ 0 , ϵ
Revised: Input: ˜ B ∈ R d × d ⩾ 0 , ϵ

Original: Output: h (˜ B ) , ∇ ˜ B h (˜ B ) 1: i ←2: ˜ B f ← ˜ B , ˜ B
Revised: Output: h (˜ B ) , ∇ ˜ B h (˜ B ) 1: i ←2: ˜ B f ← ˜ B , ˜ B

Original: g ← I , ˜ B p ← ˜ B { ˜ B f stores f i (˜ B ) , ˜ B g stores ∇ ˜ B tr
Revised: g ← I , ˜ B p ← ˜ B { ˜ B f stores f i (˜ B ) , ˜ B g stores ∇ ˜ B tr

Original: ( f i (˜ B )) , and ˜ B p stores ˜ B i } 3: while i ⩽ d do 4: ˜ B oldf ← ˜ B f , ˜ B oldg ← ˜ B g , ˜ B oldp ← ˜ B p 5:
Revised: ( f i (˜ B )) , and ˜ B p stores ˜ B i } 3: while i ⩽ d do 4: ˜ B oldf ← ˜ B f , ˜ B oldg ← ˜ B g , ˜ B oldp ← ˜ B p 5:

Original: ˜ B f ← ˜ B oldf + ˜ B oldp ˜ B oldf ,
Revised: ˜ B f ← ˜ B oldf + ˜ B oldp ˜ B oldf ,

Original: ˜ B
Revised: ˜ B

Original: p ← ˜ B oldp ˜ B oldp 6: ˜ B g ← ˜ B oldg + ˜ B
Revised: p ← ˜ B oldp ˜ B oldp 6: ˜ B g ← ˜ B oldg + ˜ B

Original: ⊤ p ˜ B oldg + i (˜ B f − ˜ B oldf + ˜ B oldp − ˜ B p ) 7: if ∥ ˜ B p ∥ ∞ ⩽ ϵ then break 8: i ← 2 i 9: end while 10: Output tr(˜ B f ) , ˜ B g
Revised: ⊤ p ˜ B oldg + i (˜ B f − ˜ B oldf + ˜ B oldp − ˜ B p ) 7: if ∥ ˜ B p ∥ ∞ ⩽ ϵ then break 8: i ← 2 i 9: end while 10: Output tr(˜ B f ) , ˜ B g

Original: Fast Truncated Matrix Power Iteration We exploit the specific structure of geometric series to further accelerate the TMPI algorithm from O ( k ) to O (log k ) matrix multiplications.
Revised: Fast Truncated Matrix Power Iteration We exploit the specific structure of geometric series to further accelerate the TMPI algorithm from O ( k ) to O (log k ) matrix multiplications.

Original: This is acheived by leveraging the following recurrence relations, with a proof provided in Appendix A.4.
Revised: This is acheived by leveraging the following recurrence relations, with a proof provided in Appendix A.4.

Original: Proposition 4.
Revised: Proposition 4.

Original: Given any d × d real matrix ˜ B , let f i ( ˜ B ) =
Revised: Given any d × d real matrix ˜ B , let f i ( ˜ B ) =

Original: ˜ B + ˜ B 2 + · · · + ˜ B i and h i ( ˜ B )
Revised: ˜ B + ˜ B 2 + · · · + ˜ B i and h i ( ˜ B )

Original: = tr( f i ( ˜ B )) .
Revised: = tr( f i ( ˜ B )) .

Original: Then we have the following recurrence relations:
Revised: Then we have the following recurrence relations:

Original: [Equation]
Revised: [Equation]

Original: This straightfowardly implies the following corollary, with a proof given in Appendix A.5.
Revised: This straightfowardly implies the following corollary, with a proof given in Appendix A.5.

Original: Corollary 1.
Revised: Corollary 1.

Original: Given any matrix d × d real matrix ˜ B , let f i ( ˜ B ) =
Revised: Given any matrix d × d real matrix ˜ B , let f i ( ˜ B ) =

Original: ˜ B + ˜ B 2 + · · · + ˜ B i and h i ( ˜ B )
Revised: ˜ B + ˜ B 2 + · · · + ˜ B i and h i ( ˜ B )

Original: = tr( f i ( ˜ B )) .
Revised: = tr( f i ( ˜ B )) .

Original: Then we have have the following recurrence relations:
Revised: Then we have have the following recurrence relations:

Original: [Equation]
Revised: [Equation]

Original: Instead of increasing the index i ( i.e. , power of ˜ B ) arithmetically by 1 , as in line 9 of Algorithm 1,
Revised: Instead of increasing the index i ( i.e. , power of ˜ B ) arithmetically by 1 , as in line 9 of Algorithm 1,

Original: Corollary 1 suggests using its recurrence relations to increase the index i geometrically by a factor of 2 , until the condition ∥
Revised: Corollary 1 suggests using its recurrence relations to increase the index i geometrically by a factor of 2 , until the condition ∥

Original: ˜ B i ∥ ∞
Revised: ˜ B i ∥ ∞

Original: ⩽ ϵ is satisfied.
Revised: ⩽ ϵ is satisfied.

Original: The full procedure named Fast TMPI is described in Algorithm 2, which requires O (log k ) matrix multiplications and O ( d 2 ) additional storage.
Revised: The full procedure named Fast TMPI is described in Algorithm 2, which requires O (log k ) matrix multiplications and O ( d 2 ) additional storage.

Original: An example implementation is given in Listing 1 in Appendix B.1.
Revised: An example implementation is given in Listing 1 in Appendix B.1.

Original: Similar strategy can be applied to the original geometric series based constraint (6a) to form a fast algorithm that requires O (log d ) matrix multiplications.
Revised: Similar strategy can be applied to the original geometric series based constraint (6a) to form a fast algorithm that requires O (log d ) matrix multiplications.

Original: A comparison of the time complexity between our proposed constraint and the existing ones is provided in Appendix B.2.
Revised: A comparison of the time complexity between our proposed constraint and the existing ones is provided in Appendix B.2.

Original: The Full Optimization Framework For NOTEARS, we apply the same augmented Lagrangian framework [4, 5] adopted by Zheng et al.
Revised: The Full Optimization Framework For NOTEARS, we apply the same augmented Lagrangian framework [4, 5] adopted by Zheng et al.

Original: [50] to convert the constrained optimization problem into the following unconstrained problem
Revised: [50] to convert the constrained optimization problem into the following unconstrained problem

Original: [Equation]
Revised: [Equation]

Original: where the parameters ρ and α are iteratively updated using the same strategy as Zheng et al.
Revised: where the parameters ρ and α are iteratively updated using the same strategy as Zheng et al.

Original: We also apply the proposed DAG constraint to GOLEM [23] that adopts likelihood-based objective with soft constraints, leading to the unconstrained optimization problem
Revised: We also apply the proposed DAG constraint to GOLEM [23] that adopts likelihood-based objective with soft constraints, leading to the unconstrained optimization problem

Original: [Equation]
Revised: [Equation]

Original: where η 1 , η 2 > 0 are the regularization coefficients.
Revised: where η 1 , η 2 > 0 are the regularization coefficients.

Original: In both formulations above, we use Algorithmor 2 to dynamically compute h k trunc ( B ⊙ B ) (and the value of k ) during each optimization iteration based on a predefined tolerance ϵ .
Revised: In both formulations above, we use Algorithmor 2 to dynamically compute h k trunc ( B ⊙ B ) (and the value of k ) during each optimization iteration based on a predefined tolerance ϵ .

Original: 3.4 Relation to Previous Works
Revised: 3.4 Relation to Previous Works

Original: Our algorithm is closely related to the following DAG constraint considered by Zheng et al.
Revised: Our algorithm is closely related to the following DAG constraint considered by Zheng et al.

Original: Lemma 1 (Zheng et al.
Revised: Lemma 1 (Zheng et al.

Original: [50, Proposition 1]) .
Revised: [50, Proposition 1]) .

Original: Let ˜ B ∈ R d
Revised: Let ˜ B ∈ R d

Original: ×
Revised: ×

Original: d ⩾ 0 with spectral radius smaller than one be the weighted adjacency matrix of a graph G with d vertices.
Revised: d ⩾ 0 with spectral radius smaller than one be the weighted adjacency matrix of a graph G with d vertices.

Original: G is a DAG if and only if
Revised: G is a DAG if and only if

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: When the spectral radius is smaller than one, the inverse of I − ˜ B is simply the following infinite geometric series:
Revised: When the spectral radius is smaller than one, the inverse of I − ˜ B is simply the following infinite geometric series:

Original: [Equation]
Revised: [Equation]

Original: Zheng et al.
Revised: Zheng et al.

Original: [50] argued that (12) is not well defined for ˜ B with spectral radius larger than 1, and in practice the series (12) may explode very quickly.
Revised: [50] argued that (12) is not well defined for ˜ B with spectral radius larger than 1, and in practice the series (12) may explode very quickly.

Original: Based on this argument, they adopted the matrix exponential for constructing the DAG constraint.
Revised: Based on this argument, they adopted the matrix exponential for constructing the DAG constraint.

Original: For the same reason, Yu et al.
Revised: For the same reason, Yu et al.

Original: [45] also used very small coefficients for higher-order terms in polynomial based DAG constraints.
Revised: [45] also used very small coefficients for higher-order terms in polynomial based DAG constraints.

Original: However, as we illustrate in Section 3, the DAG constraints proposed by Yu et al.
Revised: However, as we illustrate in Section 3, the DAG constraints proposed by Yu et al.

Original: [45], Zheng et al.
Revised: [45], Zheng et al.

Original: [50] may suffer from gradient vanishing owing to the small coefficients for higher-order terms.
Revised: [50] may suffer from gradient vanishing owing to the small coefficients for higher-order terms.

Original: In fact, our constraint (7) serves a good approximation for (11) since we are actually looking for an approximate inverse of
Revised: In fact, our constraint (7) serves a good approximation for (11) since we are actually looking for an approximate inverse of

Original: I − ˜ B with a bounded error.
Revised: I − ˜ B with a bounded error.

Original: Proposition 5.
Revised: Proposition 5.

Original: Given ˜ B ∈ R d × d ⩾ 0 , if there exists k such that ∥ ˜ B k ∥ ∞ ⩽ ϵ < 1 /d , then we have
Revised: Given ˜ B ∈ R d × d ⩾ 0 , if there exists k such that ∥ ˜ B k ∥ ∞ ⩽ ϵ < 1 /d , then we have

Original: [Equation]
Revised: [Equation]

Original: Previous works [24, 44] pointed out that for DAG constraints with form h ( B ⊙ B ) , the Hadamard product would lead to vanishing gradients in the sense that the gradient ∇ B h ( B ⊙ B ) = 

Revised: Previous works [24, 44] pointed out that for DAG constraints with form h ( B ⊙ B ) , the Hadamard product would lead to vanishing gradients in the sense that the gradient ∇ B h ( B ⊙ B ) =

Original: if and only if h ( B ⊙ B ) = 0 .
Revised: if and only if h ( B ⊙ B ) = 0 .

Original: Ng et al.
Revised: Ng et al.

Original: [24] further showed that this may lead to ill-conditioning issue when solving the constrained optimization problem.
Revised: [24] further showed that this may lead to ill-conditioning issue when solving the constrained optimization problem.

Original: One may replace the Hadamard product with absolute value, as in Wei et al.
Revised: One may replace the Hadamard product with absolute value, as in Wei et al.

Original: [44], but the non-smoothness of absolute value may make the optimization problem difficult to solve and lead to poorer performance [24].
Revised: [44], but the non-smoothness of absolute value may make the optimization problem difficult to solve and lead to poorer performance [24].

Original: As pointed out by Ng et al.
Revised: As pointed out by Ng et al.

Original: [24], QuasiNewtown methods, e.g. , L-BFGS [7], still perform well even when faced with the ill-conditioning issue caused by vanishing gradients of constraints with form h ( B ⊙ B ) .
Revised: [24], QuasiNewtown methods, e.g. , L-BFGS [7], still perform well even when faced with the ill-conditioning issue caused by vanishing gradients of constraints with form h ( B ⊙ B ) .

Original: In this work, we identify another type of gradient vanishing issue caused by (1) the higher-order terms and small coefficients in function h itself and (2) the small spectral radius of candidate matrix B , and further provide an effective solution by constructing a Truncated Matrix Power Iteration based DAG constraint.
Revised: In this work, we identify another type of gradient vanishing issue caused by (1) the higher-order terms and small coefficients in function h itself and (2) the small spectral radius of candidate matrix B , and further provide an effective solution by constructing a Truncated Matrix Power Iteration based DAG constraint.

Original:  Experiments
Revised:  Experiments

Original: We compare the performance of different DAG learning algorithms and DAG constraints to demonstrate the effectiveness of the proposed TMPI based DAG constraint.
Revised: We compare the performance of different DAG learning algorithms and DAG constraints to demonstrate the effectiveness of the proposed TMPI based DAG constraint.

Original: We provide the main experimental results in this section, and further empirical studies can be found in Appendix C.
Revised: We provide the main experimental results in this section, and further empirical studies can be found in Appendix C.

Original: 4.1 DAG Learning
Revised: 4.1 DAG Learning

Original: We first conduct experiments on synthetic datasets using similar settings as previous works [23, 46, 50].
Revised: We first conduct experiments on synthetic datasets using similar settings as previous works [23, 46, 50].

Original: In summary, random Erdös-Rényi graphs [14] are generated with d nodes and kd expected edges (denoted by ER k ).
Revised: In summary, random Erdös-Rényi graphs [14] are generated with d nodes and kd expected edges (denoted by ER k ).

Original: Edge weights generated from uniform distribution over the union of two intervals [ − 2 , − 0 .
Revised: Edge weights generated from uniform distribution over the union of two intervals [ − 2 , − 0 .

Original: 5] ∪ [0 . 5 , 2 . 0] are assigned to each edge to form a weighted adjacency matrix B .
Revised: 5] ∪ [0 . 5 , 2 . 0] are assigned to each edge to form a weighted adjacency matrix B .

Original: Then n samples are generated from the linear SEM x
Revised: Then n samples are generated from the linear SEM x

Original: = B x + e to form an n × d data matrix X , where the noise e are i.i.d.
Revised: = B x + e to form an n × d data matrix X , where the noise e are i.i.d.

Original: sampled from Gaussian, Exponential, or Gumbel distribution.
Revised: sampled from Gaussian, Exponential, or Gumbel distribution.

Original: We set the sample size n = 1000 and consider 4 different number of nodes d = 10 , 30 , 50 , 100 unless otherwise stated.
Revised: We set the sample size n = 1000 and consider 4 different number of nodes d = 10 , 30 , 50 , 100 unless otherwise stated.

Original: For each setting, we conduct 100 random simulations to obtain an average performance.
Revised: For each setting, we conduct 100 random simulations to obtain an average performance.

Original: Methods and Baselines We consider continuous DAG learning methods based on both Mean
Revised: Methods and Baselines We consider continuous DAG learning methods based on both Mean

Original: Squared Error (MSE) loss (see Eq.
Revised: Squared Error (MSE) loss (see Eq.

Original: and likelihood-based (see Eq.
Revised: and likelihood-based (see Eq.

Original: (10)) loss from GOLEM [23].
Revised: (10)) loss from GOLEM [23].

Original: For both losses, we include the following DAG constraints: (1) MSE/Likelihood loss+Exponential
Revised: For both losses, we include the following DAG constraints: (1) MSE/Likelihood loss+Exponential

Original: DAG constraint (3), i.e. NOTEARS [50]/GOLEM[23] ; (2) MSE/Likelihood loss+Binomial DAG constraint (4) from DAG-GNN [45]; (3) MSE/Likelihood loss+Spectral radius based DAG constraint from NOBEARS [21]; (4) MSE/Likelihood loss+Single
Revised: DAG constraint (3), i.e. NOTEARS [50]/GOLEM[23] ; (2) MSE/Likelihood loss+Binomial DAG constraint (4) from DAG-GNN [45]; (3) MSE/Likelihood loss+Spectral radius based DAG constraint from NOBEARS [21]; (4) MSE/Likelihood loss+Single

Original: Term DAG constraint (8); (5) MSE/Likelihood loss+Truncated Matrix Power Iteration (TMPI)
Revised: Term DAG constraint (8); (5) MSE/Likelihood loss+Truncated Matrix Power Iteration (TMPI)

Original: based DAG constraint (7).
Revised: based DAG constraint (7).

Original: For the NOCURL method [46], since it is a two stage methods where the initialization stage rely on MSE loss and
Revised: For the NOCURL method [46], since it is a two stage methods where the initialization stage rely on MSE loss and

Original: Binomial DAG constraint, we include it as a baseline, but do not combine it with likelihood loss.
Revised: Binomial DAG constraint, we include it as a baseline, but do not combine it with likelihood loss.

Original: The other baselines include GES [9] and MMHC [41, 42] 3 .
Revised: The other baselines include GES [9] and MMHC [41, 42] 3 .

Original: [Figure]
Revised: [Figure]

Original: For MSE loss based DAG learning methods (9), we set η = 0 .
Revised: For MSE loss based DAG learning methods (9), we set η = 0 .

Original: 1 and use the same strategy as Zheng et al.
Revised: 1 and use the same strategy as Zheng et al.

Original: [50] to update the parameters ρ and α .
Revised: [50] to update the parameters ρ and α .

Original: For likelihood loss based DAG learning methods (10), we set η 1 = 0 .
Revised: For likelihood loss based DAG learning methods (10), we set η 1 = 0 .

Original: 02 and η 2 = 5 . 

Revised: 02 and η 2 = 5 .

Original: as Ng et al.
Revised: as Ng et al.

Original: For the Binomial DAG constraints (4), the parameter α is set to 1 /d as Yu et al.
Revised: For the Binomial DAG constraints (4), the parameter α is set to 1 /d as Yu et al.

Original: For our TMPI DAG constraint, we set the parameter ϵ = 10 − 6 .
Revised: For our TMPI DAG constraint, we set the parameter ϵ = 10 − 6 .

Original: For the NOCURL method, we use their public available implementation and default parameter setting 4 .
Revised: For the NOCURL method, we use their public available implementation and default parameter setting 4 .

Original: For GES and MMPC, we use the implementation and default parameter setting in the CausalDiscoveryToolbox package [16].
Revised: For GES and MMPC, we use the implementation and default parameter setting in the CausalDiscoveryToolbox package [16].

Original: [Figure]
Revised: [Figure]

Original: Results
Revised: Results

Original: The results for MSE/likelihood based DAG learning algorithm are shown in Figure 2/3, where we compare the Structural Hamming Distance (SHD) of different algorithms.
Revised: The results for MSE/likelihood based DAG learning algorithm are shown in Figure 2/3, where we compare the Structural Hamming Distance (SHD) of different algorithms.

Original: The complete results for other metrics are reported in Appendix C.1.
Revised: The complete results for other metrics are reported in Appendix C.1.

Original: The original NOTEARS
Revised: The original NOTEARS

Original: ( i
Revised: ( i

Original: [Figure]
Revised: [Figure]

Original: e. MSE+Exponential) / GOLEM
Revised: e. MSE+Exponential) / GOLEM

Original: ( i
Revised: ( i

Original: [Figure]
Revised: [Figure]

Original: e. GOLEM+Exponential) has similar performance as MSE/GOLEM+Binomial.
Revised: e. GOLEM+Exponential) has similar performance as MSE/GOLEM+Binomial.

Original: This may not be surprising because the coefficients of each order term in the Exponential and Binomial constraints are actually very close (see Figure 1 for an example).
Revised: This may not be surprising because the coefficients of each order term in the Exponential and Binomial constraints are actually very close (see Figure 1 for an example).

Original: The performance of algorithms using single-term DAG constraint is often not comparable to the other polynomial-based constraints since it suffers more from gradient vanishing.
Revised: The performance of algorithms using single-term DAG constraint is often not comparable to the other polynomial-based constraints since it suffers more from gradient vanishing.

Original: The performance of algorithms using the spectral radius based constraints (BEARS) are also worse than the ones using Exponential and Binomial constraints.
Revised: The performance of algorithms using the spectral radius based constraints (BEARS) are also worse than the ones using Exponential and Binomial constraints.

Original: The algorithms using our TMPI constraints outperforms all others in almost all cases, which demonstrate the effectiveness of our DAG constraint.
Revised: The algorithms using our TMPI constraints outperforms all others in almost all cases, which demonstrate the effectiveness of our DAG constraint.

Original: Additional Experiments We conduct additional experiments with scale-free graphs, smaller sample size ( i.e. , n = 200 samples), larger graphs ( i.e. , 500 -node graphs), and denser graphs ( i.e. , ER graphs).
Revised: Additional Experiments We conduct additional experiments with scale-free graphs, smaller sample size ( i.e. , n = 200 samples), larger graphs ( i.e. , 500 -node graphs), and denser graphs ( i.e. , ER graphs).

Original: Due to the space limit, the results of these experiments are provided in Appendices C.2,
Revised: Due to the space limit, the results of these experiments are provided in Appendices C.2,

Original: C.3, C.4, and C.6, respectively, which further demonstrate the effectiveness of our proposed DAG constraint.
Revised: C.3, C.4, and C.6, respectively, which further demonstrate the effectiveness of our proposed DAG constraint.

Original: We also compare our method with NOFEARS [44] in Appendix C.5.
Revised: We also compare our method with NOFEARS [44] in Appendix C.5.

Original: 4.2 Extension to Nonlinear Case
Revised: 4.2 Extension to Nonlinear Case

Original: Although the description of our algorithm in Section 3 focuses on the linear case, it can be straightforwardly extended to the nonlinear case.
Revised: Although the description of our algorithm in Section 3 focuses on the linear case, it can be straightforwardly extended to the nonlinear case.

Original: In this section, we extend our DAG constraint to nonlinear case by replacing the binomial DAG constraint in DAG-GNN [45], NOTEARS-MLP [51] and
Revised: In this section, we extend our DAG constraint to nonlinear case by replacing the binomial DAG constraint in DAG-GNN [45], NOTEARS-MLP [51] and

Original: GRAN-DAG [20] with our TMPI constraint.
Revised: GRAN-DAG [20] with our TMPI constraint.

Original: Synthetic Data We compare our algorithm and DAG-GNN on 50 -node ER1 graph with nonlinear
Revised: Synthetic Data We compare our algorithm and DAG-GNN on 50 -node ER1 graph with nonlinear

Original: SEM x = B cos( x +1)
Revised: SEM x = B cos( x +1)

Original: + e over 5 simulations.
Revised: + e over 5 simulations.

Original: Our algorithm achieves SHD of 22 . 2 ± 4 .
Revised: Our algorithm achieves SHD of 22 . 2 ± 4 .

Original: 2 while
Revised: 2 while

Original: DAG-GNN achieves SHD of 25 . 2 ± 4 .
Revised: DAG-GNN achieves SHD of 25 . 2 ± 4 .

Original: We simulate a nonlinear dataset with 50 -node ER1 graphs and each function being an MLP as Zheng et al.
Revised: We simulate a nonlinear dataset with 50 -node ER1 graphs and each function being an MLP as Zheng et al.

Original: The original NOTEARS-MLP has SHD 16 .
Revised: The original NOTEARS-MLP has SHD 16 .

Original: 9 ± 1 . 5 , while NOTEARS-MLP with our TMPI constraint achieves an SHD of 14 . 9 ± 1 . 3 .
Revised: 9 ± 1 . 5 , while NOTEARS-MLP with our TMPI constraint achieves an SHD of 14 . 9 ± 1 . 3 .

Original: Real Data We also run an experiment on the Protein Signaling Networks dataset [31] consisting of n = 7466 samples with d = 11 nodes.
Revised: Real Data We also run an experiment on the Protein Signaling Networks dataset [31] consisting of n = 7466 samples with d = 11 nodes.

Original: The dataset is widely used to evaluate the performance of DAG learning algorithms; however, since the identifiability of the DAG is not guaranteed, we compare both SHD and SHDC (SHD of CPDAG), following Lachapelle et al.
Revised: The dataset is widely used to evaluate the performance of DAG learning algorithms; however, since the identifiability of the DAG is not guaranteed, we compare both SHD and SHDC (SHD of CPDAG), following Lachapelle et al.

Original: In this experiment, we replace the original DAG constraints in DAG-GNN [45] and Gran-DAG [20] with our TMPI DAG constraints.
Revised: In this experiment, we replace the original DAG constraints in DAG-GNN [45] and Gran-DAG [20] with our TMPI DAG constraints.

Original: The results are shown in Table 1, showing that by replacing the DAG constraint with our
Revised: The results are shown in Table 1, showing that by replacing the DAG constraint with our

Original: TMPI constraint, there is a performance improvement on SHD and SHDC for almost all cases.
Revised: TMPI constraint, there is a performance improvement on SHD and SHDC for almost all cases.

Original: 4.3 Ablation Study
Revised: 4.3 Ablation Study

Original: We use the ER3 dataset in previous section to conduct an ablation study to compare the performance of the Geometric constraint (6a) and our TMPI constraint (7), with both the naive implementation ( i.e. , linear complexity) and fast implementation ( i.e. , logarithmic complexity) from Algorithmsand 2, respectively.
Revised: We use the ER3 dataset in previous section to conduct an ablation study to compare the performance of the Geometric constraint (6a) and our TMPI constraint (7), with both the naive implementation ( i.e. , linear complexity) and fast implementation ( i.e. , logarithmic complexity) from Algorithmsand 2, respectively.

Original: The results are shown in Figure 4.
Revised: The results are shown in Figure 4.

Original: The SHD between Geometric constraint and TMPI constraint in both the naive and fast implementations are similar, and our Fast TMPI algorithm runs significantly faster than the other three, especially when the graph size is large.
Revised: The SHD between Geometric constraint and TMPI constraint in both the naive and fast implementations are similar, and our Fast TMPI algorithm runs significantly faster than the other three, especially when the graph size is large.

Original: We also conduct further empirical study to illustrate the numeric difference between different k for our
Revised: We also conduct further empirical study to illustrate the numeric difference between different k for our

Original: DAG constraint; due to limited space, a detailed discussion is provided in Appendix C.7.
Revised: DAG constraint; due to limited space, a detailed discussion is provided in Appendix C.7.

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original:  Conclusion and Future Work
Revised:  Conclusion and Future Work

Original: While polynomial constraints-based DAG learning algorithms achieve promising performance, they often suffer from gradient vanishing in practice.
Revised: While polynomial constraints-based DAG learning algorithms achieve promising performance, they often suffer from gradient vanishing in practice.

Original: We identified one important source of gradient vanishing: improper small coefficients for higher-order terms, and proposed to use the geometric series based DAG constraints to escape from gradient vanishing.
Revised: We identified one important source of gradient vanishing: improper small coefficients for higher-order terms, and proposed to use the geometric series based DAG constraints to escape from gradient vanishing.

Original: We further proposed an efficient algorithm that can evaluate the constraint with bounded error in O (log k ) complexity, where k is often far smaller than the number of nodes.
Revised: We further proposed an efficient algorithm that can evaluate the constraint with bounded error in O (log k ) complexity, where k is often far smaller than the number of nodes.

Original: By replacing the previous DAG constraints with ours, the performance of DAG learning can often be significantly improved in various settings.
Revised: By replacing the previous DAG constraints with ours, the performance of DAG learning can often be significantly improved in various settings.

Original: A clear next step would be finding strategies to adaptively adjust the coefficients for higher-order terms in polynomial based constraints.
Revised: A clear next step would be finding strategies to adaptively adjust the coefficients for higher-order terms in polynomial based constraints.

Original: In a nutshell, polynomial-based constraints may explode on candidate graphs that are far from acyclic, and also suffer from gradient vanishing problem when the graph is nearly acyclic.
Revised: In a nutshell, polynomial-based constraints may explode on candidate graphs that are far from acyclic, and also suffer from gradient vanishing problem when the graph is nearly acyclic.

Original: Fixed coefficients are not able to solve both problems at the same time.
Revised: Fixed coefficients are not able to solve both problems at the same time.

Original: Another possible direction is to use the sparse properties in DAGs to make DAG learning more efficient.
Revised: Another possible direction is to use the sparse properties in DAGs to make DAG learning more efficient.

Original: Since the adjacency matrix of DAG must be nilpotent, there might exist more compact representation of the adjacency matrix, such as a low-rank CANDECOMP/PARAFAC (CP) decomposition, which can potentially be used to derive an efficient algorithm for very large graphs.
Revised: Since the adjacency matrix of DAG must be nilpotent, there might exist more compact representation of the adjacency matrix, such as a low-rank CANDECOMP/PARAFAC (CP) decomposition, which can potentially be used to derive an efficient algorithm for very large graphs.

Original: Acknowledgements
Revised: Acknowledgements

Original: We thank the anonymous reviewers, especially Reviewer iGwL, for their helpful comments.
Revised: We thank the anonymous reviewers, especially Reviewer iGwL, for their helpful comments.

Original: ZZ, DG,
Revised: ZZ, DG,

Original: YL, EA and JQS were partially supported by Centre for Augmented Reasoning at the Australian
Revised: YL, EA and JQS were partially supported by Centre for Augmented Reasoning at the Australian

Original: Institute for Machine Learning.
Revised: Institute for Machine Learning.

Original: IN and KZ were partially supported by the National Institutes of Health (NIH) under Contract NIH-NHLB1 9R01HL159805-05A1, by the NSF-Convergence Accelerator Track-D award #2134901, by a grant from Apple Inc., and by a grant from KDDI Research Inc.. MG was supported by ARC DE210101624.
Revised: IN and KZ were partially supported by the National Institutes of Health (NIH) under Contract R01HL159805, by the NSF-Convergence Accelerator Track-D award #2134901, by a grant from Apple Inc., and by a grant from KDDI Research Inc.. MG was supported by ARC DE210101624.

Original: Checklist
Revised: Checklist

Original: For all authors... (a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope?
Revised: For all authors... (a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope?

Original: [Yes] (b) Did you describe the limitations of your work?
Revised: [Yes] (b) Did you describe the limitations of your work?

Original: [Yes] (c) Did you discuss any potential negative societal impacts of your work?
Revised: [Yes] (c) Did you discuss any potential negative societal impacts of your work?

Original: [No] (d) Have you read the ethics review guidelines and ensured that your paper conforms to them?
Revised: [No] (d) Have you read the ethics review guidelines and ensured that your paper conforms to them?

Original: [Yes] 2.
Revised: [Yes] 2.

Original: If you are including theoretical results... (a) Did you state the full set of assumptions of all theoretical results?
Revised: If you are including theoretical results... (a) Did you state the full set of assumptions of all theoretical results?

Original: [Yes] (b) Did you include complete proofs of all theoretical results?
Revised: [Yes] (b) Did you include complete proofs of all theoretical results?

Original: [Yes] See Appendices 3.
Revised: [Yes] See Appendices 3.

Original: If you ran experiments... (a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)?
Revised: If you ran experiments... (a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)?

Original: [Yes] (b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)?
Revised: [Yes] (b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)?

Original: [Yes] See Section 4 and Appendices (c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)?
Revised: [Yes] See Section 4 and Appendices (c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)?

Original: [Yes] See Section(d)
Revised: [Yes] See Section(d)

Original: Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)?
Revised: Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)?

Original: [Yes] See Appendices 4.
Revised: [Yes] See Appendices 4.

Original: If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... (a) If your work uses existing assets, did you cite the creators?
Revised: If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... (a) If your work uses existing assets, did you cite the creators?

Original: [Yes] (b) Did you mention the license of the assets?
Revised: [Yes] (b) Did you mention the license of the assets?

Original: [Yes] See Appendices (c) Did you include any new assets either in the supplemental material or as a URL?
Revised: [Yes] See Appendices (c) Did you include any new assets either in the supplemental material or as a URL?

Original: [No] (d) Did you discuss whether
Revised: [No] (d) Did you discuss whether

Original: and how consent was obtained from people whose data you’re using/curating?
Revised: and how consent was obtained from people whose data you’re using/curating?

Original: [Yes] We use publicly available datasets (e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content?
Revised: [Yes] We use publicly available datasets (e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content?

Original: [N/A] 5.
Revised: [N/A] 5.

Original: If you used crowdsourcing or conducted research with human subjects... (a) Did you include the full text of instructions given to participants and screenshots, if applicable?
Revised: If you used crowdsourcing or conducted research with human subjects... (a) Did you include the full text of instructions given to participants and screenshots, if applicable?

Original: [N/A] (b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable?
Revised: [N/A] (b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable?

Original: [N/A] (c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation?
Revised: [N/A] (c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation?

Original: [N/A]
Revised: [N/A]

Original: Appendices
Revised: Appendices

Original: A
Revised: A

Original: Proofs
Revised: Proofs

Original: A.1 Proof of Proposition
Revised: A.1 Proof of Proposition

Original: Proposition 1.
Revised: Proposition 1.

Original: Let ˜ B ∈ R d
Revised: Let ˜ B ∈ R d

Original: ×
Revised: ×

Original: d ⩾ 0 be the weighted adjacency matrix of a graph G with d vertices.
Revised: d ⩾ 0 be the weighted adjacency matrix of a graph G with d vertices.

Original: G is a
Revised: G is a

Original: DAG
Revised: DAG

Original: if and only if ˜ B d = 0 .
Revised: if and only if ˜ B d = 0 .

Original: Proof.
Revised: Proof.

Original: Any path in a d -node DAG cannot be longer than d − 1 , and thus we must have ( ˜ B d ) ij =for all i, j , which indicates for DAG we must have ˜ B d = 0 .
Revised: Any path in a d -node DAG cannot be longer than d − 1 , and thus we must have ( ˜ B d ) ij =for all i, j , which indicates for DAG we must have ˜ B d = 0 .

Original: On the other side, a nilpotent adjacency matrix must form a DAG [44, Lemma 1].
Revised: On the other side, a nilpotent adjacency matrix must form a DAG [44, Lemma 1].

Original: A.2 Proof of Proposition
Revised: A.2 Proof of Proposition

Original: Proposition 2.
Revised: Proposition 2.

Original: Let ˜ B ∈ R d
Revised: Let ˜ B ∈ R d

Original: ×
Revised: ×

Original: d ⩾ 0 be the weighted adjacency matrix of a graph G with d vertices, let k be the length of longest simple path in G , the following 3 conditions are equivalent: (1) G is a DAG, (2)
Revised: d ⩾ 0 be the weighted adjacency matrix of a graph G with d vertices, let k be the length of longest simple path in G , the following 3 conditions are equivalent: (1) G is a DAG, (2)

Original: ˜ B k +1 = 0 , and (3) h k trunc ( ˜ B ) = 0 .
Revised: ˜ B k +1 = 0 , and (3) h k trunc ( ˜ B ) = 0 .

Original: Proof.
Revised: Proof.

Original: First notice that ( ˜ B k ) jℓ > 0 if and only if there is at least a directed walk with length k from node j to node ℓ in G .
Revised: First notice that ( ˜ B k ) jℓ > 0 if and only if there is at least a directed walk with length k from node j to node ℓ in G .

Original: We consider the following cases:
Revised: We consider the following cases:

Original: • (1) =
Revised: • (1) =

Original: ⇒ (2): Since G is a DAG, the diagonal entries of ˜ B k +1 are zero.
Revised: ⇒ (2): Since G is a DAG, the diagonal entries of ˜ B k +1 are zero.

Original: Therefore, it suffices to consider its non-diagonal entries.
Revised: Therefore, it suffices to consider its non-diagonal entries.

Original: For a DAG, any directed path in a DAG must be a simple path without loop.
Revised: For a DAG, any directed path in a DAG must be a simple path without loop.

Original: If it is not, then we can find a directed path, where a node appears twice, which means that there is a loop in the graph and it is in contradiction with the acyclic property.
Revised: If it is not, then we can find a directed path, where a node appears twice, which means that there is a loop in the graph and it is in contradiction with the acyclic property.

Original: Thus if G is a DAG, there will be no path with length larger than k , and so the non-diagonal entries of ˜ B k +1 are zero.
Revised: Thus if G is a DAG, there will be no path with length larger than k , and so the non-diagonal entries of ˜ B k +1 are zero.

Original: Combining both cases, we have ˜ B k +

Revised: Combining both cases, we have ˜ B k +

Original: =
Revised: =

Original: • (1) =
Revised: • (1) =

Original: ⇒ (3): Since G is a DAG, the diagonal entries of ˜ B i , i = 1 , . . .
Revised: ⇒ (3): Since G is a DAG, the diagonal entries of ˜ B i , i = 1 , . . .

Original: , d are zeros.
Revised: , d are zeros.

Original: Therefore, we must have tr (cid:16)(cid:80) ki
Revised: Therefore, we must have tr (cid:16)(cid:80) ki

Original: =1 ˜ B i (cid:17) = 0 .
Revised: =1 ˜ B i (cid:17) = 0 .

Original: • (2) =
Revised: • (2) =

Original: ⇒ (1): Since ˜ B
Revised: ⇒ (1): Since ˜ B

Original: k
Revised: k

Original: +

Revised: +

Original: =
Revised: =

Original: 0 , ˜ B is nilpotent and G must be acyclic.
Revised: 0 , ˜ B is nilpotent and G must be acyclic.

Original: • (3) =
Revised: • (3) =

Original: ⇒ (1): It is clear that a directed graph is a DAG if and only if it does not contain simple cycle.
Revised: ⇒ (1): It is clear that a directed graph is a DAG if and only if it does not contain simple cycle.

Original: Since tr (cid:16)(cid:80) ki =1 ˜ B i (cid:17) = 0 , all path with length smaller than or equal to k must not be a (simple) cycle.
Revised: Since tr (cid:16)(cid:80) ki =1 ˜ B i (cid:17) = 0 , all path with length smaller than or equal to k must not be a (simple) cycle.

Original: If there exists any path with length larger than k that forms a simple cycle, then there exists a simple path that is longer than k , which contradicts our assumption that k is the longest simple path.
Revised: If there exists any path with length larger than k that forms a simple cycle, then there exists a simple path that is longer than k , which contradicts our assumption that k is the longest simple path.

Original: Combining both cases, G does not contain simple cycle and thus must be acyclic.
Revised: Combining both cases, G does not contain simple cycle and thus must be acyclic.

Original: Here we proved that (1) and (2) are equivalent; (1) and (3) are equivalent.
Revised: Here we proved that (1) and (2) are equivalent; (1) and (3) are equivalent.

Original: Thus the three conditions are equivalent under the assumption of the proposition.
Revised: Thus the three conditions are equivalent under the assumption of the proposition.

Original: A.3 Proof of Proposition
Revised: A.3 Proof of Proposition

Original: We first describe a property of the polynomials of matrices in Lemma 2, which will be used to prove
Revised: We first describe a property of the polynomials of matrices in Lemma 2, which will be used to prove

Original: Proposition 3.
Revised: Proposition 3.

Original: Lemma 2.
Revised: Lemma 2.

Original: Given ˜ B ∈ R
Revised: Given ˜ B ∈ R

Original: d
Revised: d

Original: × d ⩾ 0 , assume that we have two series [ α 0 , α 1 , . .
Revised: × d ⩾ 0 , assume that we have two series [ α 0 , α 1 , . .

Original: α k ] ∈ R k
Revised: α k ] ∈ R k

Original: +1 ⩾ 

Revised: +1 ⩾

Original: and [ β 0 , β 1 , . .
Revised: and [ β 0 , β 1 , . .

Original: . , β k ] ∈ R k +1 ⩾ 0 .
Revised: . , β k ] ∈ R k +1 ⩾ 0 .

Original: If we have α i
Revised: If we have α i

Original: ⩾ β i for i = 0 , 1 , . . .
Revised: ⩾ β i for i = 0 , 1 , . . .

Original: k , then the following inequalities hold: (cid:13)(cid:13)(cid:13)(cid:13)(cid:13) k
Revised: k , then the following inequalities hold: (cid:13)(cid:13)(cid:13)(cid:13)(cid:13) k

Original: (cid:88)
Revised: (cid:88)

Original: [Equation]
Revised: [Equation]

Original: = α
Revised: = α

Original: [Equation]
Revised: [Equation]

Original: F
Revised: F

Original: [Equation]
Revised: [Equation]

Original: (cid:13)(cid:13)(cid:13)(cid:13)(cid:13) k (cid:88) i =
Revised: (cid:13)(cid:13)(cid:13)(cid:13)(cid:13) k (cid:88) i =

Original: β i ˜ B
Revised: β i ˜ B

Original: i (cid:13)(cid:13)(cid:13)(cid:13)(cid:13)
Revised: i (cid:13)(cid:13)(cid:13)(cid:13)(cid:13)

Original: F , (13a) (cid:13)(cid:13)(cid:13)(cid:13)(cid:13) k (cid:88) i = α i
Revised: F , (13a) (cid:13)(cid:13)(cid:13)(cid:13)(cid:13) k (cid:88) i = α i

Original: ˜ B
Revised: ˜ B

Original: i (cid:13)(cid:13)(cid:13)(cid:13)(cid:13) ∞ ⩾ (cid:13)(cid:13)(cid:13)(cid:13)(cid:13) k (cid:88) i = β i ˜
Revised: i (cid:13)(cid:13)(cid:13)(cid:13)(cid:13) ∞ ⩾ (cid:13)(cid:13)(cid:13)(cid:13)(cid:13) k (cid:88) i = β i ˜

Original: [Equation]
Revised: [Equation]

Original: (cid:13)(cid:13)(cid:13)(cid:13)(cid:13) ∞ .
Revised: (cid:13)(cid:13)(cid:13)(cid:13)(cid:13) ∞ .

Original: (13b)
Revised: (13b)

Original: Proof.
Revised: Proof.

Original: By the assumption that ˜ B ∈ R d × d ⩾ 0 , we have ˜ B i ∈ R
Revised: By the assumption that ˜ B ∈ R d × d ⩾ 0 , we have ˜ B i ∈ R

Original: d × d ⩾ 0 for i = 0 , 1 , . . .
Revised: d × d ⩾ 0 for i = 0 , 1 , . . .

Original: , k .
Revised: , k .

Original: Then, using the assumption that α i ⩾ β i for i = 0 , 1 , . . .
Revised: Then, using the assumption that α i ⩾ β i for i = 0 , 1 , . . .

Original: k , straightly we can see that each entry of (cid:80) ki =

Revised: k , straightly we can see that each entry of (cid:80) ki =

Original: α i ˜
Revised: α i ˜

Original: B i should be no less than the corresponding entry of (cid:80) ki =

Revised: B i should be no less than the corresponding entry of (cid:80) ki =

Original: β i ˜ B i .
Revised: β i ˜ B i .

Original: Thus (13) must hold.
Revised: Thus (13) must hold.

Original: With the lemma above, we now present the proof of Proposition 3.
Revised: With the lemma above, we now present the proof of Proposition 3.

Original: Proposition 3.
Revised: Proposition 3.

Original: Given ˜ B ∈ R
Revised: Given ˜ B ∈ R

Original: d
Revised: d

Original: × d ⩾ 0 , if there exists k < d
Revised: × d ⩾ 0 , if there exists k < d

Original: such that ∥ ˜ B k ∥ ∞ ⩽ ϵ <
Revised: such that ∥ ˜ B k ∥ ∞ ⩽ ϵ <

Original: [Equation]
Revised: [Equation]

Original: , then we have
Revised: , then we have

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: Let [ λ 1 , λ 2 , . . .
Revised: Let [ λ 1 , λ 2 , . . .

Original: , λ d ] be the d eigen values of ˜ B .
Revised: , λ d ] be the d eigen values of ˜ B .

Original: We have
Revised: We have

Original: [Equation]
Revised: [Equation]

Original: which indicates that
Revised: which indicates that

Original: [Equation]
Revised: [Equation]

Original: As all entries of ˜ B are non-negative, for all j > 1 we have
Revised: As all entries of ˜ B are non-negative, for all j > 1 we have

Original: [Equation]
Revised: [Equation]

Original: 1+ j/k
Revised: 1+ j/k

Original: [Equation]
Revised: [Equation]

Original: which implies that
Revised: which implies that

Original: [Equation]
Revised: [Equation]

Original: This finishes the proof of the first part of the proposition.
Revised: This finishes the proof of the first part of the proposition.

Original: For the second part, we have
Revised: For the second part, we have

Original: [Equation]
Revised: [Equation]

Original: [Table]
Revised: [Table]

Original: [Equation]
Revised: [Equation]

Original: [Table]
Revised: [Table]

Original: [Equation]
Revised: [Equation]

Original: [Table]
Revised: [Table]

Original: [Equation]
Revised: [Equation]

Original: [Table]
Revised: [Table]

Original: ⩽
Revised: ⩽

Original: [Table]
Revised: [Table]

Original: =( k + 1) dϵ ∥∇ ˜ B h geo ( ˜ B ) ∥
Revised: =( k + 1) dϵ ∥∇ ˜ B h geo ( ˜ B ) ∥

Original: [Table]
Revised: [Table]

Original: A.4 Proof of Proposition
Revised: A.4 Proof of Proposition

Original: Proposition 4.
Revised: Proposition 4.

Original: Given any d × d real matrix ˜ B , let f i ( ˜ B ) =
Revised: Given any d × d real matrix ˜ B , let f i ( ˜ B ) =

Original: ˜ B + ˜ B 2 + · · · + ˜ B i and h i ( ˜ B )
Revised: ˜ B + ˜ B 2 + · · · + ˜ B i and h i ( ˜ B )

Original: = tr( f i ( ˜ B )) .
Revised: = tr( f i ( ˜ B )) .

Original: Then we have the following recurrence relations:
Revised: Then we have the following recurrence relations:

Original: [Equation]
Revised: [Equation]

Original: −
Revised: −

Original: [Equation]
Revised: [Equation]

Original: ⊤
Revised: ⊤

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: Substituting i + j for i in the definition of f i ( ˜ B ) , we have
Revised: Substituting i + j for i in the definition of f i ( ˜ B ) , we have

Original: [Equation]
Revised: [Equation]

Original: Similarly, to establish the recurrence relation for ∇ ˜ B h i + j ( ˜ B ) , we have
Revised: Similarly, to establish the recurrence relation for ∇ ˜ B h i + j ( ˜ B ) , we have

Original: [Equation]
Revised: [Equation]

Original: where the fourth equality follows from the product rule.
Revised: where the fourth equality follows from the product rule.

Original: A.5 Proof of Corollary
Revised: A.5 Proof of Corollary

Original: Corollary 1.
Revised: Corollary 1.

Original: Given any matrix d × d real matrix ˜ B , let f i ( ˜ B ) =
Revised: Given any matrix d × d real matrix ˜ B , let f i ( ˜ B ) =

Original: ˜ B + ˜ B 2 + · · · + ˜ B i and h i ( ˜ B )
Revised: ˜ B + ˜ B 2 + · · · + ˜ B i and h i ( ˜ B )

Original: = tr( f i ( ˜ B )) .
Revised: = tr( f i ( ˜ B )) .

Original: Then we have have the following recurrence relations:
Revised: Then we have have the following recurrence relations:

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: The first equality is straightforwardly obtained by substituting i =
Revised: The first equality is straightforwardly obtained by substituting i =

Original: j in the first equality of Proposition 4.
Revised: j in the first equality of Proposition 4.

Original: Similarly, for the second equality, substituting i =
Revised: Similarly, for the second equality, substituting i =

Original: j in the second equality of
Revised: j in the second equality of

Original: Proposition 4 yields
Revised: Proposition 4 yields

Original: [Equation]
Revised: [Equation]

Original: A.6 Proof of Proposition
Revised: A.6 Proof of Proposition

Original: Proposition 5.
Revised: Proposition 5.

Original: Given ˜ B ∈ R d × d ⩾ 0 , if there exists k such that ∥ ˜ B k ∥ ∞ ⩽ ϵ < 1 /d , then we have (cid:13)(cid:13)(cid:13)(cid:13)(cid:13)
Revised: Given ˜ B ∈ R d × d ⩾ 0 , if there exists k such that ∥ ˜ B k ∥ ∞ ⩽ ϵ < 1 /d , then we have (cid:13)(cid:13)(cid:13)(cid:13)(cid:13)

Original: ( I − ˜ B ) − 1 − k
Revised: ( I − ˜ B ) − 1 − k

Original: (cid:88)
Revised: (cid:88)

Original: i =
Revised: i =

Original: ˜ B k (cid:13)(cid:13)(cid:13)(cid:13)(cid:13)
Revised: ˜ B k (cid:13)(cid:13)(cid:13)(cid:13)(cid:13)

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: Under the assumption of the proposition
Revised: Under the assumption of the proposition

Original: [Equation]
Revised: [Equation]

Original: the spectral radius of ˜ B is upper bounded by ( dϵ ) 1 /k with similar reasoning in (15), which is smaller than one; therefore, we can write ( I − ˜ B ) − 1 = (cid:80) ∞ j =0 ˜ B j .
Revised: the spectral radius of ˜ B is upper bounded by ( dϵ ) 1 /k with similar reasoning in (15), which is smaller than one; therefore, we can write ( I − ˜ B ) − 1 = (cid:80) ∞ j =0 ˜ B j .

Original: Thus we have
Revised: Thus we have

Original: [Equation]
Revised: [Equation]

Original: [Table]
Revised: [Table]

Original: B Fast Truncated Matrix Power Iteration B.1 Example Implementation
Revised: B Fast Truncated Matrix Power Iteration B.1 Example Implementation

Original: We provide an example implementation of Algorithm 2 in Listing 1.
Revised: We provide an example implementation of Algorithm 2 in Listing 1.

Original: 24 def h
Revised: 24 def h

Original: 1e
Revised: 1e

Original: 6): d
Revised: 6): d

Original: 0] global
Revised: 0] global

Original: np np
Revised: np np

Original: 27np copyto
Revised: 27np copyto

Original: np
Revised: np

Original: np np
Revised: np np

Original: np
Revised: np

Original: sec old g sec old_B sec
Revised: sec old g sec old_B sec

Original: sec
Revised: sec

Original: 39if
Revised: 39if

Original: break
Revised: break

Original: 43return
Revised: 43return

Original: B.2 Comparison of Time Complexity of Different DAG Constraints
Revised: B.2 Comparison of Time Complexity of Different DAG Constraints

Original: The time complexity for computing the proposed DAG constraints, along with the existing ones, is provided in Table 2.
Revised: The time complexity for computing the proposed DAG constraints, along with the existing ones, is provided in Table 2.

Original: Note that the complexity is described in terms of matrix multiplications, whose efficient algorithms have received much attention in the field of numerical linear algebra in the past decades.
Revised: Note that the complexity is described in terms of matrix multiplications, whose efficient algorithms have received much attention in the field of numerical linear algebra in the past decades.

Original: Coppersmith–Winograd [12] algorithm and Strassen algorithm
Revised: Coppersmith–Winograd [12] algorithm and Strassen algorithm

Original: [40] are widely used and require O ( d 2 . 376 ) and O ( d 2 . 807 ) operations, respectively.
Revised: [40] are widely used and require O ( d 2 . 376 ) and O ( d 2 . 807 ) operations, respectively.

Original: C Additional Experimental Results C.1 Other Performance Metrics
Revised: C Additional Experimental Results C.1 Other Performance Metrics

Original: The False Discovery Rate (FDR), True Positive Rate (TPR), and False Positive Rate (FPR) are provided in this section, and our TMPI based algorithm often achieves best performance for all these metrics.
Revised: The False Discovery Rate (FDR), True Positive Rate (TPR), and False Positive Rate (FPR) are provided in this section, and our TMPI based algorithm often achieves best performance for all these metrics.

Original: [Figure]
Revised: [Figure]

Original: i More precisely, the complexity of matrix exponential depends on the desired accuracy of the computation, for which a wide variety of algorithms are available [1, 2].
Revised: i More precisely, the complexity of matrix exponential depends on the desired accuracy of the computation, for which a wide variety of algorithms are available [1, 2].

Original: Here we use a fixed complexity since the first d terms of the Taylor expansion are sufficient to form a DAG constraint.
Revised: Here we use a fixed complexity since the first d terms of the Taylor expansion are sufficient to form a DAG constraint.

Original: ii
Revised: ii

Original: Based on exponentiation by squaring
Revised: Based on exponentiation by squaring

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

Original: C.2 Experiments on Scale-Free Graphs
Revised: C.2 Experiments on Scale-Free Graphs

Original: We consider the scale-free graph model [3] and the results are shown in Figures
Revised: We consider the scale-free graph model [3] and the results are shown in Figures

Original: [Figure]
Revised: [Figure]

Original: where we can see that with different graph structures our algorithm consistently achieves better results.
Revised: where we can see that with different graph structures our algorithm consistently achieves better results.

Original: [Figure]
Revised: [Figure]

Original: C.3 Experiments with Smaller Sample Size
Revised: C.3 Experiments with Smaller Sample Size

Original: We experiment with a smaller sample size, i
Revised: We experiment with a smaller sample size, i

Original: [Figure]
Revised: [Figure]

Original: e. , n = 200 samples, on the linear SEM
Revised: e. , n = 200 samples, on the linear SEM

Original: [Figure]
Revised: [Figure]

Original: and the results are shown in Figure 8, where our algorithm outperforms all others in most of the cases.
Revised: and the results are shown in Figure 8, where our algorithm outperforms all others in most of the cases.

Original: [Figure]
Revised: [Figure]

Original: C.4 Experiments on Larger Graphs
Revised: C.4 Experiments on Larger Graphs

Original: We conduct experiments on ER2 graph with 500 nodes with Gaussian noises.
Revised: We conduct experiments on ER2 graph with 500 nodes with Gaussian noises.

Original: For these kind of graphs, the GOLEM algorithm is known to perform well [23].
Revised: For these kind of graphs, the GOLEM algorithm is known to perform well [23].

Original: Thus we combine the GOLEM algorithm with different DAG constraints, where for all DAG constraints, the parameters η 1 and η 2 for GOLEM algorithm are set to 0 .
Revised: Thus we combine the GOLEM algorithm with different DAG constraints, where for all DAG constraints, the parameters η 1 and η 2 for GOLEM algorithm are set to 0 .

Original: 02 and 5 . 0 , respectively
Revised: 02 and 5 . 0 , respectively

Original: [Figure]
Revised: [Figure]

Original: and the number of iterations is set to 70000 .
Revised: and the number of iterations is set to 70000 .

Original: The results are shown in Table 3 and our algorithm achieves the best SHD and fastest running time.
Revised: The results are shown in Table 3 and our algorithm achieves the best SHD and fastest running time.

Original: The running time are measured on a
Revised: The running time are measured on a

Original: [Table]
Revised: [Table]

Original: C.5 Comparison with NOFEARS
Revised: C.5 Comparison with NOFEARS

Original: Wei et al.
Revised: Wei et al.

Original: [44] and Ng et al.
Revised: [44] and Ng et al.

Original: [24] mentioned that the operation B ⊙ B is one source of gradient vanishing.
Revised: [24] mentioned that the operation B ⊙ B is one source of gradient vanishing.

Original: Based on the observation, Wei et al.
Revised: Based on the observation, Wei et al.

Original: [44] proposed a KKT condition based local search strategy (named NOFEARS) to avoid gradient vanishing caused by B ⊙ B .
Revised: [44] proposed a KKT condition based local search strategy (named NOFEARS) to avoid gradient vanishing caused by B ⊙ B .

Original: As shown by Wei et al.
Revised: As shown by Wei et al.

Original: [44], to attain best performance the NOFEARS method is applied as a post-processing procedure for NOTEARS[50].
Revised: [44], to attain best performance the NOFEARS method is applied as a post-processing procedure for NOTEARS[50].

Original: Our method identified a different source of gradient vanishing caused by the small coefficients for higher-order terms in DAG constraints.
Revised: Our method identified a different source of gradient vanishing caused by the small coefficients for higher-order terms in DAG constraints.

Original: Thus our work is in parallel with previous work [24, 44], and the local search strategy by Wei et al.
Revised: Thus our work is in parallel with previous work [24, 44], and the local search strategy by Wei et al.

Original: [44] can be combined with our technique.
Revised: [44] can be combined with our technique.

Original: We compare the performance of our algorithm and NOFEARS [44] in Figure 9, where our method outperforms the original NOFEARS (NOTEARS+KKTS search) in most cases.
Revised: We compare the performance of our algorithm and NOFEARS [44] in Figure 9, where our method outperforms the original NOFEARS (NOTEARS+KKTS search) in most cases.

Original: The method that combines our method and NOFEARS attains the best performance ( i.e. , lowest SHD and False
Revised: The method that combines our method and NOFEARS attains the best performance ( i.e. , lowest SHD and False

Original: Discovery Rate (FDR), highest True Positive Rate (TPR)).
Revised: Discovery Rate (FDR), highest True Positive Rate (TPR)).

Original: [Figure]
Revised: [Figure]

Original: The NOFEARS method (NOTEARS+KKTS search) achieves better performance tham that of the original NOTEARS (MSE Exponential), but it performs worse than our TMPI method in most cases.
Revised: The NOFEARS method (NOTEARS+KKTS search) achieves better performance tham that of the original NOTEARS (MSE Exponential), but it performs worse than our TMPI method in most cases.

Original: The method that combines TMPI and local search (TMPI+KKTS search) achieves the best performance.
Revised: The method that combines TMPI and local search (TMPI+KKTS search) achieves the best performance.

Original: C.6 Experiments on Denser Graphs
Revised: C.6 Experiments on Denser Graphs

Original: We have conducted a simple experiment on ER6 graphs to compare the performance of different polynomial constraints on ER6 graphs (where the expected degree of node is 12).
Revised: We have conducted a simple experiment on ER6 graphs to compare the performance of different polynomial constraints on ER6 graphs (where the expected degree of node is 12).

Original: The dataset generating procedure for ER6 graph is the same as Section 4, but the number of samples n is set to 5000.
Revised: The dataset generating procedure for ER6 graph is the same as Section 4, but the number of samples n is set to 5000.

Original: The result is shown in Figure 10, where our TMPI method achieves best performance ( i.e. , lowest SHD and False Detection Rate (FDR), highest True Positive Rate (TPR)).
Revised: The result is shown in Figure 10, where our TMPI method achieves best performance ( i.e. , lowest SHD and False Detection Rate (FDR), highest True Positive Rate (TPR)).

Original: [Figure]
Revised: [Figure]

Original: C.7 Additional Ablation Study
Revised: C.7 Additional Ablation Study

Original: We provide an ablation study to illustrate the numeric difference between different k for our
Revised: We provide an ablation study to illustrate the numeric difference between different k for our

Original: DAG constraint, as depicted in Figure 11.
Revised: DAG constraint, as depicted in Figure 11.

Original: One observes that typically the error of our truncated DAG constraints against the geometric series based DAG constraint appears to drop exponentially as k increases.
Revised: One observes that typically the error of our truncated DAG constraints against the geometric series based DAG constraint appears to drop exponentially as k increases.

Original: Furthermore, this error may often exceed the machine precision.
Revised: Furthermore, this error may often exceed the machine precision.

Original: Therefore, for our TMPI algorithm ( i
Revised: Therefore, for our TMPI algorithm ( i

Original: [Figure]
Revised: [Figure]

Original: e. , the O ( k ) implementation described in Algorithm 1)
Revised: e. , the O ( k ) implementation described in Algorithm 1)

Original: [Figure]
Revised: [Figure]

Original: the value of k is often not large, and thus the TMPI algorithm is usually faster than both the geometric and fast geometric method, as demonstrated by the empirical study in Figure 4.
Revised: the value of k is often not large, and thus the TMPI algorithm is usually faster than both the geometric and fast geometric method, as demonstrated by the empirical study in Figure 4.

Original: Our fast TMPI algorithm (i
Revised: Our fast TMPI algorithm (i

Original: [Figure]
Revised: [Figure]

Original: e., the O (log k ) implementation described in Algorithm 2) further accelerates the procedure and its running time is the shortest in most settings
Revised: e., the O (log k ) implementation described in Algorithm 2) further accelerates the procedure and its running time is the shortest in most settings

Original: [Figure]
Revised: [Figure]