import math import random from collections import defaultdict from itertools import combinations from typing import Dict, List, Tuple, Set, FrozenSet, Optional import numpy as np Face = FrozenSet[int] def all_faces(simplex: Tuple[int, ...], dim_face: int) -> List[Face]: k = dim_face + 1 if k <= 0: return [] return [frozenset(c) for c in combinations(simplex, k)] class EnergyDistribution: def __init__(self, kind: str = "uniform_int", params: Optional[dict] = None, seed: Optional[int] = None): self.kind = kind self.params = params or {} self.rng = random.Random(seed) def sample(self) -> int: if self.kind == "uniform_int": lo = int(self.params.get("low", 0)) hi = int(self.params.get("high", 10)) return self.rng.randrange(lo, hi) elif self.kind == "poisson": lam = float(self.params.get("lam", 4.0)) return int(np.random.poisson(lam)) elif self.kind == "custom_list": values = self.params.get("values", [0, 1, 2, 3, 4, 5]) return self.rng.choice(values) else: lo = int(self.params.get("low", 0)) hi = int(self.params.get("high", 10)) return self.rng.randrange(lo, hi) class NGFGenerator: def __init__( self, d: int = 2, s: int = 0, beta: float = 0.0, energy_dist: Optional[EnergyDistribution] = None, seed: Optional[int] = None, ): assert d >= 1 assert s in (-1, 0, 1) assert beta >= 0.0 self.d = int(d); self.s = int(s); self.beta = float(beta) self.energy_dist = energy_dist or EnergyDistribution("uniform_int", {"low": 0, "high": 10}, seed=seed) self.rng = random.Random(seed) np.random.seed(seed if seed is not None else None) self.N = 0 self.nodes: List[int] = [] self.node_energy: Dict[int, int] = {} self.simplexes_d: List[Tuple[int, ...]] = [] self.face_n: Dict[Face, int] = {} self.face_counts: Dict[int, Dict[Face, int]] = {delta: defaultdict(int) for delta in range(self.d)} self.edges: Set[Tuple[int, int]] = set() self.area_history: List[int] = [] self.volume_history: List[int] = [] self.steps = 0 def _add_node(self, energy: Optional[int] = None) -> int: i = self.N self.nodes.append(i) eps = energy if energy is not None else self.energy_dist.sample() self.node_energy[i] = int(eps) self.N += 1 return i def _face_energy(self, face: Face) -> int: return sum(self.node_energy[i] for i in face) def _update_area_volume(self): A = sum(1 for f, n in self.face_n.items() if n == 0) V = len(self.simplexes_d) self.area_history.append(A) self.volume_history.append(V) def _register_simplex(self, simplex: Tuple[int, ...]): simplex = tuple(sorted(simplex)) self.simplexes_d.append(simplex) for delta in range(self.d): for face in all_faces(simplex, delta): self.face_counts[delta][face] += 1 for face in all_faces(simplex, self.d - 1): if face not in self.face_n: self.face_n[face] = 0 else: self.face_n[face] += 1 if self.d >= 1: for e in all_faces(simplex, 1): u, v = sorted(tuple(e)) self.edges.add((u, v)) def initialize(self): if self.N > 0: return initial_nodes = [self._add_node() for _ in range(self.d + 1)] self._register_simplex(tuple(initial_nodes)) self.steps = 1 self._update_area_volume() def choose_face(self) -> Face: faces = list(self.face_n.keys()) weights = [] for f in faces: n = self.face_n[f] factor = 1.0 + self.s * n if self.s == -1 and n >= 1: factor = 0.0 if factor < 0: factor = 0.0 eps = self._face_energy(f) w = math.exp(-self.beta * eps) * factor weights.append(w) total_w = sum(weights) if total_w <= 0: boundary = [f for f in faces if self.face_n[f] == 0] if not boundary: boundary = faces return self.rng.choice(boundary) r = self.rng.random() * total_w acc = 0.0 for f, w in zip(faces, weights): acc += w if r <= acc: return f return faces[-1] def step(self): if self.N == 0: self.initialize() alpha = self.choose_face() i = self._add_node() new_simplex = tuple(sorted(tuple(alpha) + (i,))) self._register_simplex(new_simplex) self.steps += 1 self._update_area_volume() def run(self, total_nodes: int = 1000): self.initialize() while self.N < total_nodes: self.step() def get_boundary_faces(self) -> List[Face]: return [f for f, n in self.face_n.items() if n == 0] def node_degrees_1skeleton(self) -> Dict[int, int]: deg = {i: 0 for i in self.nodes} for u, v in self.edges: deg[u] += 1; deg[v] += 1 return deg def generalized_degree_distribution(self, delta: int) -> Dict[int, int]: hist = defaultdict(int) for _, k in self.face_counts[delta].items(): hist[k] += 1 return dict(sorted(hist.items())) def to_networkx(self): import networkx as nx G = nx.Graph() for i in self.nodes: G.add_node(i, energy=self.node_energy[i]) for u, v in self.edges: G.add_edge(u, v) return G def to_json(self) -> dict: data = { "dimension": self.d, "flavor": self.s, "beta": self.beta, "N": self.N, "nodes": [{"id": i, "energy": self.node_energy[i]} for i in self.nodes], "simplexes_d": [list(s) for s in self.simplexes_d], "edges": [list(e) for e in sorted(self.edges)], "area_history": self.area_history, "volume_history": self.volume_history, } face_hist = {} for delta in range(self.d): face_hist[str(delta)] = { "faces": [list(map(int, f)) for f in self.face_counts[delta].keys()], "k": list(map(int, self.face_counts[delta].values())), } data["face_counts"] = face_hist return data