Splines, Bezier Curves, and B-Splines

Curve Representations

There are three ways to represent a curve:

Explicit: $y = f(x)$ . Easy to evaluate but $y$ may not be a function of $x$ (e.g. a circle).
Implicit: $f(x, y) = 0$ . Works for closed curves but hard to sample points from.
Parametric: $x = x(u)$ , $y = y(u)$ where $u$ is a parameter. Both $x$ and $y$ are functions of an independent variable $u$ . Most flexible. $0 \leq u \leq 1$ typically.

A parametric curve: $p(u) = \begin{pmatrix} x(u) \\ y(u) \end{pmatrix}$ , $0 \leq u \leq 1$ .

Bezier Curves

A Bezier curve of degree $n$ is defined by $n+1$ control points $P_0, P_1, \ldots, P_n$ :

p(u) = \sum_{k=0}^{n} \binom{n}{k} (1-u)^{n-k} u^k P_k, \quad 0 \leq u \leq 1

The curve passes through $P_0$ (at $u=0$ ) and $P_n$ (at $u=1$ ) but generally not through the intermediate control points. The control points act as a scaffold that shapes the curve.

Key properties:

The curve lies within the convex hull of the control points.
The tangent at $P_0$ is along $P_1 - P_0$ , and at $P_n$ along $P_n - P_{n-1}$ .
The curve is infinitely differentiable (smooth everywhere).

For 4 control points ( $n=3$ , cubic Bezier): the most common form used in typography, animation, and vector graphics.

Parametric Surfaces

Extending to surfaces: $p(u, v)$ where both $u$ and $v$ are parameters. Bezier surfaces use a grid of control points. The surface passes through corner control points only.

B-Splines

B-splines (Basis splines) generalise Bezier curves. They are defined by:

A set of control points $P_0, \ldots, P_n$ .
A knot vector $t_0 \leq t_1 \leq \ldots \leq t_m$ .
A degree $k$ .

The curve is:

p(u) = \sum_{i=0}^{n} N_{i,k}(u) P_i

where $N_{i,k}(u)$ are the B-spline basis functions defined recursively (de Boor’s algorithm):

N_{i,0}(u) = \begin{cases} 1 & \text{if } t_i \leq u < t_{i+1} \\ 0 & \text{otherwise} \end{cases}

N_{i,k}(u) = \frac{u - t_i}{t_{i+k} - t_i} N_{i,k-1}(u) + \frac{t_{i+k+1} - u}{t_{i+k+1} - t_{i+1}} N_{i+1,k-1}(u)

Kolmogorov-Arnold Networks and B-Splines

In KANs, each edge holds a learnable function implemented as a B-spline. The activation function on each edge is:

\phi(x) = w_b \cdot \text{silu}(x) + w_s \cdot \text{spline}(x)

where $\text{spline}(x) = \sum_i c_i B_i(x)$ is a linear combination of B-spline basis functions. The coefficients $c_i$ are learned during training.

B-splines are used here because:

They are locally supported: each basis function is non-zero only over a small interval. Changing one coefficient affects only a local region of the function.
They are smooth: degree- $k$ B-splines are $C^{k-1}$ continuous.
Grid extension is straightforward: add more knots to increase resolution without retraining from scratch.

Least Squares Fitting with B-Splines

Given data points $(x_i, y_i)$ , fit a B-spline by minimising the sum of squared residuals:

\min_c \|y - Ac\|^2

where $A$ is the matrix of B-spline basis function evaluations:

A_{ij} = N_j(x_i)

Each row corresponds to a data point. Each column corresponds to a basis function. The system $A^T A c = A^T y$ (the normal equations) gives the least-squares solution.

Knots are the breakpoints where polynomial pieces join. Between two adjacent knots, the spline is a polynomial of degree $k$ . At knots, the pieces join with continuity constraints (how many derivatives match depends on the knot multiplicity).

$k = 3$ and knot values $0, 1, 2, 3, 4, 5, 6, 7$ : cubic B-spline with 5 knot spans.
Increasing knot multiplicity decreases continuity at that knot (useful for corners).

The number of basis functions equals the number of control points: $n + 1 =$ (number of knots) $- k - 1$ .