File size: 9,213 Bytes
4aa7bc6 | 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 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 | """Exact half-cell spectral certificates and a rational-length rigidity classifier.
No floating-point eigensolver is used by exact_halfcell_spectrum. At frequency pi,
subdivision into edges of length 1/2 reduces the eigenvalue count to rational
inertia of a vertex adjacency matrix. See MANUSCRIPT, computational appendix.
"""
from __future__ import annotations
from dataclasses import dataclass
from fractions import Fraction
from typing import Iterable
import networkx as nx
import sympy as sp
@dataclass(frozen=True)
class Edge:
u: int
v: int
length: Fraction
def __post_init__(self):
object.__setattr__(self, 'length', Fraction(self.length))
if self.length <= 0:
raise ValueError('Edge lengths must be strictly positive.')
def graph(edges: Iterable[Edge], dirichlet=()) -> nx.MultiGraph:
es = list(edges)
if not es:
raise ValueError('At least one edge is required.')
g = nx.MultiGraph()
for e in es:
g.add_edge(e.u, e.v, length=e.length)
ds = set(dirichlet)
if not nx.is_connected(g):
raise ValueError('The graph must be connected.')
if not ds <= set(g):
raise ValueError('Unknown Dirichlet vertex.')
if any(g.degree(v) != 1 for v in ds):
raise ValueError('This release allows Dirichlet conditions only at leaves.')
nx.set_node_attributes(g, {v: v in ds for v in g}, 'D')
return g
def suppress_degree_two(g: nx.MultiGraph) -> nx.MultiGraph:
g = g.copy()
while True:
changed = False
for v in list(g):
if g.degree(v) != 2 or g.nodes[v].get('D', False):
continue
inc = list(g.edges(v, keys=True, data=True))
if len(inc) != 2 or any(a == b for a, b, _, _ in inc):
continue # A single circle remains a loop and is excluded later.
ends = [b if a == v else a for a, b, _, _ in inc]
length = sum((z[3]['length'] for z in inc), Fraction())
g.remove_node(v)
g.add_edge(ends[0], ends[1], length=length)
changed = True
break
if not changed:
return g
def parameters(g):
d = sum(bool(g.nodes[v].get('D', False)) for v in g)
n = sum(g.degree(v) == 1 and not g.nodes[v].get('D', False) for v in g)
beta = g.number_of_edges() - g.number_of_nodes() + 1
length = sum((x['length'] for _, _, x in g.edges(data=True)), Fraction())
return d, n, beta, length
def classify(edges: Iterable[Edge], dirichlet=(), k: int | None = None):
"""Classify exact high-branch saturation using rational arithmetic.
If k=None, test the threshold pi^2 (d=1). Otherwise d=L/(k-(N+beta)/2).
A False answer means non-saturation in the declared regime, not a numerical
lower bound on the amount of strictness.
"""
g = suppress_degree_two(graph(edges, dirichlet))
D, N, beta, L = parameters(g)
B = N + beta
if len(g) == 1 and g.number_of_edges() == 1:
return dict(saturated=False, family='excluded-circle', reason='The circle has a different bound.')
if k is None:
candidate = L + Fraction(B, 2)
if candidate.denominator != 1:
return dict(saturated=False, family='none', reason='The proposed index is not integral.')
k = int(candidate)
d = Fraction(1)
else:
if not isinstance(k, int):
raise ValueError('k must be an integer.')
c = Fraction(k) - Fraction(B, 2)
if c <= 0:
return dict(saturated=False, family='outside-regime', reason='Nonpositive target frequency.')
d = L / c
base = dict(k=k, D=D, N=N, beta=beta, d=str(d), multiplicity=D+N+2*beta-1)
if k < max(B, 1 if D else 2):
return dict(base, saturated=False, family='outside-regime', reason='Outside the high-index theorem.')
q = lambda x: 2*x/d
def positive_integer(x):
return x.denominator == 1 and x > 0
if len(g) == 1 and g.number_of_edges() == 2:
good = all(positive_integer(x['length']/(2*d)) for _, _, x in g.edges(data=True))
return dict(base, saturated=good, family='figure-eight', reason='Both loop lengths must be positive even cell counts.')
if len(g) == 2 and g.number_of_edges() == 3 and nx.number_of_selfloops(g) == 0:
counts = [x['length']/d for _, _, x in g.edges(data=True)]
good = all(positive_integer(x) for x in counts) and len({int(x) % 2 for x in counts}) == 1
return dict(base, saturated=good, family='theta', reason='Three positive integer cell counts of common parity.')
skeleton = g.copy()
loop_vertices = set()
for a, b, key, x in list(g.edges(keys=True, data=True)):
if a == b:
if g.degree(a) != 3 or a in loop_vertices:
return dict(base, saturated=False, family='excluded-topology', reason='A nonexceptional loop must be pendant at a degree-three vertex.')
if not positive_integer(x['length']/(2*d)):
return dict(base, saturated=False, family='lasso-tree', reason='An attached loop has incompatible phase.')
loop_vertices.add(a)
skeleton.remove_edge(a, b, key)
if len(skeleton) < 2 or not nx.is_tree(skeleton):
return dict(base, saturated=False, family='excluded-topology', reason='The nonloop skeleton must be a tree.')
virtual_N = loop_vertices | {v for v in g if g.degree(v) == 1 and not g.nodes[v].get('D', False)}
for a, b, x in skeleton.edges(data=True):
nu = int(a in virtual_N) + int(b in virtual_N)
m = x['length']/d - Fraction(nu, 2)
if m.denominator != 1 or m < 0 or (nu == 0 and m < 1):
return dict(base, saturated=False, family='lasso-tree' if beta else 'tree', reason='A skeleton edge violates the integer/half-integer phase rule.')
return dict(base, saturated=True, family='lasso-tree' if beta else 'tree', reason='All exact topology and metric conditions hold.')
def rational_inertia(matrix):
"""Return (positive, negative, zero) using exact 1x1/2x2 congruences."""
A = sp.Matrix(matrix)
if A != A.T:
raise ValueError('A symmetric matrix is required.')
pos = neg = zero = 0
while A.rows:
size = A.rows
pivot = next((i for i in range(size) if A[i,i] != 0), None)
if pivot is not None:
perm = [pivot] + [i for i in range(size) if i != pivot]
A = A.extract(perm, perm)
a = A[0,0]
pos += int(bool(a > 0)); neg += int(bool(a < 0))
v = A[1:,0]
A = A[1:,1:] - v*v.T/a
else:
pair = next(((i,j) for i in range(size) for j in range(i+1,size) if A[i,j] != 0), None)
if pair is None:
zero += size
break
i,j = pair
perm = [i,j] + [h for h in range(size) if h not in (i,j)]
A = A.extract(perm, perm)
pivot_block = A[:2,:2]
X = A[2:,:2]
A = A[2:,2:] - X*pivot_block.inv()*X.T
pos += 1; neg += 1
return pos, neg, zero
def exact_halfcell_spectrum(edges: Iterable[Edge], dirichlet=()):
"""Exact counts below/at pi^2; lengths must be positive multiples of 1/2."""
es = list(edges)
g = graph(es, dirichlet)
ds = set(dirichlet)
vertices = {v:i for i,v in enumerate(g)}
next_node = len(vertices)
segments = []
for e in es:
q = 2*e.length
if q.denominator != 1:
raise ValueError('All lengths must be integer multiples of 1/2.')
count = int(q)
nodes = [vertices[e.u]] + list(range(next_node, next_node+count-1)) + [vertices[e.v]]
next_node += count-1
segments += list(zip(nodes[:-1],nodes[1:]))
A = sp.zeros(next_node)
for a,b in segments:
A[a,b] += 1
A[b,a] += 1 # A loop contributes two on the diagonal.
keep = [i for i in range(next_node) if i not in {vertices[v] for v in ds}]
A = A.extract(keep,keep)
pos, neg, zero = rational_inertia(A)
return dict(below=pos, multiplicity=zero, top_index=pos+zero, adjacency_dimension=len(keep), adjacency_inertia=[pos,neg,zero])
def threshold_multiplicity(edges: Iterable[Edge], dirichlet=()):
"""Independent exact ODE coefficient-nullity check at frequency pi."""
es = list(edges)
g = graph(es, dirichlet)
ds = set(dirichlet)
traces = {v:[] for v in g}; derivatives = {v:[] for v in g}
n = 2*len(es)
for j,e in enumerate(es):
q = 2*e.length
if q.denominator != 1:
raise ValueError('Half-cell lengths are required.')
c = (1,0,-1,0)[int(q)%4]; s = (0,1,0,-1)[int(q)%4]
t0=sp.zeros(1,n); t1=sp.zeros(1,n); p0=sp.zeros(1,n); p1=sp.zeros(1,n)
t0[2*j]=1; t1[2*j]=c; t1[2*j+1]=s
p0[2*j+1]=1; p1[2*j]=s; p1[2*j+1]=-c
traces[e.u].append(t0); traces[e.v].append(t1)
derivatives[e.u].append(p0); derivatives[e.v].append(p1)
rows=[]
for v in g:
if v in ds:
rows.append(traces[v][0])
else:
rows += [t-traces[v][0] for t in traces[v][1:]]
rows.append(sum(derivatives[v],sp.zeros(1,n)))
M=sp.Matrix.vstack(*rows)
return n-M.rank()
|