#!/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))