All-pairwise squared distances lead to more balanced clustering

1.   Introduction

Agglomerative clustering is the second most popular clustering algorithm after k-means. It operates by a series of local optimal merge operations until the desired number of clusters is reached. Classical choices for the merge cost function include single link, complete link and average link but none of these are particularly good for most data. Ward's method ^[1] is a much better choice, and it has been used to minimize the same total squared error (TSE) cost function as $k$-means but with better optimization of the cost function.

Agglomerative clustering also has another advantage over $k$-means as there is a variant that does not require calculating the centroids: all pairwise distances (APD) within the clusters. This can be very handy in cases where the mean of the data cannot be easily calculated. These can include strings ^[2], time series ^[3] or GPS trajectories ^[4]. Furthermore, it has been shown that APD is just a scaled variant of TSE when using squared Euclidean distance.

Our first contribution is to show that APD will lead to more balanced clustering than TSE. This is important because, while the balance property can be a desired property in some applications, it can also cause the detection of real clusters to fail when some of the clusters are much larger (or smaller) than others. In ^[5], they wanted all clusters to be roughly the same size to make results easier to analyze but in ^[6] the balanced tendency caused a smaller country (Iceland) to merge into a larger country, thereby failing to detect the real clusters.

Our second contribution is to show that APD can also be formulated as a cut-based clustering. We give alternate proof for Hyugens' theorem and show that the APD of a cluster is equal to its TSE multiplied by its size (APD = $n\cdot$TSE). We also propose a cut-based variant called Squared Cut (Scut) and present a fast sequential variant of $k$-means to minimize the cost function. This algorithm is significant due to the slowness of agglomerative algorithms, which are lower bound by O($n^2$) in their exact form.

The rest of the paper is organized as follows. In Section 2, we review the existing cost functions for traditional and balanced clustering. In Section 3, we present how clustering and cut-based methods are connected and present an alternative proof for Huygens' theorem. This theorem is important because it demonstrates the similarity between different representations of the APD cost function. In Section 4, we present a k-means-based algorithm for minimizing APD. In Section 5, Scut is extended to $l^p_2$ $k$-clustering. Experiments and conclusions are then given in Sections 6 and 7, respectively.

2.   Cost functions for traditional and balanced clustering

In this section, we introduce different cost functions and algorithms for traditional and balanced clustering. The choice of algorithm depends on the selected cost function, which is an important factor. By far the most common cost function in clustering is the total squared error (TSE), or equivalently, the mean squared error (MSE):

where $x_i$ is a data point, $C_j$ is the centroid of cluster $j$ and $P_i$ is the label of the cluster which $x_i$ is assigned to. These can be generalized to other $p$-norms, even to infinite norms ($p = \infty$). Reference [7] discussed how the infinity norm criterion could be used in practice. Instead of taking the maximum, the infinity norm was approximated by a $p$-norm with a high value of $p$. This is because a $p$-norm has an analytic formulation that can then be optimized.

A balancing constraint can be given along with the cost function ^[8],

where $n_j$ denotes the size of the cluster $j$.

2.1.   k-Means clustering

The Euclidean sum-of-squares clustering ($k$-means clustering) aims at finding the best grouping of $n$ points in $k$ clusters and it has been shown to be an NP-hard problem ^[9]. The clusters are represented by center points (centroids), and the aim is to minimize the mean squared error (MSE), calculated as the mean distance of the points from their nearest centroid, or, equivalently, to minimize the total squared error (TSE), calculated as the sum of the squared distances of the points from their centroids. $k$-Means clustering minimizes

where $TSE_i$ is the total squared error of the $i$th cluster. This can also be written as

where $n_j$ is the number of points in cluster $j$ and $MSE_j$ is the mean squared error of the $j$th cluster. The TSE and MSE for a single cluster $j$ are calculated as

When $k$ and dimensionality $d$ are constant, the $k$-means clustering problem (minimizing TSE) can be solved in polynomial $O(n^{kd+1})$ time ^[10]. Although polynomial, this is still slow, and suboptimal algorithms are therefore used. The $k$-means algorithm ^[11] is fast and simple, although its worst-case number of iterations is $O(n^{kd})$. The advantage of $k$-means is that it finds a local optimum starting from any initial centroid location by a simple iterative two-step procedure. A drawback of $k$-means is that it cannot always find the global optimum. This is one of the reasons why slower agglomerative clustering ^[12,13,14], or more complex variants of $k$-means ^[15,16,17], is used.

Gaussian mixture models (EM algorithm) ^[18,19] and cut-based methods ^[20,21] have also been used. Recent research has considered clustering using analytic functions ^[7] and fitting the data into the model before fitting the model to the data ^[22].

2.2.   Balanced clustering

Balanced clustering is defined as a type of clustering where the points are evenly distributed between the clusters. In other words, every cluster includes either $\lfloor n/k\rfloor$ or $\lceil n/k\rceil$ points. We define a balanced clustering problem as a problem that aims at minimizing the imbalance, while also minimizing some other cost function, such as MSE. The imbalance is measured by

There is a need for balance, it is useful in workload balancing, wireless sensor networks and sightseeing tour design. In traveling salesman problem a shortest route for the salesman through all the cities. For example, in ^[8] a clustering algorithm is applied to the multiple traveling salesman problem ^[23]. The algorithm clusters the cities so that each cluster can be solved by one salesman. The goal is to achieve an equal workload among salesmen. The following is an example of partitioning a dataset for 4-TSP, that is, there are four salesmen in Figure 1 ^[24].

Clustering is used in wireless sensor networks for the energy efficiency of nodes and the lifetime of the network ^[25,26]. Targeting certain sizes of clusters is also useful ^[27,28].

Balanced clustering, in general, is a two-objective optimization problem, in which the two aims can be in conflict with each other: minimize a cost function such as MSE, and balance the cluster sizes at the same time. Traditional clustering aims at minimizing the MSE completely without considering cluster size balance. Balancing, on the other hand, would be trivial if we did not care about MSE, which involves dividing the vectors into equal size clusters randomly. To optimize both, there are two approaches: Balance-constrained and balance-driven clustering.

In balance-constrained clustering, cluster size balance is a mandatory requirement that must be met, and minimizing MSE is a secondary criterion. In some applications, cluster size balance is not a mandatory requirement. It is enough that cluster sizes are more balanced. In balance-driven clustering, balanced clustering is an aim, but it is not mandatory. It is a compromise between the two goals, namely the balance and the MSE. The solution is a weighted cost function between the MSE and the imbalance, or it is a heuristic, which aims at minimizing MSE but indirectly creates a more balanced result than optimizing MSE alone.

Next, we review the existing methods that aim to achieve balanced clustering. Bradley et al. ^[29] presented a constrained $k$-means algorithm where the assignment step of $k$-means is implemented as a linear programming problem in which a minimum number of points in a cluster is set as a constraint. In ^[8], a balanced $k$-means algorithm using the Hungarian algorithm and fixed-size clusters is presented. It solves the $k$-means assignment step as an assignment problem. It is a balance-constrained algorithm that forces balanced clusters.

The method in ^[30] tried to find a partition close to a given partition, but so that the cluster size constraints were fulfilled. Banerjee and Ghosh ^[31] presented an algorithm based on frequency sensitive competitive learning (FSCL) where the centroids competed for the points. It multiplicatively scaled the error (the distance from the data point to the centroid) by the number of times that a centroid had won in the past. This meant that larger clusters were less likely to gain points in the future. Althoff et al. ^[32] used FSCL, but their solution incorporated an additive distance bias instead of a multiplicative distance bias. They reported that their algorithm was more stable for high-dimensional feature spaces.

Banerjee and Ghosh ^[33] introduced a fast ($O(kn\log n)$) algorithm for balanced clustering that used three steps: sampling the given data, clustering the sampled data and populating the clusters with the data points that were not sampled in the first step. Size regularized cut SRCut ^[34] is defined as the sum of the inter-cluster similarity and a regularization term measuring the relative size of two clusters. In ^[35], there was a term included in the cost function, which aimed at facilitating the balancing. In ^[36], the size of the maximum-size cluster was minimized in a $k$-means-type algorithm.

There are also application-based solutions in networking ^[27] that aim to balance network loads. With these solutions, the clustering is done through self-organization without central control. In ^[28], energy-balanced routing between sensors was the goal; thus, only the most suitably balanced number of nodes were cluster members. The classification of some algorithms into these two classes and the types of the algorithms can be found in Table 1.

3.   Cut-based methods

Cut-based clustering is a process where the dataset is cut into smaller parts based on similarity $S(x_l, x_s)$ or cost $d(x_l, x_s)$ between pairs of points. The partitioning of a dataset into two parts A and B can be indicated as cut($A, B$), while the value of cut($A, B$) is the total weight of all pairs of points where one is from part $A$ and the other is from part $B$:

The weights $w$ can be defined either as distances or similarities between the two points (see a summary of their use in Figure 2). Unless otherwise noted, we use (squared) Euclidean distances in this paper. The cut($A, B$) equals the total pairwise weights of $A\cup B$ subtracted by the pairwise weights within the parts $A$ and $B$:

where $W$ is the sum of all pairwise weights (here we assume that arc lengths are symmetric).

where $W(A)$ is the sum of the pairwise weights within part $A$:

where $W(B)$ is defined similarly.

In cut-based clustering, the most common objective (cost or utility) functions are Minimum cut ^[39], Maximum cut ^[40], Sparsest cut ^[41], Ratio cut ^[38] and Normalized cut, Ncut, ^[20]. In Minimum cut, the points are partitioned into two parts, so that the cut is minimized. In Maximum cut, the cut is maximized. In Sparsest cut, the value of the cut is divided by the minimum of the number of points in the resulting parts. In Ratio cut, the cost of a cut is normalized by the number of points $n_A$ or $n_B$, while in Ncut, the cut is normalized by the similarities to all the other points in the dataset. These normalizations favor balanced cuts ^[42], p. 401. In Mcut ^[21], the cost function aims at minimizing cut($A$, $B$), the similarity of $A$ and $B$, while maximizing the similarities within the parts ($W(A)$ and $W(B)$) at the same time. Mcut tends to make balanced clusters, even when compared to Ratio cut and Mcut ^[21]. A summary of these methods is in Table 2 and an example in Figure 3.

The methods optimize the following definitions:

where $\bar{A}$ is the complement point set of $A$, $\bar{B}$ is the complement point set of $B$ and $W(A)$ is the total similarities between the pairs of points within cluster $A$. Optimizing the cost functions (16) and (17) aims at minimizing the cuts (the numerators), while at the same time maximizing the denominators. Often one approximates this problem through relaxation, i.e., solving a nearby easier problem. Relaxing Ncut leads to normalized spectral clustering, while relaxing RatioCut leads to unnormalized spectral clustering ^[42]. There is also a relaxation based on semidefinite programming for Ncut ^[44]. The methods Ncut, Ratio cut and Mcut, in their basic forms, cut the graph into two parts. Although extensions exist, which recursively cut the graph into $k$ parts, $k > 2$, these methods do not consider cutting the graph simultaneously into more than two parts. In our method, which we will introduce in the next sections, cutting into $k$ parts is a standard procedure.

3.1.   MAX $k$-CUT method

In the weighted MAX $k$-CUT problem ^[45] one partitions a graph into $k$ subgraphs so that the sum of the weights of the edges between the subgraphs is maximized. The weights are the distances. MAX $k$-CUT aims at partitioning the data into $k$ clusters $A_1, ..., A_k$. Following the notation of Section 3 and writing the factor 1/2 in order to avoid summing the weights twice, the MAX $k$-CUT problem is defined as

See an example of MAX $k$-CUT in Figure 4. This is an NP-hard problem ^[46] for general weights. If we use Euclidean distance for the weights, then weighted MAX $k$-CUT results in the minimum intra-cluster pairwise Euclidean distances among any $k$-CUT. This is due to the fact that when we maximize what is taken off, we, at the same time, minimize what is left. If we use the squared Euclidean distances, we end up minimizing intra-cluster pairwise squared Euclidean distances, see Equation 20. With squared Euclidean distances as the weights, the problem is expected to remain NP-hard. NP-hardness is proved for two cluster cases ^[47].

3.2.   Scut

In this paper, we formulate all-pairwise squared distances using a cut-based method called Squared cut (Scut). This method is called $l_2^2$ $k$-clustering ^[48]. It is a special case of APD that uses squared Euclidean distances. However, we formulate it by using the TSEs and MSEs of the clusters and show that the method leads to more balanced solutions for clustering problem than TSE itself. It is formulated as a cut-based method and it has been shown that it is a close relative to the MAX $k$-CUT method ^[49]. We present an algorithm for the problem that is more practical than the exhaustive Stirling search proposed in ^[50] for $l_2^2$ $k$-clustering. The algorithm is a sequential variant of the $k$-means algorithm, with immediate updates directly optimizing the cost function.

A general $k$-clustering problem in ^[49] defined the cost by calculating all pairwise distances within the clusters for an arbitrary weighted graph. The paper ^[51] studied the problem when the distances satisfied the triangle inequality. Schulman ^[48] gave probabilistic algorithms for $l_2^2$ $k$-clustering. The running time was linear if the dimensionality $d = o(\log n/\log \log n)$ but otherwise it was $n^{O(\log \log n)}$. De la Vega et al. ^[50] improved and extended Schulman's results, giving a true polynomial time approximation algorithm for arbitrary dimensions. However, even their algorithm was slow in practice. We, therefore, present a faster algorithm for the Squared cut method.

In Scut, we form the graph by assigning the squared Euclidean distances as the weights of the edges between every pair of points. In a single cluster $j$, the intra-cluster pairwise squared distances = $n_j\cdot TSE_j$. The generalization of this to all clusters is known as Huygens' theorem. Huygens' theorem is crucial for our method because it relates the pairwise distances to the intra-clusters TSE, and thus, to the Scut cost function:

where $k$ is the number of clusters, $x_s$ and $x_t$ are point numbers $s$ and $t$ in part $P_j$, $n_j$ is the number of points and $TSE_j$ is the total squared error of the $j$th cluster. Note that this Scut cost tells what there is inside the clusters, not what there is between the clusters. Based on (6), this may also be written as

where $MSE_j$ is the mean squared error of the $j$th cluster. In cut-notation, the cost function is the total pairwise squared Euclidean weights minus the value of MAX $k$-CUT:

where the $A_j$s are subsets of the dataset. From this, we conclude that using squared Euclidean distances as weights and optimizing MAX $k$-CUT results in optimization of the Scut cost function (20). The difference between the MAX $k$-CUT used in calculating Scut cost and MAX $k$-CUT in general is the choice of the weights. Our cut-based method has an MSE-based cost function and tends to balance clusters because of the $n_j^2$ factors in (21). This can be seen by the following simple example, where we assume that the two clusters have the same mean squared error: $MSE_1 = MSE_2 = MSE$ (Figure 5). Their total errors are $2^2\cdot MSE_1 = 4\cdot MSE$ and $10^2\cdot MSE_2 = 100\cdot MSE$. Adding one more point increases the error by $(n+1)^2\cdot MSE-n^2\cdot MSE = (2n+1)\cdot MSE$. In Figure 5, the cost would increase by $5\cdot MSE$ if the point is added into cluster 1 and $21\cdot MSE$ if into cluster 2. The cost function therefore always favors putting points into a smaller cluster which tends to make more balanced clusters. The cost function leads to more balanced clustering in general. This is supported by logical argument (Figure 5) and experimental evidence. We do not have proof that this will happen in all cases. Due to the suboptimality of $k$-means, it is possible that different cost functions would lead to different suboptimal solutions. The suboptimal solution obtained by TSE might be more balanced in certain situations. However, we expect Scut to provide more balanced results than TSE in most cases. Demonstration of the calculation of the cost can be found in Figures 6 and 7.

3.3.   Proof of Huygens' theorem

We provide here an alternative, simpler and new proof of Huygens' theorem. An earlier proof can be found in Späth's book ^[52], p. 52. The name Huygens is mentioned in connection with this theorem in ^[9]. Our proof is based on differentiation:

By $x_{vt}$ we denote the point $v$, feature $t$ and by Scut$_i$ we denote the pairwise intra-cluster squared distances. For a single cluster $i$,

Huygens' theorem for one cluster $i$ is

$\Leftrightarrow$

Our proof of Huygens' theorem is achieved by differentiating $TSE_i$ and Scut$_i$ with respect to $x_{st}$, the feature $t$ of point $s$ and by showing that these differ only by the factor $n_i$. Both of the differentiations use the chain rule:

Next, we calculate the other derivative:

Thus

In addition, we know that $TSE_i$ and Scut$_i$ are both equal to 0 when the points are at the same location as the centroid. Based on this and (23), we conclude that Huygens' theorem holds. □

4.   Approximating Scut

4.1.   $k$-means variant for Scut

We next define the sequential $k$-means variant for the Scut method. In the algorithm, points are repeatedly re-partitioned to the cluster that provides the lowest value for the Scut cost function. The partitioning of the points is done one by one, and a change of cluster will cause an immediate update of the two affected clusters (their centroid and size). We use the fact that calculating the pairwise total squared distance within clusters is the same as calculating the Scut cost function in TSE form (20). We next derive a fast $O(1)$ update formula which calculates how much the value of the cost function changes when one point is moved from one cluster to another. We keep on moving points to other clusters as long as the cost function decreases, see Algorithm 1. This may require repeating the process of going through the points multiple times before stopping. The approximation ratio is the same as in the subsequent Equation (30), where $\alpha_k > 1-k^{-1}$, which is derived in ^[46]. The update formula follows the merged cost in the agglomerative clustering algorithm ^[12]. It includes the change of TSE when adding a point, the change of TSE when removing a point and the change of the overall cost with respect to the cost function (20).

The total cost before the move with respect to the two clusters is

where $n_{A}$ and $n_{B}$ are the number of points in the clusters $A$ and $B$. $C_{A}$ and $C_{B}$ are the centroid locations, and $x_i$ is the data point involved in the operation. The total cost after the move is

From these we get the change in cost:

See an example of a point changing its cluster in Figure 8, where the changes in the TSEs are $\Delta TSE_{add} = 12$ and $\Delta TSE_{remove} = 4.5.$ The change in the cost function $\Delta {\text{Scut}} = -10.$

4.2.   Approximation ratio

We can provide an approximation ratio $\epsilon _k$ for Scut using the known approximation ratio $\alpha _k = 1- k^{-1}$ for MAX $k$-CUT ^[46]. The approximation ratio of MAX $k$-CUT is calculated using the sum of pairwise weights that were cut off (MAX $k$-CUT) while Scut uses the sum of remaining weights, see Figure 9. We can derive $\epsilon _k$ from $\alpha _k$ for the expected case as follows:

Since we have a lower bound for $\alpha _k$, it is possible to get an upper bound for $\epsilon _k$. However, this bound is dataset-specific and also depends on the number of clusters ($k$). In practice, the denominator of (30) becomes very small in all of the cases we tested, so the upper bound does not have much practical relevance.

5.   $l_2^p$ $k$-Clustering

A generalization of the Scut cost function (20) is $l_2^p$ $k$-Clustering, i.e., all-pairwise powered distances as cost. So far, in this article, we have dealt with the case where $p = 2$, but $p$ can have other values, like $p = 1$ or $p = 3$. It is a known fact that, in centroid-based clustering, when using absolute values in distance calculations (this corresponds to $p = 1$ here), the outlier points tend not to be put in one-point clusters compared to when squared distances are used. Thus we believe that here $p = 1$ tends to make less-balanced clusters and $p > 2$ tends to make more balanced clusters than the more common $p = 2$. As an extreme, if we use $p = \infty$, we will get clusters where the points of point pairs with the largest pairwise distances are in different clusters. We show that the relation corresponding to Huygens' theorem does not hold for this generalized cost function:

Theorem. Huygens' theorem does not hold for powers higher than two because there exists a dataset $X$ for which the following holds:

Proof. Consider a dataset of two points $x_s$ and $x_t$, located at a distance of 1 from each other. Then

i.e.,

So we have found an $X$ for Equation 34. □

6.   Experiments

We use datasets from the Machine Learning Unit in the School of Computing, University of Eastern Finland ^[53]. The s-sets are synthetic, two-dimensional (2-d) and have increasingly overlapping clusters with the postfix number, iris is a real dataset.

The benefits of balancing clustering algorithms are best seen when clustering is done for non-balanced datasets. To compare how close the obtained clustering is to balance-constrained clustering having equal distribution of sizes $\lceil n/k \rceil$ and $\lfloor n/k \rfloor$, we measure the imbalance by calculating the difference in the cluster sizes and a balanced $n/k$ distribution using Equation (8) with 30 repeats.

The results in Table 3 show that the fast Scut algorithm outperforms $k$-means when compared to the Scut cost function (20) even with the balanced datasets, for which one could have expected $k$-means to perform equally well. We use the centroid index (CI) to measure the success at cluster level ^[54,55] (S-sets). Given a ground truth solution ($G$) and clustering solution ($C$), the centroid index counts how many real clusters are missing a center, or alternatively, how many clusters have too many centers. The CI-value is the higher of the two numbers ^[54]. When CI = 0, it means that the clustering is correct. The Tables 3 and 4 have a line indicating how many times the numbers in columns are best. Of course, these indications do not have statistical meaning (not used in a formal statistical test), but these are just indications.

The results in Table 4 show Scut yields more balanced results than $k$-means. See an example clustering result in Figure 10 for the locations in the Finland dataset. A sightseeing designer would perhaps like to divide the locations into two clusters so that in both clusters there would be a well-balanced number of locations and that route lengths in clusters would be short. To interpret the figures note that in Eastern Finland the density of locations is high in this dataset. From Figure 10 we see that Scut balances better than $k$-means. The Scut cost is better in Scut than in $k$-means, because of the balancing property of Scut. $k$-Means gives better $MSE$ than Scut for this dataset. Figure 10 demonstrates an application area for the Scut method that justifies the usefulness of the method.

The results in Table 4 show that 85% of the clustering results are more balanced with the proposed method than with the $k$-means method. They were equally balanced in 8% of the cases, and in the remaining 8% of the cases, the $k$-means result was more balanced. We tried also with a semidefinite programming-based algorithm, but it turned out to be too slow in practice: with 50 points, the computing time is approximately 20 s, but with 150 points it is already about 7 hours. The memory requirement for 150 points would also be very high: 4.4 GB. The results in Table 3 are therefore only for the fast approximation algorithm because it is able to deal with considerably large datasets. For calculations, we used a PC and Octave software.

We next compare the resulting partition sizes of the Scut method and the $k$-means method, when we have two groups of points of sizes 1 and 100. We assume that all pairwise distances are 1 within each group, and we change the between groups distance from 5 to 10, see Figure 11. Imbalance is calculated using (8). It starts to become lower with Scut, when the inter-partition distance is decreased from 10, whereas with $k$-means it remains the same, see Figure 12.

We made also an experiment where we plotted MSEs and imbalances for several algorithms and datasets. The rationale for this is that we see which algorithms give both low MSEs and low imbalances. The genetic algorithm ^[56] combines the properties of several clusterings in one generation to make a better clustering for the next generation. It is the best representative for optimizing MSE. In Scut, $k$-means* and repeated $k$-means, we chose the results with the best balance. In constrained $k$-means, the cluster size parameters were set to balance = 0, and MSE was then optimized. In Ncut we used the implementation ^[57] by Cour, Yu and Shi from the University of Pennsylvania. We used 100 repetitions for all algorithms and chose the best results, see Figure 13. The genetic algorithm optimizes MSE best, but the result is less balanced. Scut always provides a good balance, while balanced $k$-means and constrained $k$-means always gave 0 imbalance. $k$-Means* and Ncut performed well with one dataset. Overall, Scut performs well in both balance and MSE.

We made also an experiment to see how much edge weights are inter-partitional and how much are intra-partitional. We calculated all-pairwise squared distances $W$ for some datasets and the mean value for the approximated MAX $k$-CUT obtained by 100 runs of the fast algorithm, see Table 5. We see the surprising fact that, in most cases, the cut contains over 90% of all the edge weights. This yields a high value for the upper bound of the approximation factor $\epsilon _k$ for the tested sets. This means that a good guaranteed approximation cannot be made for many datasets in the way presented.

7.   Conclusions

We have formulated the all-pairwise squared distances cost function as a cut-based method called Squared cut (Scut) using TSE, MSE and cluster sizes. We showed that this method leads to more balanced clustering. We used the solution of the MAX $k$-CUT problem to minimize the pairwise intra-cluster squared distances and used Huygens' theorem to show that this corresponds to minimizing the cost function. We gave an alternate proof of Huygens' theorem. Since Scut is expected to be an NP-hard problem, it could not be solved optimally for practical-sized datasets. We, therefore, introduced a sequential $k$-means algorithm to minimize the cost function directly. We showed through experiments that the proposed approach provides better overall joint optimization of MSE and cluster balance compared to other methods. We also treated the case of raising the distances to the $p$th power, by showing that the relation corresponding to Huygens' theorem does not hold in this case.

Conflict of interest

All authors declare no conflicts of interest in this paper.