An efficient implementation for solving the all pairs minimax path problem in an undirected dense graph

## Abstract

Abstract. We provide an efficient O ⁢ ( n 2 ) 𝑂 superscript 𝑛 2 O(n^{2}) italic_O ( italic_n start_POSTSUPERSCRIPT 2 end_POSTSUPERSCRIPT ) implementation for solving the all pairs minimax path problem or widest path problem in an undirected dense graph. It is a code implementation of the Algorithm 4 (MMJ distance by Calculation and Copy) in a previous paper. The distance matrix is also called the all points path distance (APPD). We conducted experiments to test the implementation and algorithm, compared it with several other algorithms for solving the APPD matrix. Result shows Algorithm 4 works good for solving the widest path or minimax path APPD matrix. It can drastically improve the efficiency for computing the APPD matrix. There are several theoretical outcomes which claim the APPD matrix can be solved accurately in O ⁢ ( n 2 ) 𝑂 superscript 𝑛 2 O(n^{2}) italic_O ( italic_n start_POSTSUPERSCRIPT 2 end_POSTSUPERSCRIPT ) . However, they are impractical because there is no code implementation of these algorithms. It seems Algorithm 4 is the first algorithm that has an actual code implementation for solving the APPD matrix of minimax path or widest path problem in O ⁢ ( n 2 ) 𝑂 superscript 𝑛 2 O(n^{2}) italic_O ( italic_n start_POSTSUPERSCRIPT 2 end_POSTSUPERSCRIPT ) , in an undirected dense graph.

## 1. Introduction

The minimax path problem is a classic problem in graph theory and optimization. It involves finding a path between two nodes in a weighted graph such that the maximum weight of the edges in the path is minimized. (^1^11[https://en.wikipedia.org/wiki/Widest_path_problem](https://en.wikipedia.org/wiki/Widest_path_problem))

Given a graph $G=(V,E)$ where $V$ is the set of vertices and $E$ is the set of edges, each edge $e\in E$ has a weight $e_{w}$. For an undirected graph with $n$ vertices, the maximum number of edges is $\frac{n(n-1)}{2}$. A dense graph has close to $\frac{n(n-1)}{2}$ edges. We can say a dense graph has $O(n^{2})$ edges. In an undirected graph, each edge is bidirectional, meaning it connects two vertices in both directions.

The objective of the minimax path problem is to find a path $P$ from a starting node $i$ to a destination node $j$ such that the maximum weight of the edges in the path $P$ is minimized. A minimax path distance between a pair of points is the maximum weight in a minimax path between the points (Equation 2).

$$ (1) $\Phi=\{max_weight(p)~{}|~{}p\in\Theta_{(i,j,G)}\}$ $$

$$ (2) $M(i,j~{}|~{}G)=min(\Phi)$ $$

where $G$ is the undirected dense graph. $\Theta_{(i,j,G)}$ is the set of all paths from node $i$ to node $j$. $p$ is a path from node $i$ to node $j$, $max_weight(p)$ is the maximum weight in path $p$. $\Phi$ is the set of all maximum weights.   $min(\Phi)$ is the minimum of Set $\Phi$ (Liu, ).

The distance can also be called the longest-leg path distance (LLPD) (Little
et al., ) or Min-Max-Jump distance (MMJ distance) (Liu, ). The all pairs minimax path distances calculate the distance between each pair of points in a dataset $X$ or graph $G$ . It is also called all points path distance (APPD) (Little
et al., ). It is a matrix of shape $n\times n$. A dataset $X$ can be straightforwardly converted to a complete graph.

We can use a modified version of the Floyd–Warshall algorithm to solve the APPD in both directed and undirected dense graphs (Weisstein, ), or use the Algorithm 1 (MMJ distance by recursion) in (Liu, ), both of them take $O(n^{3})$ time. However, in an undirected dense graph, we have a better choice. We may use an $O(n^{2})$ algorithm to calculate the APPD matrix. There are several theoretical outcomes which claim the APPD matrix can be solved accurately in $O(n^{2})$ (Sibson, ; Demaine
et al., , ; Alon and Schieber, ). However, there is no code implementation of these algorithms, which implies they are impractical.

Code implementation is the process of translating a design or algorithm into a programming language. It is critical in algorithm design where ideas are turned into practical, executable code that performs specific tasks.

In section 4.3 (MMJ distance by calculation and copy) of (Liu, ), the author proposes an algorithm which also claims to solve the APPD matrix accurately in $O(n^{2})$, in an undirected dense graph. The algorithm is referred to as Algorithm 4 (MMJ distance by Calculation and Copy). In the paper, the algorithm is left unimplemented and untested. In this paper, we introduce a code implementation of Algorithm 4, and test it.

The widest path problem is a closely related topic to minimax path problem. In contrary, The objective of the widest path problem is to find a path $P$ from a starting node $s$ to a destination node $t$ such that the minimum weight of the edges in the path $P$ is maximized. Any algorithm for the widest path problem can be easily transformed into an algorithm for solving the minimax path problem, or vice versa, by reversing the sense of all the weight comparisons performed by the algorithm. Therefore, we can roughly say that the widest path problem and the minimax path problem are equivalent.

Figure: (a) Algorithm 4
Refer to caption: extracted/5758094/img/algo_4.png

Figure: Figure 2. A variant of the Floyd-Warshall algorithm for solving the minimax path problem
Refer to caption: extracted/5758094/img/floyd.png

Figure: Figure 3. Python implementation of MST_shortest_path, see Table 1
Refer to caption: extracted/5758094/img/mst_short.png

## 2. RELATED WORK

Numerous distance measures have been proposed in the literature, including Euclidean distance, Manhattan Distance, Chebyshev Distance, Minkowski Distance, Hamming Distance, and cosine similarity. These measures are frequently used in algorithms like k-NN, UMAP, and HDBSCAN. Euclidean distance is the most commonly used metric, while cosine similarity is often employed to address Euclidean distance’s issues in high-dimensional spaces. Although Euclidean distance is widely used and universal, it does not adapt to the geometry of the data, as it is data-independent. Consequently, various data-dependent metrics have been developed, such as diffusion distances (Coifman and Lafon, ; Coifman et al., ), which arise from diffusion processes within a dataset, and path-based distances (Fischer and
Buhmann, ; Chang and Yeung, ).

Minimax path distance has been used in various machine learning models, such as unsupervised clustering analysis (Little
et al., ; Fischer
et al., , ; Fischer and
Buhmann, ), and supervised classification (Chehreghani, ; Liu, ). The distance typically performs well with non-convex and highly elongated clusters, even when noise is present (Little
et al., ).

### 2.1. Calculation of minimax path distance

The challenge of computing the minimax path distance is known by several names in the literature, such as the maximum capacity path problem, the widest path problem, the bottleneck edge query problem (Pollack, ; Hu, ; Camerini, ; Gabow and Tarjan, ), the longest-leg path distance (LLPD) (Little
et al., ), and the Min-Max-Jump distance (MMJ distance) (Liu, ).

A straightforward computation of minimax path distance is computationally expensive due to the large search space (Little
et al., ). However, for a fixed pair of points $x$ and $y$ connected in a graph $G=G(V,E)$, the distance can be calculated in $O(|E|)$ time (Punnen, ).

A well-known fact about minimax path distance is: “the path between any two nodes in a minimum spanning tree (MST) is a minimax path.”(Hu, ) With this conclusion, we can simplify an undirected dense graph into a minimum spanning tree, when calculating the minimax path distance.

### 2.2. Computing the all points path distance

Computing minimax path distance for all points is known as the all points path distance (APPD) problem. Applying the bottleneck spanning tree construction to each point results in an APPD runtime of $O(\min\{n^{2}\log(n)+n|E|,n|E|\log(n)\})$ (Little
et al., ; Camerini, ; Gabow and Tarjan, ). The resulting APPD may not be accurate when calculating with bottleneck spanning tree, because a MST (minimum spanning tree) is necessarily a MBST (minimum bottleneck spanning tree), but a MBST is not necessarily a MST. A variant of the Floyd-Warshall algorithm can calculate the APPD accurately in $O(n^{3})$ (Aho and Hopcroft, ).
Several theoretical results suggest that the APPD matrix can be accurately solved in $O(n^{2})$ time (Sibson, ; Demaine
et al., , ; Alon and Schieber, ). However, the absence of code implementations for these algorithms indicates their impracticality.

Figure: Figure 4. Performance of the algorithms (implementations)
Refer to caption: x1.png

**Table 1. Profiles of the four algorithms. Two of them are implemented with different programming languages, Python and C++**
| Implementation ID | Implementation name | Complexity | Coding language | Notes |
| --- | --- | --- | --- | --- |
| 0 | Algo_1_Python | $O(n^{3})$ | Python | Algorithm 1 (MMJ distance by recursion) |
| 1 | Algo_1_C++ | $O(n^{3})$ | C++ | Algorithm 1 (MMJ distance by recursion) |
| 2 | Floyd_Warshall_Python | $O(n^{3})$ | Python | A variant of Floyd-Warshall Algorithm |
| 3 | Floyd_Warshall_C++ | $O(n^{3})$ | C++ | A variant of Floyd-Warshall Algorithm |
| 4 | MST_shortest_path | $O(n^{3}log(n))$ | Python | Calculate the shortest path in a MST |
| 5 | Algo_4 | $O(n^{2})$ | Python | Algorithm 4 (MMJ distance by Calculation and Copy ) |

**Table 2. Performance of the four algorithms. N is the number of points in the datasets.**
|  | data 139 (N = 120) | data 109 (N = 300) | data 18 (N = 500) | data 19 (N = 850) | data 16 (N = 2500) | data 35 (N = 5000) | data 136 (N = 10000) |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Algo_1_Python | 13.451s | 208.363s | 990.308s | 4681.911s | >7200s | >7200s | >7200s |
| Algo_1_C++ | 0.033s | 0.414s | 1.794s | 9.032s | 237.961s | 1986.928s | >7200s |
| Floyd_Warshall_Python | 1.489s | 23.353s | 106.745s | 534.683s | >7200s | >7200s | >7200s |
| Floyd_Warshall_C++ | 0.033s | 0.436s | 2.324s | 10.035s | 253.909s | 2162.514s | >7200s |
| MST_shortest_path | 0.399s | 4.229s | 24.926s | 110.449s | 2503.483s | >7200s | >7200s |
| Algo_4 | 0.02s | 0.073s | 0.191s | 0.511s | 4.311s | 17.015s | 67.048s |

## 3. Implementation of the algorithm

As described in Section 1, the Algorithm 4 (MMJ distance by Calculation and Copy) in (Liu, ) also claims to solve the APPD matrix accurately in $O(n^{2})$, in an undirected dense graph. But it is left unimplemented and untested. Figure 1(a) is Algorithm 4 (MMJ distance by Calculation and Copy) in (Liu, ), for convenience of reading, we re-post it here. Figure 1(b) is its python implementation.

Note the three embedded for-loops make it look like an $O(n^{3})$ algorithm, but it is actually an
$O(n^{2})$ algorithm. Because when the variable $i$ in $Line~{}21$ is small, both tree1 and tree2 are of size $O(n)$; but when the variable $i$ is large, both tree1 and tree2 are of size $O(1)$. The final net effect is that the three embedded for-loops only access each cell of the APPD matrix only once. Therefore, it is an $O(n^{2})$ algorithm.

In the implementation, we first construct a minimum spanning tree (MST) of the undirected dense graph. The complexity of constructing a MST with prim’s algorithm is $O(n^{2})$. Then, we sort the edges of the MST in descending order. It is critical to remove the edges from the MST one-by-one, from large to small. Only by this we can get the two sub-trees, tree1 and tree2. By traversing each sub-tree, nodes of the two sub-trees can be obtained, respectively.

## 4. Testing of the algorithm

In an experiment, we tested the Algorithm 4 (MMJ distance by Calculation and Copy) on seven datasets with different number of data points, note a dataset can be easily converted to a complete graph. The performance of Algorithm 4 is compared with three other algorithms that can calculate the APPD matrix.

Table 1 lists the profiles of the four algorithms. Algo_1 is the Algorithm 1 (MMJ distance by recursion) in (Liu, ), it has complexity of $O(n^{3})$; Floyd_Warshall is a variant of the Floyd-Warshall algorithm. Figure 2 is its python implementation. It has complexity of $O(n^{3})$; MST_shortest_path firstly construct a minimum spanning tree (MST) of the undirected dense graph, then calculate the shortest path between each pair of nodes, then compute the maximum weight on the shortest path. Its complexity is $O(n^{3}log(n))$. Figure 3 is its python implementation. The implementation is based on Madhav-99’s code (^2^22[https://github.com/Madhav-99/Minimax-Distance](https://github.com/Madhav-99/Minimax-Distance)); Algo_4 is Algorithm 4 (MMJ distance by Calculation and Copy) in (Liu, ), it has complexity of $O(n^{2})$. Both Algo_1 and Floyd_Warshall are implemented with C++ and python, respectively, to test the difference between different programming languages.

### 4.1. Performance

Table 2 is performance of the algorithms (implementations). We test each algorithm with seven datasets which have different number of data points. The data sources corresponding to the data IDs can be found at this URL. (^3^33[https://github.com/mike-liuliu/Min-Max-Jump-distance](https://github.com/mike-liuliu/Min-Max-Jump-distance)) The values are the time of calculating the minimax path APPD by each algorithm, on a desktop computer with “3.3 GHz Quad-Core Intel Core i5” CPU and 16 GB RAM.

To save time, we stop the execution of an algorithm if it cannot obtain the APPD matrix in 7200s (two hours). The computing time is recorded only once for each dataset and algorithm. Figure 4 converts the values in Table 2 into a figure. It can be seen that Algorithm 4 has achieved a good performance than other algorithms. It can calculate the APPD matrix of 10,000 points in about 67 seconds, while other algorithms cannot finish it in two hours.

Reasonably, the C++ implementations of Algo_1 and Floyd_Warshall are much faster than their python edition. Interestingly, when implemented in python, Algo_1 is much slower than Floyd_Warshall, but a little faster than Floyd_Warshall in C++.

### 4.2. Solving the widest path problem

As stated in Section 7 (Solving the widest path problem) of (Liu, ), Algorithm 4 (MMJ distance by Calculation and Copy) can be revised to solve the widest path problem APPD in undirected graphs, by constructing a maximum spanning tree and sort the edges in ascending order. In another experiment, we tested using Algorithm 4 to compute the widest path APPD. Result shows Algorithm 4 works good for solving the widest path problem.

## 5. Discussion

### 5.1. Merit of Algorithm 1

Algorithm 1 (MMJ distance by recursion) has a merit of warm-start. Suppose we have calculated the APPD matrix $M_{G}$ of a large graph $G$, then we got a new point (or node) $p$, where $p\notin G$. The new graph is noted $G+p$. To calculate the APPD matrix of graph $G+p$, if we use other algorithms, we may need to start from zero. Algorithm 1 has the merit of utilizing the calculated $M_{G}$ for computing the new APPD matrix, with the conclusions of Theorem 3.3., 3.5., 6.1., and Corollary 3.4. in (Liu, ). This is especially useful when the graph is a directed dense graph, where starting from zero needs $O(n^{3})$ complexity, but a warm-start of Algorithm 1 (MMJ distance by recursion) only needs $O(n^{2})$ complexity. We can say Algorithm 1 supports online machine learning(^4^44[https://en.wikipedia.org/wiki/Online_machine_learning](https://en.wikipedia.org/wiki/Online_machine_learning)), in which data becomes available in a sequential order.

### 5.2. Using parallel programming

If speed is the main concern of calculating the APPD matrix. We can use parallel programming to accelerate Algorithm 4. Firstly, we can use different processors for traversing the tree1 and tree2 in $Line~{}25~{}and~{}26$ of Figure 1(b). Secondly, we can copy the minimum spanning tree (MST) to many processors. For the $n$th processor, we just remove the $n$ largest edges, obtaining the $n$th tree1 and tree2, traversing them, then fill in the corresponding positions of the APPD matrix that are decided by the $n$th tree1 and tree2.

## 6. Conclusion

We implemented the Algorithm 4 (MMJ distance by Calculation and Copy) that was introduced in a previous paper. Then tested the implementation and compared it with several other algorithms that can calculate the all pairs minimax path distances, or also called the all points path distance (APPD). Experiment shows Algorithm 4 works good for solving the widest path or minimax path APPD matrix. As an algorithm of $O(n^{2})$ complexity, it can drastically improve the efficiency of calculating the APPD matrix. Note algorithms for solving the APPD matrix are at least in $O(n^{2})$ complexity, because the matrix is an $n\times n$ matrix.

In Section 2.3.3. of the paper “Path-Based Spectral Clustering: Guarantees, Robustness to Outliers, and Fast Algorithms,” (Little
et al., ) Dr. Murphy and his collaborators write:

“Naively applying the bottleneck spanning tree construction to each point gives an APPD runtime of $O(min\{n^{2}log(n)+n|E|,n|E|log(n)\})$. However the APPD distance matrix can be computed in $O(n^{2})$, for example with a modified SLINK algorithm (Sibson, 1973), or with Cartesian trees (Alon and Schieber, 1987; Demaine et al., 2009, 2014). ”

The author sent an email for further clarity about this statement.

The author:

“You indicated the APPD distance matrix can be computed in $O(n^{2})$. However, I searched the Internet and github, I have not found any code implementation that can accurately calculate the APPD distance matrix in $O(n^{2})$. Do you know any code implementation of that? Please indicate it to me. ”

Dr. Murphy:

“If you can find an implementation of SLINK to do single linkage clustering in $O(n^{2})$, then you can do APPD by reading off the distances from the resulting dendrogram. I don’t know any implementations of SLINK, and it may be easier to prove things about than to implement practically. ”

“Regarding tree structures, these are certainly more of theoretical interest, and I would not be surprised if there were no practical implementations of them at all. So, achieving $O(n^{2})$ via those methods may be impractical. ”

Therefore, we can roughly conclude: the Algorithm 4 (MMJ distance by Calculation and Copy) in (Liu, ), is the first algorithm that has actual code implementation to solve the APPD matrix of minimax path or widest path problem in $O(n^{2})$, in an undirected dense graph.

## Peer Reviews

confidence: 5
contribution: 1
initial_rating: 1
presentation: 1
questions: No questions.
soundness: 1
strengths: The paper does not contain any significant contribution.
summary: The praper implements and experimentally tests an algorithm for computing minimax path distance that was proposed in paper Liu 2023. In my opinion the contribution of the paper is certianly below ICLR bar, as there are the following shortcomings:
- the paper is in area of exparimental algorithmis with no siginificant contribution to machine learning, 
- there is no siginificant contribution to algorithms, i.e., the paper just implents in a straight-forward way the algorithms and tests it, there is not technincal challange in this implementation, nor the tests introduce any nowel methodology,
- the paper makes false statement that previous quadratic time algorithms have not been impmemented - this is not true as even the orginal paper by Sibson from 1973 contains the Fortran implementation of the algorithm.
weaknesses: - the paper is in area of exparimental algorithmis with no siginificant contribution to machine learning, 
- there is no siginificant contribution to algorithms, i.e., the paper just implents in a straight-forward way the algorithms and tests it, there is not technincal challange in this implementation, nor the tests introduce any nowel methodology,
- the paper makes false statement that previous quadratic time algorithms have not been impmemented - this is not true as even the orginal paper by Sibson from 1973 contains the Fortran implementation of the algorithm.

---

confidence: 5
contribution: 1
initial_rating: 1
presentation: 1
questions: NA
soundness: 1
strengths: The problem of finding all pairs of minimax path is interesting and has applications within ML
summary: Given an undirected graph, this paper considers the problem of computing the minimax path problem between all pairs of vertices. For any path, let the bottleneck edge be the largest edge on the path. For all pairs of vertices, compute a path with the smallest bottleneck edge. The authors refer to a prior paper that suggests a simple spanning tree based algorithm to compute this bottleneck edge and also state that this algorithm has an execution time of O(n^2). The main contribution of this algorithm is in the implementation of this algorithm.
weaknesses: * A straight-forward implementation of an existing algorithm cannot be considered publishable research
* Writing quality and presentation is extremely poor
* Theoretical claims about complexity is not formally established.

---

confidence: 4
contribution: 1
initial_rating: 1
presentation: 2
questions: I fundamentally don't see the point in this paper, it seems that all the heavy work and clever ideas were due to the Liu paper. Your correspondence in the conclusion section talks about a paper that was written before Liu, and I believe that implementing that would be hard, but it doesn't mean that implementing Liu's algorithm is hard. Implementing Liu's algorithm seems like a homework exercise, and please clarify any obstacles in doing this.
soundness: 3
strengths: the problem is well motivated in general.
summary: This paper is about an implementation of an algorithm for all pairs minimax path problem in undirected dense graphs that works in $O(n^2)$ time. The problem asks to output the minimax distance between every pair of points s and t, where the minimax distance between s and t is the minimum of the maximum weighted edge in a path from s to t, over all the paths from s to t. The algorithm is from "Gangli Liu. 2023. Min-Max-Jump distance and its applications. arXiv preprint arXiv:2301.05994 (2023).", and essentially first finds an MST, and uses the fact that the minimax distance between any s and t is the maximum weighted edge on the st path in the MST. Then they use this fact to fill up an n by n matrix storing all these values. This paper basically codes this algorithm up.
weaknesses: while the problem is well motivated, finding an implementation for the algorithm is not very well motivated. It seems that no implementation existed before because the algorithms were not very efficient, and the algorithm of Liu is quite simple and efficient. The mere fact of coding that algorithm up is a simple classroom exercise it seems. If there are techniques used for going from the pseucode to the implementation, the authors have not described them, and it seems from the code that there are no such techniques. 
Besides the above fundamental point, the write up could be polished, there are several grammatical mistakes. 
abstract: "it is a code implementation of..." -> " this paper is a code implementation of the minimax path algorithm in Liu".
line 18:: works good -> works well.
line 106:: the sense -> the sign
in the related work it is good to note if there are any other papers like your paper where they implement an algorithm from a previous paper.

---

confidence: 4
contribution: 1
initial_rating: 1
presentation: 2
questions: Since the APPD matrix contains O(n^2) elements, explicitly computing APPD matrix in O(n^2) time is an optimal algorithm. Thus, I want to consider a variant of this problem: given a graph $G$ with $n$ vertices and $m$ edges, we preprocess $G$ to build a data structure $D$ that can answer the minimax path distance of any vertex pair in reasonable time. For relatively dense graphs, where $m=o(n^2)$ and $m=\omega(n)$, we can expect to lower the preprocessing time or space requirement below $n^2$ at the cost of query time of $D$. Do you know any existing works for this problem?
soundness: 1
strengths: Judging from the manuscript, this is the first implementation for $O(n^2)$ time algorithm for the all pairs minimax path problem. Because this algorithm works for any graph including dense graph (where $m=\Theta(n^2)$), this is actually an optimal algorithm.
summary: Given a weighted graph and a vertex pair, the minimax path problem is to compute a path between the given vertex pair such that the maximum weight of the edges in the path is minimized. All pairs minimax path problem seeks to compute the maximum weight of the minimax path for every vertex pair. This paper implements a fast algorithm for the all pairs minimax path problem, which is proposed in the previous paper. Experiments show that their implementation is indeed faster.
weaknesses: The most prominent weakness of this work is that it only provides an implementation of the existing method of the previous paper of Liu (arXiv 2023). I think the implementation itself can be considered as a significant contribution when the original algorithm has some difficulties in implementing and they are tackled by some novel or dedicated techniques. However, the implemented algorithm (Figure 1(a)) is much simpler that seems to be easily implemented, and actually it is implemented by short Python codes (Figure 1(b)). We do not find any implementation techniques in Section 3; Section 3 consists of just an explanation for the existing method of Liu. This means that obtaining simple algorithm that is easy for implement has already been done in the previous work. Thus, I think this is not a significant contribution.

Another weakness of this work is that it is never compared empirically with the existing (and traditional) O(n^2) algorithm. In the conclusion, the authors claim that the SLINK algorithm of Sibson (1973) is difficult to implement by quoting the conversation with other people. However, we easily find some SLINK implementations such as https://github.com/battuzz/slink and https://github.com/jackyust/SLINK_CLINK . Moreover, the paper of Sibson also has a FORTRAN implementation of his algorithm. Thus, it is questionable that the SLINK algorithm is hard to implement. At least, the authors should try to implement SLINK and compare it with the proposed implementation.

Minor comments:
- The citations should be enclosed with brackets. Maybe you use \citet{...} instead of \citep{...}, don't you?
- Tables 1 and 2 are significantly wider than the paper width; please fit these tables into the paper width.

Meta-review: The paper studies an algorithm for computing minimax path distances in graphs that was proposed in prior work. The main contribution of the work is an implementation and experimental evaluation of the algorithm. There was strong consensus among the reviewers that this work does not meet the bar for acceptance. The paper provides a straightforward implementation of an existing algorithm and there is little relevance of this work to the ICLR community.

Decision: Reject