% ====================================================
:- pred constr(bool). 
:- mode constr(in). 
:- ignore constr/1.

% ====================================================
% Program. mergesorting in ascending order.E.g., 3 =< 5 =< 5 =< 8 =< ...
:- pred mergesort(list(int),list(int)).
:- mode mergesort(in,out).
mergesort([], []).
mergesort([H,K], [H,K]). %error: erase clause
mergesort([H,K|T],S) :-
   cons(K,T,KT),          
   cons(H,KT,HKT),          
   split(HKT,L1,L2),       
   mergesort(L1,S1),       
   mergesort(L2,S2),
   merge(S1,S2,S).         % merging

:- pred cons(int,list(int),list(int)).
:- mode cons(in,in,out).
cons(H,T,[H|T]).

:- pred split(list(int),list(int),list(int)).
:- mode split(in,out,out).
split(L,L1,L2) :- N1=(N div 2),    
     length(L,N),                    
     takedrop(N1,L,L1,L2).

:- pred length(list(int),int).
:- mode length(in,out).
length([],L) :- constr(L=0).
length([H|T],L) :-
  L=(LT+1),
  length(T,LT).

:- pred takedrop(int,list(int),list(int),list(int)).
:- mode takedrop(in,in,out,out).
takedrop(N,[],[],[]).
takedrop(N,L,[],L) :- N=<0.
takedrop(N,[H|T],[H|T1],L) :- 
  N>=1, N1=(N-1),  
  takedrop(N1,T,T1,L).

:- pred merge(list(int),list(int),list(int)).
:- mode merge(in,in,out).
merge([],L,L).                 
merge([X|Xs],[],[X|Xs]).
merge([X|Xs],[Y|Ys],[X|Zs]) :-
     X=<Y, cons(Y,Ys,YYs),
     merge(Xs,YYs,Zs).
merge([X|Xs],[Y|Ys],[Y|Zs]) :-
     X>Y, cons(X,Xs,XXs),
     merge(XXs,Ys,Zs).
     
% ====================================================
% catamorphisms

:- pred is_asorted(list(int),bool).
:- mode is_asorted(in,out).
:- cata is_asorted/2-1.

is_asorted([],Res) :- constr(Res).
is_asorted([H|T],Res) :-
    hd(T,IsDefT,HdT),
    is_asorted(T,ResT),
    constr(Res=(IsDefT => (H=<HdT & ResT))).

% ---
:- pred hd(list(int),bool,int).
:- mode hd(in,out,out).
:- cata hd/3-1.

hd([],IsDef,Hd) :- constr( ~IsDef & Hd=0 ).    % 0 can be any int.
hd([H|T],IsDef,Hd) :- constr( IsDef & Hd=H ).
  
% ====================================================
% verification. 
% Property:
:- pred ff1.
ff1 :-                               
   constr( ~(CS)), 
   is_asorted(L,CL), 
   is_asorted(S,CS),  
   mergesort(L,S).

% abstractions (postcondition: true)

:- spec merge(A,C,E) ==> is_asorted(A,B), is_asorted(C,D), is_asorted(E,F) => constr(true).

:- spec split(E,A,C) ==> is_asorted(E,SE), is_asorted(A,SA), is_asorted(C,SC) => constr(true).

:- spec cons(C,A,D) ==> is_asorted(A,SA), is_asorted(D,SD) => constr(true).

:- spec takedrop(G,A,E,C) ==> is_asorted(A,B), is_asorted(E,F), is_asorted(C,D) => constr(true).

% ================================================================= 
:- query ff1/0.
% =================================================================