Mathematica Stack Exchange is a question and answer site for users of Mathematica. Join them; it only takes a minute:

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top

Here's the code:

yan = FunctionInterpolation[x^2, {x, -1, 1}];
FullSimplify[yan[x] > -1, -1 < x < 1]

Needless to say, what I expect to see in the output is "True", but FullSimplify doesn't seem to work. What function should I turn to?

@J.M. @belisarius @acl

囧…A very simple solution suddenly struck me, it is:

yan = FunctionInterpolation[x^2, {x, -1, 1}];
MinValue[{yan[x], -1 < x < 1},x]>-1
share|improve this question
Huh? "seems not to work" is correct? I just delete it because of my language sense…OK, let me add it back. – xzczd Aug 6 '12 at 5:55
"doesn't seem to work" as you added is more standard, but in my opinion "seems not to work" is also acceptable and understandable. – Mr.Wizard Aug 6 '12 at 6:10
In fact I've become confused after I searched the Internet, so I turned to the standard form to be on the safe side 囧. – xzczd Aug 6 '12 at 6:47
up vote 5 down vote accepted

The following is basically the same @acl did, but using the package InterpolatingFunctionAnatomy which (in principle) will behave better than peeking at the internal structures when Mma version changes.

yan = FunctionInterpolation[x^2, {x, -1, 1}];

yin = InterpolatingPolynomial[Transpose[Flatten /@
                                 InterpolatingFunctionValuesOnGrid@yan}], x];
FullSimplify[yin > -1, -1 < x < 1]
share|improve this answer
very nice. how come I have less votes than you though, despite being first and explaining details?! Not fair! :) – acl Aug 5 '12 at 19:38
@acl That was because I forgot to upvote your answer. Easy to correct! :D – Dr. belisarius Aug 5 '12 at 19:40
really, I was joking! – acl Aug 5 '12 at 19:48
In fact, you don't need to load the package if you remember the actual syntax being used internally; in this case, it's yan["Coordinates"] and yan["ValuesOnGrid"] that can be used directly. Still, this works only because the original function was well approximated by a polynomial. In general, a polynomial interpolant can be more oscillatory than the piecewise polynomial interpolant used by InterpolatingFunction[]; be careful! – J. M. Aug 5 '12 at 23:48
@J.M. yes, it was intended just for this case – Dr. belisarius Aug 5 '12 at 23:52

You can do this by explicitly constructing the InterpolatingPolynomial corresponding to yan, and then using FullSimplify:

yin = InterpolatingPolynomial[Transpose[Flatten /@ {yan[[3]],yan[[4]]}],x];
FullSimplify[yin > -1, -1 < x < 1]

Why does this work? Because yan actually has a list of points:


Mathematica graphics

so I can extract them with Transpose[Flatten /@ {yan[[3]],yan[[4]]}] and use them to construct a polynomial, which does the same thing as the interpolation function but which FullSimplify can now handle.

Maybe there's a better way to construct the InterpolatingPolynomial but this works.

share|improve this answer

Your Answer


By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.