/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) IFR [EQUIVALENT, 0 ms]
(4) HASKELL
(5) BR [EQUIVALENT, 0 ms]
(6) HASKELL
(7) COR [EQUIVALENT, 6 ms]
(8) HASKELL
(9) LetRed [EQUIVALENT, 0 ms]
(10) HASKELL
(11) NumRed [SOUND, 1 ms]
(12) 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) IFR (EQUIVALENT)
If Reductions:
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;
"

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

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

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

(5) 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"

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

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

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

(7) 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 zv zw = takeWhile2 zv zw;
"
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) vuz = emEm5 (x : vv) vuz;
!! (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 zz vuu = emEm0 zz vuu;
"
"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 vuw vux = emEm1 vuw vux;
"
"emEm4 True (x : vv) vuz = x;
emEm4 vvu vvv vvw = emEm3 vvv vvw;
"
"emEm5 (x : vv) vuz = emEm4 (vuz == 0) (x : vv) vuz;
emEm5 vvx vvy = emEm3 vvx vvy;
"
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 wwu = showLitChar22 wwu;
showLitChar wvw = showLitChar20 wvw;
showLitChar c = showLitChar18 c;
showLitChar wux = showLitChar16 wux;
showLitChar vzz = showLitChar14 vzz;
showLitChar vzv = showLitChar12 vzv;
showLitChar vyx = showLitChar10 vyx;
showLitChar vxz = showLitChar8 vxz;
showLitChar vxv = showLitChar6 vxv;
showLitChar vwx = showLitChar4 vwx;
showLitChar vvz = showLitChar2 vvz;
showLitChar c = showLitChar0 c;
"
"showLitChar0 c = showString ('\' : snd (asciiTab !! (fromEnum c)));
"
"showLitChar1 True vvz = protectEsc ('H' ==) (showString ('\' : 'S' : 'O' : []));
showLitChar1 vwu vwv = showLitChar0 vwv;
"
"showLitChar2 vvz = showLitChar1 (vvz == '\14') vvz;
showLitChar2 vww = showLitChar0 vww;
"
"showLitChar3 True vwx = showString ('\' : 'v' : []);
showLitChar3 vwy vwz = showLitChar2 vwz;
"
"showLitChar4 vwx = showLitChar3 (vwx == '\11') vwx;
showLitChar4 vxu = showLitChar2 vxu;
"
"showLitChar5 True vxv = showString ('\' : 't' : []);
showLitChar5 vxw vxx = showLitChar4 vxx;
"
"showLitChar6 vxv = showLitChar5 (vxv == '\9') vxv;
showLitChar6 vxy = showLitChar4 vxy;
"
"showLitChar7 True vxz = showString ('\' : 'r' : []);
showLitChar7 vyu vyv = showLitChar6 vyv;
"
"showLitChar8 vxz = showLitChar7 (vxz == '\13') vxz;
showLitChar8 vyw = showLitChar6 vyw;
"
"showLitChar9 True vyx = showString ('\' : 'n' : []);
showLitChar9 vyy vyz = showLitChar8 vyz;
"
"showLitChar10 vyx = showLitChar9 (vyx == '\10') vyx;
showLitChar10 vzu = showLitChar8 vzu;
"
"showLitChar11 True vzv = showString ('\' : 'f' : []);
showLitChar11 vzw vzx = showLitChar10 vzx;
"
"showLitChar12 vzv = showLitChar11 (vzv == '\12') vzv;
showLitChar12 vzy = showLitChar10 vzy;
"
"showLitChar13 True vzz = showString ('\' : 'b' : []);
showLitChar13 wuu wuv = showLitChar12 wuv;
"
"showLitChar14 vzz = showLitChar13 (vzz == '\8') vzz;
showLitChar14 wuw = showLitChar12 wuw;
"
"showLitChar15 True wux = showString ('\' : 'a' : []);
showLitChar15 wuy wuz = showLitChar14 wuz;
"
"showLitChar16 wux = showLitChar15 (wux == '\7') wux;
showLitChar16 wvu = showLitChar14 wvu;
"
"showLitChar17 c True = showChar c;
showLitChar17 c False = showLitChar16 c;
"
"showLitChar18 c = showLitChar17 c (c >= '\32');
showLitChar18 wvv = showLitChar16 wvv;
"
"showLitChar19 True wvw = showString ('\' : '\' : []);
showLitChar19 wvx wvy = showLitChar18 wvy;
"
"showLitChar20 wvw = showLitChar19 (wvw == '\') wvw;
showLitChar20 wvz = showLitChar18 wvz;
"
"showLitChar21 True wwu = showString ('\' : 'D' : 'E' : 'L' : []);
showLitChar21 wwv www = showLitChar20 www;
"
"showLitChar22 wwu = showLitChar21 (wwu == '\127') wwu;
showLitChar22 wwx = showLitChar20 wwx;
"
"showLitChar23 c True = (showChar '\') . protectEsc isDigit (shows (fromEnum c));
showLitChar23 c False = showLitChar22 c;
"
"showLitChar24 c = showLitChar23 c (c > '\127');
showLitChar24 wwy = showLitChar22 wwy;
"
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 wxu = cont0 wxu;
"
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 wxv = showsPrec2 p wxv;
showsPrec p c = showsPrec0 p c;
"
"showsPrec0 p c = (showChar ''') . (showLitChar c) . showChar ''';
"
"showsPrec1 True p wxv = showString (''' : '\' : ''' : ''' : []);
showsPrec1 wxw wxx wxy = showsPrec0 wxx wxy;
"
"showsPrec2 p wxv = showsPrec1 (wxv == ''') p wxv;
showsPrec2 wxz wyu = showsPrec0 wxz wyu;
"

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

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

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

(9) 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 wxu = cont0 wxu;
} 
"
are unpacked to the following functions on top level
"protectEscCont2 wyv (ww : wx) = protectEscCont1 wyv ww wx (wyv ww);
protectEscCont2 wyv wxu = protectEscCont0 wyv wxu;
"
"protectEscCont wyv (ww : wx) = protectEscCont2 wyv (ww : wx);
protectEscCont wyv s = protectEscCont0 wyv s;
"
"protectEscCont0 wyv s = s;
"
"protectEscCont1 wyv ww wx True = ('\' : '&' : []) ++ ww : wx;
protectEscCont1 wyv ww wx False = protectEscCont0 wyv (ww : wx);
"

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

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

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

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

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