/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, 3 ms]
(8) HASKELL
(9) LetRed [EQUIVALENT, 0 ms]
(10) HASKELL
(11) NumRed [SOUND, 14 ms]
(12) HASKELL


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

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

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

(1) LR (EQUIVALENT)
Lambda Reductions:
The following Lambda expression
"\(q,_)->q"
is transformed to
"q1 (q,_) = q;
"
The following Lambda expression
"\(_,r)->r"
is transformed to
"r0 (_,r) = r;
"
The following Lambda expression
"\(m,_)->m"
is transformed to
"m0 (m,_) = m;
"

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

(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;
"

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

(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
"frac@(Float wv ww)"
is replaced by the following term
"Float wv ww"
The bind variable of the following binding Pattern
"frac@(Double wy wz)"
is replaced by the following term
"Double wy wz"

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

(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);
"
"takeWhile1 p x xs True = x : takeWhile p xs;
takeWhile1 p x xs False = takeWhile0 p x xs otherwise;
"
"takeWhile0 p x xs True = [];
"
"takeWhile2 p (x : xs) = takeWhile1 p x xs (p x);
"
"takeWhile3 p [] = [];
takeWhile3 yu yv = takeWhile2 yu yv;
"
The following Function with conditions
"p |n' >= nflip (<=) m|otherwiseflip (>=) m;
"
is transformed to
"p  = p2;
"
"p0 True = flip (>=) m;
"
"p1 True = flip (<=) m;
p1 False = p0 otherwise;
"
"p2  = p1 (n' >= n);
"
The following Function with conditions
"undefined |Falseundefined;
"
is transformed to
"undefined  = undefined1;
"
"undefined0 True = undefined;
"
"undefined1  = undefined0 False;
"
The following Function with conditions
"toEnum 0 = False;
toEnum 1 = True;
"
is transformed to
"toEnum yx = toEnum3 yx;
toEnum yw = toEnum1 yw;
"
"toEnum0 True yw = True;
"
"toEnum1 yw = toEnum0 (yw == 1) yw;
"
"toEnum2 True yx = False;
toEnum2 yy yz = toEnum1 yz;
"
"toEnum3 yx = toEnum2 (yx == 0) yx;
toEnum3 zu = toEnum1 zu;
"
The following Function with conditions
"toEnum 0 = ();
"
is transformed to
"toEnum zv = toEnum5 zv;
"
"toEnum4 True zv = ();
"
"toEnum5 zv = toEnum4 (zv == 0) zv;
"
The following Function with conditions
"toEnum 0 = LT;
toEnum 1 = EQ;
toEnum 2 = GT;
"
is transformed to
"toEnum vuv = toEnum11 vuv;
toEnum zx = toEnum9 zx;
toEnum zw = toEnum7 zw;
"
"toEnum6 True zw = GT;
"
"toEnum7 zw = toEnum6 (zw == 2) zw;
"
"toEnum8 True zx = EQ;
toEnum8 zy zz = toEnum7 zz;
"
"toEnum9 zx = toEnum8 (zx == 1) zx;
toEnum9 vuu = toEnum7 vuu;
"
"toEnum10 True vuv = LT;
toEnum10 vuw vux = toEnum9 vux;
"
"toEnum11 vuv = toEnum10 (vuv == 0) vuv;
toEnum11 vuy = toEnum9 vuy;
"

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

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

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

(9) LetRed (EQUIVALENT)
Let/Where Reductions:
The bindings of the following Let/Where expression
"takeWhile p (numericEnumFromThen n n') where {
p  = p2;
;
p0 True = flip (>=) m;
;
p1 True = flip (<=) m;
p1 False = p0 otherwise;
;
p2  = p1 (n' >= n);
} 
"
are unpacked to the following functions on top level
"numericEnumFromThenToP2 vuz vvu vvv = numericEnumFromThenToP1 vuz vvu vvv (vuz >= vvu);
"
"numericEnumFromThenToP vuz vvu vvv = numericEnumFromThenToP2 vuz vvu vvv;
"
"numericEnumFromThenToP0 vuz vvu vvv True = flip (>=) vvv;
"
"numericEnumFromThenToP1 vuz vvu vvv True = flip (<=) vvv;
numericEnumFromThenToP1 vuz vvu vvv False = numericEnumFromThenToP0 vuz vvu vvv otherwise;
"
The bindings of the following Let/Where expression
"(fromIntegral q,r :% y) where {
q  = q1 vu30;
;
q1 (q,xu) = q;
;
r  = r0 vu30;
;
r0 (xv,r) = r;
;
vu30  = quotRem x y;
} 
"
are unpacked to the following functions on top level
"properFractionR0 vvw vvx (xv,r) = r;
"
"properFractionQ1 vvw vvx (q,xu) = q;
"
"properFractionQ vvw vvx = properFractionQ1 vvw vvx (properFractionVu30 vvw vvx);
"
"properFractionR vvw vvx = properFractionR0 vvw vvx (properFractionVu30 vvw vvx);
"
"properFractionVu30 vvw vvx = quotRem vvw vvx;
"
The bindings of the following Let/Where expression
"m where {
m  = m0 vu6;
;
m0 (m,xx) = m;
;
vu6  = properFraction x;
} 
"
are unpacked to the following functions on top level
"truncateVu6 vvy = properFraction vvy;
"
"truncateM vvy = truncateM0 vvy (truncateVu6 vvy);
"
"truncateM0 vvy (m,xx) = m;
"

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

(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;
}