1 Interval arithmetic fundamentals

1.1 Interval representation and notation

Interval arithmetic models a quantity that is not known exactly by representing it as a closed real interval \([a,b]\), where \(a \le b\). The intended meaning is that the true value lies somewhere inside the interval. For a variable \(x\), the notation \(\mathbf{x}=[a,b]\) typically denotes this uncertainty set.

The interval endpoints are usually stored as floating-point numbers. The method relies on two principles: (i) every real value consistent with the inputs must be accounted for, and (ii) computations must be carried out so that any rounding effects do not exclude valid possibilities.

1.2 Containment principle (enclosure property)

The core requirement is the containment (or enclosure) property: if \(\mathbf{x}\) and \(\mathbf{y}\) are input intervals and \(f\) is an arithmetic expression, then the interval result \(\mathbf{z}\) must contain all values \(f(x,y)\) that can arise from choosing any admissible \(x \in \mathbf{x}\) and \(y \in \mathbf{y}\).

For basic operations, this is enforced by using interval-specific rules that produce lower and upper bounds that are valid for the full range of admissible inputs.

1.3 Width and midpoint concepts

Two derived quantities often summarize an interval:

  • Midpoint: \(m=(a+b)/2\), a representative “center” value.
  • Width (or radius): \(w=b-a\) or \(r=(b-a)/2\), measuring uncertainty magnitude.

Smaller width indicates tighter bounds, while larger width signals greater uncertainty or increased overestimation from computations. These concepts are particularly useful when comparing the quality of different interval results.

1.4 Rounding modes and directed rounding

Interval arithmetic is tightly connected to floating-point behavior. To guarantee enclosures, computations typically use directed rounding:

  • rounding downward for lower bounds,
  • rounding upward for upper bounds.

Many interval libraries implement primitives that compute the result with outward rounding automatically. This prevents a common failure mode where normal rounding could accidentally produce a bound that is too small (excluding a feasible value) or too large (overstating uncertainty unnecessarily).

1.5 Basic arithmetic operators on intervals

1.5.1 Addition and subtraction

For intervals \(\mathbf{x}=[a,b]\) and \(\mathbf{y}=[c,d]\):

  • Addition: \(\mathbf{x}+\mathbf{y}=[a+c,\, b+d]\).
  • Subtraction: \(\mathbf{x}-\mathbf{y}=[a-d,\, b-c]\).

These rules are exact in real arithmetic and preserve the enclosure property under outward rounding.

1.5.2 Multiplication

Multiplication depends on signs because the product of endpoints may not be the minimum or maximum. A standard rule is: \[ \mathbf{x}\cdot \mathbf{y} = \big[\min(ac,ad,bc,bd),\ \max(ac,ad,bc,bd)\big], \] again with directed rounding applied to the endpoints. This ensures the product covers all possible combinations.

1.5.3 Division and handling division by zero

Division \(\mathbf{x}/\mathbf{y}\) is defined only when the denominator interval does not include zero. If \(0\notin \mathbf{y}\), one can compute: \[ \mathbf{x}/\mathbf{y} = \mathbf{x}\cdot (1/\mathbf{y}), \] where \(1/\mathbf{y}=[1/b,\, 1/a]\) with endpoints ordered appropriately. If \(0\in \mathbf{y}\), the expression may be undefined or produce an unbounded result. Interval arithmetic treatments handle this via one of the following approaches, depending on the library and mathematical model:

  • returning a union of intervals (for methods that support it),
  • returning an interval spanning negative and positive values with infinities,
  • or raising an exception indicating division by an interval that may contain zero.

The key is that the implementation must not silently discard feasible values that arise near the problematic denominator.

2 Interval evaluation and dependency issues

2.1 Natural interval extensions

Given an expression \(g(x)\) and an interval \(\mathbf{x}\), a natural interval extension is obtained by replacing each occurrence of \(x\) by \(\mathbf{x}\) and applying the corresponding interval arithmetic operations. For example, with \(g(x)=x^2-x\), one would compute \(\mathbf{x}^2-\mathbf{x}\) using interval rules.

While this guarantees containment, it may yield bounds that are far wider than necessary because the same variable reused in multiple places is treated as independently varying within the interval.

2.2 The dependency problem

The dependency problem arises when an expression includes repeated variables. Interval arithmetic assumes each occurrence can vary independently, which can create products of ranges that cannot occur simultaneously in any real evaluation.

2.2.1 Repeated variables and overestimation

Consider \(x-x\) with \(\mathbf{x}=[0,1]\). A natural extension yields: \[ \mathbf{x}-\mathbf{x} = [0,1]-[0,1]=[-1,1], \] even though the true value is identically \(0\). This illustrates how repeated-variable dependencies inflate interval results.

Overestimation is often the dominant source of loose bounds in practical computations, especially for nonlinear expressions.

2.3 Relaxations and inclusion functions

An inclusion function for \(f\) maps an input interval to an output interval that contains all possible values of \(f\) over the input set. Natural extensions provide one inclusion function, but better ones can be constructed.

Relaxations are often used to derive inclusion functions that are closer to the true range, trading complexity for improved tightness.

2.4 Tightening strategies (simple bounds)

Tightness can be improved by applying algebraic transformations that reduce the impact of dependencies or by using basic bounding techniques:

  • factoring expressions when possible,
  • rewriting to avoid cancellation artifacts,
  • using symmetry or known sign information,
  • applying constraints (e.g., if a variable is known to be nonnegative).

Even modest restructuring can shrink widths significantly.

2.5 Monotonicity-based improvements

If a function is monotone on an interval, its image interval can be computed sharply by evaluating endpoints. For monotone increasing \(f\) on \([a,b]\), one gets \(f([a,b])=[f(a),f(b)]\); for monotone decreasing, the endpoints swap. This approach can reduce overestimation, particularly for elementary functions within restricted domains.

For general nonlinear functions, monotonicity may hold only on subintervals, motivating partitioning strategies.

3 Functions and elementary operations

3.1 Pointwise extension to functions

To extend a function \(f\) to interval inputs, interval arithmetic typically aims to compute an interval \(\mathbf{f}(\mathbf{x})\) satisfying: \[ f(x)\in \mathbf{f}(\mathbf{x})\quad\text{for all }x\in\mathbf{x}. \] This is a pointwise extension concept: rather than treating intervals as algebraic objects with new semantics, one interprets the interval result as a guaranteed range of the original function over the uncertain inputs.

3.2 Images of intervals under monotone functions

When monotonicity is established (globally or locally), interval images can be computed using endpoint evaluations. This yields bounds that are often tight relative to natural extensions, because it respects the structure of the function’s variation across the domain.

In practice, monotonicity detection or verification may be combined with interval splitting to maintain the validity of monotone assumptions.

3.3 Non-monotone functions and range bounding

Non-monotone behavior complicates range estimation. If a function attains maxima or minima inside the interval, endpoint-only evaluation can miss interior extremes. Interval methods therefore employ bounding techniques such as:

  • splitting the domain into smaller pieces where behavior is simpler,
  • using derivative information to locate potential turning points,
  • applying known global bounds for function curvature.

The goal remains enclosure with improved tightness.

3.4 Trigonometric functions and periodicity

Sine and cosine are periodic and oscillatory, making naive interval evaluation prone to severe overestimation. Sound interval extensions must account for possible phase coverage across the interval:

  • if the interval length spans enough to include a full period component, the range may become the full \([-1,1]\),
  • otherwise, bounds are derived by evaluating at relevant points that capture maxima/minima within the covered phase.

Accurate handling requires careful reasoning about periodicity and about which parts of the cycle are included.

3.5 Exponential and logarithmic bounds

The exponential function is monotone increasing over \(\mathbb{R}\), so interval images are typically computed from endpoints, producing tight bounds: \[ \exp([a,b])=[\exp(a),\exp(b)]. \] Logarithms are monotone increasing only on their natural domain of positive inputs. When \(\mathbf{x}\) includes nonpositive values, interval methods must either signal invalidity or return a result consistent with the mathematical domain restriction. When \(\mathbf{x}\subset (0,\infty)\), one can often compute tight images via endpoint logarithms.

3.6 Piecewise functions and conditional expressions

Many real-world models use conditional definitions (e.g., \(\text{if }x>0\text{ then }f_1(x)\text{ else }f_2(x)\)). Interval evaluation must account for cases where the condition may be true for some values inside the interval and false for others.

A typical approach is branching over interval subcases:

  • split the input interval according to where the condition changes,
  • evaluate each branch on the corresponding subintervals,
  • take the union (or hull) of the resulting intervals to preserve enclosure.

The complexity increases with the number of nested conditionals, so implementations often favor conservative but efficient approximations.

4 Error bounds, soundness, and correctness

4.1 Absolute vs relative enclosure quality

Interval results can be judged by how tight they are. Two common perspectives are:

  • absolute quality, related to raw width \(w\),
  • relative quality, related to width compared to magnitude (useful when values vary over orders of magnitude).

In numerical verification, relative tightness may be more meaningful than absolute width, especially for functions that scale rapidly.

4.2 Lipschitz-style reasoning (informal bounds)

While formal interval calculus does not automatically guarantee tightness, one can sometimes estimate how uncertainty propagates using smoothness properties. Lipschitz-style reasoning uses the idea that if \(f\) does not change faster than some rate on a region, then input width bounds the output width. In interval contexts, such estimates can guide algorithm design (e.g., where splitting will most reduce uncertainty).

In practice, these arguments are often informal aids rather than replacements for enclosure guarantees.

4.3 Managing floating-point uncertainty

Floating-point arithmetic introduces rounding errors beyond the interval endpoints. Interval arithmetic addresses this by:

  • outward rounding of operations,
  • using correct rounding modes in all primitives (including transcendental functions),
  • optionally inflating results by a small safety margin if the implementation cannot guarantee exact directed rounding for certain operations.

Correctness depends heavily on the quality of the underlying interval library and its transcendental function support.

4.4 Guarantees vs conservatism trade-offs

Soundness (enclosure) usually comes with conservatism (wider intervals). Tightness improves correctness in downstream tasks (e.g., proving a sign condition), but there is a computational cost associated with achieving it—such as splitting intervals or using more complex inclusion functions.

A central design tension is therefore:

  • more rigorous but slower, using finer partitions and sharper bounds,
  • faster but looser, using simpler natural extensions.

The best choice depends on the target verification goal and available resources.

4.5 Examples of verification using intervals

Interval arithmetic can verify statements such as:

  • whether a function is always positive on a domain,
  • whether a polynomial has a root inside a region,
  • whether an inequality holds for all admissible inputs.

Typically, one computes an interval for the expression; if the resulting interval is strictly above (or below) zero, the inequality is guaranteed. If the interval straddles zero, the method is inconclusive, not incorrect—often suggesting the need for refinement (e.g., splitting the domain).

5 Computational aspects

5.1 Algorithmic complexity considerations

The computational cost of interval arithmetic grows with:

  • the number of operations and transcendental calls,
  • the frequency of interval splitting (when used),
  • the precision of endpoints,
  • and dependency management strategies that reduce overestimation.

In many workflows, the dominant expense is not arithmetic itself but the control logic for refinement and the handling of many subintervals.

5.2 Overestimation control tactics

Common tactics to control width include:

  • splitting the input interval into smaller parts,
  • selecting inclusion functions that respect monotonicity,
  • rewriting expressions to reduce repeated-variable effects,
  • using constraint propagation to narrow variables based on equations and inequalities.

Each tactic can reduce overestimation but may increase overhead, so implementations often balance them dynamically.

5.3 Adaptive interval strategies

Adaptive methods adjust splitting granularity based on intermediate results. For instance, if an interval result is too wide to prove a sign condition, the algorithm subdivides the region most responsible for uncertainty. Other heuristics prioritize subdomains where the expression is most sensitive to input variation.

Adaptive refinement is common in interval root finding and global optimization, where termination criteria depend on achieving sufficiently tight enclosures.

5.4 Implementation considerations (libraries and primitives)

Effective interval arithmetic requires reliable primitives for:

  • outward rounding for basic operations,
  • correctly rounded interval versions of elementary functions (exp, log, sin, cos, etc.),
  • consistent handling of special values (infinities, NaNs, and domain errors),
  • and optional support for features like interval splitting and hull computations.

Most practical systems use established interval arithmetic libraries rather than implementing directed rounding and transcendental intervals from scratch.

5.5 Performance profiling and benchmarks

Performance evaluation often includes:

  • runtime versus achieved enclosure width,
  • number of subintervals processed,
  • success rates in verification tasks,
  • sensitivity to machine precision and rounding settings.

Benchmarks typically compare different inclusion function choices or different splitting heuristics. Profiling helps identify whether bottlenecks stem from transcendental evaluation, subinterval explosion, or overhead in memory management.

6 Applications in calculus and numerical analysis

6.1 Interval-based root finding (bracketing)

Interval methods can locate roots of equations \(f(x)=0\) by maintaining an interval that is guaranteed to contain a root. Bracketing techniques require sign changes across endpoints (or interval evaluations that demonstrate such a change). At each refinement step, the interval is subdivided and tested to determine whether a root remains in each candidate region.

The enclosure property ensures that if the algorithm reports a root in a final interval, the root indeed lies within it.

6.2 Derivative bounds with intervals

Derivative information supports rigorous numerical analysis. Interval arithmetic can bound \(f'(x)\) over a domain by evaluating an interval enclosure of the derivative. Such bounds enable:

  • Lipschitz-type estimates for function variation,
  • guaranteed convergence behavior for iterative methods,
  • validation of monotonicity or curvature assumptions used for range bounding.

6.3 Guaranteed bounds for integrals and sums

Integrals over uncertain inputs can be bounded by combining interval evaluation with numerical quadrature methods that produce enclosure results. Common strategies use interval versions of:

  • partitioned integration rules,
  • error-controlled quadrature,
  • and verified summation bounds for series.

These methods support rigorous estimation even when the integrand depends on uncertain parameters.

6.4 Interval methods for differential equations (overview)

For differential equations, interval techniques can produce guaranteed bounds on solution trajectories over a time interval. One broad class uses interval enclosures with stepwise propagation (e.g., using inclusion functions for the right-hand side). Ensuring soundness often involves using validated step sizes and bounding truncation and rounding effects.

Because dependencies can compound over time, these methods typically rely on careful subdivision and often incorporate derivative or Jacobian information.

6.5 Sensitivity analysis using intervals

Sensitivity analysis investigates how uncertainties in parameters affect outputs. Interval arithmetic provides a natural framework: propagate parameter intervals through the model to obtain output intervals that enclose all plausible outcomes. The width of the output interval can be used as an uncertainty measure, and comparisons across model variants can highlight which parameters dominate uncertainty.

7 Worked examples and practice problems

7.1 Basic arithmetic example with uncertainties

Suppose a measurement yields \(x\in[1.9,2.1]\) and \(y\in[3.0,3.2]\). Using interval arithmetic:

  • \(x+y = [1.9+3.0,\ 2.1+3.2]=[4.9,5.3]\).
  • \(x-y = [1.9-3.2,\ 2.1-3.0]=[-1.3,0.1]\).
  • \(x\cdot y\) uses endpoint products: compute all products \(1.9\cdot3.0\), \(1.9\cdot3.2\), \(2.1\cdot3.0\), \(2.1\cdot3.2\), then take the minimum and maximum.

The resulting intervals describe all values consistent with the input uncertainty ranges.

7.2 Bounding a polynomial over an interval

Let \(p(x)=x^2-3x+2\) with \(x\in[0.5,2.0]\). A natural interval extension evaluates: \[ \mathbf{p}=\mathbf{x}^2 - 3\mathbf{x} + [2,2]. \] One computes \(\mathbf{x}^2\) by taking endpoint squares and selecting the minimum and maximum, then forms the affine combination using interval addition/subtraction and scalar multiplication. The output interval encloses the true range of \(p(x)\) over the domain, though it may be wider than necessary due to dependency.

To improve tightness, a common practice is to rewrite the polynomial, for example factoring \(p(x)=(x-1)(x-2)\) and then using interval multiplication with sign-aware reasoning, potentially reducing overestimation.

7.3 Bounding transcendental expressions

Consider \(f(x)=e^x\) for \(x\in[-0.2,0.1]\). Since \(e^x\) is monotone increasing, the interval image is: \[ e^{[-0.2,0.1]}=[e^{-0.2},\, e^{0.1}]. \] For expressions like \(\sin(x)\) over the same domain, periodicity matters. Interval evaluation must account for whether the covered range crosses points where sine reaches \(\pm1\); otherwise the bound can be derived from endpoint values alone.

7.4 Verifying an inequality with interval arithmetic

To verify that \(g(x)\ge 0\) for all \(x\in[a,b]\), compute an interval \(\mathbf{g}\) that contains all values \(g(x)\). If \(\mathbf{g}\) lies entirely above zero, e.g. \(\mathbf{g}=[\ell,u]\) with \(\ell>0\), then the inequality holds everywhere on the interval. If \(\ell\le 0\le u\), the inequality cannot be confirmed from this computation alone, and refinement is typically required (such as splitting \([a,b]\) into smaller subintervals).

7.5 Common pitfalls and debugging tips

Common issues include:

  • Missing outward rounding: if directed rounding is not active for interval primitives, enclosures may fail.
  • Uncontrolled dependency growth: natural extensions can become overly broad; rewriting or splitting helps.
  • Domain violations: applying \(\log\) to intervals that touch or cross zero yields invalid results unless handled explicitly.
  • Overreliance on natural extensions: correct but loose bounds may lead to inconclusive verification.

Debugging often involves checking whether the interval result truly encloses sample evaluations, verifying library settings, and comparing the impact of alternative expression forms or domain partitions.