File size: 3,740 Bytes
4fd2269 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 | #!/usr/bin/env python3
"""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
# Start global node list with graph vertices; edge-interior FE nodes follow.
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]:
# center 0, leaves 1..m
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))
|