\subsection{Computational Complexity and Memory}
\label{app:complexity}
In this section, we provide a detailed complexity and memory analysis of our method, aligning each term with the
algorithms in Appendix~\ref{app:complexity}. We denote by $N$ the number of Gaussians, $K\!\gg\!k$ the Euclidean
pre-neighbor count and the Mahalanobis $k$-NN degree, $r\!\in(0,1]$ the downsampling ratio for the GNN, $N'=rN$ the
downsampled node count, $|E|\!\approx\!Nk$ the edge cardinality on the full graph (and $|E'|\!\approx\!N'k$ on the
subsample), $H$ the number of attention heads, $d$ the hidden width, $L$ the number of GNN layers, $|\Omega|$ the number
of pixels per rendered view, $C$ the number of candidate views for hole detection, $B$ the number of bridging Gaussians,
and $|\mathcal{J}|$ the number of boundary seeds used for local plane filling. We also use $T_{\text{regularize}}$ and
$T_{\text{build}}$ for constraint and graph-building periods, respectively.

\paragraph{Topology-aware graph regularizer  (Algs.~\ref{alg:build-graph}--\ref{alg:execute}).}
\textbf{(i) Euclidean pre-selection.} Building a KD-tree takes $O(N\log N)$ time and $O(N)$ memory, querying top-$K$
neighbors for all nodes costs $O\big(N(\log N + K)\big)$, yielding a candidate set per node. \textbf{(ii) Mahalanobis
refinement.} For each node we evaluate $K$ quadratic forms with a fixed $3{\times}3$ metric, giving
$O(NK)$ arithmetic plus $O(NK)$ selection to retrieve top-$k$ (or $O(NK\log k)$ with partial sort). We store at most
$O(NK)$ candidate indices during refinement and finally keep $O(Nk)$ neighbors. \textbf{(iii) Symmetrization \& connected
components.} Forming an undirected adjacency with at most $|E|\!\approx\!Nk$ edges and computing connected components via
BFS/Union-Find costs $O(N{+}|E|)=O(N{+}Nk)$ time and $O(N{+}|E|)$ memory. \textbf{(iv) Hole detection
(Alg.~\ref{alg:holes}).} Scoring $C$ candidate views by the low-opacity ratio and computing a $5{\times}5$ dilation per
view cost $O(C|\Omega|)$. Unprojecting $M$ boundary pixels and mapping to nearest Gaussians via a KD-tree gives
$O(M\log N)$ time and $O(N)$ extra memory for the tree. \textbf{(v) Bridging and filling (Alg.~\ref{alg:plan-edits}).}
Let the boundary sets of the two dominant components have sizes $m_1,m_2$. A naive closest-pair search takes
$O(m_1m_2)$, while a KD-tree implementation reduces this to $O\big((m_1{+}m_2)\log N\big)$. Inserting $B$ interpolated
Gaussians is $O(B)$. For intra-component filling, each of the $|\mathcal{J}|$ seeds gathers $k$ neighbors and fits a
local plane by $3{\times}3$ eigendecomposition, which is $O(|\mathcal{J}|k)$ time and $O(|\mathcal{J}|)$ memory.
\textbf{(vi) Atomic execution (Alg.~\ref{alg:execute}).} Pruning $|\mathcal{R}|$ nodes and inserting $B$ nodes is linear
in the edit sizes, nearest-neighbor inheritance uses a single KD-tree query per insertion, $O(B\log N)$.

\paragraph{GNN-based appearance propagation module (Alg.~\ref{alg:gnn}).}
\textbf{(i) Downsampled graph.} With ratio $r$, we operate on $N'=rN$ nodes and $|E'|\!\approx\!N'k$ edges. If neighbors
are rebuilt on the downsample, the Euclidean pre-selection plus Mahalanobis refinement mirror the costs above with $N$
replaced by $N'$. \textbf{(ii) Message passing.} For a GATv2 layer with edge features, the dominant term is linear in
edges and width: $O(|E'|Hd)$ for attention/logits and aggregation, $L$ layers give $O(L|E'|Hd)$. Backprop introduces a constant-factor overhead (typically $\times 2\!-\!3$) but does not change asymptotics. \textbf{(iii) Residual write-back
\& visibility-adaptive blending.} Updating opacity and SH on the downsample is $O(N'd_{\text{app}})$ with $d_{\text{app}}$
the appearance sub-vector size (opacity\,+\,SH). \textbf{(iv) Survival-score caching.} Writing the temperature-scaled
scores ${score}'_i$ back to a global buffer is $O(N')$ time and $O(N)$ memory for one scalar per Gaussian.

\paragraph{Semantic-rarity and boundary-aware
modulator (Alg.~\ref{alg:srb}).}
Computing per-class pixel counts on a subset of frames, extracting 4-neighborhood boundaries (a discrete morphological
gradient), and applying the weighted $\ell_1$ loss are all linear in pixels: $O(|\Omega|)$ time with $O(|\Omega|)$
temporary memory for masks. In practice, weights $w(\mathbf{u})$ are computed on the fly and do not require storing
full-size buffers across steps.

\paragraph{Amortized per-iteration cost.}
Let $\mathcal{C}_{\text{photo}}$ be the photometric rendering loss cost, $\mathcal{C}_{\text{regularize}}$ the
regularization cost (build graph, hole detection, edit, and
$\mathcal{C}_{\text{gnn}}\!=\!O(L|E'|Hd) \!=\! O\!\big(L\,r\,N\,k\,H\,d\big)$ the GNN pass (on the subsampled graph).
With regularization triggered every $T_{\text{regularize}}$ iterations and GNN building/execution every $T_{\text{build}}$, the
amortized complexity per iteration is
\[
\mathcal{C}_{\text{iter}}
\;=\;
\mathcal{C}_{\text{photo}}
\;+\;
\frac{\mathcal{C}_{\text{regularize}}}{T_{\text{regularize}}}
\;+\;
\frac{\mathcal{C}_{\text{build(down)}}}{T_{\text{build}}}
\;+\;
\mathbf{1}[\text{GNN active}]\,\mathcal{C}_{\text{gnn}},
\]
where $\mathcal{C}_{\text{build(down)}}$ denotes the optional neighbor rebuild on the downsample. Using typical settings
$(k{=}8,\,K{=}100,\,r{\in}[0.2,0.4],\,L{=}3,\,H{=}4,\,d{=}64)$, the dominant training overhead beyond
$\mathcal{C}_{\text{photo}}$ is linear in $N$, specifically $O(r\,k\,N)$ up to the constant $L H d$, all planning terms
are also near-linear because $K,k$ are fixed small constants.

\paragraph{Memory footprint.}
\textbf{Regularizer.} Storing Euclidean candidates and Mahalanobis neighbors requires $O(NK)$ and $O(Nk)$ indices,
respectively, the CSR adjacency for connected components uses $O(N{+}|E|)$ space. KD-trees for nearest-neighbor queries
are $O(N)$. \textbf{GNN.} For the downsample, node activations plus edge activations per layer take
$O\big(N'd + |E'|d\big)$, and thus $O\big(L(N'd + |E'|d)\big)$ if kept for backprop, in practice, gradient checkpointing
reduces the peak factor without changing asymptotics. Survival scores add one scalar per Gaussian ($O(N)$).
\textbf{SRB.} Pixel-wise weights and masks can be streamed, peak memory is $O(|\Omega|)$ for the active minibatch.

\paragraph{Runtime neutrality.}
All auxiliary modules---topology-aware graph regularizer, GNN refinement, and SRB weighting---are \emph{training-only}. After optimization, the representation is a standard Gaussian set,
inference uses the unmodified 3DGS tile-based rasterizer with the same asymptotic cost as the baseline.

\paragraph{Summary.}
Under fixed local connectivity $(k)$ and constant-width GNN $(H,d,L)$, both the time and memory overheads of our
auxiliary components scale \emph{linearly} with $N$ (up to downsampling factor $r$), while pixel-space terms are linear in
$|\Omega|$. This preserves scalability to large scenes and maintains baseline inference complexity.
