Prove termination of (optimized) diff algorithm implementation

[ninioArtillero]

This PR adds an static check for the ses (smallest edit script) function termination by defining a wave front's distance to the endpoint as decreasing metric. This function is the implementation's entry point to the Myers diff algorithm, whose original specification waives the need for a termination proof by bounding the algorithm's outer loop by the known worst case edit script length (i.e. the sum of both input's lengths). The implicit termination proof contained in this check provides a compeling argument for the correctness of the implementation by stablishing a link with its original specification.

The check depends on:

• The refactoring of dstep (2825ba1) and ses (572638c ) functions. The former resulting in a 4x performance improvement that required a new benchmark comparing inputs with a bigger size difference (607c8d3) to be noticed.
• The addition of phantom (i.e. unused in source code) parameters to dstep and addsnake (8eba64a) to thread a notion of the edit grid within the call stack
• And the inclusion of supplementary functions that are only relevant to the Liquid Haskell specifications and have no impact in the implementation whatsoever.

Refactorings

The "iterate, flatten and find" steps of ses are merged in a single "search" step. Formerly, the search for the endpoint was done using dropWhile (\dl -> poi dl /= lena || poj dl /= lenb) on a single infinite stream containing all nodes, from succesive iterations of the wave front, in order. Now, the seach :: Int -> [DL] -> [DI] does the same thing, inspecting one wave front iteration at a time, allowing Liquid Haskell to reason about the incremental reach of the wave front to the goal. Benchmarks (cabal bench) shows a negligeble performance gain on this change alone when tested on a local branch. This is still the case after the dstep optimization; before and after benchmark results are shown below.

The dstep optimization consist (informally) of narrowing the wave front to in-bound nodes only: checks are placed to drop non-competing and out-of-bound nodes. The performance gain on the existing benchmark is barely noticeable. However, the new benchmark comparing inputs differing noticeably in size shows the gain to be in the order of 4x for this case. Incidentally, this addresses #1 robustly for all disparities between input sizes, which the additional equations to getDiffBy added in #28 solved for the specific case of an input of size 0; these equations are removed to avoid the unnecessary complexity of this ad hoc case.
This refactoring is instrumental to prove dstep reduces wfDistanceToGoal (6590d8e), providing guarantee that the manhattanDistance is non-negative on all wave front nodes. Also, the previously local hStep and vStep functions where moved to the top level in to reflect them (bc324f5), making their unfoldings available in the refinement logic, in order to reduce the specification load: otherwise, they incur in substantive specifications of their own (as found before this change in 6590d8e). For details on how this refactoring is related to the wave front specification see [NOTE: diagonal-invariant].

Benchmarks

Before dstep refactoring (on 607c8d3)

Benchmark simple: RUNNING...
benchmarking diff bool lists/1000 bools
time                 5.747 ms   (5.610 ms .. 5.851 ms)
                     0.998 R�   (0.998 R� .. 0.999 R�)
mean                 5.534 ms   (5.503 ms .. 5.581 ms)
std dev              122.2  s   (89.75  s .. 175.3  s)

benchmarking diff bool lists/1000/500 bools
time                 7.767 ms   (7.691 ms .. 7.842 ms)
                     1.000 R�   (0.999 R� .. 1.000 R�)
mean                 7.736 ms   (7.698 ms .. 7.777 ms)
std dev              119.6  s   (96.57  s .. 148.0  s)

Benchmark simple: FINISH

After dstep refactoring, but before ses refactoring (on 6590d8e)

Benchmark simple: RUNNING...
benchmarking diff bool lists/1000 bools
time                 5.199 ms   (5.158 ms .. 5.263 ms)
                     0.999 R�   (0.999 R� .. 1.000 R�)
mean                 5.179 ms   (5.156 ms .. 5.202 ms)
std dev              68.38  s   (56.26  s .. 86.47  s)

benchmarking diff bool lists/1000/500 bools
time                 1.897 ms   (1.886 ms .. 1.912 ms)
                     1.000 R�   (0.999 R� .. 1.000 R�)
mean                 1.893 ms   (1.887 ms .. 1.899 ms)
std dev              21.91  s   (17.44  s .. 26.36  s)

Benchmark simple: FINISH

After both refactorings (on 52f18d4):

Benchmark simple: RUNNING...
benchmarking diff bool lists/1000 bools
time                 4.604 ms   (4.570 ms .. 4.629 ms)
                     1.000 R�   (1.000 R� .. 1.000 R�)
mean                 4.633 ms   (4.617 ms .. 4.651 ms)
std dev              53.36  s   (44.97  s .. 65.39  s)

benchmarking diff bool lists/1000/500 bools
time                 1.619 ms   (1.609 ms .. 1.630 ms)
                     1.000 R�   (1.000 R� .. 1.000 R�)
mean                 1.629 ms   (1.625 ms .. 1.634 ms)
std dev              16.82  s   (14.07  s .. 20.30  s)

Benchmark simple: FINISH

Phantom parameters and Liquid Haskell supplementary functions.

The new phantom parameters in dstep and addsnake carrying both input lengths are used to pass these values to the supplementary functions defined under the Proving the Algorithm's Termination in LiquidHaskell code section at the bottom of Diff.hs.

LiquidHaskell specific machinery leading to the definition of the WaveFront refinement type alias (introduced in #32) is moved to the new code section LiquidHaskell Wave Front Specification, also near the bottom of the file. The DLN alias is modified to take parameters for the input lengths, and a local invariant for the DL type is added in a using annotation to make the positivity of its coordinates available in contexts where their values where not pattern matched.

[facundominguez]

This PR should revert 33bf8bc, which is made redundant by a0f181c.

[facundominguez]

Very nice \o/