Splitting list into sorted sublists (Prolog) - prolog

Question

How can I divide a list [5,4,2,8,3,1,6,9,5] into a list of sub-lists that would be split at the values that break the sequence?
For example a list [5,4,2,8,3,1,6,9,5] should yield a list of sub-lists like [5], [4], [2,8], [3], [1,6,9], [5] or [[5], [4], [2,8], [3], [1,6,9], [5]] (doesn't matter).
Any ideas on this or suggestions how to resolve this problem?
Thanks.

Answer 1

This seemed like a DCG problem to me, so here is one DCG solution:
ascending([X|Xs]) -->
[X],
ascending(X, Xs).
ascending(X, [Y|Xs]) -->
[Y],
{ X =< Y },
{ ! },
ascending(Y, Xs).
ascending(_X, []) -->
[].
This can be used with phrase/3 to obtain both the sorted prefix and the remaining elements:
?- phrase(ascending(Asc), [1,2,3,4,5], Rest).
Asc = [1, 2, 3, 4, 5],
Rest = [].
?- phrase(ascending(Asc), [1,2,3,4,5,2,3,4,5], Rest).
Asc = [1, 2, 3, 4, 5],
Rest = [2, 3, 4, 5].
?- phrase(ascending(Asc), [1,2,3,4,5,2,3,4,5], Rest), phrase(ascending(Asc2), Rest, Final).
Asc = [1, 2, 3, 4, 5],
Rest = Asc2, Asc2 = [2, 3, 4, 5],
Final = [].
The main predicate is just:
sorted_sublists([], []).
sorted_sublists(List, [Prefix|Remaining]) :-
phrase(ascending(Prefix), List, Rest),
sorted_sublists(Rest, Remaining).
However, the cut in ascending//2 is somewhat ugly. Negation in DCGs is a bit tedious, but with constraints it can be made to work:
:- use_module(library(clpfd)).
ascending(X, [Y|Xs]) -->
{ X #=< Y },
[Y],
ascending(Y, Xs).
ascending(X, []) -->
{ X #=< Y },
\+ [Y].
This is quite nice, I think. Is there some way of doing something similar but not necessarily with constraints? Essentially, a way of writing in a DCG "match the empty list, or a nonempty list that does not satisfy some predicate P"?

Answer 2

Quite tricky, but it can be done with DCG :
sub([A,B|T]) --> [[A]], {A > B},sub([B|T]); {A =< B, phrase(sub_1([A,B|T], S), R, [])}, [R], sub(S).
sub([A]) --> [[A]].
sub([]) --> [].
sub_1([A,B|T], S) --> [A], {A =< B}, sub_1([B|T], S);[A], {A > B, S = [B|T]}.
sub_1([A], []) --> [A].
Result :
?- phrase(sub([5,4,2,8,3,1,6,9,5] ), A, []).
A = [[5], [4], [2, 8], [3], [1, 6, 9], [5]] ;
false
.

Answer 3

You just asked for a strategy, but I really wasn't able to come up with a good one. I hope someone else comes along with a better approach than any of mine.
I'm really unhappy with my solution, because it feels like a problem this simple deserves a simple solution and my solution is not very simple. In fact, I feel like something like this ought to work:
sorted_sublists([], []).
sorted_sublists(L, [Prefix|Remaining]) :-
append(Prefix, Suffix, L),
sort(Prefix, Prefix),
sorted_sublists(Suffix, Remaining).
This seems reasonably declarative to me: give me a prefix of L, if it is already sorted, put it in the result list and recur on what remains. However, this doesn't work because Prefix can be the empty list, but if you fix it like so:
sorted_sublists([], []).
sorted_sublists(L, [Prefix|Remaining]) :-
append(Prefix, Suffix, L),
Prefix=[_|_],
sort(Prefix, Prefix),
sorted_sublists(Suffix, Remaining).
It still doesn't work because you get a plethora of solutions, the last of which is the one you actually want:
[debug] ?- sorted_sublists([1,2,3,1,2,1,1], Sublists).
Sublists = [[1], [2], [3], [1], [2], [1], [1]] ;
Sublists = [[1], [2], [3], [1, 2], [1], [1]] ;
Sublists = [[1], [2, 3], [1], [2], [1], [1]] ;
Sublists = [[1], [2, 3], [1, 2], [1], [1]] ;
Sublists = [[1, 2], [3], [1], [2], [1], [1]] ;
Sublists = [[1, 2], [3], [1, 2], [1], [1]] ;
Sublists = [[1, 2, 3], [1], [2], [1], [1]] ;
Sublists = [[1, 2, 3], [1, 2], [1], [1]] ;
false.
Still, it seems like motion in the right direction. What if we had a predicate that could peel off the first sorted prefix? If we had that, we could skip append/3 and the erroneous solutions. So let's focus on writing that predicate. I came up with this:
sorted_prefix([Last], [Last], []).
sorted_prefix([X,Y|Ys], Prefix, Suffix) :-
(X < Y ->
sorted_prefix([Y|Ys], Prefix0, Suffix),
Prefix = [X|Prefix0]
;
Prefix = [X], Suffix = [Y|Ys]
).
So the base case is that we have just one element in our list. That's a sorted prefix.
The inductive case is trickier. The idea is that if the first two items are in order, I want to recur on the second item plus the remaining list, and I want to prepend my result onto that result. In other words, if the sorted prefix of L is R and X is less than the first item of L, then the sorted prefix of [X|L] is [X|R]. If that isn't the case, we wind up in the other situation, which is that if X is greater than the first element of L, the sorted prefix of [X|L] is just [X]. In that case, we also have to work out the suffix, which is just going to be L.
The final sorted_sublists/2 becomes a bit simpler:
sorted_sublists([], []).
sorted_sublists(L, [Prefix|Remaining]) :-
sorted_prefix(L, Prefix, Suffix),
sorted_sublists(Suffix, Remaining).
This is just recursively peeling off one sorted prefix at a time.