Draft:Non dominated sorting

Non-dominated sorting (also known as non-dominated ranking) is a technique that involves categorizing a set of elements based on their dominance relationship with each other. The purpose of non-dominated sorting is to rank the elements from the best to the worst element according to their dominance relationship. The dominance relationship between elements is determined by comparing their scores on a fixed number of objective functions .

In this context, an element dominates another element if it is better than the other element in at least one objective and no worse in any other objectives. For example, if we have two elements A and B, and A has a better value than B in at least one objective, and no worse value in any other objectives, then A dominates B. On the other hand, if B has a better value than A in at least one objective, and no worse value in any other objectives, then B dominates A. If neither A dominates B nor B dominates A, then A and B are said to be non-dominated or incomparable with respect to each other.

Non-dominated sorting is a technique used to sort elements into different non-dominated fronts. Each front represents a subset of elements that are not dominated by any other elements in the same front. Elements in a given front are dominated by elements in the fronts that come before it, and dominate elements in the front that comes after it.

The first non-dominated front contains the best elements - those that are not dominated by any other elements. The second front contains elements that are dominated only by elements in the first front (an element in the second front is not necessarily dominated by all the elements in the first front, but by at least one of them). The subsequent fronts contain elements that are progressively less optimal with respect to the objective functions.

In fact the first front corresponds exactly to the maximal elements of the set.

Non-dominated sorting is often used in multi-objective optimization algorithms.

A simple example

Let's say we have the following set of elements with two objective functions, x and y:

       x, y
   A: (5, 4)
   B: (3, 5)
   C: (2, 3)
   D: (4, 5)
   E: (7, 5)
   F: (4, 3)

To perform non-dominated sorting on this set, we can first compare each element to every other element. For example, we can compare element A to element B as follows:

• A dominates B in the x dimension (A's x value of 5 is greater than B's x value of 3)
• B dominates A in the y dimension (B's y value of 5 is greater than A's y value of 4)

Thus we can see the A and B do not dominated each other.

We repeat this process for all pairs of elements in the set. Then, we can use this information to sort the elements into different non-dominated fronts. The first front contains the elements that are not dominated by any other elements - in this case, just element E. The second front contains the elements that are dominated only by elements in the first front - in this case, elements A and D. The third front contains the elements that are dominated only by elements in the first and second fronts - in this case, elements B and F. The fourth and final front contains the element that is dominated by all other elements - in this case, element C.

So the non-dominated fronts for this set are:

   Front 1: E
   Front 2: A, D
   Front 3: B, F
   Front 4: C

Usage

Non-dominated sorting, is a concept and algorithm widely employed in various domains to solve multi-objective optimization problems. The primary objective of non-dominated sorting is to classify a set of solutions into distinct fronts based on their dominance relationship, enabling the identification of the most desirable solutions.

Non-dominated sorting plays a crucial role in evolutionary algorithms and genetic algorithms . These algorithms simulate an evolutionary process, iteratively generating and improving a population of candidate solutions. Non-dominated sorting allows the algorithms to identify and maintain a diverse set of non-dominated solutions.

Algorithms and complexity

Various algorithms have been devised to perform non-dominated sorting. The first algorithm for non-dominated sorting was introduced in 1995 N. Srinivas and K. Deb in a paper presenting the NSGA optimization algorithm . It had a complexity of O(MN ³) where M is the number of objectives and N is the population size. More recent algorithms have been developed with improved time complexity such as Fast Non-Dominated Sorting (FNS) (O(MN ²)), Jensen’s algorithm (O(N log ^M−1 N)) , or the Efficient Non-Dominated Sorting (ENS) (from O(MN log N) to O(MN ²)) .

The non-dominated sorting algorithm used in can be described simply as follows:

1. Start with a set of elements called S.
2. Iteratively, find the elements in S that are not dominated by any other elements. These elements are considered to be in a new "front" (in the first iteration, it's the first front).
3. Remove these elements from S.
4. If S is empty, the algorithm ends. Otherwise, go back to step 2.

In summary, the algorithm identifies non-dominated elements and assigns them to fronts, removing them from consideration until all elements have been processed.

External links

Here are links to some implementation of non-domminated sorting

• https://github.com/mbuzdalov/non-dominated-sorting
• https://github.com/anyoptimization/pymoo/tree/main/pymoo/util/nds