🔢 mathematics

A Quaternion--BCH Framework for the Local Accuracy of SIDER Interpolation

This paper establishes a quaternion-Lie algebra framework using Baker-Campbell-Hausdorff expansions to prove that the recursive SIDER- $n$ interpolation method achieves local accuracy of order $O(h^{n+1})$ for smooth spherical curves by demonstrating how each recursive step increases the approximation order through algebraic cancellation and preserved filtered degree structures.

Original authors: Shingyu Leung

Published 2026-06-12

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Shingyu Leung

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to draw a smooth, curved line connecting a series of dots that are all stuck to the surface of a giant, perfect basketball. This is a common problem in computer graphics (like animating a spinning robot) and physics.

The problem is that if you try to draw a straight line between the dots on a flat piece of paper (like a standard computer program does), the line will cut right through the inside of the basketball, leaving the surface. If you then try to "squash" that line back onto the surface, the curve gets distorted and loses its smoothness.

This paper introduces a clever new way to solve this, called SIDER. Here is the simple breakdown of what the authors did and why it works, using everyday analogies.

1. The Problem: Drawing on a Ball vs. a Flat Map

Think of the surface of the ball as a curved world. Standard math tools are like a flat map; they work great for flat ground but get messy when you try to map a globe.

The Old Way: You draw a straight line on a flat map and then try to wrap it around the ball. The result is wobbly and inaccurate.
The SIDER Way: Instead of using a flat map, the authors use a special "language" (quaternions) that understands the ball's curvature from the very beginning. It's like using a GPS that knows the Earth is round, rather than a paper map that thinks it's flat.

2. The Secret Ingredient: The "BCH" Translator

The authors realized that the math used to connect two points on a ball (called SLERP) is actually very similar to a complex algebraic recipe known as the Baker–Campbell–Hausdorff (BCH) formula.

Think of this formula as a translator.

Normally, connecting points on a ball involves messy, curved geometry (like trying to measure the distance between two cities by walking over hills).
The authors' framework translates this "hilly" problem into a "flat" algebraic problem. They convert the curved path into a straight-line calculation in a special mathematical space, do the math, and then translate it back.

The Big Discovery:
When they looked at this translation, they found a surprising shortcut.

No "Middle" Step: Usually, when you approximate a curve, you have to account for a "bend" (a quadratic term). The authors found that for this specific method, the "bend" cancels out perfectly.
The First Wobble is Tiny: The first time the math gets "curvy" again, it happens at a very high level (a cubic term). This means the method is incredibly accurate right from the start.

3. The Construction: Building a Tower of Accuracy

The SIDER method builds the curve in layers, like stacking blocks to make a tower.

Layer 1 (The Base): They start by connecting three points. Because of the "translator" trick mentioned above, this first layer is already as accurate as a standard quadratic curve (a smooth parabola).
Layer 2 and Up (The Recursive Step): To get even smoother curves, they take two of these small, accurate layers and combine them.
- In normal math, combining two approximations usually introduces new errors.
- But in this framework, the "curvy" parts of the math (the non-linear parts) are so small and well-behaved that they don't mess up the combination.
- It's like stacking two perfectly balanced blocks: the tower gets taller (more accurate) without wobbling.

4. The Result: A Perfectly Smooth Curve

The paper proves mathematically that for every layer you add to this tower, the accuracy improves by one step.

If you use 3 points, you get a very smooth curve.
If you use 4 points, you get an even smoother curve.
If you use n points, the error is so small it disappears almost instantly as you get closer to the points.

The "Fine Print" (What the Paper Actually Says)

The authors are very careful to state the limits of their magic:

It's Local: This works best when the points are close together. If you try to connect points on opposite sides of the basketball (antipodal points), the math gets confused, just like how a flat map gets confused at the poles.
It's for Smooth Data: The method assumes the curve you are drawing is smooth. If the data is jagged or broken, this specific proof doesn't guarantee the result will be perfect (though the authors mention this method is used as a building block for other tools that handle jagged data).
Equal Spacing: The proof assumes the dots are spaced evenly, like rungs on a ladder.

Summary

The paper essentially says: "We found a way to translate the difficult geometry of drawing on a sphere into a simple algebraic recipe. This recipe has a hidden superpower: the usual errors cancel out, allowing us to stack simple approximations on top of each other to create a curve that is incredibly accurate and smooth, without ever leaving the surface of the sphere."

Technical Summary: A Quaternion–BCH Framework for the Local Accuracy of SIDER Interpolation

Problem Statement
The paper addresses the challenge of interpolating data constrained to the unit sphere $S^2$ , a common task in scientific computing involving directions, orientations, and rigid-body motions. Standard Euclidean polynomial interpolation fails to preserve the spherical constraint, and projecting the result back to the sphere alters the geometry and approximation properties. While Spherical Linear Interpolation (SLERP) preserves the unit constraint and is geometrically natural, piecewise SLERP curves suffer from limited smoothness and low-order accuracy. The SIDER (Spherical Interpolation of orDER $n$ ) method, introduced in prior work [1], offers a recursive high-order construction inspired by Bézier and Neville-type interpolation, replacing affine steps with SLERP. However, a rigorous proof of its local accuracy order $O(h^{n+1})$ for smooth data has been difficult due to the curvature-dependent correction terms inherent in SLERP operations.

Methodology
The paper develops a quaternion–Lie algebra framework to analyze the local consistency of SIDER. The core methodological shift involves representing points on $S^2$ as pure unit quaternions and measuring interpolation errors in fixed-base quaternion logarithmic coordinates.

Quaternion Representation: Data points $p \in S^2$ are embedded as pure unit quaternions $q = (0, p)$ . The Lie algebra $\text{Im } \mathbb{H}$ is identified with $\mathbb{R}^3$ , where the Lie bracket corresponds to twice the cross product.
Exact BCH Representation: The key insight is that in left-trivialized logarithmic coordinates, the SLERP operation admits an exact representation via the Baker–Campbell–Hausdorff (BCH) formula:
$\log(q_\theta^{-1} \text{SLERP}(q_\theta e^X, q_\theta e^Y, \lambda)) = \text{BCH}(X, \lambda \text{BCH}(-X, Y))$
This converts the geometric interpolation problem into an algebraic problem involving filtered Lie-polynomial expansions.
Filtered Divided-Error Calculus: The proof utilizes a "filtered" analogue of classical divided-error arguments. The error is expanded as a formal power series in the step size $h$ , where coefficients are polynomials in the shifted stencil variable $\xi = \theta - i$ . The filtration tracks the polynomial degree relative to the power of $h$ .

Key Contributions and Structural Results
The analysis reveals two critical structural properties of the SLERP operation within this framework:

Affine Leading Order: The SLERP map is affine to leading order in logarithmic coordinates.
Absence of Quadratic Correction: The expansion contains no quadratic term.
Cubic Commutator Correction: The first nonlinear correction is cubic and commutator-valued (proportional to $[Y-X, [X, Y]]$ ). Since commutators of pure imaginary quaternions correspond to cross products, this term vanishes when the endpoint errors are collinear.

Main Results
The paper proves the local accuracy of SIDER- $n$ for smooth spherical curves sampled at equally spaced parameter values under a "small-stencil" assumption (ensuring all points remain in a common normal neighborhood).

Base Case (SIDER2): The SIDER2 interpolant, constructed from three data points, exhibits a third-order local error ( $O(h^3)$ ). The proof shows that the leading error term matches that of ordinary quadratic interpolation in Euclidean space. The cubic BCH correction vanishes at this order because the lowest-order logarithmic data are collinear multiples of the curve's tangent vector, causing the commutator term to be zero.
Recursive Step: The paper establishes a recursive order-raising lemma. If two adjacent SIDER- $(k-1)$ $(k - 1)$ candidates have errors in a "filtered divided-error form" (i.e., $O(h^k)$ $O (h^{k})$ with specific nodal factors), the next SIDER- $k$ $k$ step raises the order to $O(h^{k+1})$ $O (h^{k + 1})$ .
- The affine part of the recursion performs a Neville-type finite-difference cancellation, generating an extra factor of $h$ and a new nodal product $\Pi_k(\xi)$ .
- The nonlinear BCH remainder is shown to preserve the sharp filtered degree structure. When expressed in diagonal variables, the nonlinear terms contain sufficient powers of the difference between inputs to compensate for the interpolation parameter powers, ensuring the error remains within the required polynomial degree bounds.
General Theorem: For every fixed $n \ge 2$ , the SIDER- $n$ reconstruction satisfies:
$d_{S^2}(\gamma(\theta h), P_i^{[n]}(\theta; h)) = O(h^{n+1})$
The proof identifies the shift-invariance of the leading divided-error coefficient as the algebraic compatibility condition that allows the Neville-type cancellation to persist through the recursion.

Significance and Scope
The paper provides a rigorous, algebraic proof of the expected local accuracy of the SIDER method, resolving the complexity of curvature-dependent terms by leveraging the BCH expansion. It clarifies that the non-commutative geometry of the sphere does not degrade the leading-order accuracy of the recursive interpolation, provided the data is smooth and the stencil is small.

The analysis is strictly local and asymptotic. It assumes:

Equally spaced parameter values.
Data points and intermediate values remain within a common normal neighborhood (avoiding antipodal ambiguity and large angular jumps).
Smoothness of the underlying curve.

The paper explicitly states that it analyzes the smooth SIDER interpolation operators and does not address the global stability, monotonicity, or non-oscillatory behavior of the SENO (Spherical Essentially Non-Oscillatory) stencil-selection procedure, though it provides the consistency foundation for the smooth candidates used therein. The framework is currently restricted to uniform stencils; extension to nonuniform stencils would require reformulating the divided-error calculus with nonuniform weights.

Note: The paper concludes with a disclosure that the computational modeling and mathematical derivation were performed with the assistance of GPT-5.5 (Thinking), and the findings are presented as AI-assisted hypotheses subject to future formal peer verification.