Test that M(subsequence(X)) <= M(X) for most probes

Author: Morwenn

docs/Measures-of-disorder.md

@@ -217,6 +217,8 @@ Computes the minimum number of exchanges required to sort $X$, which corresponds
 
 `max_for_size`: $|X| - 1$ when every element in $X$ is one element away from its sorted position.
 
+**Note:** *Exc* does not respect Mannila's criterion 3 (a subsequence contains no more disorder than the whole sequence): $Exc(\langle 3, 1, 2, 0 \rangle) = 1$, but $Exc(\langle 3, 1, 2 \rangle) = 2$.
+
 *Warning: this algorithm might be noticeably slower when the passed range is not random-access.*
 
 ### *Ham*
@@ -233,7 +235,9 @@ Computes the number of elements in $X$ that are not in their sorted position, wh
 
 `max_for_size`: $|X|$ when every element in $X$ is one element away from its sorted position.
 
-**Note:** *Ham* does not respect Mannila's criterion 5: $Ham(\langle 4, 1, 2, 3 \rangle) \not \le |\langle 1, 2, 3 \rangle| + Ham(\langle 1, 2, 3 \rangle)$.
+**Note:** *Ham* does not respect Mannila's criterion 3 (a subsequence contains no more disorder than the whole sequence): $Ham(\langle 3, 1, 2, 0 \rangle) = 2$, but $Ham(\langle 3, 1, 2 \rangle) = 3$.
+
+**Note²:** *Ham* does not respect Mannila's criterion 5: $Ham(\langle 4, 1, 2, 3 \rangle) \not \le |\langle 1, 2, 3 \rangle| + Ham(\langle 1, 2, 3 \rangle)$.
 
 ### *Inv*
 

tests/probes/every_probe_common.cpp

@@ -140,6 +140,45 @@ TEMPLATE_TEST_CASE( "test order isomorphism for every probe", "[probe]",
     });
 }
 
+TEMPLATE_TEST_CASE( "test M(subsequence(X)) <= M(X) for most probes M", "[probe]",
+                    decltype(cppsort::probe::block),
+                    decltype(cppsort::probe::dis),
+                    decltype(cppsort::probe::enc),
+                    decltype(cppsort::probe::inv),
+                    decltype(cppsort::probe::max),
+                    decltype(cppsort::probe::mono),
+                    decltype(cppsort::probe::osc),
+                    decltype(cppsort::probe::rem),
+                    decltype(cppsort::probe::runs),
+                    decltype(cppsort::probe::spear),
+                    decltype(cppsort::probe::sus) )
+{
+    // Third property formalized by Mannila
+    // Ensure that the disorder that exists in a subsequence is no
+    // greater than the disorder that exists in the whole sequence
+
+    rc::prop("M(subsequence(X)) ≤ M(X)", [](std::vector<int> sequence) {
+        std::decay_t<TestType> measure;
+        auto disorder_x = measure(sequence);
+
+        std::uniform_int_distribution<int> uni(0, sequence.size());
+
+        using diff_t = std::vector<int>::difference_type;
+        using param_t = std::uniform_int_distribution<diff_t>::param_type;
+        std::uniform_int_distribution<diff_t> dist;
+
+        diff_t size = sequence.size();
+        auto number_of_elements_to_remove = dist(hasard::engine(), param_t{0, size});
+        for (; number_of_elements_to_remove > 0; --number_of_elements_to_remove) {
+            auto idx = dist(hasard::engine(), param_t{0, size - 1});
+            sequence.erase(sequence.begin() + idx);
+            --size;
+        }
+
+        return measure(sequence) <= disorder_x;
+    });
+}
+
 TEMPLATE_TEST_CASE( "test M(aX) <= |X| + M(X) for most probes M", "[probe]",
                     decltype(cppsort::probe::block),
                     decltype(cppsort::probe::dis),

tests/probes/exc.cpp

@@ -56,4 +56,12 @@ TEST_CASE( "measure of disorder: exc", "[probe][exc]" )
         const std::vector<int> collection = { 0, 0, -1 };
         CHECK( exc(collection) == 1 );
     }
+
+    SECTION( "Example of Exc(subsequence(X)) > Exc(X)" )
+    {
+        const std::forward_list<int> seq =    { 3, 1, 2, 0 };
+        const std::forward_list<int> subseq = { 3, 1, 2 };
+        CHECK( exc(seq) == 1 );
+        CHECK( exc(subseq) == 2 );
+    }
 }

tests/probes/ham.cpp

@@ -49,6 +49,14 @@ TEST_CASE( "measure of disorder: ham", "[probe][ham]" )
         CHECK( ham(collection) == 0 );
     }
 
+    SECTION( "Example of Ham(subsequence(X)) > Ham(X)" )
+    {
+        const std::forward_list<int> seq =    { 3, 1, 2, 0 };
+        const std::forward_list<int> subseq = { 3, 1, 2 };
+        CHECK( ham(seq) == 2 );
+        CHECK( ham(subseq) == 3 );
+    }
+
     rc::prop("Ham(X) ≠ 1", [](const std::vector<int>& sequence) {
         return cppsort::probe::ham(sequence) != 1;
     });