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


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


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


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

(0) HASKELL
(1) LR [EQUIVALENT, 0 ms]
(2) HASKELL
(3) CR [EQUIVALENT, 0 ms]
(4) HASKELL
(5) IFR [EQUIVALENT, 0 ms]
(6) HASKELL
(7) BR [EQUIVALENT, 2 ms]
(8) HASKELL
(9) COR [EQUIVALENT, 0 ms]
(10) HASKELL
(11) LetRed [EQUIVALENT, 0 ms]
(12) HASKELL
(13) NumRed [SOUND, 29 ms]
(14) HASKELL


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

(0)
Obligation:
mainModule Main 
module Main where {
import qualified Prelude;
}

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

(1) LR (EQUIVALENT)
Lambda Reductions:
The following Lambda expression
"\ab->(a,b)"
is transformed to
"zip0 a b = (a,b);
"

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

(2)
Obligation:
mainModule Main 
module Main where {
import qualified Prelude;
}

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

(3) CR (EQUIVALENT)
Case Reductions:
The following Case expression
"case loc of {
[]  -> id;
_  -> (showString ('\10' : 'A' : 'c' : 't' : 'i' : 'o' : 'n' : ':' : '\32' : [])) . showString loc}
"
is transformed to
"showsPrec0 loc [] = id;
showsPrec0 loc _ = (showString ('\10' : 'A' : 'c' : 't' : 'i' : 'o' : 'n' : ':' : '\32' : [])) . showString loc;
"
The following Case expression
"case descr of {
[]  -> id;
_  -> (showString ('\10' : 'R' : 'e' : 'a' : 's' : 'o' : 'n' : ':' : '\32' : [])) . showString descr}
"
is transformed to
"showsPrec1 descr [] = id;
showsPrec1 descr _ = (showString ('\10' : 'R' : 'e' : 'a' : 's' : 'o' : 'n' : ':' : '\32' : [])) . showString descr;
"
The following Case expression
"case mbFile of {
Nothing  -> id;
Just name  -> (showString ('\10' : 'R' : 'e' : 's' : 'o' : 'u' : 'r' : 'c' : 'e' : ':' : '\32' : [])) . showString name}
"
is transformed to
"showsPrec2 Nothing = id;
showsPrec2 (Just name) = (showString ('\10' : 'R' : 'e' : 's' : 'o' : 'u' : 'r' : 'c' : 'e' : ':' : '\32' : [])) . showString name;
"
The following Case expression
"case x of {
IOError_UserError  -> 'U' : 'E' : [];
IOError_IllegalError  -> 'I' : 'O' : [];
IOError_PermDenied  -> 'P' : 'D' : [];
IOError_AlreadyExists  -> 'A' : 'E' : [];
IOError_AlreadyInUse  -> 'R' : 'B' : [];
IOError_DoesNotExist  -> 'D' : 'N' : 'E' : [];
IOError_FullError  -> 'R' : 'E' : [];
IOError_EOF  -> 'E' : 'O' : 'F' : [];
IOError_WriteError  -> 'W' : 'E' : []}
"
is transformed to
"show0 IOError_UserError = 'U' : 'E' : [];
show0 IOError_IllegalError = 'I' : 'O' : [];
show0 IOError_PermDenied = 'P' : 'D' : [];
show0 IOError_AlreadyExists = 'A' : 'E' : [];
show0 IOError_AlreadyInUse = 'R' : 'B' : [];
show0 IOError_DoesNotExist = 'D' : 'N' : 'E' : [];
show0 IOError_FullError = 'R' : 'E' : [];
show0 IOError_EOF = 'E' : 'O' : 'F' : [];
show0 IOError_WriteError = 'W' : 'E' : [];
"

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

(4)
Obligation:
mainModule Main 
module Main where {
import qualified Prelude;
}

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

(5) IFR (EQUIVALENT)
If Reductions:
The following If expression
"if b then (showChar '(') . p . showChar ')' else p"
is transformed to
"showParen0 p True = (showChar '(') . p . showChar ')';
showParen0 p False = p;
"
The following If expression
"if primGEqNatS x y then Succ (primDivNatS (primMinusNatS x y) (Succ y)) else Zero"
is transformed to
"primDivNatS0 x y True = Succ (primDivNatS (primMinusNatS x y) (Succ y));
primDivNatS0 x y False = Zero;
"
The following If expression
"if primGEqNatS x y then primModNatS (primMinusNatS x y) (Succ y) else Succ x"
is transformed to
"primModNatS0 x y True = primModNatS (primMinusNatS x y) (Succ y);
primModNatS0 x y False = Succ x;
"
The following If expression
"if primGEqNatS x y then primModNatP (primMinusNatS x y) (Succ y) else primMinusNatS y x"
is transformed to
"primModNatP0 x y True = primModNatP (primMinusNatS x y) (Succ y);
primModNatP0 x y False = primMinusNatS y x;
"

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

(6)
Obligation:
mainModule Main 
module Main where {
import qualified Prelude;
}

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

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

Binding Reductions:
The bind variable of the following binding Pattern
"s@(ww : wx)"
is replaced by the following term
"ww : wx"

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

(8)
Obligation:
mainModule Main 
module Main where {
import qualified Prelude;
}

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

(9) COR (EQUIVALENT)
Cond Reductions:
The following Function with conditions
"takeWhile p [] = [];
takeWhile p (x : xs)|p xx : takeWhile p xs|otherwise[];
"
is transformed to
"takeWhile p [] = takeWhile3 p [];
takeWhile p (x : xs) = takeWhile2 p (x : xs);
"
"takeWhile0 p x xs True = [];
"
"takeWhile1 p x xs True = x : takeWhile p xs;
takeWhile1 p x xs False = takeWhile0 p x xs otherwise;
"
"takeWhile2 p (x : xs) = takeWhile1 p x xs (p x);
"
"takeWhile3 p [] = [];
takeWhile3 zy zz = takeWhile2 zy zz;
"
The following Function with conditions
"!! (x : vv) 0 = x;
!! (vw : xs) n|n > 0xs !! (n - 1);
!! (vx : vy) vz = error [];
!! [] wu = error [];
"
is transformed to
"!! (x : vv) vvw = emEm5 (x : vv) vvw;
!! (vw : xs) n = emEm3 (vw : xs) n;
!! (vx : vy) vz = emEm1 (vx : vy) vz;
!! [] wu = emEm0 [] wu;
"
"emEm0 [] wu = error [];
"
"emEm1 (vx : vy) vz = error [];
emEm1 vuw vux = emEm0 vuw vux;
"
"emEm2 vw xs n True = xs !! (n - 1);
emEm2 vw xs n False = emEm1 (vw : xs) n;
"
"emEm3 (vw : xs) n = emEm2 vw xs n (n > 0);
emEm3 vuz vvu = emEm1 vuz vvu;
"
"emEm4 True (x : vv) vvw = x;
emEm4 vvx vvy vvz = emEm3 vvy vvz;
"
"emEm5 (x : vv) vvw = emEm4 (vvw == 0) (x : vv) vvw;
emEm5 vwu vwv = emEm3 vwu vwv;
"
The following Function with conditions
"showLitChar c|c > '\127'(showChar '\') . protectEsc isDigit (shows (fromEnum c));
showLitChar '\127' = showString ('\' : 'D' : 'E' : 'L' : []);
showLitChar '\' = showString ('\' : '\' : []);
showLitChar c|c >= '\32'showChar c;
showLitChar '\7' = showString ('\' : 'a' : []);
showLitChar '\8' = showString ('\' : 'b' : []);
showLitChar '\12' = showString ('\' : 'f' : []);
showLitChar '\10' = showString ('\' : 'n' : []);
showLitChar '\13' = showString ('\' : 'r' : []);
showLitChar '\9' = showString ('\' : 't' : []);
showLitChar '\11' = showString ('\' : 'v' : []);
showLitChar '\14' = protectEsc ('H' ==) (showString ('\' : 'S' : 'O' : []));
showLitChar c = showString ('\' : snd (asciiTab !! (fromEnum c)));
"
is transformed to
"showLitChar c = showLitChar24 c;
showLitChar wwx = showLitChar22 wwx;
showLitChar wvz = showLitChar20 wvz;
showLitChar c = showLitChar18 c;
showLitChar wvu = showLitChar16 wvu;
showLitChar wuw = showLitChar14 wuw;
showLitChar vzy = showLitChar12 vzy;
showLitChar vzu = showLitChar10 vzu;
showLitChar vyw = showLitChar8 vyw;
showLitChar vxy = showLitChar6 vxy;
showLitChar vxu = showLitChar4 vxu;
showLitChar vww = showLitChar2 vww;
showLitChar c = showLitChar0 c;
"
"showLitChar0 c = showString ('\' : snd (asciiTab !! (fromEnum c)));
"
"showLitChar1 True vww = protectEsc ('H' ==) (showString ('\' : 'S' : 'O' : []));
showLitChar1 vwx vwy = showLitChar0 vwy;
"
"showLitChar2 vww = showLitChar1 (vww == '\14') vww;
showLitChar2 vwz = showLitChar0 vwz;
"
"showLitChar3 True vxu = showString ('\' : 'v' : []);
showLitChar3 vxv vxw = showLitChar2 vxw;
"
"showLitChar4 vxu = showLitChar3 (vxu == '\11') vxu;
showLitChar4 vxx = showLitChar2 vxx;
"
"showLitChar5 True vxy = showString ('\' : 't' : []);
showLitChar5 vxz vyu = showLitChar4 vyu;
"
"showLitChar6 vxy = showLitChar5 (vxy == '\9') vxy;
showLitChar6 vyv = showLitChar4 vyv;
"
"showLitChar7 True vyw = showString ('\' : 'r' : []);
showLitChar7 vyx vyy = showLitChar6 vyy;
"
"showLitChar8 vyw = showLitChar7 (vyw == '\13') vyw;
showLitChar8 vyz = showLitChar6 vyz;
"
"showLitChar9 True vzu = showString ('\' : 'n' : []);
showLitChar9 vzv vzw = showLitChar8 vzw;
"
"showLitChar10 vzu = showLitChar9 (vzu == '\10') vzu;
showLitChar10 vzx = showLitChar8 vzx;
"
"showLitChar11 True vzy = showString ('\' : 'f' : []);
showLitChar11 vzz wuu = showLitChar10 wuu;
"
"showLitChar12 vzy = showLitChar11 (vzy == '\12') vzy;
showLitChar12 wuv = showLitChar10 wuv;
"
"showLitChar13 True wuw = showString ('\' : 'b' : []);
showLitChar13 wux wuy = showLitChar12 wuy;
"
"showLitChar14 wuw = showLitChar13 (wuw == '\8') wuw;
showLitChar14 wuz = showLitChar12 wuz;
"
"showLitChar15 True wvu = showString ('\' : 'a' : []);
showLitChar15 wvv wvw = showLitChar14 wvw;
"
"showLitChar16 wvu = showLitChar15 (wvu == '\7') wvu;
showLitChar16 wvx = showLitChar14 wvx;
"
"showLitChar17 c True = showChar c;
showLitChar17 c False = showLitChar16 c;
"
"showLitChar18 c = showLitChar17 c (c >= '\32');
showLitChar18 wvy = showLitChar16 wvy;
"
"showLitChar19 True wvz = showString ('\' : '\' : []);
showLitChar19 wwu wwv = showLitChar18 wwv;
"
"showLitChar20 wvz = showLitChar19 (wvz == '\') wvz;
showLitChar20 www = showLitChar18 www;
"
"showLitChar21 True wwx = showString ('\' : 'D' : 'E' : 'L' : []);
showLitChar21 wwy wwz = showLitChar20 wwz;
"
"showLitChar22 wwx = showLitChar21 (wwx == '\127') wwx;
showLitChar22 wxu = showLitChar20 wxu;
"
"showLitChar23 c True = (showChar '\') . protectEsc isDigit (shows (fromEnum c));
showLitChar23 c False = showLitChar22 c;
"
"showLitChar24 c = showLitChar23 c (c > '\127');
showLitChar24 wxv = showLitChar22 wxv;
"
The following Function with conditions
"cont (ww : wx)|p ww('\' : '&' : []) ++ ww : wx;
cont s = s;
"
is transformed to
"cont (ww : wx) = cont2 (ww : wx);
cont s = cont0 s;
"
"cont0 s = s;
"
"cont1 ww wx True = ('\' : '&' : []) ++ ww : wx;
cont1 ww wx False = cont0 (ww : wx);
"
"cont2 (ww : wx) = cont1 ww wx (p ww);
cont2 wxx = cont0 wxx;
"
The following Function with conditions
"undefined |Falseundefined;
"
is transformed to
"undefined  = undefined1;
"
"undefined0 True = undefined;
"
"undefined1  = undefined0 False;
"
The following Function with conditions
"showsPrec p ''' = showString (''' : '\' : ''' : ''' : []);
showsPrec p c = (showChar ''') . (showLitChar c) . showChar ''';
"
is transformed to
"showsPrec p wxy = showsPrec5 p wxy;
showsPrec p c = showsPrec3 p c;
"
"showsPrec3 p c = (showChar ''') . (showLitChar c) . showChar ''';
"
"showsPrec4 True p wxy = showString (''' : '\' : ''' : ''' : []);
showsPrec4 wxz wyu wyv = showsPrec3 wyu wyv;
"
"showsPrec5 p wxy = showsPrec4 (wxy == ''') p wxy;
showsPrec5 wyw wyx = showsPrec3 wyw wyx;
"
The following Function with conditions
"showl [] = showChar '"';
showl ('"' : cs) = (showString ('\' : '"' : [])) . showl cs;
showl (c : cs) = (showLitChar c) . showl cs;
"
is transformed to
"showl [] = showl3 [];
showl (wzu : cs) = showl2 (wzu : cs);
showl (c : cs) = showl0 (c : cs);
"
"showl0 (c : cs) = (showLitChar c) . showl cs;
"
"showl1 True (wzu : cs) = (showString ('\' : '"' : [])) . showl cs;
showl1 wzv wzw = showl0 wzw;
"
"showl2 (wzu : cs) = showl1 (wzu == '"') (wzu : cs);
showl2 wzx = showl0 wzx;
"
"showl3 [] = showChar '"';
showl3 wzz = showl2 wzz;
"

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

(10)
Obligation:
mainModule Main 
module Main where {
import qualified Prelude;
}

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

(11) LetRed (EQUIVALENT)
Let/Where Reductions:
The bindings of the following Let/Where expression
"f . cont where {
cont (ww : wx) = cont2 (ww : wx);
cont s = cont0 s;
;
cont0 s = s;
;
cont1 ww wx True = ('\' : '&' : []) ++ ww : wx;
cont1 ww wx False = cont0 (ww : wx);
;
cont2 (ww : wx) = cont1 ww wx (p ww);
cont2 wxx = cont0 wxx;
} 
"
are unpacked to the following functions on top level
"protectEscCont1 xuu ww wx True = ('\' : '&' : []) ++ ww : wx;
protectEscCont1 xuu ww wx False = protectEscCont0 xuu (ww : wx);
"
"protectEscCont0 xuu s = s;
"
"protectEscCont xuu (ww : wx) = protectEscCont2 xuu (ww : wx);
protectEscCont xuu s = protectEscCont0 xuu s;
"
"protectEscCont2 xuu (ww : wx) = protectEscCont1 xuu ww wx (xuu ww);
protectEscCont2 xuu wxx = protectEscCont0 xuu wxx;
"
The bindings of the following Let/Where expression
"(showChar '"') . showl cs where {
showl [] = showl3 [];
showl (wzu : cs) = showl2 (wzu : cs);
showl (c : cs) = showl0 (c : cs);
;
showl0 (c : cs) = (showLitChar c) . showl cs;
;
showl1 True (wzu : cs) = (showString ('\' : '"' : [])) . showl cs;
showl1 wzv wzw = showl0 wzw;
;
showl2 (wzu : cs) = showl1 (wzu == '"') (wzu : cs);
showl2 wzx = showl0 wzx;
;
showl3 [] = showChar '"';
showl3 wzz = showl2 wzz;
} 
"
are unpacked to the following functions on top level
"showListShowl [] = showListShowl3 [];
showListShowl (wzu : cs) = showListShowl2 (wzu : cs);
showListShowl (c : cs) = showListShowl0 (c : cs);
"
"showListShowl1 True (wzu : cs) = (showString ('\' : '"' : [])) . showListShowl cs;
showListShowl1 wzv wzw = showListShowl0 wzw;
"
"showListShowl2 (wzu : cs) = showListShowl1 (wzu == '"') (wzu : cs);
showListShowl2 wzx = showListShowl0 wzx;
"
"showListShowl3 [] = showChar '"';
showListShowl3 wzz = showListShowl2 wzz;
"
"showListShowl0 (c : cs) = (showLitChar c) . showListShowl cs;
"
The bindings of the following Let/Where expression
"(showChar '[') . (shows x) . showl xs where {
showl [] = showChar ']';
showl (x : xs) = (showChar ',') . (shows x) . showl xs;
} 
"
are unpacked to the following functions on top level
"showListShowl4 [] = showChar ']';
showListShowl4 (x : xs) = (showChar ',') . (shows x) . showListShowl4 xs;
"

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

(12)
Obligation:
mainModule Main 
module Main where {
import qualified Prelude;
}

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

(13) NumRed (SOUND)
Num Reduction:All numbers are transformed to their corresponding representation with Succ, Pred and Zero.
----------------------------------------

(14)
Obligation:
mainModule Main 
module Main where {
import qualified Prelude;
}