```
Test 1: typical mistakes

Problem 2: naive interval computations should be applied to the
original function, NOT to its transformed form; when you make a
transformation, the function remains the same but the result of
applying naive interval computation changes. For example, for
f(x)=2x-x, if you apply it to x=[0,1], you get
2[0,1]-[0,1]=[0,1]-[0,1]=[-1,2], but for the equivalent form
f(x)=x, we get a different answer [0,1]. Both are correct in the
sense that both are enclosures

Problem 3: I explicitly asked to apply naive interval computations
only when the function is NOT monotonic, and it happens to be
monotonic, so you should apply the fact that for a monotonic
function on the interval [a,b], the range is [f(a),f(b)] (when
increasing) or [f(b),f(a)] (if decreasing)

Problem 4:

* On centered form with checking monotonicity first, if you checked
and the function is monotonic, you get its range, there is no need
to apply centered form

* Once you have ranges for both subintervals, you need to take the
union of these ranges to get the range on the original interval

Problem 5: for x1 on [a1,b1], either x1 = a1, or x1 = b1, or the
partial derivative with respect to x1 is equal to 0; similar, for
x2, we have 3 similar options, so we need to consider 9 possible
cases, they nicely fit into the table, when 3 cases for x1 are
rows and 3 cases for x2 are columns

Problem 7: the task was NOT to find the range, but to LOCATE the
maximum, i.e., to find the values x at which maximum can be
attained, we did that by dismissing some subintervals; in this
particular case, since the function is increasing on each
subinterval, we dismiss all subinterval except for its right-end
point; out of two right-end points, the first one is smaller than
maximum so far, so we end up with a single location x = 0

Problem 8: you bisect ONLY when after the whole cycle, i.e., after
applying ALL the rules, you get the same intervals for all the
unknown. Bisection doubles the time, so if you apply it every time
for n steps, you need 2^n steps - which makes the algorithm not
feasible. DO NOT bisect over ALL intervals - this again leads to
2^n cases and is, thus, in general, not feasible, you only bisect
over ONE of the variables ```