Test that M(XY) <= M(X) + M(Y) if X <= Y for most probes

Author: Morwenn

docs/Measures-of-disorder.md

@@ -144,7 +144,7 @@ Measures of disorder are pretty formalized, so the names of the functions in the
 Computes the number of elements in a sequence that aren't followed by the same element in the sorted sequence.
 
 Our implementation is slightly different from the original description in *Sublinear merging and natural mergesort* by S. Carlsson, C. Levcopoulos and O. Petersson:
-* It doesn't add 1 to the general result, thus returning 0 when $X$ is sorted - therefore respecting the Mannila definition of a MOP.
+* It doesn't add 1 to the general result, thus returning 0 when $X$ is sorted and respecting Mannila's first criterion for what makes a measure of presortedness (though this change might be responsible for the breakage of criterion 4).
 * It explicitly handles *equivalent elements*, while the original formal definition makes it difficult.
 
 | Complexity  | Memory      | Iterators     |
@@ -153,6 +153,8 @@ Our implementation is slightly different from the original description in *Subli
 
 `max_for_size`: $|X| - 1$ when $X$ is sorted in reverse order.
 
+**Note:** `probe::block` does not respect Mannila's criterion 4: $Block(\langle 1, 0 \rangle) = 1$ and $Block(\langle 2, 3 \rangle) = 0$, but $Block(\langle 1, 0, 2, 3 \rangle) = 2$.
+
 ### *Dis*
 
 ```cpp
@@ -285,6 +287,8 @@ The measure of disorder is slightly different from its original description in [
 
 `max_for_size`: $\frac{|X| + 1}{2} - 1$ when $X$ is a sequence of elements that are alternatively greater then lesser than their previous neighbour.
 
+**Note:** `probe::mono` does not respect Mannila's criterion 4: $Mono(\langle 1, 2, 3, 4, 5 \rangle) = 0$ and $Mono(\langle 10, 9, 8, 7, 6 \rangle) = 0$, but $Mono(\langle 1, 2, 3, 4, 5, 10, 9, 8, 7, 6 \rangle) = 1$.
+
 ### *Osc*
 
 ```cpp
@@ -299,7 +303,9 @@ Computes the *Oscillation* measure described by C. Levcopoulos and O. Petersson
 
 `max_for_size`: $\frac{|X|(|X| - 2) - 1}{2}$ when the values in $X$ are strongly oscillating.
 
-**Note:** *Osc* does not respect Mannila's criterion 5: $Osc(\langle 2, 4, 1, 3, 1, 3 \rangle) \not \le |\langle 4, 1, 3, 1, 3 \rangle| + Osc(\langle 4, 1, 3, 1, 3 \rangle)$, though it is possible that it only happens when equivalent elements are involved.
+**Note:** *Osc* does not respect Mannila's criterion 4: $Osc(\langle 0 \rangle) = 0$ and $Osc(\langle 3, 2, 1 \rangle) = 0$, but $Osc(\langle 0, 3, 2, 1 \rangle) = 2$.
+
+**Note²:** *Osc* does not respect Mannila's criterion 5: $Osc(\langle 2, 4, 1, 3, 1, 3 \rangle) \not \le |\langle 4, 1, 3, 1, 3 \rangle| + Osc(\langle 4, 1, 3, 1, 3 \rangle)$, though it is possible that it only happens when equivalent elements are involved.
 
 ### *Rem*
 

tests/probes/every_probe_common.cpp

@@ -179,6 +179,66 @@ TEMPLATE_TEST_CASE( "test M(subsequence(X)) <= M(X) for most probes M", "[probe]
     });
 }
 
+namespace
+{
+    // Split a sequence into two consequent subsequences X and Y,
+    // with all elements of X being not greater than all elements of Y,
+    // the split point is chosen at random
+
+    auto split_in_two(std::vector<int>& sequence)
+        -> std::vector<int>::iterator
+    {
+        using diff_t = std::vector<int>::difference_type;
+        using param_t = std::uniform_int_distribution<diff_t>::param_type;
+
+        auto size = static_cast<diff_t>(sequence.size());
+        std::uniform_int_distribution<diff_t> dist;
+        auto x_begin = sequence.begin();
+        auto y_begin = x_begin + dist(hasard::engine(), param_t{0, size});
+        std::nth_element(x_begin, y_begin, sequence.end());
+        return y_begin;
+    }
+}
+
+TEMPLATE_TEST_CASE( "test M(XY) <= M(X) + M(Y) if X <= Y for most probes M", "[probe]",
+                    decltype(cppsort::probe::dis),
+                    decltype(cppsort::probe::enc),
+                    decltype(cppsort::probe::exc),
+                    decltype(cppsort::probe::max),
+                    decltype(cppsort::probe::sus) )
+{
+    // Fourth property formalized by Mannila
+    // Ensure that the disorder found in the concatenation of two sequences is not
+    // greater than the sum of the individual sequences' disorders when all elements
+    // of the second sequence are greater than all elements of the first sequence
+
+    // Note: some measures do not appear here because we test a stronger bound
+    //       instead (see the next test)
+
+    rc::prop("M(XY) ≤ M(X) + M(Y) if X ≤ Y", [](std::vector<int> sequence) {
+        auto y_begin = split_in_two(sequence);
+        std::decay_t<TestType> measure;
+        return measure(sequence) <= measure(sequence.begin(), y_begin) + measure(y_begin, sequence.end());
+    });
+}
+
+TEMPLATE_TEST_CASE( "test M(XY) = M(X) + M(Y) if X <= Y for some probes M", "[probe]",
+                    decltype(cppsort::probe::ham),
+                    decltype(cppsort::probe::inv),
+                    decltype(cppsort::probe::rem),
+                    decltype(cppsort::probe::runs),
+                    decltype(cppsort::probe::spear) )
+{
+    // Property formalized by Estivill-Castro in *Sorting and Measures of Disorder*
+    // It is a stronger bound on Mannila's fourth property that some measures satisfy
+
+    rc::prop("M(XY) = M(X) + M(Y) if X ≤ Y", [](std::vector<int> sequence) {
+        auto y_begin = split_in_two(sequence);
+        std::decay_t<TestType> measure;
+        return measure(sequence) == measure(sequence.begin(), y_begin) + measure(y_begin, sequence.end());
+    });
+}
+
 TEMPLATE_TEST_CASE( "test M(aX) <= |X| + M(X) for most probes M", "[probe]",
                     decltype(cppsort::probe::block),
                     decltype(cppsort::probe::dis),
@@ -192,7 +252,7 @@ TEMPLATE_TEST_CASE( "test M(aX) <= |X| + M(X) for most probes M", "[probe]",
                     decltype(cppsort::probe::sus) )
 {
     // Fifth property formalized by Mannila
-    // The following probes don't satisfy it: ham, osc, spear
+    // The following probes don't satisfy it: Ham, Osc, Spear
 
     rc::prop("M(⟨a⟩X) ≤ |X| + M(X)", [](const std::vector<int>& sequence) {
         std::decay_t<TestType> measure;
@@ -307,29 +367,3 @@ TEMPLATE_TEST_CASE( "test monotonicity", "[probe]",
             : disorder_wyz <= disorder_wxz;
     });
 }
-
-TEMPLATE_TEST_CASE( "test M(XY) = M(X) + M(Y) if X <= Y for most probes M", "[probe]",
-                    decltype(cppsort::probe::ham),
-                    decltype(cppsort::probe::inv),
-                    decltype(cppsort::probe::rem),
-                    decltype(cppsort::probe::runs),
-                    decltype(cppsort::probe::spear) )
-{
-    // Property formalized by Estivill-Castro in *Sorting and Measures of Disorder*
-    // Not all measures of presortedness satisfy it, but a lot do
-
-    rc::prop("M(XY) = M(X) + M(Y) if X ≤ Y", [](std::vector<int> sequence) {
-        using diff_t = std::vector<int>::difference_type;
-        using param_t = std::uniform_int_distribution<diff_t>::param_type;
-
-        // Split the sequence into two consequent subsequences X and Y
-        auto size = static_cast<diff_t>(sequence.size());
-        std::uniform_int_distribution<diff_t> dist;
-        auto x_begin = sequence.begin();
-        auto y_begin = x_begin + dist(hasard::engine(), param_t{0, size});
-        std::nth_element(x_begin, y_begin, sequence.end());
-
-        std::decay_t<TestType> measure;
-        return measure(sequence) == measure(x_begin, y_begin) + measure(y_begin, sequence.end());
-    });
-}