# How to get the boolean value of an inequality involving an InterpolatingFunction?

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

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

• Huh? "seems not to work" is correct? I just delete it because of my language sense…OK, let me add it back. Aug 6, 2012 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. Aug 6, 2012 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 囧. Aug 6, 2012 at 6:47

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

yin = InterpolatingPolynomial[Transpose[Flatten /@ {yan[],yan[]}],x];
FullSimplify[yin > -1, -1 < x < 1]
(*True*)


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

FullForm[yan] so I can extract them with Transpose[Flatten /@ {yan[],yan[]}] 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.

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.

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

yin = InterpolatingPolynomial[Transpose[Flatten /@
{InterpolatingFunctionCoordinates@yan,
InterpolatingFunctionValuesOnGrid@yan}], x];
FullSimplify[yin > -1, -1 < x < 1]
(*
True
*)

• very nice. how come I have less votes than you though, despite being first and explaining details?! Not fair! :)
– acl
Aug 5, 2012 at 19:38
• @acl That was because I forgot to upvote your answer. Easy to correct! :D Aug 5, 2012 at 19:40
• really, I was joking!
– acl
Aug 5, 2012 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! Aug 5, 2012 at 23:48
• @J.M. yes, it was intended just for this case Aug 5, 2012 at 23:52

Today I ocasionally recall this question I asked 10 years ago, and notice nowadays ResourceFunction["InterpolatingFunctionToPiecewise"] or InterpolationToPiecewise in this post seems to be the best choice to resolve the problem:

yan = FunctionInterpolation[x^2, {x, -1, 1}];
yanAnalytic = ResourceFunction["InterpolatingFunctionToPiecewise"][yan, x]
FullSimplify[yanAnalytic > -1, -1 < x < 1]
(* True *)


This method perfectly handles the troublesome case shown by J.M., too:

func = FunctionInterpolation[1/(1 + x^2), {x, -2, 2}];
funcAnalytic = ResourceFunction["InterpolatingFunctionToPiecewise"][func, x];
Simplify[funcAnalytic < 3/2, -2 < x < 2]
(* True *)


BTW, I don't evaluate my MinValue method in the question as the best, because it's essentially a numeric method. MinValue has secretly called NMinimize internally!:

Trace[MinValue[{yan[x], -1 < x < 1}, x], __NMinimize, TraceInternal -> True] 