| |
| """Simple P1 finite-element eigenvalue solver for compact metric trees. |
| |
| Dirichlet conditions are imposed at every degree-one graph vertex. |
| Interior graph vertices use the natural Kirchhoff condition generated by the |
| continuous H1 finite-element space. |
| |
| This code is for numerical regression checks only; it is not part of the proof. |
| """ |
|
|
| from __future__ import annotations |
|
|
| from dataclasses import dataclass |
| from typing import Dict, List, Tuple |
| import math |
| import numpy as np |
| from scipy.linalg import eigh |
|
|
|
|
| @dataclass(frozen=True) |
| class Edge: |
| u: int |
| v: int |
| length: float |
|
|
|
|
| def assemble_tree(edges: List[Edge], elements_per_unit: int = 240): |
| if not edges: |
| raise ValueError("at least one edge is required") |
| if any(e.length <= 0 for e in edges): |
| raise ValueError("all edge lengths must be positive") |
|
|
| vertices = sorted({e.u for e in edges} | {e.v for e in edges}) |
| vid = {v: i for i, v in enumerate(vertices)} |
| degree: Dict[int, int] = {v: 0 for v in vertices} |
| for e in edges: |
| degree[e.u] += 1 |
| degree[e.v] += 1 |
|
|
| |
| next_node = len(vertices) |
| edge_nodes: List[List[int]] = [] |
| edge_nelems: List[int] = [] |
| for e in edges: |
| ne = max(4, int(round(elements_per_unit * e.length))) |
| edge_nelems.append(ne) |
| nodes = [vid[e.u]] |
| for _ in range(ne - 1): |
| nodes.append(next_node) |
| next_node += 1 |
| nodes.append(vid[e.v]) |
| edge_nodes.append(nodes) |
|
|
| n = next_node |
| K = np.zeros((n, n), dtype=float) |
| M = np.zeros((n, n), dtype=float) |
|
|
| for e, nodes, ne in zip(edges, edge_nodes, edge_nelems): |
| h = e.length / ne |
| ke = np.array([[1.0, -1.0], [-1.0, 1.0]]) / h |
| me = (h / 6.0) * np.array([[2.0, 1.0], [1.0, 2.0]]) |
| for a, b in zip(nodes[:-1], nodes[1:]): |
| idx = np.ix_([a, b], [a, b]) |
| K[idx] += ke |
| M[idx] += me |
|
|
| dirichlet_nodes = {vid[v] for v in vertices if degree[v] == 1} |
| free = np.array([i for i in range(n) if i not in dirichlet_nodes], dtype=int) |
| if len(free) == 0: |
| raise ValueError("no free degrees of freedom") |
|
|
| Kr = K[np.ix_(free, free)] |
| Mr = M[np.ix_(free, free)] |
| return Kr, Mr, degree |
|
|
|
|
| def eigenvalues(edges: List[Edge], count: int, elements_per_unit: int = 240) -> np.ndarray: |
| K, M, _ = assemble_tree(edges, elements_per_unit=elements_per_unit) |
| vals = eigh(K, M, subset_by_index=(0, min(count - 1, K.shape[0] - 1)), eigvals_only=True) |
| vals = np.asarray(vals, dtype=float) |
| vals[vals < 0] = np.maximum(vals[vals < 0], -1e-10) |
| return vals |
|
|
|
|
| def polya_value(k: int, total_length: float) -> float: |
| return (math.pi * k / total_length) ** 2 |
|
|
|
|
| def normalized_defect(lam: float, k: int, total_length: float) -> float: |
| return lam / polya_value(k, total_length) - 1.0 |
|
|
|
|
| def star(lengths: List[float]) -> List[Edge]: |
| |
| return [Edge(0, i + 1, float(L)) for i, L in enumerate(lengths)] |
|
|
|
|
| def double_branch_tree(lengths: List[float]) -> List[Edge]: |
| """Five-edge tree with two degree-3 branching vertices. |
| |
| Topology: |
| 1 -- 0 -- 3 -- 4 |
| | | |
| 2 5 |
| |
| Edge order: (0,1), (0,2), (0,3), (3,4), (3,5) |
| """ |
| if len(lengths) != 5: |
| raise ValueError("five lengths required") |
| pairs = [(0, 1), (0, 2), (0, 3), (3, 4), (3, 5)] |
| return [Edge(u, v, float(L)) for (u, v), L in zip(pairs, lengths)] |
|
|
|
|
| if __name__ == "__main__": |
| e = star([1 / 3, 1 / 3, 1 / 3]) |
| vals = eigenvalues(e, count=8) |
| for i, val in enumerate(vals, start=1): |
| print(i, val, normalized_defect(val, i, 1.0)) |
|
|
