Analysis and Deep Learning on Geometric Data

Contents

• Introduction and overview
• 0. Reminders: spectrum, surfaces, vector calculus
• 1. Discrete differential geometry
• 2. The Laplace-Beltrami operator
• 3. Shape descriptors and distances
• 4. Functional maps
• 5. Parameterization and processing
• 6. Deep learning on surfaces
• 7. Euclidean equivariance
• 8. Applications and LLGA connections
• 9. Course research notes — Geometric Data Analysis (Ovsjanikov)
• Exercises
• Projects and assessment
• References

Introduction and overview

Audience: an engineer comfortable with GNNs and meshes who wants the geometric operators behind shape analysis (the Laplacian, functional maps).

Empirical first: we start from what fails in practice — a shape-matching accuracy that collapses (from about 82% to 51% in a typical lab run) as soon as the mesh is remeshed, a 3D network that ignores curvature — and only then name the tools that fix it: the spectrum, functional maps, networks on surfaces.

The module goes from discrete differential geometry to deep learning on surfaces, following the work of Maks Ovsjanikov’s Geometric Data Analysis (GDA) group.

What you will be able to do

• Discretize the notions of differential geometry on meshes.
• Compute and interpret the Laplace-Beltrami operator and the spectrum of a shape.
• Build shape descriptors and distances that are comparable across surfaces.
• Put shapes in correspondence through functional maps.
• Parameterize and process surfaces to make them usable.
• Train networks that operate directly on surfaces.
• Understand Euclidean equivariance and its role in geometric learning.

Official objectives and syllabus

Official description (master’s wiki): the SynapseS 2026-2027 sheet of this course unit is not yet published (the S3/S4 tracks of the catalog are currently empty); the description confirmed below is that of the wiki, which specifies the volume (24 h), credits (2 ECTS) and instructor.

An introduction to advanced topics in the modern analysis of geometric data, centered on a) the mathematical foundations — discrete differential geometry, mapping, optimization — and b) deep learning for the state-of-the-art methods: a panorama of the foundations of shape analysis and processing, then a move to modern deep-learning-based techniques to solve problems such as shape classification, correspondence and parameterization.

The following table maps these official themes to the sections of the material.

Beyond this official description, the material adds two deepenings: the reading of the course instructor’s research (ch. 9) and the applications and connections of the master’s program (ch. 8).

Where this course fits in the program

M2 module (period 1), 24 h for 2 ECTS, mandatory for every LLGA student.

Prerequisites: Graph Machine and Deep Learning for Generative AI (mandatory; its spectral graph Laplacian foreshadows the Laplace-Beltrami operator) and a Deep Learning course. Digital Representation and Analysis of Shapes and Signal Processing help if you took them, but they are not required: the boxes of chapter 0 (meshes, Fourier and heat, optimal transport) give what this page uses from them.

If you took Shapes (AI-systems route): you have already seen most of sessions 2–4 (Shapes ch. 5, 7 and 8). Skim ch. 1–3 for the proofs and the notation, then spend the time on functional maps and learning (ch. 4–7).

Canonical statements. Other LLGA pages link here instead of re-deriving: discrete Gauss–Bonnet, the mean-curvature normal, the cotangent Laplacian from the Dirichlet energy and the HKS with its stability bound.

Downstream, it prepares Graph Generative Models and Applications — where 3D molecules become graphs to be generated — and is one of the entry routes toward the research track of the master.

Course outline

• Reminders: spectrum, surfaces, vector calculus — the mathematics of the module, put back in hand on surface examples.
• Discrete differential geometry — transposing curvatures and derivatives to the discrete world of meshes.
• The Laplace-Beltrami operator — the central spectral operator of shape analysis.
• Shape descriptors and distances — comparing surfaces through computable signatures.
• Functional maps — putting shapes in correspondence by transporting functions.
• Parameterization and processing — flattening and parameterizing surfaces to process them.
• Deep learning on surfaces — defining and training networks directly on geometry.
• Euclidean equivariance — building models that respect the symmetries of space.
• Applications and LLGA connections — where geometry meets the other tracks of the master, with three worked bridges to graphs and language (self-study).
• Course research notes — Geometric Data Analysis (Ovsjanikov) — the papers of the Geometric Data Analysis group, read with the tools of the module (self-study).
• Exercises — spectral computations and correspondences to carry out on real meshes.
• Projects and assessment — solo and group project subjects, a written-exam proposal and a grading rubric.
• References — the foundational papers of geometric analysis and learning on shapes.

Session plan

24 h in class = 8 sessions of 3 h. The volume is the one the master’s wiki gives for this course unit (24 h, 2 ECTS; the SynapseS 2026–2027 sheet is not yet published); no session-by-session programme is published, so the split below is our proposal for covering these notes in that time. Level 1 = foundations (reviews, definitions, first worked examples), 2 = core methods, 3 = advanced theory; the level never goes down from one session to the next.

Self-study, outside the 24 h (about 5.5 h in total): ch. 0 box OT in one page, to read before session 5 (≈ 0.5 h) · ch. 8 Worked bridges — HKS on a graph, graph alignment by functional maps, text–shape retrieval (≈ 2 h) · ch. 9 Course research notes — HKS, functional maps, ZoomOut, DiffusionNet, read as papers (≈ 3 h).

How to study this module

• Connect each new operator to its graph cousin: the Graph ML Laplacian is the best anchor point of the module.
• Visualize: eigenfunctions of the Laplace-Beltrami operator, heat kernels, and descriptors are understood as colors on a mesh.
• Implement the descriptors on small meshes before moving on to full datasets.
• Redo chapter 0 without hesitation: vector calculus and spectra are used in every chapter.
• Read the foundational papers on functional maps after the corresponding chapter — the course provides a guided reading of them.
• Look early at the applications of chapter 8 and the research notes of chapter 9: that is where internship and research topics take shape.

0. Reminders: spectrum, surfaces, vector calculus

Every later chapter rests on three pieces of mathematics: the spectral theorem for symmetric matrices, the notion of a surface, and integration by parts on it. This chapter recalls them, with proofs, and sets up the Fourier analogy that the module follows.

Convolution and Fourier (reminder). Convolution (f * g)(x) = \int f(x-y)g(y)dy is the unique commutative, bilinear, continuous, translation-invariant product. The Fourier transform diagonalizes it: \widehat{f*g} = \hat f \cdot \hat g, \qquad \widehat{\Delta f} = -\|\omega\|^2\hat f . This whole machinery disappears on a surface (no translation group); the Laplacian — and it alone — plays its role: this is the program of chapters 2–4.

Heat is a low-pass filter (reminder). On \mathbb{R}^n, the heat equation \partial_t u = \Delta u is solved by convolution with a Gaussian, and in Fourier each frequency is damped: u(t) = G_t * u_0, \qquad G_t(x) = (4\pi t)^{-n/2}e^{-\|x\|^2/4t}, \qquad \hat u(t,\omega) = e^{-t\|\omega\|^2}\,\hat u_0(\omega). High frequencies die first, so diffusing for a time t keeps the details larger than about \sqrt t. On a surface, \|\omega\|^2 becomes \lambda_k and the damping becomes e^{-t\lambda_k} (Theorem 2.3): the HKS of ch. 3 and DiffusionNet of ch. 6 are built on this filter.

1. Discrete differential geometry

A computer stores a surface as a mesh of triangles, while curvature, gradients and the Laplacian are defined on smooth surfaces. This chapter transposes these notions to meshes. A concrete scene shows why they matter: to align two scans of the same object, raw XYZ coordinates work when the pose is fixed but break as soon as the object bends; we need intrinsic quantities, which do not change under such deformations.

• Normal of a face: n_f \propto (v_j - v_i) \times (v_k - v_i); vertex normal: area-weighted (or angle-weighted) average;
• Barycentric coordinates: in a triangle (i,j,k), every point can be written \alpha v_i + \beta v_j + \gamma v_k, \alpha + \beta + \gamma = 1, with \alpha = normalized area of the opposite sub-triangle; they serve to interpolate any function from the vertices to the interior of the faces (a mesh carries values only at vertices);
• Finite differences vs finite elements: the “FD” route approximates \Delta f by combinations of neighbors (like the graph Laplacian). The “FEM” route projects onto the basis of hat functions \psi_i (1 at v_i, 0 at the other vertices, affine on the faces) and assembles the stiffness matrix L_c and the mass matrix M: (L_c)_{ij} = \int_{\mathcal M} \langle\nabla\psi_i, \nabla\psi_j\rangle\, dA, \qquad M_{ij} = \int_{\mathcal M} \psi_i\psi_j\, dA . In practice M is lumped to the diagonal of vertex areas A_i, and the discrete Laplacian is \Delta \approx -M^{-1}L_c. The explicit computation of (L_c)_{ij} on a triangle — an object of ch. 2 — recovers exactly the cotangents: FEM and discrete geometry converge.

2. The Laplace-Beltrami operator

On a surface there is no Fourier transform, because there are no translations; the operator that takes its place is the Laplacian of the surface. This chapter builds it on meshes (the cotangent matrix), derives it from an energy, and proves the two properties that make it the central tool of shape analysis: its eigenfunctions act as frequencies, and it does not change when the surface bends without stretching.

import igl                     # libigl: reference discrete geometry library
import numpy as np
from scipy.sparse.linalg import eigsh

v, f = igl.read_triangle_mesh("bunny.obj")
L_c = -igl.cotmatrix(v, f)      # libigl returns the NSD matrix: negate ONCE -> PSD stiffness
M = igl.massmatrix(v, f, igl.MASSMATRIX_TYPE_VORONOI)   # lumped mass
# generalized problem L_c phi = lambda M phi (shift-invert around 0)
evals, evecs = eigsh(L_c, k=20, M=M, sigma=-1e-8)       # 0 = lambda_1 < lambda_2 <= ...
# visualize evecs[:, k] as a "texture" on the mesh -> vibration modes
# NB: the Dirichlet energy can also be assembled face by face:
G = igl.grad(v, f)              # per-face gradients, shape (3|F|, |V|)
# E_D(f) = 0.5 * sum_T area_T * |grad f|_T^2  (= 0.5 * f @ L_c @ f)

3. Shape descriptors and distances

To compare or match two shapes we need, at each point, a signature that is computable and unchanged when the shape bends. This chapter builds such descriptors from the spectrum of chapter 2 (HKS, WKS, ShapeDNA), together with intrinsic distances, and states the limit of the whole spectral approach.

• Scale-normalized HKS: dilating the shape by s gives \lambda_k \to s^{-2}\lambda_k and \phi_k \to s^{-1}\phi_k (unit norm on an area multiplied by s^2), hence \mathrm{HKS}'(x, t) = s^{-2}\,\mathrm{HKS}(x,\, t/s^2). Dividing by \max_x \mathrm{HKS}(x,t) removes the amplitude s^{-2} but not the rescaled time t/s^2. Two fixes:

  • measure time in units of the shape, t = \tau\cdot\mathrm{Area} or t = \tau/\lambda_2, and then normalise the amplitude;
  • the scale-invariant HKS of Bronstein & Kokkinos (2010): sample t = \alpha^\tau, take \log\mathrm{HKS}, differentiate in \tau (removes the amplitude), and keep the modulus of its Fourier transform in \tau (removes the shift in \tau);

• Wave Kernel Signature (Aubry et al., 2011): a quantum particle of energy e distributed log-uniformly: \mathrm{WKS}(x, e) = \sum_k \phi_k(x)^2 e^{-(\log e - \log\lambda_k)^2/2\sigma^2} — a Gaussian window on a logarithmic scale: each energy probes one precise frequency band (better localization than the HKS, whose every t mixes low frequencies);

• ShapeDNA (Reuter et al.): the vector (\lambda_1, \dots, \lambda_k) — normalized by area — as a global “fingerprint”; L^2 distance between fingerprints;

• Intrinsic distances:

  • geodesic (shortest path on the surface): Dijkstra’s algorithm on the graph of the mesh (edge lengths) gives an upper bound — edge paths are only some of the paths on the surface, and their zigzag error does not vanish when a regular mesh is refined;
  • continuous refinement (Fast Marching, Kimmel–Sethian) lets paths cross faces and solves the eikonal equation \|\nabla d\| = 1 by a growing wavefront, which lowers the Dijkstra estimate toward the true distance;
  • the modern “heat method” variant (Crane et al.) first solves heat and then takes its renormalized gradient — O(linear solver);
  • diffusion distance (prop. 2.4): truncated spectral approximations of both;

• Can one hear the shape of a drum? No — Gordon, Webb, and Wolpert (1992) constructed pairs of planar domains (polygonal drums) that are isospectral but not isometric. The spectrum does not determine the shape: this is a fundamental (and mathematically sound) limit of the whole spectral pipeline — ShapeDNA, spectral constraints of functional maps, HKS.

  In practice: the spectrum discriminates almost everything, and one always complements it with operator and descriptor constraints (ch. 4);

• Flattening (embedding): the first non-constant eigenfunctions give an embedding x \mapsto (\phi_2(x), \dots, \phi_{k+1}(x)) that “unfolds” the shape (\phi_1 is constant and dropped) — the exact analogue of Laplacian eigenmaps and spectral clustering for graphs (Graph ML, ch. 4; spectral positional encodings in Advanced GNN ch. 4 if you take it): same algebra, different object.

4. Functional maps

Finding which point of one shape corresponds to which point of another is a huge combinatorial problem. This chapter replaces it with a small linear one: instead of matching points, we transport functions, and in the spectral bases of chapter 2 the map becomes a k \times k matrix.

C = least_squares(k=k0, descriptors)          # coarse start
for k in range(k0, kmax, step):
    Pi = argmax_per_column(Phi_N[k] @ C @ Phi_M[k].T)   # hard
    C = solve(constraints + coupling(Pi), dim=k)        # soft
return Pi                                          # final correspondence

• Partial maps: when only a part of \mathcal M corresponds to \mathcal N, T_F becomes a restriction; the matrix C is then rectangular (or one embeds \mathcal M into \mathcal N via a prolongation operator); the constraints adapt (descriptors only on the visible part);
• Learned extensions: the descriptors D can be produced by a network (FMNet of Litany et al. 2017, then GeomFMaps of Donati et al. 2020 — deep geometric functional maps): the network learns descriptors that are optimal for the matrix C, the resolution remaining a differentiable least squares; the complete computation graph (network → C → correspondence loss) is trained end to end (Architecture 6.3);
• Supervised vs unsupervised: with annotated pairs (FAUST), one directly supervises C or the geodesic error of \Pi; otherwise, one penalizes the structure that C should have — bijectivity, orthogonality, Laplacian commutativity (Architecture 6.3): unsupervised works well for quasi-isometries (humans);
• Applications: texture transfer: the texture (a color function!) on \mathcal M is transported by b_{\mathcal N} = C\,b_{\mathcal M} — a matrix multiplication; pose transfer (the correspondence coordinates), morphing;
• LLGA connection: a functional map ≈ an optimal transport between reduced bases; shape alignment ≈ graph alignment by Gromov-Wasserstein (box OT in one page of ch. 0; Optimal Transport, ch. 5); the three languages — GNN, OT, functional maps — describe the same operation of structural correspondence.

5. Parameterization and processing

Many tasks — texturing, remeshing, editing, reconstruction from a scan — need a surface to be flattened, smoothed or rebuilt. This chapter shows that most of these operations reduce to minimizing an energy built on the Laplacian of chapter 2, hence to solving a sparse linear system.

• Conformal: a map is conformal if it preserves angles — the local Jacobian is a similarity du = s\,R (Cauchy–Riemann intuition: real and imaginary parts are conjugate harmonic); it preserves the shape of small details (textures without shear), but distorts areas;

• LSCM — least-squares conformal maps (Lévy et al. 2002): for a map (u, v), conformality is the Cauchy–Riemann equation \nabla v = R_{90}\nabla u on each face. LSCM minimizes its squared residual, which splits into the Dirichlet energy minus the signed area of the image: E_{\mathrm{LSCM}}(u,v) = \tfrac12\sum_T |T|\,\big\|\nabla_T v - R_{90}\nabla_T u\big\|^2 = E_D(u) + E_D(v) - \mathcal A(u, v). The energy is quadratic in (u,v); its minimizer is only defined up to a similarity, so one pins two vertices and solves one sparse linear system. Unlike Tutte, the boundary is free;

• ARAP — as-rigid-as-possible: minimize E_{\mathrm{ARAP}}(u) = \sum_{T}\min_{R_T \in SO(2)} \big\|J_T(u) - R_T\big\|_F^2, where J_T(u) is the Jacobian of the map on face T and R_T the “closest” rotation. Local/global solver:

  1. local: each face fixes R_T = UV^\top (SVD of J_T);
  2. global: with the rotations fixed, E becomes quadratic in u → linear system;

  alternate until convergence — a geometric EM; an angle/area compromise without excessive distortion;

• Spectral smoothing/filtering: attenuate high frequencies (denoise), sharpening — signal processing (M1) transported to surfaces;

• Deformation: laplacian editing: move handles while preserving \Delta\mathbf{x} of the positions (the details): minimize \sum_i\|(L_c\mathbf{x}')_i - (L_c\mathbf{x})_i\|^2 under constraints — the same machinery as the harmonic map; skinning, morphing — graphics/AR applications of the sister ViCAI module;

• Poisson reconstruction: from a normal field \mathbf{v} (oriented, scan): look for the indicator function \chi of the solid whose gradient best matches \mathbf{v}. An exact solution would satisfy \nabla\chi = \mathbf{v} \quad\Longrightarrow\quad \Delta\chi = \mathrm{div}\,\mathbf{v}, but a measured \mathbf{v} is generally not a gradient, so the converse fails. The Poisson equation is the normal equation of \min_\chi \int\|\nabla\chi - \mathbf{v}\|^2: it computes the least-squares projection of \mathbf{v} onto gradients. This is the bridge scan → closed mesh;

• Decimation — quadric error metric: associate to each vertex the quadric (sum of the products of the unit plane equations) Q_i = \sum_{p \in \text{incident planes}} A_p^\top A_p . The cost of contracting edge (i,j) to the point \bar v is Q_{ij}(\bar v) = Q_i(\bar v) + Q_j(\bar v) — a quadratic form, minimized in closed form; one contracts the lowest-cost edges with a binary heap;

• Curvature-based remeshing: vertex density \propto local curvature (deficit of ch. 1) — allocate the triangle budget where the geometry demands it.

# Spectral smoothing: low-pass filtering on the eigenfunctions
import numpy as np
from scipy.sparse.linalg import eigsh
# L_c, M: stiffness and mass of ch. 2; f: per-vertex function, shape (n,)
evals, evecs = eigsh(L_c, k=200, M=M, sigma=-1e-8)   # 200 modes (ch. 2 kept only 20)
k = 30                                     # keep the 30 lowest frequencies
coef = evecs.T @ (M @ f)                   # spectral coefficients, shape (200,)
coef[k:] = 0                               # axis 0 is the eigen-index: cut modes k+1..200
f_smooth = evecs @ coef
# soft variant: coef *= 1/(1 + (evals/lambda0)**2)  (Butterworth)
# for an (n, d) signal, use coef[k:, :] = 0 and evals[:, None]

6. Deep learning on surfaces

The networks of image processing assume a regular grid, which point clouds and meshes do not have. This chapter presents the architectures that learn directly on 3D data — PointNet and its local extensions, then DiffusionNet — and the obstacle they all face: a surface has no canonical orientation for a filter.

• Transformers on surfaces: global attention between points/vertices with intrinsic positional encodings (HKS, random geodesic distances) as the positional add-on: the GPS recipe transplanted. A GPS layer (Rampášek et al. 2022) adds, with residuals and normalization, a local message-passing update and a global self-attention update over all nodes, then applies an MLP; positional encodings (Laplacian eigenvectors, random-walk statistics, or here the HKS) are concatenated to the input features. Details in Advanced GNN ch. 5 if you take it; quadratic cost → hierarchical subsampling;
• Self-supervised learning: geometric pretexts — predict descriptors (HKS: “know thyself”), local orientation, reconstruct masked regions; contrastive pre-training between views/poses of the same shape (as PointContrast, Xie et al. 2020, does for point clouds): LLM pre-training applied to surfaces;
• Benchmarks: Dataset Task Metric —————- ————————————– —————————- FAUST / SCAPE human correspondence (various poses) mean geodesic error (×100) SHREC shape retrieval mAP ModelNet40 cloud classification accuracy ShapeNet-parts part segmentation mIoU

# Mesh classification via LBO-features + small classifier (lab skeleton)
import torch
# features: (n, 7) = [Gauss_curvature, Mean_curvature, HKS(t1..t5)] per vertex
encoder = torch.nn.Sequential(
    torch.nn.Linear(7, 128), torch.nn.ReLU(),
    torch.nn.Linear(128, 64),
)
head = torch.nn.Linear(64, n_classes)                     # classification head
pooled = encoder(features).max(dim=0).values              # (64,): max over VERTICES (dim 0)
logits = head(pooled).unsqueeze(0)                        # (1, n_classes)

# DiffusionNet "learned diffusion" (Architecture 6.2): one time per channel
class LearnedDiffusion(torch.nn.Module):
    def __init__(self, d):
        super().__init__()
        self.t = torch.nn.Parameter(torch.zeros(d))       # softplus(t) > 0, one per channel
    def forward(self, H, evals, evecs, mass):             # H: (n, d); evecs: (n, k); mass: (n,)
        H_spec = evecs.T @ (mass[:, None] * H)            # (k, d) spectral coefficients
        t = torch.nn.functional.softplus(self.t)          # (d,)
        decay = torch.exp(-evals[:, None] * t[None, :])   # (k, d): e^{-lambda_k t_c}
        return evecs @ (decay * H_spec)                   # (n, d); parentheses matter

7. Euclidean equivariance

A rotated or translated molecule is the same molecule, and a network should not have to learn this from data. This chapter defines equivariance, recalls the EGNN layer proved equivariant in Graph ML, and asks what invariance means for point clouds and surfaces — where bending adds a symmetry that rotations alone do not cover.

• Point clouds: PointNet on raw XYZ (ch. 6) is permutation-invariant but not rotation-invariant. Three cures, in increasing strength: random-rotation augmentation (approximate, learned from data), invariant inputs (distances, angles), or layers that are equivariant by construction (EGNN, SE(3)-transformers);
• Surfaces: intrinsic objects — \Delta_{\mathcal M}, its spectrum, the HKS, DiffusionNet fed with HKS — are invariant to rigid motions and to isometric bending, a much larger symmetry than E(3). DiffusionNet fed with XYZ is not, hence the rotation augmentation of the recipe in ch. 6. Its gradient features (Architecture 6.2) are invariant to a local change of tangent frame — a gauge symmetry, the surface cousin of E(n) equivariance;
• Equivariance vs invariance: for classification, invariance suffices (max pooling) — but to generate or localize, one needs equivariance (to output positions consistent with the inputs); the same debate as “final aggregation vs messages” in GNN theory;
• SE(3)-transformers (sketch): for the continuous version, attention is built on equivariant fields (irreducible representations; invariant keys/queries, vector-valued values) — the machinery exceeds this course, but the principle stands: invariant similarities, transformed values;
• E(2)-symmetric routing: in a routing problem on a 2D map (travelling salesman, vehicle routing), the optimal tour does not change when the customer coordinates are rotated, reflected or translated. Sym-NCO (Kim, Park & Park, NeurIPS 2022) trains a neural solver with a REINFORCE baseline shared across rotated copies of each instance, plus a regularizer that makes the encoder’s embedding rotation-invariant — augmentation turned into a training signal. The Year 2 dispatcher subject of the transverse project (Y2.4) builds on it;
• Connection with the Advanced GNN module, ch. 8: EGNN is a GNN whose messages are constrained by geometry — “geometry first, network second”; the generation of conformers by EGNN (positions = equivariant output) meets diffusion models (the three-line DDPM recall is in ch. 8).

8. Applications and LLGA connections

This chapter gathers where the tools of the module are used — molecules, proteins, industry, shape generation — and then works out, for self-study, three bridges to the graph and LLM tracks of the master.

• 3D molecules: a molecule is an equivariant cloud (EGNN, ch. 7) — conformer prediction (equilibrium geometries minimize energy); generation by equivariant diffusion, where an EGNN is the denoiser (EDM, Hoogeboom et al. 2022; see the recall below, Graph Generative Models, ch. 5 for EDM among the diffusion models and ch. 8 for the applications); properties (solubility, toxicity) via geometric descriptors (molecular HKS/WKS);
• Proteins: binding interfaces = correspondence of molecular surfaces (shape complementarity — partial functional maps); docking; geometry meets the master’s molecule-graph pipeline (Graph ML);
• Industry: CAD/mesh retrieval, 3D scanning (reverse engineering: Poisson reconstruction of ch. 5), quality control by comparison to tolerances, dental/orthopedics (crowns = quasi-isometric shapes); autonomous vehicles (lidars = clouds → PointNet++/DGCNN); AR/VR: avatars (human body correspondence — FAUST in production), mesh compression (spectral coordinates);
• Shape generation: diffusion on point clouds and meshes (noising/denoising positions and connectivities — the DDPM recalled below, in \mathbb{R}^{3n} with equivariance); the “shape-GPT” future: surface tokens.

Worked bridges (self-study, ≈ 2 h)

Three worked examples connect the module to graphs and to language. Each one reuses a chapter almost verbatim, and each one is the seed of a Year 2 transverse-project subject.

Bridge A — the HKS on a graph Laplacian. A graph has no metric, but it has a Laplacian L = D - A (symmetric positive semi-definite, 1-based spectrum, Graph ML, ch. 4). It plays the role of L_c, with M = I, and Definition 3.1 carries over unchanged: \mathrm{HKS}(v,t) is the heat that stays at node v after time t.

Two things change. Graphs have no physical scale, so measure time in units of 1/\lambda_2 and normalise each time column — the scale normalisation of ch. 3. And graphs can be large: there, compute only the low end of the spectrum with a sparse shift-invert solver, and check what it returns. Lanczos can return fewer copies of a repeated eigenvalue than its multiplicity, and leaves hanging on the same node, frequent in real graphs, create exactly such repeats. On the 77-node example below, the dense solver is exact and instant.

import numpy as np, networkx as nx
from scipy.sparse.linalg import eigsh

G = nx.les_miserables_graph()                     # 77 characters, weighted co-appearance graph
L = nx.laplacian_matrix(G).astype(float)          # L = D - A: sparse, PSD (plays L_c, M = I)
lam, phi = np.linalg.eigh(L.toarray())            # all 77 eigenpairs, ascending
# large graph: lam, phi = eigsh(L, k=200, sigma=-1e-3), then check repeated eigenvalues
ts = np.geomspace(0.1, 10, 8) / lam[1]            # time grid in units of 1/lambda_2
hks = (phi**2) @ np.exp(-np.outer(lam, ts))       # (n, 8): HKS(v, t)
hks /= hks.sum(axis=0, keepdims=True)             # amplitude normalisation per time
nodes = list(G.nodes())
print([nodes[i] for i in np.argsort(-hks[:, 0])[:3]])   # most heat kept at small t

At small t the heat stays longest at peripheral characters of degree 1 — low degree means slow leakage. Jondrette and MlleVaubois come first; then six characters seen only with Myriel tie exactly (they are twins, see Bridge B), so which of them is printed third depends on rounding.

These leaves make \lambda = 1 an eigenvalue of multiplicity 9. A 30-mode eigsh run often misses some of its copies, and the ranking then changes from run to run: the warning above, observed. Used as node features, these columns are a structural encoding of the kind studied in Advanced GNN, ch. 4.

On a knowledge graph (Y2.1) or a transaction graph (Y2.5), the stability bound of ch. 3 suggests that a few injected edges move the HKS little. Treat this as a hypothesis to test, not a theorem: the bound is for small perturbations, and one edge can be a large perturbation of a sparse graph.

Bridge B — graph alignment by functional maps. Two graphs on the same entities, with an unknown node correspondence (two snapshots of a network, two knowledge graphs over shared entities), are two “shapes”. Ch. 4 applies verbatim: eigenbases of both Laplacians, HKS columns as the functions to preserve, C by Resolution 4.3, then a one-to-one node map. This is the pipeline of GRASP (Hermanns et al., 2021), without its base-alignment step.

The protocol needs gold correspondences: take G_2 as a randomly permuted copy of G_1, optionally with a fraction of its edges removed, and score the fraction of nodes mapped to their true partner.

from scipy.optimize import linear_sum_assignment
def basis(G, k):                                  # dense eigh: fine below ~5,000 nodes
    Ld = nx.laplacian_matrix(G, nodelist=range(len(G))).toarray().astype(float)
    lam, phi = np.linalg.eigh(Ld); return lam[:k], phi[:, :k]
def hks_cols(lam, phi, q=16):
    return (phi**2) @ np.exp(-np.outer(lam, np.geomspace(0.1, 10, q) / lam[1]))
def fmap(D1, D2, l1, l2, alpha=1e-3, mu=1e-6):    # Resolution 4.3, one Omega_i per row
    k = len(l1)
    return np.stack([np.linalg.solve(D1 @ D1.T + alpha * np.diag((l1 - l2[i])**2)
                                     + mu * np.eye(k), D1 @ D2[i]) for i in range(k)])

G1 = nx.convert_node_labels_to_integers(nx.karate_club_graph())
perm = np.random.default_rng(0).permutation(len(G1))   # gold: node u of G1 is perm[u] in G2
G2 = nx.relabel_nodes(G1, dict(enumerate(perm)))        # remove a few edges here for noise
l1, P1 = basis(G1, 30); l2, P2 = basis(G2, 30)
C = fmap(P1.T @ hks_cols(l1, P1), P2.T @ hks_cols(l2, P2), l1, l2)
cost = ((P2[:, None, :] - (P1 @ C.T)[None, :, :])**2).sum(-1)  # delta functions, mapped by C
rows, cols = linear_sum_assignment(cost)                # node rows[i] of G2 <-> cols[i] of G1
print("accuracy", np.mean(perm[cols] == rows))

• On Zachary’s karate club (34 nodes, weighted edges) this recovers every node without noise. With 5% of the edges removed (4 of 78, graph kept connected), it averages about 85%, with a wide spread: from about 73% to 94% over 60 random draws.
• On Les Misérables it reaches only about 80% even without noise (75–92% across random permutations). Eleven of the 77 characters are exact twins — six seen only with Myriel, five only with Valjean, all with the same edge weight — and no structural method can tell twins apart. Guessing within each group caps the expected accuracy at about 88%: report this ceiling next to the accuracy.
• Removing edges can disconnect a graph, which adds zero eigenvalues and breaks the spectral matching: align the largest connected components.

Bridge C — 3D + language: contrastive text–shape retrieval. The CLIP objective of LLM 8.2b works with a shape tower in place of the image tower.

• Towers: a shape encoder f_\theta — PointNet (Architecture 6.1) on 2,048 points sampled on the surface, or DiffusionNet — followed by a linear projection; a frozen pretrained text encoder g followed by a trainable projection; both outputs are \ell_2-normalised. A few thousand captioned shapes cannot train a language model, so the shape tower learns to land in the text space.
• InfoNCE in three lines: for a batch of B pairs (x_i, y_i) and a temperature \tau (about 0.07, often learned), s_{ij} = \frac{\langle f_\theta(x_i),\, g(y_j)\rangle}{\tau}, \qquad \mathcal L = -\frac{1}{2B}\sum_{i=1}^{B}\Big[\log\frac{e^{s_{ii}}}{\sum_{j} e^{s_{ij}}} + \log\frac{e^{s_{ii}}}{\sum_{j} e^{s_{ji}}}\Big]. Each row and each column of S = (s_{ij}) is a B-way classification whose correct class is the diagonal.
• Data: ABO, Amazon Berkeley Objects (Collins et al., CVPR 2022), about 8,000 artist-made 3D models of real products with their catalogue listings; use the product title and category as the caption, and split by product.
• Metric: Recall@k for text → shape, the fraction of text queries whose shape is among the k nearest shape embeddings, for k = 1, 5, 10; then again on remeshed or resampled test shapes, the robustness question of ch. 6.
• Towards an LLM: the projected shape embedding can enter an LLM as a soft token through a trained projector, as images do in LLM 8.2b — the “3D tokens” idea made concrete, and the shape tower of the Y2.3 subject.

import torch.nn.functional as F
zs = F.normalize(proj_s(pointnet(points)), dim=-1)       # (B, d) shape embeddings
zt = F.normalize(proj_t(text_encoder(titles)), dim=-1)   # (B, d); text_encoder frozen
S = zs @ zt.T / tau                                      # (B, B) similarities
y = torch.arange(len(S))
loss = 0.5 * (F.cross_entropy(S, y) + F.cross_entropy(S.T, y))   # InfoNCE, both directions

9. Course research notes — Geometric Data Analysis (Ovsjanikov)

Maks Ovsjanikov heads the Geometric Data Analysis group at LIX (École Polytechnique). The four publications below are not merely “references” for this course: they are the course — every chapter from 2 to 6 stems directly from them.

Exercises

1. ★ Cotangents. Verify that the stiffness matrix L_c is symmetric and that L_c\mathbf{1} = 0. On a flat mesh, check that the coordinate functions are discretely harmonic — (L_c x)_i = (L_c y)_i = 0 at every interior vertex (linear precision) — whereas a generic f, such as \sin(3x)\,y^2, gives L_c f \ne 0.
2. ★ Gauss–Bonnet on the cube. Verify numerically theorem 1.3 on the cube meshed into 12 triangles; what happens to the sum of deficits if each face is subdivided into 4? (answer: unchanged — why?).
3. ★ Spectrum = fingerprint. Compute the first 20 eigenvalues of \Delta for two rigid shapes and their articulated (bent) versions; plot the superimposed spectra and comment on the isometric invariance.
4. ★ Heat kernel and PDEs. Verify that h_t(x, y) = \sum_k e^{-\lambda_k t}\phi_k(x)\phi_k(y) solves \partial_t h_t = \Delta_y h_t, h_0(x, y) = \delta_x(y), and deduce that u(t) = e^{t\Delta}u_0 diffuses any initial condition.
5. ★ EGNN invariance. In the EGNN equations recalled in ch. 7, show that the messages m_{ij} depend only on distances that are invariant under E(n), and that the position update is equivariant; compare your proof with Graph ML, Proposition 8.3.
6. ★★ Stiffness of a triangle. On a triangle T = (i, j, k) with hat functions \psi_i, \psi_j, \psi_k, show that \int_T \langle\nabla\psi_i, \nabla\psi_j\rangle\, dA = -\frac12\cot\theta_k, where \theta_k is the angle at vertex k, opposite to edge (i,j).
7. ★★ HKS. Show that \mathrm{HKS}(x, t) is isometrically invariant; compute and visualize multi-scale HKS on a FAUST human — identify the “self-descriptive points” (hands, head).
8. ★★ Toy functional map. Two known isometric meshes: build C by least squares (descriptor + commutation constraints); reconstruct the correspondence; measure the mean geodesic error; what happens if k is too small?
9. ★★ Spectral commutation. Show that if T : \mathcal M \to \mathcal N is an isometry, then T_F \Delta_{\mathcal M} = \Delta_{\mathcal N} T_F, and that in the eigenbasis this forces C\Lambda_{\mathcal M} \approx \Lambda_{\mathcal N} C — hence the structure (almost block-diagonal over clusters of close eigenvalues) of C.
10. ★★ PointNet invariance. Show that max pooling and the product are permutation-invariant, but that the product is numerically unstable (explosion/underflow of multiplicative gradients) while the mean dilutes local signals; implement the three aggregators and check on a permuted cloud (stability + selectivity of a discriminative sub-region).
11. ★★★ DiffusionNet vs GCN. On FAUST (correspondence): compare a GCN on the graph of the mesh vs DiffusionNet (learned diffusion times); discuss why diffusion is a good geometric “mixer”.
    • Data: FAUST (Bogo et al., CVPR 2014; free registration at faust.is.tue.mpg.de): 100 registered human scans, 10 people × 10 poses, all with the same 6,890-vertex template, so vertex i of one scan corresponds to vertex i of every other — the ground truth. Train on scans 0–79, test on 80–99.
    • Robustness set: the remeshed FAUST of Ren et al. (2018), about 5,000 vertices per shape with different connectivities, distributed with its correspondences to the template.
    • Setup: pip install torch potpourri3d robust_laplacian, clone github.com/nmwsharp/diffusion-net, precompute and cache the operators once (recipe of ch. 6); a free GPU tier is enough.
    • Protocol: both networks output per-vertex features fed to the functional-map head of Architecture 6.3; report the mean geodesic error, normalised by the square root of the area, on the original and on the remeshed test shapes.
12. ★★★ Project. Shape retrieval: extract (HKS, spectrum, curvatures) → aggregation → similarity by optimal transport (W_1 on descriptor distributions); evaluate the mAP on a subset of SHREC; the three connections of the course at work.
    • Data: the SHREC’11 non-rigid track (Lian et al., 2011), 600 watertight meshes in 30 classes of 20 shapes in various poses. A subset of 10 classes × 20 shapes is enough; the simplified versions distributed with MeshCNN (Hanocka et al., 2019) load in seconds.
    • Pipeline: per shape, normalise to unit area and compute 100 eigenpairs; then the HKS (16 times, ch. 3), the WKS, ShapeDNA (the first 50 eigenvalues) and a histogram of the angle deficit (ch. 1). Compare two shapes by W_1 between their area-weighted HKS distributions with POT’s ot.emd2 (box OT in one page, ch. 0).
    • Evaluation: each shape queries the 199 others; report the mean average precision (mAP) and compare with the baseline ShapeDNA + Euclidean distance.

Projects and assessment

The official assessment is not displayed: the SynapseS 2026–2027 sheet of this course unit is not yet published, and the master’s wiki gives only its volume (24 h), credits (2 ECTS) and instructor. Everything below is therefore a proposal: project subjects at the scale of a course project, a written exam and a rubric.

The projects exercise mainly O4 (graph-structured and geometric data) and O6 (3D data as a modality), O5 (graphs × language) through the worked bridges of ch. 8, and O7 (hands-on work on real datasets) throughout. They are course-sized versions of the Year 2 transverse-project subjects (Y2.1–Y2.5), which all draw on this module.

Solo projects

1. [Solo · ≈ 25 h] Why matching collapses under remeshing. Papers: Sharp, Attaiki, Crane and Ovsjanikov (2022), DiffusionNet; Melzi et al. (2019), ZoomOut.
   • Question: which correspondence pipelines survive a change of mesh, and why do the others fail — the collapse described in the introduction?
   • Work: on FAUST and its remeshed version (setup of Ex. 11), compare a GCN on raw XYZ, HKS/WKS functional maps (Resolution 4.3), the same refined by ZoomOut, and DiffusionNet with a functional-map head (Architecture 6.3). Plot the mean geodesic error against k and against mesh resolution, and explain each failure with ch. 2 (graph Laplacian vs cotangent Laplacian, eigenvalue drift across meshes).
   • Success: a table original vs remeshed for the four pipelines over 3 seeds, in which every degradation larger than the seed spread is explained by a measured cause.
   • Deliverables: code, 4–6 page report, 10-minute talk. Chapters: ch. 2, ch. 3, ch. 4, ch. 6.
2. [Solo · ≈ 25 h] Equivariant 3D molecular property prediction. Paper: Satorras, Hoogeboom and Welling (2021), EGNN. Connects this course to Graph ML, ch. 8 and Graph Generative Models, ch. 8.
   • Question: how much training data does built-in E(3) equivariance save on molecular property prediction?
   • Work: implement an EGNN layer (recall of ch. 7) and test its equivariance with random orthogonal matrices and translations. On QM9 (Ramakrishnan et al., 2014; torch_geometric.datasets.QM9), predict the HOMO–LUMO gap with the EGNN and with a non-equivariant GNN fed raw coordinates, with and without rotation augmentation, for 1k, 5k and 20k training molecules.
   • Success: learning curves over 3 seeds; an equivariance error at float precision (relative error below 10^{-5} in float32); a clear statement of where augmentation closes the gap and where it does not. Stretch goal: an EGNN denoiser for a tiny conformer DDPM (recall of ch. 8).
   • Deliverables: code, 4–6 page report, 10-minute talk. Chapters: ch. 7, ch. 8.
3. [Solo · ≈ 20 h] From raw scans to texture transfer. Papers: Kazhdan, Bolitho and Hoppe (2006), Poisson reconstruction; Lévy et al. (2002), LSCM.
   • Question: how much distortion does each flattening method introduce, and can a functional map carry a texture from one person to another?
   • Work: from two raw FAUST scans (FAUST ships raw scans next to the registrations), run Poisson reconstruction and quadric decimation (Open3D); cut a disk-like patch and flatten it with Tutte (uniform weights), cotangent-harmonic, LSCM and ARAP maps; measure angle and area distortion and count folded triangles. Then transfer a texture between the two registrations with a functional map (ch. 4).
   • Success: a four-method distortion table; a fold count per method — zero for uniform weights, as Tutte guarantees, and for cotangent weights the folds, if any, traced to negative-weight edges (perturb the patch to create obtuse triangles if none occur); a texture-error map against the ground-truth correspondence.
   • Deliverables: code, 4–6 page report, 10-minute talk. Chapters: ch. 4, ch. 5.

Group projects

1. [Group of 3 · ≈ 30 h each] Spectral shape retrieval with optimal transport. Papers: Mémoli (2011), Gromov–Wasserstein distances and the metric approach to object matching; Reuter, Wolter and Peinecke (2006), ShapeDNA. Connects this course to Optimal Transport, ch. 5.
   • Question: on non-rigid shapes, which pair (descriptor, transport distance) retrieves best, and at what cost?
   • Work: extend Ex. 12 on the SHREC’11 subset. Descriptors: HKS, WKS, ShapeDNA, curvature histograms. Distances: W_1, Sinkhorn, and Gromov–Wasserstein on geodesic or diffusion distance matrices (POT). Ablate the time grid, k and the entropic regularisation; probe isospectral pairs (the Gordon–Webb–Wolpert drums, meshed in 2D) and near-isometric failure cases.
   • Split: descriptors and spectra; transport distances and their cost; evaluation, ablations and failure cases.
   • Success: an mAP table with bootstrap intervals over queries, a cost–accuracy plot, and at least one failure explained by the theory of ch. 3.
   • Deliverables: code, joint 8–10 page report, 20-minute talk. Chapters: ch. 0 (OT box), ch. 1, ch. 3, ch. 8.
2. [Group of 3 · ≈ 30 h each] Text-to-shape retrieval: 3D tokens for an LLM. Data: ABO, Amazon Berkeley Objects (Collins et al., 2022). Connects this course to Large Language Models, 8.2b and prepares the Y2.3 subject.
   • Question: can a shape encoder trained against a frozen text encoder answer language queries over a 3D catalogue, and does it survive remeshing?
   • Work: Bridge C of ch. 8 at full scale — PointNet and DiffusionNet shape towers, a frozen text tower, InfoNCE. Then expose retrieval to an LLM, either as a tool that returns the top-k shape identifiers or through a trained projector that turns the shape embedding into a soft token.
   • Split: data and shape towers; contrastive training and evaluation; LLM interface and robustness study.
   • Success: Recall@1, 5 and 10 (text → shape) on held-out products with bootstrap intervals, Recall@10 at least five times the chance level; the drop under remeshing reported for each tower; one logged end-to-end demo.
   • Deliverables: code, joint 8–10 page report, 20-minute talk with the demo. Chapters: ch. 6, ch. 8.
3. [Group of 3 · ≈ 30 h each] Graph alignment with functional maps, reproduced. Paper: Hermanns, Tsitsulin, Munkhoeva, Bronstein, Mottin and Karras (2021), GRASP: Graph Alignment through Spectral Signatures. Connects this course to Graph ML, ch. 4 and Advanced GNN, ch. 4; seed of the Y2.1 subject.
   • Question: how far does Bridge B go on real networks with noise, and what do GRASP’s extra steps buy?
   • Work: SNAP graphs (ego-Facebook, 4,039 nodes; CA-GrQc, 5,242 nodes), each permuted with 0–5% of its edges removed, largest connected component kept. Implement Bridge B with sparse eigensolvers, then GRASP’s base alignment and a ZoomOut-style refinement; compare with a Hungarian matching on HKS columns alone.
   • Split: data and noise protocol; spectral pipeline and refinement; evaluation, twin ceiling and scaling to 10^4 nodes.
   • Success: accuracy-vs-noise curves over 5 seeds with the twin ceiling marked, and a measured answer to “which step brings which gain”.
   • Deliverables: code, joint 8–10 page report, 20-minute talk. Chapters: ch. 3, ch. 4, ch. 8.

Written exam (proposal)

Two hours, one handwritten A4 sheet allowed, no electronic device; four questions.

1. Question (5 points). A matching pipeline built on raw XYZ coordinates works on test shapes in the training pose, but fails on bent poses and on remeshed copies. Explain both failures, name the tools of the course that fix each one, and give one limit of these fixes. Expected: XYZ is extrinsic, so it changes under rotation and isometric bending, while the spectrum and the HKS are intrinsic (Theorem 2.5). A graph Laplacian depends on connectivity; the cotangent Laplacian converges to \Delta_{\mathcal M} and DiffusionNet needs only operators. Limits: isospectral shapes, intrinsic symmetries, scale, multiple eigenvalues.

2. Question (7 points). A regular octahedron with unit edges has its six vertices at (\pm r, 0, 0), (0, \pm r, 0), (0, 0, \pm r), with r = 1/\sqrt2.

   1. Compute the angle deficit at each vertex and check Theorem 1.3. (b) Compute the cotangent weight w_{ij} of an edge and the barycentric area A_i. (c) Compute H_i\mathbf{n}_i = \tfrac12(M^{-1}L_c\mathbf{x})_i at (r, 0, 0) and compare with the circumscribed sphere.

   Expected: (a) four angles of \pi/3 meet at each vertex, so the deficit is 2\pi/3, and 6 \times \frac{2\pi}{3} = 4\pi = 2\pi\chi, \qquad \chi = 6 - 12 + 8 = 2 .

   2. Both opposite angles are 60°, so w_{ij} = \tfrac12\cdot\tfrac{2}{\sqrt3} = 1/\sqrt3. Four triangles of area \sqrt3/4 meet at each vertex, so A_i = 4 \cdot \tfrac13 \cdot \tfrac{\sqrt3}{4} = 1/\sqrt3.

   3. The four neighbours of (r,0,0) are (0,\pm r,0) and (0,0,\pm r); their differences with the vertex sum to (4r, 0, 0), so (L_c\mathbf{x})_i = \frac{1}{\sqrt3}\,(4r, 0, 0), \qquad H_i\mathbf{n}_i = \tfrac12\sqrt3\cdot\frac{1}{\sqrt3}(4r,0,0) = (\sqrt2, 0, 0). The normal points outward and H_i = \sqrt2 = 1/r, exactly the mean curvature of the circumscribed sphere.

3. Question (5 points). Let T : \mathcal M \to \mathcal N be an isometry and T_F(g) = g \circ T^{-1}, and let C be its matrix in orthonormal eigenbases, as in Theorem 4.1: C_{ij} = \big\langle\phi_i^{\mathcal N},\, T_F\phi_j^{\mathcal M}\big\rangle .

   1. Prove that C\Lambda_{\mathcal M} = \Lambda_{\mathcal N}C. (b) Prove that C^\top C = I when complete bases are used.

   Expected: (a) Theorem 2.5 gives T_F\Delta_{\mathcal M} = \Delta_{\mathcal N}T_F. Compute one inner product in two ways, using the self-adjointness of \Delta_{\mathcal N}: -\lambda_i^{\mathcal N}C_{ij} = \big\langle \Delta_{\mathcal N}\phi_i^{\mathcal N}, T_F\phi_j^{\mathcal M}\big\rangle = \big\langle \phi_i^{\mathcal N}, T_F\Delta_{\mathcal M}\phi_j^{\mathcal M}\big\rangle = -\lambda_j^{\mathcal M}C_{ij}. Hence, for all i, j, C_{ij}\big(\lambda_j^{\mathcal M} - \lambda_i^{\mathcal N}\big) = 0, which is the entrywise form of C\Lambda_{\mathcal M} = \Lambda_{\mathcal N}C.

   2. An isometry preserves areas, hence the inner products of functions. By Parseval in the complete basis of \mathcal N: (C^\top C)_{jl} = \sum_i C_{ij}C_{il} = \big\langle T_F\phi_j^{\mathcal M}, T_F\phi_l^{\mathcal M}\big\rangle = \big\langle \phi_j^{\mathcal M}, \phi_l^{\mathcal M}\big\rangle = \delta_{jl}.

4. Question (3 points). In DiffusionNet, the gradient of a feature at a vertex is a complex number z written in an arbitrary tangent frame. Show that z depends on the frame but g = \mathrm{Re}(\bar z\,a z), with a learned a \in \mathbb{C}, does not. Why does the diffusion step need no frame at all?

   Expected: rotating the frame by \theta maps z to e^{-\mathrm{i}\theta}z, so z itself rotates, while \overline{e^{-\mathrm{i}\theta}z}\;a\,e^{-\mathrm{i}\theta}z = e^{\mathrm{i}\theta}e^{-\mathrm{i}\theta}\,\bar z\,a z = \bar z\,a z . Diffusion e^{t\Delta} acts on scalar functions through the intrinsic, isotropic operator \Delta: no direction is ever chosen.

Grading rubric (proposal)

References

• M. Ovsjanikov, M. Ben-Chen, J. Solomon, A. Butscher, L. Guibas, Functional Maps: A Flexible Representation of Maps Between Shapes, SIGGRAPH 2012 — the founding paper of the course.
• N. Sharp, S. Attaiki, K. Crane, M. Ovsjanikov, DiffusionNet: Discretization Agnostic Learning on Surfaces, TOG 2022; S. Melzi, J. Ren, E. Rodolà, A. Sharma, P. Wonka, M. Ovsjanikov, ZoomOut: Spectral Upsampling for Efficient Shape Correspondence, SIGGRAPH Asia 2019; J. Sun, M. Ovsjanikov, L. Guibas, A Concise and Provably Informative Multi-Scale Signature Based on Heat Kernel (HKS), SGP 2009.
• M. Bronstein et al., Shape Analysis: Foundations and Trends (non-rigid shape); Geometric Deep Learning: Going beyond Euclidean Data, IEEE SPM 2017; Geometric Deep Learning: Grids, Groups, Graphs, Geodesics, and Gauges (the “blueprint”), 2021.
• C. Qi et al., PointNet, CVPR 2017; PointNet++, NeurIPS 2017; Y. Wang et al., Dynamic Graph CNN for Learning on Point Clouds (DGCNN/EdgeConv), TOG 2019.
• V. Satorras, E. Hoogeboom, M. Welling, E(n) Equivariant Graph Neural Networks (EGNN), ICML 2021.
• K. Crane, F. de Goes, M. Desbrun, P. Schröder, Digital Geometry Processing with Discrete Exterior Calculus, 2013 — the reference DGP course; U. Pinkall & K. Polthier, Computing Discrete Minimal Surfaces and Their Conjugates (discrete Dirichlet and cotangents), 1993; M. Meyer, M. Desbrun, P. Schröder, A. Barr, Discrete Differential-Geometry Operators for Triangulated 2-Manifolds (mixed Voronoi, deficit), 2003.
• D. Boscaini et al., Learning Spectral Descriptors / Geodesic CNN — the entry of deep learning on surfaces; M. Aubry, U. Schlickewei, D. Cremers (Wave Kernel Signature), ICCV 2011; M. Reuter, F. Wolter, N. Peinecke (ShapeDNA), CAD 2006.
• C. Gordon, D. Webb, S. Wolpert, One cannot hear the shape of a drum, Bull. AMS 1992 (isospectral but not isometric); R. Kimmel & J. Sethian, Computing Geodesic Paths on Manifolds (Fast Marching), PNAS 1998; K. Crane, C. Weischedel, M. Wardetzky, The Heat Method for Distance Computation, TOG 2013.
• M. Garland & P. Heckbert, Surface Simplification Using Quadric Error Metrics, SIGGRAPH 1997; L. Liu, L. Zhang, Y. Xu, C. Gotsman, S. Gortler, A Local/Global Approach to Mesh Parameterization (ARAP), SGP 2008; M. Kazhdan, M. Bolitho, H. Hoppe, Poisson Surface Reconstruction, SGP 2006.
• Added with the 2026 revision: M. Bronstein, I. Kokkinos, Scale-Invariant Heat Kernel Signatures for Non-rigid Shape Recognition, CVPR 2010; B. Lévy, S. Petitjean, N. Ray, J. Maillot, Least Squares Conformal Maps for Automatic Texture Atlas Generation, SIGGRAPH 2002; W. Tutte, How to Draw a Graph, Proc. LMS 1963; M. Floater, One-to-one Piecewise Linear Mappings over Triangulations, Math. Comp. 2003, and Mean Value Coordinates, CAGD 2003; N. Sharp, K. Crane, A Laplacian for Nonmanifold Triangle Meshes (with the point-cloud Laplacian), SGP 2020.
• Learned functional maps: O. Litany et al., Deep Functional Maps (FMNet), ICCV 2017; J.-M. Roufosse, A. Sharma, M. Ovsjanikov, Unsupervised Deep Learning for Structured Shape Matching, ICCV 2019; N. Donati, A. Sharma, M. Ovsjanikov, Deep Geometric Functional Maps (GeomFMaps), CVPR 2020.
• Bridges and projects: J. Hermanns, A. Tsitsulin, M. Munkhoeva, A. Bronstein, D. Mottin, P. Karras, GRASP: Graph Alignment through Spectral Signatures, APWeb-WAIM 2021; M. Kim, J. Park, J. Park, Sym-NCO: Leveraging Symmetricity for Neural Combinatorial Optimization, NeurIPS 2022; J. Collins et al., ABO: Dataset and Benchmarks for Real-World 3D Object Understanding, CVPR 2022; E. Hoogeboom, V. Satorras, C. Vignac, M. Welling, Equivariant Diffusion for Molecule Generation in 3D, ICML 2022; F. Mémoli, Gromov–Wasserstein Distances and the Metric Approach to Object Matching, Found. Comput. Math. 2011; L. Rampášek et al., Recipe for a General, Powerful, Scalable Graph Transformer (GPS), NeurIPS 2022; S. Xie et al., PointContrast, ECCV 2020.
• Datasets: F. Bogo, J. Romero, M. Loper, M. Black, FAUST, CVPR 2014; J. Ren, A. Poulenard, P. Wonka, M. Ovsjanikov, Continuous and Orientation-preserving Correspondences via Functional Maps (remeshed FAUST/SCAPE), SIGGRAPH Asia 2018; Z. Lian et al., SHREC’11 Track: Shape Retrieval on Non-rigid 3D Watertight Meshes, 3DOR 2011; R. Ramakrishnan et al., Quantum Chemistry Structures and Properties of 134 kilo Molecules (QM9), Scientific Data 2014.
• libigl; Discrete Differential Geometry (Caltech/Coursera) — the tools of the lab sessions.