/export/starexec/sandbox2/solver/bin/starexec_run_standard /export/starexec/sandbox2/benchmark/theBenchmark.hs /export/starexec/sandbox2/output/output_files


--------------------------------------------------------------------------------


YES
proof of /export/starexec/sandbox2/benchmark/theBenchmark.hs
# AProVE Commit ID: 794c25de1cacf0d048858bcd21c9a779e1221865 marcel 20200619 unpublished dirty


H-Termination with start terms of the given HASKELL could be proven:

(0) HASKELL
(1) IFR [EQUIVALENT, 0 ms]
(2) HASKELL
(3) BR [EQUIVALENT, 0 ms]
(4) HASKELL
(5) COR [EQUIVALENT, 0 ms]
(6) HASKELL
(7) LetRed [EQUIVALENT, 0 ms]
(8) HASKELL
(9) Narrow [SOUND, 0 ms]
(10) AND
    (11) QDP
        (12) QDPSizeChangeProof [EQUIVALENT, 0 ms]
        (13) YES
    (14) QDP
        (15) QDPSizeChangeProof [EQUIVALENT, 0 ms]
        (16) YES
    (17) QDP
        (18) DependencyGraphProof [EQUIVALENT, 0 ms]
        (19) QDP
        (20) TransformationProof [EQUIVALENT, 0 ms]
        (21) QDP
        (22) QDPSizeChangeProof [EQUIVALENT, 0 ms]
        (23) YES
    (24) QDP
        (25) QDPSizeChangeProof [EQUIVALENT, 0 ms]
        (26) YES


----------------------------------------

(0)
Obligation:
mainModule Main 
module Maybe where {
import qualified List;
import qualified Main;
import qualified Prelude;
}
module List where {
import qualified Main;
import qualified Maybe;
import qualified Prelude;
deleteBy :: (a  ->  a  ->  Bool)  ->  a  ->  [a]  ->  [a];
deleteBy _ _ [] = [];
deleteBy eq x (y : ys) =  if x `eq` y then ys else y : deleteBy eq x ys;

elem_by :: (a  ->  a  ->  Bool)  ->  a  ->  [a]  ->  Bool;
elem_by _ _ [] = False;
elem_by eq y (x : xs) = x `eq` y || elem_by eq y xs;

nubBy :: (a  ->  a  ->  Bool)  ->  [a]  ->  [a];
nubBy eq l = nubBy' l [] where { 
nubBy' [] _ = [];
nubBy' (y : ys) xs  | elem_by eq y xs = nubBy' ys xs
 | otherwise = y : nubBy' ys (y : xs);
 };

unionBy :: (a  ->  a  ->  Bool)  ->  [a]  ->  [a]  ->  [a];
unionBy eq xs ys = xs ++ foldl (flip (deleteBy eq)) (nubBy eq ys) xs;

}
module Main where {
import qualified List;
import qualified Maybe;
import qualified Prelude;
}

----------------------------------------

(1) IFR (EQUIVALENT)
If Reductions:
The following If expression
"if eq x y then ys else y : deleteBy eq x ys"
is transformed to
"deleteBy0 ys y eq x True = ys;
deleteBy0 ys y eq x False = y : deleteBy eq x ys;
"

----------------------------------------

(2)
Obligation:
mainModule Main 
module Maybe where {
import qualified List;
import qualified Main;
import qualified Prelude;
}
module List where {
import qualified Main;
import qualified Maybe;
import qualified Prelude;
deleteBy :: (a  ->  a  ->  Bool)  ->  a  ->  [a]  ->  [a];
deleteBy _ _ [] = [];
deleteBy eq x (y : ys) = deleteBy0 ys y eq x (x `eq` y);

deleteBy0 ys y eq x True = ys;
deleteBy0 ys y eq x False = y : deleteBy eq x ys;

elem_by :: (a  ->  a  ->  Bool)  ->  a  ->  [a]  ->  Bool;
elem_by _ _ [] = False;
elem_by eq y (x : xs) = x `eq` y || elem_by eq y xs;

nubBy :: (a  ->  a  ->  Bool)  ->  [a]  ->  [a];
nubBy eq l = nubBy' l [] where { 
nubBy' [] _ = [];
nubBy' (y : ys) xs  | elem_by eq y xs = nubBy' ys xs
 | otherwise = y : nubBy' ys (y : xs);
 };

unionBy :: (a  ->  a  ->  Bool)  ->  [a]  ->  [a]  ->  [a];
unionBy eq xs ys = xs ++ foldl (flip (deleteBy eq)) (nubBy eq ys) xs;

}
module Main where {
import qualified List;
import qualified Maybe;
import qualified Prelude;
}

----------------------------------------

(3) BR (EQUIVALENT)
Replaced joker patterns by fresh variables and removed binding patterns.
----------------------------------------

(4)
Obligation:
mainModule Main 
module Maybe where {
import qualified List;
import qualified Main;
import qualified Prelude;
}
module List where {
import qualified Main;
import qualified Maybe;
import qualified Prelude;
deleteBy :: (a  ->  a  ->  Bool)  ->  a  ->  [a]  ->  [a];
deleteBy wv ww [] = [];
deleteBy eq x (y : ys) = deleteBy0 ys y eq x (x `eq` y);

deleteBy0 ys y eq x True = ys;
deleteBy0 ys y eq x False = y : deleteBy eq x ys;

elem_by :: (a  ->  a  ->  Bool)  ->  a  ->  [a]  ->  Bool;
elem_by vy vz [] = False;
elem_by eq y (x : xs) = x `eq` y || elem_by eq y xs;

nubBy :: (a  ->  a  ->  Bool)  ->  [a]  ->  [a];
nubBy eq l = nubBy' l [] where { 
nubBy' [] wu = [];
nubBy' (y : ys) xs  | elem_by eq y xs = nubBy' ys xs
 | otherwise = y : nubBy' ys (y : xs);
 };

unionBy :: (a  ->  a  ->  Bool)  ->  [a]  ->  [a]  ->  [a];
unionBy eq xs ys = xs ++ foldl (flip (deleteBy eq)) (nubBy eq ys) xs;

}
module Main where {
import qualified List;
import qualified Maybe;
import qualified Prelude;
}

----------------------------------------

(5) COR (EQUIVALENT)
Cond Reductions:
The following Function with conditions
"undefined |Falseundefined;
"
is transformed to
"undefined  = undefined1;
"
"undefined0 True = undefined;
"
"undefined1  = undefined0 False;
"
The following Function with conditions
"nubBy' [] wu = [];
nubBy' (y : ys) xs|elem_by eq y xsnubBy' ys xs|otherwisey : nubBy' ys (y : xs);
"
is transformed to
"nubBy' [] wu = nubBy'3 [] wu;
nubBy' (y : ys) xs = nubBy'2 (y : ys) xs;
"
"nubBy'0 y ys xs True = y : nubBy' ys (y : xs);
"
"nubBy'1 y ys xs True = nubBy' ys xs;
nubBy'1 y ys xs False = nubBy'0 y ys xs otherwise;
"
"nubBy'2 (y : ys) xs = nubBy'1 y ys xs (elem_by eq y xs);
"
"nubBy'3 [] wu = [];
nubBy'3 wz xu = nubBy'2 wz xu;
"

----------------------------------------

(6)
Obligation:
mainModule Main 
module Maybe where {
import qualified List;
import qualified Main;
import qualified Prelude;
}
module List where {
import qualified Main;
import qualified Maybe;
import qualified Prelude;
deleteBy :: (a  ->  a  ->  Bool)  ->  a  ->  [a]  ->  [a];
deleteBy wv ww [] = [];
deleteBy eq x (y : ys) = deleteBy0 ys y eq x (x `eq` y);

deleteBy0 ys y eq x True = ys;
deleteBy0 ys y eq x False = y : deleteBy eq x ys;

elem_by :: (a  ->  a  ->  Bool)  ->  a  ->  [a]  ->  Bool;
elem_by vy vz [] = False;
elem_by eq y (x : xs) = x `eq` y || elem_by eq y xs;

nubBy :: (a  ->  a  ->  Bool)  ->  [a]  ->  [a];
nubBy eq l = nubBy' l [] where { 
nubBy' [] wu = nubBy'3 [] wu;
nubBy' (y : ys) xs = nubBy'2 (y : ys) xs;
nubBy'0 y ys xs True = y : nubBy' ys (y : xs);
nubBy'1 y ys xs True = nubBy' ys xs;
nubBy'1 y ys xs False = nubBy'0 y ys xs otherwise;
nubBy'2 (y : ys) xs = nubBy'1 y ys xs (elem_by eq y xs);
nubBy'3 [] wu = [];
nubBy'3 wz xu = nubBy'2 wz xu;
 };

unionBy :: (a  ->  a  ->  Bool)  ->  [a]  ->  [a]  ->  [a];
unionBy eq xs ys = xs ++ foldl (flip (deleteBy eq)) (nubBy eq ys) xs;

}
module Main where {
import qualified List;
import qualified Maybe;
import qualified Prelude;
}

----------------------------------------

(7) LetRed (EQUIVALENT)
Let/Where Reductions:
The bindings of the following Let/Where expression
"nubBy' l [] where {
nubBy' [] wu = nubBy'3 [] wu;
nubBy' (y : ys) xs = nubBy'2 (y : ys) xs;
;
nubBy'0 y ys xs True = y : nubBy' ys (y : xs);
;
nubBy'1 y ys xs True = nubBy' ys xs;
nubBy'1 y ys xs False = nubBy'0 y ys xs otherwise;
;
nubBy'2 (y : ys) xs = nubBy'1 y ys xs (elem_by eq y xs);
;
nubBy'3 [] wu = [];
nubBy'3 wz xu = nubBy'2 wz xu;
} 
"
are unpacked to the following functions on top level
"nubByNubBy'3 xv [] wu = [];
nubByNubBy'3 xv wz xu = nubByNubBy'2 xv wz xu;
"
"nubByNubBy' xv [] wu = nubByNubBy'3 xv [] wu;
nubByNubBy' xv (y : ys) xs = nubByNubBy'2 xv (y : ys) xs;
"
"nubByNubBy'2 xv (y : ys) xs = nubByNubBy'1 xv y ys xs (elem_by xv y xs);
"
"nubByNubBy'1 xv y ys xs True = nubByNubBy' xv ys xs;
nubByNubBy'1 xv y ys xs False = nubByNubBy'0 xv y ys xs otherwise;
"
"nubByNubBy'0 xv y ys xs True = y : nubByNubBy' xv ys (y : xs);
"

----------------------------------------

(8)
Obligation:
mainModule Main 
module Maybe where {
import qualified List;
import qualified Main;
import qualified Prelude;
}
module List where {
import qualified Main;
import qualified Maybe;
import qualified Prelude;
deleteBy :: (a  ->  a  ->  Bool)  ->  a  ->  [a]  ->  [a];
deleteBy wv ww [] = [];
deleteBy eq x (y : ys) = deleteBy0 ys y eq x (x `eq` y);

deleteBy0 ys y eq x True = ys;
deleteBy0 ys y eq x False = y : deleteBy eq x ys;

elem_by :: (a  ->  a  ->  Bool)  ->  a  ->  [a]  ->  Bool;
elem_by vy vz [] = False;
elem_by eq y (x : xs) = x `eq` y || elem_by eq y xs;

nubBy :: (a  ->  a  ->  Bool)  ->  [a]  ->  [a];
nubBy eq l = nubByNubBy' eq l [];

nubByNubBy' xv [] wu = nubByNubBy'3 xv [] wu;
nubByNubBy' xv (y : ys) xs = nubByNubBy'2 xv (y : ys) xs;

nubByNubBy'0 xv y ys xs True = y : nubByNubBy' xv ys (y : xs);

nubByNubBy'1 xv y ys xs True = nubByNubBy' xv ys xs;
nubByNubBy'1 xv y ys xs False = nubByNubBy'0 xv y ys xs otherwise;

nubByNubBy'2 xv (y : ys) xs = nubByNubBy'1 xv y ys xs (elem_by xv y xs);

nubByNubBy'3 xv [] wu = [];
nubByNubBy'3 xv wz xu = nubByNubBy'2 xv wz xu;

unionBy :: (a  ->  a  ->  Bool)  ->  [a]  ->  [a]  ->  [a];
unionBy eq xs ys = xs ++ foldl (flip (deleteBy eq)) (nubBy eq ys) xs;

}
module Main where {
import qualified List;
import qualified Maybe;
import qualified Prelude;
}

----------------------------------------

(9) Narrow (SOUND)
Haskell To QDPs

digraph dp_graph {
node [outthreshold=100, inthreshold=100];1[label="List.unionBy",fontsize=16,color="grey",shape="box"];1 -> 3[label="",style="dashed", color="grey", weight=3];
3[label="List.unionBy xw3",fontsize=16,color="grey",shape="box"];3 -> 4[label="",style="dashed", color="grey", weight=3];
4[label="List.unionBy xw3 xw4",fontsize=16,color="grey",shape="box"];4 -> 5[label="",style="dashed", color="grey", weight=3];
5[label="List.unionBy xw3 xw4 xw5",fontsize=16,color="black",shape="triangle"];5 -> 6[label="",style="solid", color="black", weight=3];
6 -> 168[label="",style="dashed", color="red", weight=0];
6[label="xw4 ++ foldl (flip (List.deleteBy xw3)) (List.nubBy xw3 xw5) xw4",fontsize=16,color="magenta"];6 -> 169[label="",style="dashed", color="magenta", weight=3];
6 -> 170[label="",style="dashed", color="magenta", weight=3];
169 -> 209[label="",style="dashed", color="red", weight=0];
169[label="foldl (flip (List.deleteBy xw3)) (List.nubBy xw3 xw5) xw4",fontsize=16,color="magenta"];169 -> 210[label="",style="dashed", color="magenta", weight=3];
169 -> 211[label="",style="dashed", color="magenta", weight=3];
170[label="xw4",fontsize=16,color="green",shape="box"];168[label="xw41111111 ++ xw15",fontsize=16,color="burlywood",shape="triangle"];727[label="xw41111111/xw411111110 : xw411111111",fontsize=10,color="white",style="solid",shape="box"];168 -> 727[label="",style="solid", color="burlywood", weight=9];
727 -> 188[label="",style="solid", color="burlywood", weight=3];
728[label="xw41111111/[]",fontsize=10,color="white",style="solid",shape="box"];168 -> 728[label="",style="solid", color="burlywood", weight=9];
728 -> 189[label="",style="solid", color="burlywood", weight=3];
210[label="xw4",fontsize=16,color="green",shape="box"];211[label="List.nubBy xw3 xw5",fontsize=16,color="black",shape="box"];211 -> 216[label="",style="solid", color="black", weight=3];
209[label="foldl (flip (List.deleteBy xw3)) xw18 xw411",fontsize=16,color="burlywood",shape="triangle"];729[label="xw411/xw4110 : xw4111",fontsize=10,color="white",style="solid",shape="box"];209 -> 729[label="",style="solid", color="burlywood", weight=9];
729 -> 217[label="",style="solid", color="burlywood", weight=3];
730[label="xw411/[]",fontsize=10,color="white",style="solid",shape="box"];209 -> 730[label="",style="solid", color="burlywood", weight=9];
730 -> 218[label="",style="solid", color="burlywood", weight=3];
188[label="(xw411111110 : xw411111111) ++ xw15",fontsize=16,color="black",shape="box"];188 -> 192[label="",style="solid", color="black", weight=3];
189[label="[] ++ xw15",fontsize=16,color="black",shape="box"];189 -> 193[label="",style="solid", color="black", weight=3];
216[label="List.nubByNubBy' xw3 xw5 []",fontsize=16,color="burlywood",shape="box"];731[label="xw5/xw50 : xw51",fontsize=10,color="white",style="solid",shape="box"];216 -> 731[label="",style="solid", color="burlywood", weight=9];
731 -> 219[label="",style="solid", color="burlywood", weight=3];
732[label="xw5/[]",fontsize=10,color="white",style="solid",shape="box"];216 -> 732[label="",style="solid", color="burlywood", weight=9];
732 -> 220[label="",style="solid", color="burlywood", weight=3];
217[label="foldl (flip (List.deleteBy xw3)) xw18 (xw4110 : xw4111)",fontsize=16,color="black",shape="box"];217 -> 221[label="",style="solid", color="black", weight=3];
218[label="foldl (flip (List.deleteBy xw3)) xw18 []",fontsize=16,color="black",shape="box"];218 -> 222[label="",style="solid", color="black", weight=3];
192[label="xw411111110 : xw411111111 ++ xw15",fontsize=16,color="green",shape="box"];192 -> 197[label="",style="dashed", color="green", weight=3];
193[label="xw15",fontsize=16,color="green",shape="box"];219[label="List.nubByNubBy' xw3 (xw50 : xw51) []",fontsize=16,color="black",shape="box"];219 -> 223[label="",style="solid", color="black", weight=3];
220[label="List.nubByNubBy' xw3 [] []",fontsize=16,color="black",shape="box"];220 -> 224[label="",style="solid", color="black", weight=3];
221 -> 209[label="",style="dashed", color="red", weight=0];
221[label="foldl (flip (List.deleteBy xw3)) (flip (List.deleteBy xw3) xw18 xw4110) xw4111",fontsize=16,color="magenta"];221 -> 225[label="",style="dashed", color="magenta", weight=3];
221 -> 226[label="",style="dashed", color="magenta", weight=3];
222[label="xw18",fontsize=16,color="green",shape="box"];197 -> 168[label="",style="dashed", color="red", weight=0];
197[label="xw411111111 ++ xw15",fontsize=16,color="magenta"];197 -> 202[label="",style="dashed", color="magenta", weight=3];
223[label="List.nubByNubBy'2 xw3 (xw50 : xw51) []",fontsize=16,color="black",shape="box"];223 -> 227[label="",style="solid", color="black", weight=3];
224[label="List.nubByNubBy'3 xw3 [] []",fontsize=16,color="black",shape="box"];224 -> 228[label="",style="solid", color="black", weight=3];
225[label="xw4111",fontsize=16,color="green",shape="box"];226[label="flip (List.deleteBy xw3) xw18 xw4110",fontsize=16,color="black",shape="box"];226 -> 229[label="",style="solid", color="black", weight=3];
202[label="xw411111111",fontsize=16,color="green",shape="box"];227[label="List.nubByNubBy'1 xw3 xw50 xw51 [] (List.elem_by xw3 xw50 [])",fontsize=16,color="black",shape="box"];227 -> 230[label="",style="solid", color="black", weight=3];
228[label="[]",fontsize=16,color="green",shape="box"];229[label="List.deleteBy xw3 xw4110 xw18",fontsize=16,color="burlywood",shape="triangle"];733[label="xw18/xw180 : xw181",fontsize=10,color="white",style="solid",shape="box"];229 -> 733[label="",style="solid", color="burlywood", weight=9];
733 -> 231[label="",style="solid", color="burlywood", weight=3];
734[label="xw18/[]",fontsize=10,color="white",style="solid",shape="box"];229 -> 734[label="",style="solid", color="burlywood", weight=9];
734 -> 232[label="",style="solid", color="burlywood", weight=3];
230[label="List.nubByNubBy'1 xw3 xw50 xw51 [] False",fontsize=16,color="black",shape="box"];230 -> 233[label="",style="solid", color="black", weight=3];
231[label="List.deleteBy xw3 xw4110 (xw180 : xw181)",fontsize=16,color="black",shape="box"];231 -> 234[label="",style="solid", color="black", weight=3];
232[label="List.deleteBy xw3 xw4110 []",fontsize=16,color="black",shape="box"];232 -> 235[label="",style="solid", color="black", weight=3];
233[label="List.nubByNubBy'0 xw3 xw50 xw51 [] otherwise",fontsize=16,color="black",shape="box"];233 -> 236[label="",style="solid", color="black", weight=3];
234 -> 237[label="",style="dashed", color="red", weight=0];
234[label="List.deleteBy0 xw181 xw180 xw3 xw4110 (xw3 xw4110 xw180)",fontsize=16,color="magenta"];234 -> 238[label="",style="dashed", color="magenta", weight=3];
235[label="[]",fontsize=16,color="green",shape="box"];236[label="List.nubByNubBy'0 xw3 xw50 xw51 [] True",fontsize=16,color="black",shape="box"];236 -> 239[label="",style="solid", color="black", weight=3];
238[label="xw3 xw4110 xw180",fontsize=16,color="green",shape="box"];238 -> 244[label="",style="dashed", color="green", weight=3];
238 -> 245[label="",style="dashed", color="green", weight=3];
237[label="List.deleteBy0 xw181 xw180 xw3 xw4110 xw20",fontsize=16,color="burlywood",shape="triangle"];735[label="xw20/False",fontsize=10,color="white",style="solid",shape="box"];237 -> 735[label="",style="solid", color="burlywood", weight=9];
735 -> 242[label="",style="solid", color="burlywood", weight=3];
736[label="xw20/True",fontsize=10,color="white",style="solid",shape="box"];237 -> 736[label="",style="solid", color="burlywood", weight=9];
736 -> 243[label="",style="solid", color="burlywood", weight=3];
239[label="xw50 : List.nubByNubBy' xw3 xw51 (xw50 : [])",fontsize=16,color="green",shape="box"];239 -> 246[label="",style="dashed", color="green", weight=3];
244[label="xw4110",fontsize=16,color="green",shape="box"];245[label="xw180",fontsize=16,color="green",shape="box"];242[label="List.deleteBy0 xw181 xw180 xw3 xw4110 False",fontsize=16,color="black",shape="box"];242 -> 247[label="",style="solid", color="black", weight=3];
243[label="List.deleteBy0 xw181 xw180 xw3 xw4110 True",fontsize=16,color="black",shape="box"];243 -> 248[label="",style="solid", color="black", weight=3];
246[label="List.nubByNubBy' xw3 xw51 (xw50 : [])",fontsize=16,color="burlywood",shape="triangle"];737[label="xw51/xw510 : xw511",fontsize=10,color="white",style="solid",shape="box"];246 -> 737[label="",style="solid", color="burlywood", weight=9];
737 -> 249[label="",style="solid", color="burlywood", weight=3];
738[label="xw51/[]",fontsize=10,color="white",style="solid",shape="box"];246 -> 738[label="",style="solid", color="burlywood", weight=9];
738 -> 250[label="",style="solid", color="burlywood", weight=3];
247[label="xw180 : List.deleteBy xw3 xw4110 xw181",fontsize=16,color="green",shape="box"];247 -> 251[label="",style="dashed", color="green", weight=3];
248[label="xw181",fontsize=16,color="green",shape="box"];249[label="List.nubByNubBy' xw3 (xw510 : xw511) (xw50 : [])",fontsize=16,color="black",shape="box"];249 -> 252[label="",style="solid", color="black", weight=3];
250[label="List.nubByNubBy' xw3 [] (xw50 : [])",fontsize=16,color="black",shape="box"];250 -> 253[label="",style="solid", color="black", weight=3];
251 -> 229[label="",style="dashed", color="red", weight=0];
251[label="List.deleteBy xw3 xw4110 xw181",fontsize=16,color="magenta"];251 -> 254[label="",style="dashed", color="magenta", weight=3];
252[label="List.nubByNubBy'2 xw3 (xw510 : xw511) (xw50 : [])",fontsize=16,color="black",shape="box"];252 -> 255[label="",style="solid", color="black", weight=3];
253[label="List.nubByNubBy'3 xw3 [] (xw50 : [])",fontsize=16,color="black",shape="box"];253 -> 256[label="",style="solid", color="black", weight=3];
254[label="xw181",fontsize=16,color="green",shape="box"];255[label="List.nubByNubBy'1 xw3 xw510 xw511 (xw50 : []) (List.elem_by xw3 xw510 (xw50 : []))",fontsize=16,color="black",shape="box"];255 -> 257[label="",style="solid", color="black", weight=3];
256[label="[]",fontsize=16,color="green",shape="box"];257 -> 686[label="",style="dashed", color="red", weight=0];
257[label="List.nubByNubBy'1 xw3 xw510 xw511 (xw50 : []) (xw3 xw50 xw510 || List.elem_by xw3 xw510 [])",fontsize=16,color="magenta"];257 -> 687[label="",style="dashed", color="magenta", weight=3];
257 -> 688[label="",style="dashed", color="magenta", weight=3];
257 -> 689[label="",style="dashed", color="magenta", weight=3];
257 -> 690[label="",style="dashed", color="magenta", weight=3];
257 -> 691[label="",style="dashed", color="magenta", weight=3];
257 -> 692[label="",style="dashed", color="magenta", weight=3];
257 -> 693[label="",style="dashed", color="magenta", weight=3];
687[label="xw3 xw50 xw510",fontsize=16,color="green",shape="box"];687 -> 695[label="",style="dashed", color="green", weight=3];
687 -> 696[label="",style="dashed", color="green", weight=3];
688[label="[]",fontsize=16,color="green",shape="box"];689[label="xw3",fontsize=16,color="green",shape="box"];690[label="xw510",fontsize=16,color="green",shape="box"];691[label="xw50",fontsize=16,color="green",shape="box"];692[label="xw511",fontsize=16,color="green",shape="box"];693[label="[]",fontsize=16,color="green",shape="box"];686[label="List.nubByNubBy'1 xw48 xw49 xw50 (xw51 : xw52) (xw55 || List.elem_by xw48 xw49 xw54)",fontsize=16,color="burlywood",shape="triangle"];739[label="xw55/False",fontsize=10,color="white",style="solid",shape="box"];686 -> 739[label="",style="solid", color="burlywood", weight=9];
739 -> 697[label="",style="solid", color="burlywood", weight=3];
740[label="xw55/True",fontsize=10,color="white",style="solid",shape="box"];686 -> 740[label="",style="solid", color="burlywood", weight=9];
740 -> 698[label="",style="solid", color="burlywood", weight=3];
695[label="xw50",fontsize=16,color="green",shape="box"];696[label="xw510",fontsize=16,color="green",shape="box"];697[label="List.nubByNubBy'1 xw48 xw49 xw50 (xw51 : xw52) (False || List.elem_by xw48 xw49 xw54)",fontsize=16,color="black",shape="box"];697 -> 701[label="",style="solid", color="black", weight=3];
698[label="List.nubByNubBy'1 xw48 xw49 xw50 (xw51 : xw52) (True || List.elem_by xw48 xw49 xw54)",fontsize=16,color="black",shape="box"];698 -> 702[label="",style="solid", color="black", weight=3];
701[label="List.nubByNubBy'1 xw48 xw49 xw50 (xw51 : xw52) (List.elem_by xw48 xw49 xw54)",fontsize=16,color="burlywood",shape="triangle"];741[label="xw54/xw540 : xw541",fontsize=10,color="white",style="solid",shape="box"];701 -> 741[label="",style="solid", color="burlywood", weight=9];
741 -> 703[label="",style="solid", color="burlywood", weight=3];
742[label="xw54/[]",fontsize=10,color="white",style="solid",shape="box"];701 -> 742[label="",style="solid", color="burlywood", weight=9];
742 -> 704[label="",style="solid", color="burlywood", weight=3];
702[label="List.nubByNubBy'1 xw48 xw49 xw50 (xw51 : xw52) True",fontsize=16,color="black",shape="box"];702 -> 705[label="",style="solid", color="black", weight=3];
703[label="List.nubByNubBy'1 xw48 xw49 xw50 (xw51 : xw52) (List.elem_by xw48 xw49 (xw540 : xw541))",fontsize=16,color="black",shape="box"];703 -> 706[label="",style="solid", color="black", weight=3];
704[label="List.nubByNubBy'1 xw48 xw49 xw50 (xw51 : xw52) (List.elem_by xw48 xw49 [])",fontsize=16,color="black",shape="box"];704 -> 707[label="",style="solid", color="black", weight=3];
705[label="List.nubByNubBy' xw48 xw50 (xw51 : xw52)",fontsize=16,color="burlywood",shape="triangle"];743[label="xw50/xw500 : xw501",fontsize=10,color="white",style="solid",shape="box"];705 -> 743[label="",style="solid", color="burlywood", weight=9];
743 -> 708[label="",style="solid", color="burlywood", weight=3];
744[label="xw50/[]",fontsize=10,color="white",style="solid",shape="box"];705 -> 744[label="",style="solid", color="burlywood", weight=9];
744 -> 709[label="",style="solid", color="burlywood", weight=3];
706 -> 686[label="",style="dashed", color="red", weight=0];
706[label="List.nubByNubBy'1 xw48 xw49 xw50 (xw51 : xw52) (xw48 xw540 xw49 || List.elem_by xw48 xw49 xw541)",fontsize=16,color="magenta"];706 -> 710[label="",style="dashed", color="magenta", weight=3];
706 -> 711[label="",style="dashed", color="magenta", weight=3];
707[label="List.nubByNubBy'1 xw48 xw49 xw50 (xw51 : xw52) False",fontsize=16,color="black",shape="box"];707 -> 712[label="",style="solid", color="black", weight=3];
708[label="List.nubByNubBy' xw48 (xw500 : xw501) (xw51 : xw52)",fontsize=16,color="black",shape="box"];708 -> 713[label="",style="solid", color="black", weight=3];
709[label="List.nubByNubBy' xw48 [] (xw51 : xw52)",fontsize=16,color="black",shape="box"];709 -> 714[label="",style="solid", color="black", weight=3];
710[label="xw48 xw540 xw49",fontsize=16,color="green",shape="box"];710 -> 715[label="",style="dashed", color="green", weight=3];
710 -> 716[label="",style="dashed", color="green", weight=3];
711[label="xw541",fontsize=16,color="green",shape="box"];712[label="List.nubByNubBy'0 xw48 xw49 xw50 (xw51 : xw52) otherwise",fontsize=16,color="black",shape="box"];712 -> 717[label="",style="solid", color="black", weight=3];
713[label="List.nubByNubBy'2 xw48 (xw500 : xw501) (xw51 : xw52)",fontsize=16,color="black",shape="box"];713 -> 718[label="",style="solid", color="black", weight=3];
714[label="List.nubByNubBy'3 xw48 [] (xw51 : xw52)",fontsize=16,color="black",shape="box"];714 -> 719[label="",style="solid", color="black", weight=3];
715[label="xw540",fontsize=16,color="green",shape="box"];716[label="xw49",fontsize=16,color="green",shape="box"];717[label="List.nubByNubBy'0 xw48 xw49 xw50 (xw51 : xw52) True",fontsize=16,color="black",shape="box"];717 -> 720[label="",style="solid", color="black", weight=3];
718 -> 701[label="",style="dashed", color="red", weight=0];
718[label="List.nubByNubBy'1 xw48 xw500 xw501 (xw51 : xw52) (List.elem_by xw48 xw500 (xw51 : xw52))",fontsize=16,color="magenta"];718 -> 721[label="",style="dashed", color="magenta", weight=3];
718 -> 722[label="",style="dashed", color="magenta", weight=3];
718 -> 723[label="",style="dashed", color="magenta", weight=3];
719[label="[]",fontsize=16,color="green",shape="box"];720[label="xw49 : List.nubByNubBy' xw48 xw50 (xw49 : xw51 : xw52)",fontsize=16,color="green",shape="box"];720 -> 724[label="",style="dashed", color="green", weight=3];
721[label="xw500",fontsize=16,color="green",shape="box"];722[label="xw501",fontsize=16,color="green",shape="box"];723[label="xw51 : xw52",fontsize=16,color="green",shape="box"];724 -> 705[label="",style="dashed", color="red", weight=0];
724[label="List.nubByNubBy' xw48 xw50 (xw49 : xw51 : xw52)",fontsize=16,color="magenta"];724 -> 725[label="",style="dashed", color="magenta", weight=3];
724 -> 726[label="",style="dashed", color="magenta", weight=3];
725[label="xw51 : xw52",fontsize=16,color="green",shape="box"];726[label="xw49",fontsize=16,color="green",shape="box"];}

----------------------------------------

(10)
Complex Obligation (AND)

----------------------------------------

(11)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_foldl(xw3, :(xw4110, xw4111), ba) -> new_foldl(xw3, xw4111, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(12) QDPSizeChangeProof (EQUIVALENT)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. 

From the DPs we obtained the following set of size-change graphs:
*new_foldl(xw3, :(xw4110, xw4111), ba) -> new_foldl(xw3, xw4111, ba)
The graph contains the following edges 1 >= 1, 2 > 2, 3 >= 3


----------------------------------------

(13)
YES

----------------------------------------

(14)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_psPs(:(xw411111110, xw411111111), xw15, ba) -> new_psPs(xw411111111, xw15, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(15) QDPSizeChangeProof (EQUIVALENT)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. 

From the DPs we obtained the following set of size-change graphs:
*new_psPs(:(xw411111110, xw411111111), xw15, ba) -> new_psPs(xw411111111, xw15, ba)
The graph contains the following edges 1 > 1, 2 >= 2, 3 >= 3


----------------------------------------

(16)
YES

----------------------------------------

(17)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_nubByNubBy'(xw48, :(xw500, xw501), xw51, xw52, ba) -> new_nubByNubBy'1(xw48, xw500, xw501, xw51, xw52, :(xw51, xw52), ba)
   new_nubByNubBy'1(xw48, xw49, xw50, xw51, xw52, :(xw540, xw541), ba) -> new_nubByNubBy'10(xw48, xw49, xw50, xw51, xw52, xw541, ba)
   new_nubByNubBy'10(xw48, xw49, xw50, xw51, xw52, [], ba) -> new_nubByNubBy'(xw48, xw50, xw49, :(xw51, xw52), ba)
   new_nubByNubBy'10(xw48, xw49, :(xw500, xw501), xw51, xw52, xw54, ba) -> new_nubByNubBy'1(xw48, xw500, xw501, xw51, xw52, :(xw51, xw52), ba)
   new_nubByNubBy'1(xw48, xw49, xw50, xw51, xw52, [], ba) -> new_nubByNubBy'(xw48, xw50, xw49, :(xw51, xw52), ba)
   new_nubByNubBy'10(xw48, xw49, xw50, xw51, xw52, :(xw540, xw541), ba) -> new_nubByNubBy'10(xw48, xw49, xw50, xw51, xw52, xw541, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(18) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
----------------------------------------

(19)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_nubByNubBy'1(xw48, xw49, xw50, xw51, xw52, :(xw540, xw541), ba) -> new_nubByNubBy'10(xw48, xw49, xw50, xw51, xw52, xw541, ba)
   new_nubByNubBy'10(xw48, xw49, xw50, xw51, xw52, [], ba) -> new_nubByNubBy'(xw48, xw50, xw49, :(xw51, xw52), ba)
   new_nubByNubBy'(xw48, :(xw500, xw501), xw51, xw52, ba) -> new_nubByNubBy'1(xw48, xw500, xw501, xw51, xw52, :(xw51, xw52), ba)
   new_nubByNubBy'10(xw48, xw49, :(xw500, xw501), xw51, xw52, xw54, ba) -> new_nubByNubBy'1(xw48, xw500, xw501, xw51, xw52, :(xw51, xw52), ba)
   new_nubByNubBy'10(xw48, xw49, xw50, xw51, xw52, :(xw540, xw541), ba) -> new_nubByNubBy'10(xw48, xw49, xw50, xw51, xw52, xw541, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(20) TransformationProof (EQUIVALENT)
By instantiating [LPAR04] the rule new_nubByNubBy'1(xw48, xw49, xw50, xw51, xw52, :(xw540, xw541), ba) -> new_nubByNubBy'10(xw48, xw49, xw50, xw51, xw52, xw541, ba) we obtained the following new rules [LPAR04]:

   (new_nubByNubBy'1(z0, z1, z2, z3, z4, :(z3, z4), z5) -> new_nubByNubBy'10(z0, z1, z2, z3, z4, z4, z5),new_nubByNubBy'1(z0, z1, z2, z3, z4, :(z3, z4), z5) -> new_nubByNubBy'10(z0, z1, z2, z3, z4, z4, z5))


----------------------------------------

(21)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_nubByNubBy'10(xw48, xw49, xw50, xw51, xw52, [], ba) -> new_nubByNubBy'(xw48, xw50, xw49, :(xw51, xw52), ba)
   new_nubByNubBy'(xw48, :(xw500, xw501), xw51, xw52, ba) -> new_nubByNubBy'1(xw48, xw500, xw501, xw51, xw52, :(xw51, xw52), ba)
   new_nubByNubBy'10(xw48, xw49, :(xw500, xw501), xw51, xw52, xw54, ba) -> new_nubByNubBy'1(xw48, xw500, xw501, xw51, xw52, :(xw51, xw52), ba)
   new_nubByNubBy'10(xw48, xw49, xw50, xw51, xw52, :(xw540, xw541), ba) -> new_nubByNubBy'10(xw48, xw49, xw50, xw51, xw52, xw541, ba)
   new_nubByNubBy'1(z0, z1, z2, z3, z4, :(z3, z4), z5) -> new_nubByNubBy'10(z0, z1, z2, z3, z4, z4, z5)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(22) QDPSizeChangeProof (EQUIVALENT)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. 

From the DPs we obtained the following set of size-change graphs:
*new_nubByNubBy'(xw48, :(xw500, xw501), xw51, xw52, ba) -> new_nubByNubBy'1(xw48, xw500, xw501, xw51, xw52, :(xw51, xw52), ba)
The graph contains the following edges 1 >= 1, 2 > 2, 2 > 3, 3 >= 4, 4 >= 5, 5 >= 7


*new_nubByNubBy'1(z0, z1, z2, z3, z4, :(z3, z4), z5) -> new_nubByNubBy'10(z0, z1, z2, z3, z4, z4, z5)
The graph contains the following edges 1 >= 1, 2 >= 2, 3 >= 3, 4 >= 4, 6 > 4, 5 >= 5, 6 > 5, 5 >= 6, 6 > 6, 7 >= 7


*new_nubByNubBy'10(xw48, xw49, xw50, xw51, xw52, :(xw540, xw541), ba) -> new_nubByNubBy'10(xw48, xw49, xw50, xw51, xw52, xw541, ba)
The graph contains the following edges 1 >= 1, 2 >= 2, 3 >= 3, 4 >= 4, 5 >= 5, 6 > 6, 7 >= 7


*new_nubByNubBy'10(xw48, xw49, xw50, xw51, xw52, [], ba) -> new_nubByNubBy'(xw48, xw50, xw49, :(xw51, xw52), ba)
The graph contains the following edges 1 >= 1, 3 >= 2, 2 >= 3, 7 >= 5


*new_nubByNubBy'10(xw48, xw49, :(xw500, xw501), xw51, xw52, xw54, ba) -> new_nubByNubBy'1(xw48, xw500, xw501, xw51, xw52, :(xw51, xw52), ba)
The graph contains the following edges 1 >= 1, 3 > 2, 3 > 3, 4 >= 4, 5 >= 5, 7 >= 7


----------------------------------------

(23)
YES

----------------------------------------

(24)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_deleteBy(xw3, xw4110, :(xw180, xw181), ba) -> new_deleteBy0(xw181, xw180, xw3, xw4110, ba)
   new_deleteBy0(xw181, xw180, xw3, xw4110, ba) -> new_deleteBy(xw3, xw4110, xw181, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(25) QDPSizeChangeProof (EQUIVALENT)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. 

From the DPs we obtained the following set of size-change graphs:
*new_deleteBy0(xw181, xw180, xw3, xw4110, ba) -> new_deleteBy(xw3, xw4110, xw181, ba)
The graph contains the following edges 3 >= 1, 4 >= 2, 1 >= 3, 5 >= 4


*new_deleteBy(xw3, xw4110, :(xw180, xw181), ba) -> new_deleteBy0(xw181, xw180, xw3, xw4110, ba)
The graph contains the following edges 3 > 1, 3 > 2, 1 >= 3, 2 >= 4, 4 >= 5


----------------------------------------

(26)
YES