WorksComputer Science
The Sign Code: The Hidden Binary Nature of Deep Networks
Abstract
Every neuron in a trained network outputs a number that can be separated into its sign (positive or negative) and its magnitude (absolute size). We call the set of all neuron signs the sign code. This raises a key question: does classification depend more on the sign code or on the magnitudes? For overparameterized vision classifiers with sign-preserving activations, the answer is overwhelmingly the sign code. A -nearest neighbor classifier operating only on this binary sign code achieves accuracy comparable to the full model across different architectures, activation functions, and datasets. Moreover, replacing all magnitudes in every layer with random noise while keeping the original signs barely changes residual network performance. In contrast, flipping just 20% of the signs reduces accuracy to chance. Models generalize well when same-class inputs share similar sign codes. When this overlap is disrupted by a regularizer, training accuracy remains high, but test performance collapses. A margin decomposition helps explain these results: the sign-only contribution to each logit grows as in network width, dominating the magnitude residual. The natural unit of analysis for these networks may not be through their continuous weight space but instead through their discrete sign codes.
Introduction
ReLU networks admit a clean piecewise-linear decomposition: each input activates a subset of neurons, and within the resulting region the network acts as an affine map. This combinatorial structure has been a productive lens on deep learning, underpinning analyses of linear-region counts [36, 29, 37, 39, 18, 12], spline and max-affine views [2], and gate-and path-based studies of expressivity and generalization [Neyshabur et al., 2015a,b, Fiat et al., 2018, Lakshminarayanan and Singh, 2020, Gonon et al., 2023, Lebeurrier et al., 2026]. But modern networks rarely use ReLU, while SiLU, GELU, and tanh have no piecewise-linear structure to exploit so that the tools built around ReLU do not transfer. We ask whether the combinatorial object underlying these ReLU analyses, which side of each neuron’s hyperplane the input falls on, survives the move to smooth activations, and whether it remains the dominant carrier of classification signal.
For any sign-preserving activation (ReLU, SiLU, GELU, tanh), each neuron output decomposes exactly as , where is a binary sign and is a non-negative magnitude (Figure 1a,b). The sign identifies which combinatorial region of representation space the input occupies; the magnitude specifies where within that region. We call the collection the sign code of the network, and ask whether it alone carries the essential information for classification. Across architectures, activations, and datasets, our experiments reveal a sharp asymmetry: the sign code is sufficient to recover full-model accuracy and causally dominant under intervention, while magnitudes are largely redundant (Figure 1c).
Figure 1. a) Every neuron in a feedforward network computes a pre-activation , which the activation function maps to . b) For any sign-preserving activation, this output decomposes as : a binary sign encoding which side of the neuron’s hyperplane the input falls on, and a non-negative magnitude encoding how far. We test the causal role of each component with two channel-isolating interventions: randomly flipping signs while preserving magnitudes, or replacing magnitudes while enforcing the sign code. c) Flipping just 20% of sign bits collapses accuracy to chance (red); replacing every magnitude in every layer preserves far more classification performance (blue), and is nearly lossless for residual networks. The forward computation is dominated by binary routing decisions rather than raw activation strengths.
Our contributions are:
The sign code is informationally sufficient for classification. A -nearest-neighbour classifier on the last-layer binary sign code, with no access to magnitudes, weights, or logits, matches full model accuracy in the overparameterized regime, across architectures, activations, and datasets. We give a formal sufficient certificate for this transition (§ 3 and § 6).
Networks are robust to magnitude perturbations but not to sign code perturbations. We compare two interventions that isolate the sign and magnitude channels: destroying signs while preserving magnitudes is catastrophic, whereas randomizing magnitudes while preserving the clean sign trajectory is much less harmful. We check this asymmetry across four activations and two architecture families (§ 4, Figure 3).
Figure 3. Left (2×2): Accuracy under channel destruction. Red: sign flip (sign code routing destroyed, magnitudes intact). Blue: magnitude replacement with random draws (magnitudes destroyed, sign code routing intact). Solid: FFNN; dashed: ResNet; mean s.d. over 5 draws. Right: Intervention formulas and summary of what each intervention removes. Routing destruction collapses accuracy to chance by across all conditions; projected replacement of every magnitude preserves far more classification performance, and is nearly lossless for residual networks.
Class-coherent sign geometry is tied to generalization. Models generalize when same-class inputs share similar sign codes. A regularizer that actively repels within-class sign codes maintains high training accuracy while sharply degrading test accuracy, suggesting that class-coherent sign structure is a necessary ingredient for generalization in these models (§ 5).
Taken together, these results suggest that the natural unit of analysis for these networks may not be their continuous weight space but their discrete sign code.
Related Work
A large body of work studies ReLU networks through their input-space partitions, counting linear regions and bounding expressive gains from depth [36, 29, 37, 39, 18, 12] or interpreting deep networks as input-dependent affine maps indexed by activation patterns [2]. Binary activation patterns have been examined as hash representations [19], learned via specialised objectives [35], and used for verification [Gong et al., 2023]; on the theoretical side, path-norm, path-kernel, and gate-decoupling analyses elevate gates to a primary object of study [Neyshabur et al., 2015a,b, Lakshminarayanan and Singh, 2020, Fiat et al., 2018, Gonon et al., 2023, Lebluer et al., 2026]. The gate-decoupling line is closest to our work: Fiat et al. [ [10] separates gating from linearity and Lakshminarayanan and Singh [ [26] builds kernels from the active subnetwork. Both treat gates as a useful analytical device for ReLU; we make three stronger claims: informational sufficiency, causal dominance under intervention, and a link between sign geometry and generalization (§ 3 to § 5). We establish them across all sign-preserving activations, including smooth ones with no piecewise-linear structure. Neural collapse [34, 17] describes convergence of continuous features toward class means; our results hold outside this regime (see Section B.2 for a thorough comparison). A comprehensive discussion of related work is given in Appendix § 9.
Background: The Sign–Magnitude Decomposition
Setup
We consider an -layer feedforward network (FFNN) with hidden representations and, for ,
where , , and is a coordinatewise activation function. The output layer produces logits .
Each neuron in layer computes a pre-activation . The zero set is a hyperplane in the representation space of the preceding layer. A layer of neurons therefore partitions its input space by hyperplanes, assigning each input a binary code, one bit per neuron, that records which side of every hyperplane it falls on. The question is whether the activation function preserves this partition.
Sign-preserving activations
Definition 2.1 (Sign-preserving activation). An activation is sign-preserving if for every , where for and otherwise.
ReLU, SiLU, GELU, and tanh are all sign-preserving which will be the central point of study. A ReLU neuron zeroes out the negative half-space entirely, producing the sharpest possible partition; smooth activations such as SiLU and GELU attenuate rather than annihilate the negative side, but the sign of the output still mirrors the sign of the pre-activation. We discuss non sign-preserving activations such as softplus in Appendix C.
The decomposition
Every sign-preserving activation allows us to split each neuron’s output into two factors: a binary routing decision and a continuous magnitude.
Definition 2.2 (Sign–magnitude decomposition). Let be sign-preserving and let be the output of neuron at layer . The sign and magnitude of neuron are
so that the neuron’s output is
In vector form, the full hidden representation decomposes as . The sign code of the network is the concatenation of all per-layer sign vectors:
Because is sign-preserving, : the sign code is determined entirely by the pre-activation signs and is therefore identical across all sign-preserving activations sharing the same weights. Intuitively, records which combinatorial region of representation space the input occupies, which side of every learned hyperplane it falls on, while records where within that region. The sign code recovers the classical ReLU gate pattern under the relabelling active, inactive. The sign–magnitude decomposition for smooth activations (SiLU, GELU, tanh) captures the same combinatorial structure without requiring exact piecewise-affine behaviour. We discuss the natural generalization of this decomposition to convolutional layers as well as residual blocks in Section B.1.
Experiment: Sign Codes Are Informationally Sufficient
The sign–magnitude decomposition (Definition 2.2) splits every hidden representation into a discrete sign code and a continuous magnitude. We begin with a natural question:
Question 1: Does the sign code alone, without any magnitude information, already contain enough structure to predict class labels?
We test this by building the simplest possible classifier that operates only on the binary sign code of a single hidden layer, and comparing its accuracy to that of the full network.
Experimental setup: Sign-NN
For each trained model we extract the sign code of the last hidden layer only: for FFNNs, the output code of the last BasicBlock for ResNets, and the output code of the final transformer block for ViTs. This is a strict subset of the full-network sign code (4). Full extraction details are given in Appendix § 12. We equip the sign code space with the normalised Hamming distance
and classify each test point by majority vote among its -nearest training-set neighbours in this distance. The resulting classifier, sign-NN, uses only the binary sign code of a single layer. It has no access to activation magnitudes, to the sign codes of any earlier layer, or to the network’s weights or logits. To quantify how well the sign code captures the network’s classification, we define the sign gap:
the absolute difference between the sign-NN test error and the full model’s test error. When , the binary sign code is sufficient to match the network’s test error; when is large, information outside the last-layer sign code remains relevant to the model’s predictions.
Results: The sign gap across activation functions and architectures
Figure 2a displays as a function of network depth and width across all three architectures (FFNN, ResNet, ViT; SiLU activation, CIFAR-10). See Appendix § 13 for a description of the exact architectures and the general training setup. For shallow or narrow networks the sign gap is substantial: the sign code loses information that the full network retains. As depth and width increase, shrinks monotonically and becomes negligible () once both dimensions are sufficiently large. Sign-code sufficiency is not an unconditional property of the architecture; it is an emergent property of overparameterized networks. There is a clear phase boundary in the depth–width plane beyond which the last-layer sign code matches the full network’s test performance. This is the regime targeted by the certificate in § 6. Figure 2b plots sign-NN against full model test accuracy for overparameterized networks (depth 6, width 1024 FFNN, standard ResNet-18 and depth 6, 256 embedding dimension, 8 heads ViT). We train 540 models spanning three architectures, four sign-preserving activations, three datasets (MNIST, CIFAR-10, CIFAR-100), 5 dataset sizes and 3 seeds. In the overparameterized regime, points cluster tightly around the diagonal with no systematic dependence on architecture, activation, or dataset. The experiment is conservative: it uses only the last layer’s sign code, a small fraction of the full routing record, yet this already matches model performance across all four activations, including smooth ones (SiLU, GELU, tanh) with no piecewise-affine structure (thus generalizes the observations in [19]). This is not a consequence of neural collapse: our models are far from the collapsed regime (NC1 , NCM accuracy well below model accuracy, see Section B.2).

Figure 2. a) The sign gap (Eq. (6)) as a function of network depth and width for three architectures (FFNN, ResNet, ViT) with SiLU on CIFAR-10. The gap shrinks monotonically with increasing depth and width, with a clear phase boundary (yellow lines) beyond which . b) Sign-kNN accuracy versus full model test accuracy across standard architectures (rows: FFNN, ResNet-18, ViT), activations (columns: ReLU, SiLU, GELU, Tanh), and datasets (colours: MNIST, CIFAR-10, CIFAR-100). The dashed line is . Training and model details for all figures are in Appendix § 13.
Observation 1: Last-layer sign codes become informationally sufficient in the overparameterized regime. The last-layer sign code empirically suffices to match the model’s test error; the sign gap vanishes with depth and width.
Experiment: Testing robustness to sign code and magnitude perturbations
The last section showed that sign codes are informative: a nearest-neighbour classifier on the binary sign code of a single hidden layer tracks model accuracy. But informative does not mean causal. Both sign and magnitude are deterministic functions of the same weights, so either channel, or both, could carry the classification signal:
Question 2: How does the network respond to distinct perturbations: one that perturbs only the discrete sign code, and one that perturbs only the continuous magnitudes?
If the sign code is merely a by-product and the real computation flows through magnitudes, then corrupting signs should be tolerable and corrupting magnitudes catastrophic. If the sign code is the dominant computational channel, the pattern should be the reverse.
Experimental setup: Two channel-isolating interventions
Recall that at every hidden layer , the representation decomposes as (Definition 2.2). Both interventions select neurons independently with probability at every hidden layer, but they are not meant to be symmetric natural forward passes. They are channel-isolating tests: one destroys routing while preserving magnitudes, and the other destroys magnitude information while enforcing the clean routing trajectory. The interventions differ in which channel is corrupted (Figure 3, right) and in the projection needed to keep that corruption isolated.
Intervention 1: destroy routing, preserve magnitudes. Each selected neuron has its sign negated while its magnitude is preserved. The corrupted representation propagates freely through all downstream layers, potentially altering their sign codes and magnitudes.
Intervention 2: destroy magnitudes, preserve routing. We first cache the clean sign code at every layer via an unmodified forward pass. Each selected neuron then has its magnitude replaced by , , a class-agnostic random draw carrying zero information about the input. The replacement is projected: at every downstream layer, the cached clean sign code is enforced and only magnitudes are recomputed. This is a causal-mediation test: it asks what remains of the computation when the sign trajectory is held fixed, not whether the network could recover that trajectory after magnitude corruption. At , every magnitude in every layer is a random number, yet the sign code is perfectly preserved.
Results of the robustness tests
We sweep for four activations (ReLU, SiLU, GELU, tanh) and two architectures (FFNN on SVHN, ResNet-18 on CIFAR-10), averaging over five independent mask draws. Flipping just 20% of sign bits () collapses accuracy to near chance () across all eight conditions; the ResNet’s skip connections do not compensate (Figure 3). At , the ResNet maintains 93–95% accuracy across all four activations: every magnitude in every layer is an independent random number, yet the network classifies as well as with correct magnitudes. The FFNN retains near-full accuracy for tanh and degrades substantially for the rest, but remains far above the corresponding sign-flip failures.
The two interventions are deliberately asymmetric. Intervention 2 asks: does the network need any magnitude information beyond what the sign code encodes? Answering this requires isolating the magnitude channel, if corrupted magnitudes cascaded through downstream layers, they would induce secondary sign flips, corrupting both channels simultaneously. Projected replacement caches the clean sign code and enforces it at every layer, holding routing fixed while destroying magnitude content. Intervention 1 needs no analogous projection: negating a sign preserves , so the magnitude channel is untouched by construction. The FFNN degradation under Intervention 2 is itself predicted by activation symmetry: tanh is odd, so its output is entirely determined by the sign code (near-zero drop for magnitudes and symmetry upon full sign-code swaps); ReLU, GELU, and SiLU each possess a sign-blind even component invisible to the sign code, with values 0.50, 0.34, 0.23 at which matches the degradation ranking (ReLU pp; GELU pp; SiLU pp; tanh pp). The ResNet’s immunity follows from the skip connection preserving sign structure under projected replacement.
Observation 2: Networks are robust to magnitude perturbations but not to sign code perturbations. Projected replacement of every magnitude preserves far more classification performance than sign corruption; flipping of signs destroys the forward pass.
Experiment: Testing class-coherent sign geometry
Sections 3 and 4 showed that overparameterized networks can classify through sign code, and that corrupting the sign trajectory is far more destructive than corrupting magnitudes. But computation through signs does not by itself explain generalization. A network could classify through signs and still assign each example an idiosyncratic, non-transferable sign code, hence:
Question 3: What sign code structure supports generalization?
We focus here on evidence for necessity and leave sufficiency to future work.
Experimental setup: Varying class neighbourhood purity through a regularizer
Measuring sign code class structure. A sign code neighbourhood of a datapoint is label-pure if the nearest training points in Hamming distance share the class of . We measure this property with the leave-one-out (LOO) purity at neighbours:
where denotes the nearest training points in Hamming distance excluding itself. When is high, same-class inputs occupy tight, overlapping regions in sign space, exactly the structure that sign-kNN exploits. When is near (chance), the sign code carries no local class geometry. To test the role of class-pure neighbourhoods in generalization, we design a regularizer that actively destroys them.
Causal test: within-class sign repulsion. For each neuron we form a continuous proxy of its binary routing decision, concatenate across layers, and -normalise. The repulsion loss penalises routing overlap between same-class pairs:
For ReLU, SiLU, and GELU we use a sigmoid gate proxy , which targets the active set that dominates the forward pass; for tanh, where positive and negative neurons contribute equally, we instead use a tanh sign proxy . The choice of proxy, and why gate repulsion is strictly stronger than sign repulsion for non-odd activations, is discussed in Appendix H.6.
Results
Figure 4a plots train LOO purity against test accuracy for a range of models. Label-pure sign-code neighbourhoods predict good generalization; label-mixed ones the opposite. The -trained models land in the low-purity, low-accuracy corner on the same trend line, confirming the relationship is not an artifact of architecture or dataset. Panel b) shows SiLU dynamics: train accuracy reaches 97% while test accuracy monotonically drops to 40% as the regularizer destroys class-aligned routing. Panel c) summarises across activations: for ReLU, SiLU, and GELU, repulsion sharply degrades test accuracy and purity while training accuracy stays above 97%; tanh is partially robust due to its magnitude symmetry (, Appendix H). The network still memorises every training example–representational capacity is intact—but the routing patterns are no longer shared across same-class inputs, and generalization collapses. While may affect correlated properties, this combination of high training and degraded test accuracy provides causal evidence that within-class sign-code coherence plays a direct role in generalization for the models studied.
Figure 4. a) Train LOO purity () versus test accuracy across models (grey: FFNN on SVHN, widths 4–1024, depths 1–12, SiLU) and -trained models (coloured). High neighbourhood purity tracks generalization (Spearman ); models fall on the same trend line. b) Training dynamics under (SiLU, width 1024, depth 8, SVHN). Train accuracy reaches 97%; test accuracy drops to 40%. Dashed: Test accuracy of the normally trained baseline. c) Summary across activations (depth 8, width 1024, SVHN). Repulsion sharply degrades test accuracy and LOO purity for ReLU, SiLU, and GELU while training accuracy remains 97%. Tanh is partially robust (; Appendix H).
Observation 3: Class-coherent sign geometry is necessary for generalization. Networks generalize when same-class inputs share similar sign codes; a regularizer that repels within-class sign codes preserves training accuracy but collapses test accuracy.
Theory: Overparameterization Makes Neural Networks Binary
Sections 3 and 4 showed that sign codes become informationally sufficient in the overparameterized regime and are causally dominant under channel-isolating interventions. We now provide an exact decomposition of the logit into a sign-only term and a magnitude residual, together with a certificate that predicts when the sign-only classifier agrees with the full network.
Decomposing the logit
The class- logit decomposes as for a last hidden layer of width . Replacing each magnitude by its conditional mean , the unique MMSE predictor of from the single bit (Appendix § 14, Proposition F.2), splits this into two exact pieces:
The sign-only logit depends on only through the binary sign code. The residual captures everything the sign code misses: the per-neuron deviations of each magnitude from its sign-conditional average. The pairwise margin inherits the same split:
and the sign-only prediction disagrees with the full network only when the residual overwhelms the sign-only margin: .
A certificate for sign domination
The decomposition raises a quantitative question: when is the sign-only margin large enough that the residual cannot flip the prediction? For each input with full-model predicted class and each competitor , define the per-neuron vote bias , which measures how decisively, on average, each neuron's sign-weighted contribution favours over , and the conditional residual moment , which captures how much the residual fluctuates among inputs that share the same sign code and full-model prediction. Conditioning on both ensures that the class pair and sign-only margin are fixed under the conditional measure. This is a population quantity; in the experiments we estimate the same signal using the residual diagnostics described in Appendix § 15. The gate-domination score is:
Theorem 6.1 (Gate domination). Let be the disagreement rate between the full network and its sign-only version. Assume that ties in both classifiers occur with probability zero under the data distribution, and that all residual second moments are finite.
(i) Disagreement bound: .
(ii) Width scaling: If for all competitors , then .
Proof. The full proof is in Appendix F.7.
Interpretation and empirical validation
Figure 5 displays , , and the sign-gap across 360 trained FFNNs (12 depths 10 widths 3 seeds, SiLU, CIFAR-10). The theorem gives a sufficient explanation for why overparameterized networks can become effectively binary. Each neuron casts a sign vote for or against each class; depth composes these votes into a decisive bias (), and width averages out the magnitude noise through -scaling. The sign-only margin grows as while the residual grows at most as , so improves with added neurons until the sign-only classifier agrees with the full network. Neither mechanism suffices alone: at depth 1, votes are unbiased () and even at width 4096 (panel b), bottom row); narrow-but-deep networks have biased votes but too few neurons for the averaging to suppress magnitude noise. The yellow line in panels (a)–(c) marks where both conditions are jointly met: above it, and . Panel d) is the key result: the plotted configurations collapse onto a single -vs- curve, regardless of whether a model achieves its through width, depth, or both. We verify all theorem conditions and discuss their scope in Appendix G; the analysis is most informative for FFNNs with asymmetric activations, while for tanh and residual architectures the causal interventions (§ 4) provide the stronger evidence.
Discussion
In overparameterized networks, classification depends far more on a discrete sign code with class-coherent sign geometry than on precise activation magnitudes. Preserving sign trajectories while randomizing magnitudes retains high accuracy, whereas small sign perturbations collapse performance catastrophically. This suggests that existing generalization theory may be missing an important granularity: the binary sign code quotients weight space into equivalence classes, and generalization bounds formulated directly over this discrete object would be invariant to magnitude redundancies that can make norm-based bounds vacuous. Our analysis also offers a hypothesis on why gated activations (SiLU, GELU, and GLU variants) are dominantly used in modern transformers: their large magnitude asymmetry (Section H) amplifies the sign-only margin, making the binary routing channel maximally decisive, whereas symmetric activations like tanh place no signal in this channel.
Limitations. While we empirically treat multiple architectures, our theoretical analysis centres on feedforward networks. The gate-domination score can remain modest for residual networks and odd activations even when the sign trajectory is causally dominant under intervention (Section H), and we restrict attention to sign-preserving activations. Our empirical evidence comes from small-scale vision benchmarks (CIFAR, SVHN, MNIST) and classification tasks; whether the sign code mechanism extends to large-scale settings, language modelling, or regression is left to future work.
Acknowledgments and Disclosure of Funding
This work was supported by the Laboratory for AI Security Research (LASR). The views expressed in this paper are those of the authors and do not necessarily reflect the position of LASR or His Majesty’s Government.
Related work
A central motivation for this paper is the generalization puzzle in overparameterized deep learning. Modern networks can interpolate random labels while still generalizing on natural data, forcing a re-examination of classical capacity arguments [41]. This led to a large literature on norm-, margin-, PAC-Bayes-, and compression-based explanations of generalization [8, 32, 3, 1, 23], and to studies of the interpolation regime through double descent and overparameterization [4, 30, 33]. A complementary line analyzes the implicit bias of optimization, showing convergence toward max-margin or otherwise structured solutions in linear, homogeneous, and wide-network settings [40, 28, 5]. Another influential debate ties generalization to sharpness or flatness of minima [24, 6]. Our work is motivated by the same puzzle, but shifts the explanatory target from continuous weights to the discrete routing pattern induced by the network.
A second line studies neural networks through their activation patterns and the partitions they induce. Early work on rectifiers emphasized sparse activation and the practical advantages of non-saturating units [14]. For ReLU and related piecewise-linear networks, several papers quantified the number of response or linear regions and the expressive gains from depth [36, 29, 37, 39]. Later work showed that the number of linear regions realized in practice can be far below worst-case counts [18], and that linear regions are not equally important functionally [12]. Closely related spline and max-affine views interpret deep networks as input-dependent affine maps indexed by activation patterns [2]. Our sign code perspective is closest to this tradition, but differs in emphasis: the goal here is not primarily to count regions or characterize expressivity, but to argue that the binary code identifying a region can itself become the dominant carrier of class information.
Some aspects of binary activation patterns have been studied. It was shown in He et al. [ [19] that the sign code induced by a trained classifier can behave as a hash representation. Park et al. introduces a specialized unsupervised objective that learns binary activation codes in order to increase encoder expressivity and improve downstream classification and retrieval [2021]. Related work has shown that class-dependent partial sign codes can be extracted from trained ReLU networks and used to verify that the network assigns the same label to inputs consistent with those partial sign codes [13].
This paper is especially close to the path- and gate-based literature. Path-SGD and path-norm analyses emphasized geometries and complexity measures that respect ReLU rescaling symmetries better than raw Euclidean weight space [31 b]. Lakshminarayanan and Singh introduced neural path features and the neural path kernel, explicitly encoding the active subnetwork selected by the gates [26]. Fiat et al. made the separation between gating and linear computation explicit by decoupling the two roles in the neuron [10]. More recent work extended path-based analyses to modern DAG architectures and principled rescaling procedures [15, 27]. Among existing lines, this is the closest antecedent to our thesis: we likewise elevate gates from a bookkeeping device to a primary object of analysis, but we go further by arguing for three complementary claims—informational sufficiency, causal dominance under intervention, and theoretical dominance of the sign code once magnitude residuals concentrate.
Our empirical results also connect to work on representation geometry in trained classifiers. Visualization and representation-similarity studies show that networks that generalize organize their internal representations differently from networks that memorize [22, 25]. Neural collapse sharpened this picture by showing that late-layer features can converge toward class means and nearest-class-mean decision rules during terminal training phases [34, 17]. Our sign-NN and codebook-collapse analyses are complementary to this literature: they replace continuous Euclidean geometry by discrete Hamming geometry on sign codes, and ask whether class structure is already recoverable before or even without full collapse of the continuous feature cloud.
Finally, because the present paper studies sign-preserving activations and multiple backbone families, it also interfaces with the activation-function and architecture literature. The experiments span residual networks and vision transformers [20, 7], and include GELU and SiLU/Swish-style smooth activations in addition to ReLU and tanh [21, 38, 9]. The redundancy and erasure-robustness story we observe is also adjacent to pruning, compression, and sparse-subnetwork results [16, 11]: heavily overparameterized networks often contain substantial slack. The distinction is that pruning and compression typically operate in parameter space, whereas our thesis is about input-dependent routing structure. The claim is not merely that many weights are removable, but that overparameterization can induce a simpler, more redundant binary partition whose class geometry increasingly governs prediction.
Additional material for the main paper
Extension of sign extraction
Convolutional blocks. For a convolutional output , Definition 2.2 applies entrywise, yielding a sign code tensor that records both which channels and where in space each feature responds positively. We compress the spatial dimensions by majority vote on a grid ( throughout), giving bits per layer.
Residual blocks. A residual block adds a learned branch to a skip connection:
where is a sub-network (typically two convolutional or fully-connected layers with their own activations). Two families of sign codes arise. The activations inside the branch produce internal sign codes, computed exactly as in Definition 2.2. For a standard two-layer branch with intermediate activation, the internal code is . The block-output code records the sign of the sum of skip and branch, and need not equal ; it is precisely the sign flips introduced by the branch that allow each block to refine the combinatorial partition of the preceding layer. The full sign code of an -block residual network concatenates both internal and output codes across all blocks:
Omitting either the internal or the output codes would lose information about the routing decisions the network makes.
Relationship to Neural Collapse
Neural collapse [34, 17] describes a terminal-phase phenomenon in which (NC1) within-class feature variance vanishes relative to between-class variance, (NC2) class means converge to an equiangular tight frame, (NC3) the last-layer classifier aligns with the class means, and (NC4) a nearest-class-mean (NCM) classifier matches network accuracy. A natural question is whether sign code sufficiency is simply a consequence of neural collapse: if features have already collapsed onto class means, any reasonable representation—including the sign code—would trivially separate classes.
We measure all four NC metrics across the full FFNN width–depth grid (SiLU, SVHN, 80 training epochs) in Figure 6. The models are far from the collapsed regime. NC1 () remains above 1 throughout most of the grid, indicating that within-class scatter still dominates between-class scatter; values below 1 would indicate meaningful collapse. NC3 (cosine alignment between the classifier weights and the class-mean directions) stays below 0.4 for most configurations, far from the ideal value of 1. NC4 (NCM test accuracy) peaks around 60–70%, substantially below the full model accuracy of 80% achieved by the same networks. NC2 (ETF deviation) is near zero at large widths but this alone does not indicate collapse—it reflects only the angular structure of the class means, not the tightness of the feature clouds around them.

Figure 6. Neural collapse diagnostics across the width–depth grid (FFNN, SiLU, SVHN, 80 epochs). Top row: NC1 (, log scale), NC2 (ETF deviation), NC3 (weight–mean cosine alignment). Bottom row: NC4 (nearest-class-mean test accuracy), sign purity, and NC summary curves across widths for selected depths. NC1 remains above 1 and NC3 below 0.4 across most configurations, confirming that the models have not undergone neural collapse. NCM test accuracy (NC4) peaks at , well below full model accuracy. Despite this, sign purity is high wherever the network is sufficiently wide and deep—class-discriminative sign code structure emerges independently of, and prior to, neural collapse.
Despite this absence of collapse, the sign code is already informationally sufficient (§ 3) and causally dominant under intervention (§ 4) in precisely the same models. Sign purity—the fraction of training points whose sign code is shared only with same-class examples—is high across much of the grid even where NC1 remains large and NC4 is poor (compare bottom-left and bottom-centre panels of Figure 6). Class structure is thus recoverable in discrete Hamming space well before the continuous features converge toward their class means. This makes the sign code mechanism strictly more general than neural collapse: it does not require prolonged terminal-phase training, and it operates through combinatorial routing geometry rather than through concentration of continuous features.
Non-Sign-Preserving Activations
The sign-preserving property (Definition 2.1) covers the activations dominant in modern practice: ReLU, SiLU/Swish, GELU, and tanh are all sign-preserving and account for the vast majority of architectures in current use. The decomposition with applies directly to all of them. We briefly discuss what happens outside this class.
Shifted-threshold activations (e.g. softplus). Softplus, , is strictly positive for all and therefore not sign-preserving: always. However, softplus is monotone, so it preserves the ordering of pre-activations. A natural generalization is to replace the zero threshold with the activation’s symmetry axis. For softplus, , and the function is approximately linear for and approximately flat for . Defining directly—bypassing the activation output—recovers a meaningful binary partition: it still records which side of the neuron’s learned hyperplane the input falls on. The magnitude can then be defined relative to this threshold, e.g. . We have not tested this variant experimentally, but the monotonicity of softplus ensures that the partition induced by is identical to the one studied throughout the paper—only the magnitude profile changes. Symmetric activations (e.g. , ). Squaring or other even functions destroy sign information entirely: . The sign–magnitude decomposition as stated does not apply. Yet a binary routing question remains meaningful—one could ask whether exceeds some data-dependent threshold (e.g. the median pre-activation magnitude), partitioning inputs into high-activation and low-activation regimes. Whether such a partition carries class-discriminative structure comparable to the sign code is an open empirical question. We note that even activations like are rarely used in isolation in modern networks; they typically appear inside gated units (e.g. in some GLU variants) where the gating component restores a sign-preserving partition on at least one branch.
In summary, the sign-preserving assumption is not restrictive in practice: it covers all standard activations, and for the main exception (softplus), the pre-activation sign provides an equivalent partition. Extending the framework to genuinely non-monotone or even activations is possible in principle but would require a different choice of binary code, and we leave this to future work.
Sign Code Extraction
This appendix documents the precise extraction procedure for the sign code used throughout the paper. We describe the procedure separately for each architecture family and specify exactly which tensors are recorded, which are discarded, and how the full-network sign code is assembled. All sign codes use the convention if and otherwise (in particular, ).
Feedforward networks (FFNN)
Architecture. Our FFNN models are of the form
where every hidden layer applies the same sign-preserving activation (one of ReLU, SiLU, GELU, or tanh). The model exposes an nn.ModuleList of nn.Linear layers (hidden_layers) and a final nn.Linear output layer (output_layer).
Extraction. We register a forward hook on each nn.Linear in hidden_layers. The hook records the pre-activation , i.e. the output of the linear layer before the activation is applied. After the forward pass completes, we apply to each captured pre-activation to obtain the post-activation , and compute:
Because is sign-preserving, , so the sign code is equivalently determined by the pre-activation signs.
Full sign code. The full-network sign code is the concatenation across all hidden layers:
The output layer is not activated and is therefore excluded from the sign code.
What is not extracted. The output logits are recorded for evaluation but do not contribute to the sign code. No sign code is computed for the input (there is no activation to decompose).
Residual networks (ResNet)
Architecture. We use torchvision BasicBlock-based ResNets (ResNet-18, ResNet-34). The architecture comprises a convolutional stem followed by four layer groups, each containing multiple residual blocks, followed by global average pooling and a linear classifier:
Each BasicBlock has the following internal structure:
where the skip connection is the identity when dimensions match, or a learned convolution with batch normalisation (downsample) when a spatial or channel-dimension change occurs. Note that torchvision BasicBlock uses a single nn.ReLU module that is called twice during the forward pass: once after bn1 (internal) and once after the residual addition (output).
Extraction. We register five hooks per block and one hook on the stem:
Stem activation. A forward hook on
model.relucaptures , the stem output after the first ReLU (but before max-pooling). We record and .
Block input. A forward pre-hook on the block module captures the input tensor entering the block. This serves as the skip connection when no downsampling is needed.
Internal branch activation. A forward hook on
block.relucaptures every ReLU output inside the block. In aBasicBlockthe shared ReLU is called exactly twice; the first output is the internal branch activation . We record and .
Branch output (pre-addition). A forward hook on
block.bn2captures , the output of the residual branch before addition with the skip.
Skip connection. If the block has a downsample module, a forward hook captures its output. Otherwise, the skip is the block input recorded in step 2.
Residual sum and block output. We compute the residual sum from the tensors captured in steps 4 and 5. This is the pre-activation of the block’s output ReLU. The block-output activation is captured via a forward hook on the block module itself. We record and . Because ReLU is sign-preserving, ; we additionally store and for diagnostic use.
Full sign code. The full-network sign code concatenates the stem code and both the internal and output codes from every block:
where is the total number of BasicBlocks across all four layer groups (e.g. for ResNet-18). For convolutional layers the sign code tensors have shape ; we compress each to bits using majority-vote spatial pooling on a grid ().
What is not extracted. The global average-pooling layer and the final linear classifier (fc) are not activated by a sign-preserving nonlinearity and do not contribute to the sign code. The second ReLU output per block (captured by the shared block.relu hook) is functionally identical to the block-output activation captured by the block-level hook; we use the latter and discard the former. The stem’s max-pooling layer is applied after the stem ReLU and does not introduce a new sign decision, so no separate code is extracted for it.
Vision Transformer (ViT)
Architecture. Our ViT follows the standard pre-norm design:
where each transformer block has the structure
The MLP sub-block is Linear GELU Dropout Linear Dropout.
Extraction. Unlike the FFNN and ResNet extractors, the ViT extractor performs a manual forward pass through the model’s modules rather than relying on hooks. This gives explicit access to every intermediate tensor. For each transformer block , we record three sign–magnitude pairs:
Post-attention residual stream. . We record and . This is the sign of the residual stream after the attention sub-block has added its contribution.
MLP hidden activation. . We record and . This is the internal sign code of the MLP, analogous to the internal branch code in a ResNet block. GELU is sign-preserving, so is determined by the pre-activation signs.
Block output. . We record and . As with ResNets, the output sign code need not equal the input sign code: sign flips introduced by the MLP branch refine the partition.
Additionally, we record the patch-embedding tokens and their sign and magnitude. These serve as the “stem” of the ViT and are available for diagnostic use, though they do not pass through a sign-preserving activation and are therefore not included in the default sign code.
Full sign code. The full-network sign code concatenates all three code families across all transformer blocks:
Each sign code tensor has shape for the residual-stream codes and for the MLP hidden code, where is the sequence length (number of patches plus one [CLS] token). For the experiments in the main paper we flatten over the token dimension.
What is not extracted. The self-attention weights are continuous routing variables and do not admit a binary sign decomposition; they are not included in the sign code. The final layer norm and the classification head do not involve a sign-preserving activation and are excluded.
Spatial compression of convolutional sign codes
Convolutional sign code tensors can be very high-dimensional (e.g. bits for a single layer of ResNet-18 on inputs). To obtain a fixed-length code that is comparable across spatial resolutions, we partition each channel’s feature map into a grid of (approximately) equal patches and replace each patch by its majority sign:
This yields bits per layer. We use throughout, which balances spatial resolution against code dimensionality. The majority-vote rule means that if more than half of the spatial locations in the patch have a positive activation, preserving the dominant sign in each spatial neighbourhood.
Random projection for high-dimensional codes
Even after spatial compression, the full-network sign code can have – dimensions. Computing exact Hamming distances between all pairs of points in costs , which becomes prohibitive for large and . We reduce the dimensionality by projecting the sign code with a random binary matrix (entries i.i.d. Rademacher, ) and re-binarising:
By standard results on random hyperplane hashing, the normalised Hamming distance between two projected codes satisfies where is the angle between the original sign vectors treated as real-valued vectors, providing an unbiased approximation to the original Hamming distance. In all experiments labelled “projected” in the main paper, we use .
Summary of extracted quantities
Table 1 summarises which tensors are recorded for each architecture and how they contribute to the full sign code.
| Architecture | Tensor | Code type | Full S | §Section 3 |
| FFNN | Layer sign | ✓ | last only | |
| Output logits | — | × | × | |
| ResNet | Stem ReLU output | Stem | ✓ | × |
| Int. | ✓ | × | ||
| Out. | ✓ | last only | ||
| Avgpool / fc | — | × | × | |
| ViT | Patch tokens (pre-transformer) | Stem | × | × |
| Attn. | ✓ | × | ||
| Int. | ✓ | × | ||
| (block output) | Out. | ✓ | last only | |
| Final norm / head | — | × | × |
Table 1. Summary of sign code extraction across architectures. Int. = internal branch/MLP hidden code; Out. = block-output code; Attn. = post-attention residual stream code. “Full S” indicates inclusion in the full-network sign code; indicates the code used for the last-layer sign-space -NN experiment in Section 3.
Which codes are used where. The informational sufficiency experiment (§ 3) uses only the last hidden layer’s sign code: the final hidden layer for FFNNs, the output code of the last BasicBlock for ResNets, and the output code of the last transformer block for ViTs. This is a deliberately conservative choice: a single layer’s binary code—a small fraction of the full-network sign code—already accounts for the network’s generalization performance. The full-network sign code (all layers concatenated) is used in later sections where tighter certificates or mechanistic decompositions require the complete routing record.
Training Details
Training Details & Hyperparameters
Scope. This appendix summarizes the training protocol used for the main correlation sweeps, the intervention experiments, and the repulsion-regularized runs.
Baseline sweeps. The main width–depth heatmaps use CIFAR-10 with the full 50,000-example training set. The cross-dataset scatter in Figure 2b uses three architecture families (FFNN, ResNet-18, ViT), four activations (ReLU, SiLU, GELU, tanh), three datasets (MNIST, CIFAR-10, CIFAR-100), five training-set sizes (1k, 5k, 10k, 25k, 50k), and three random seeds, for a total of 540 trained models.
Optimization.
Loss: cross-entropy throughout; label smoothing is zero by default, with ViT on CIFAR-10 using 0.1.
Optimizers: AdamW for FFNN and ViT; SGD with Nesterov momentum for ResNet-18.
Base learning rates: FFNN uses base learning rate ; ResNet-18 uses ; ViT uses on CIFAR-10.
Scaling rule: for FFNN sweeps, the effective learning rate is
with an additional factor 0.2 for tanh. For ViT sweeps, the effective learning rate is
Schedules: FFNN uses a constant learning rate in the baseline sweeps. ResNet-18 and ViT use cosine decay; ResNet-18 uses 5 warmup epochs and ViT uses 10 warmup epochs.
Batch sizes: 256 for FFNN, 64 for ResNet-18, and 128 for ViT.
Weight decay: for FFNN, for ResNet-18, and for ViT.
Mixed precision: enabled for all large sweeps unless explicitly disabled.
Stopping rule. The main heatmap sweeps use a maximum of 120 epochs together with a practical early-stop rule based on training accuracy: 0.95 for FFNN, 0.995 for ResNet-18, and 0.98 for ViT. These thresholds were used as a compute-saving heuristic once the model had clearly fit the training set; they were not used in the repulsion runs, where late-training dynamics are part of the result.
Data and augmentation.
Splits: standard train/test splits; no held-out validation split.
Augmentation: ResNet-18 and ViT use
RandomCrop(32, padding = 4)andRandomHorizontalFlipon CIFAR; horizontal flips are disabled for SVHN. FFNN uses no data augmentation.Normalization: standard per-dataset mean/std normalization.
Initialization and normalization. FFNN layers use Kaiming initialization for ReLU/SiLU/GELU and Xavier initialization for tanh. ResNet-18 uses the standard convolutional and batch-normalized residual-block parameterization. ViT uses the standard pre-norm transformer parameterization with layer norm.
Seeds and counts. The fixed-size cross-dataset sweep uses three seeds per configuration. The main width–depth heatmaps use one seed per grid point. The CIFAR-10 heatmaps in Figure 2a comprise 132 FFNN models, 108 ResNet-18 models, and 113 ViT models (353 total).
Intervention experiments. The sign-flip and magnitude-replacement experiments use corruption rates
with five independent corruption masks per setting, applied to all hidden layers.
Repulsion runs. The repulsion experiments are trained on SVHN with longer schedules (maximum 2500 epochs), AdamW, the same FFNN learning-rate rule, and no early stopping. All other baseline hyperparameters are kept fixed unless explicitly overridden by the regularizer.
Compute budget. The full project required approximately 400 H100 GPU-hours on a 4×H100 cluster, including the main sweeps, intervention experiments, repulsion reruns, and auxiliary failed/restarted jobs. This number should be understood as a rough end-to-end estimate rather than an exact accounting.
Architecture Specifications
FFNN. Inputs are flattened to vectors. All hidden layers share the same width , and the depth equals the number of hidden layers. The activation is ReLU, SiLU, GELU, or tanh, followed by a linear classifier. There is no final normalization layer before the output head.
ResNet-18. We use a CIFAR-style residual network rather than the ImageNet torchvision stem: the input stem is a convolution with stride 1 and no max-pooling. Residual blocks use batch normalization, and the residual branch is scaled by with and the total number of residual blocks. Channel widths follow (base width), scaled uniformly by the chosen width multiplier.
Depth allocation for ResNet-18. When the total residual depth is varied, blocks are distributed across the four stages by round-robin allocation. Concretely, depth gives stage layout , depth gives , and depth gives .
ViT. The ViT models use patch size 4, a learned class token, learned positional embeddings, pre-norm transformer blocks, multi-head self-attention with 8 heads, an MLP ratio of 4, and a linear classifier on the [CLS] token. Width controls the embedding dimension and depth controls the number of transformer blocks.
Sweep grids.
FFNN (Figure 2a): widths and depths .
ResNet-18 (Figure 2a): widths and depths .
ViT (Figure 2a): widths and depths , with the seven largest models (4096, 6–12) omitted.
Purity/repulsion grid (Figure 4): FFNN widths and depths ; ResNet-18 widths and depths .
Reference parameter counts. For CIFAR-sized inputs, representative models have:
FFNN , : 10,504,202 parameters.
ResNet-18 , : 701,466 parameters.
ViT , : 4,771,082 parameters.
Repulsion Regularizer
Definition. For a batch with labels , we form a continuous proxy for the sign or gate pattern by concatenating selected pre-activations across layers, applying a temperature-scaled proxy, for ReLU/SiLU/GELU and for tanh, and then -normalizing. The repulsion loss penalizes within-class alignment:
The total loss is
Schedule and layers. The regularization weight is linearly ramped from zero:
For the Figure 4 runs, epochs and . The proxy is computed from the pre-activations of all FFNN hidden layers.
Training protocol. The repulsion runs keep the baseline optimizer and data pipeline, but use a long schedule (2500 epochs) with no early stopping so that the late-stage collapse in test accuracy is visible. In the main SVHN experiments, the regularizer uses and .
Sensitivity. The effect is not confined to a single regularization strength: in additional SVHN reruns, both and preserved near-perfect training accuracy while producing the same qualitative collapse in test accuracy and purity.
Algorithm 1 Repulsion-regularized training
for each minibatch do
compute logits and hidden pre-activations
form proxy features , where or tanh
normalize each
form same-class pairs
compute
compute
backpropagate and update parameters
end for
Regularizer-specific hyperparameters.
Weight: in the main runs.
Temperature: .
Normalization constant: .
Proxy: sigmoid for ReLU/SiLU/GELU; tanh for tanh.
Layers: all hidden layers.
Sign-kNN Protocol & Sensitivity
Protocol. Sign-NN is computed from the last-layer sign code. Codes are stored as vectors and compared by dot product, which is equivalent to Hamming distance up to an affine transformation. The main-paper sweeps use a fixed with majority-vote prediction and deterministic tie-breaking by class count. Training examples form the reference bank and test examples are used as queries.
Random projection. When projected sign-NN is reported, the code is first mapped by a random projection to dimension and averaged over five independent projections. The main sign-NN results in the paper use the full sign code rather than the projected code.
Sensitivity to . To check that the main conclusions are not sensitive to the choice of , we reevaluated three overparameterized SVHN SiLU FFNN checkpoints using a 20k-example training bank and 5k test queries. The table reports accuracy (not error rate):
| Model | model acc. | |||||
| , | 0.817 | 0.799 | 0.807 | 0.808 | 0.809 | 0.809 |
| , | 0.826 | 0.777 | 0.770 | 0.780 | 0.780 | 0.778 |
| , | 0.830 | 0.823 | 0.826 | 0.825 | 0.826 | 0.825 |
Table 1 (PDF p. 22).
Across the regime where sign-NN is already close to the network accuracy, performance varies only weakly with ; changing from 1 to 20 alters accuracy by at most a few points. The , row sits near the transition region, where the sign gap is still visible but already small enough to preserve the same qualitative conclusion.
The Canonical Gauge, the Logit Decomposition, and the Gate Domination Bound
This appendix provides a self-contained derivation of the logit decomposition (Eq. (9)), explains why the conditional mean magnitude is the unique optimal choice of reference magnitude—the canonical gauge—and gives the full proof of the gate domination bound (Theorem 6.1).
Setup and notation
Recall from Definition 2.2 that every neuron in the last hidden layer produces an output
Sign convention. We adopt throughout. For ReLU, this assigns the entire inactive region to the negative sign (), so is well defined for every input. For smooth sign-preserving activations (SiLU, GELU, tanh), only the boundary is affected by this convention; under an absolutely continuous pre-activation distribution, this set has probability zero.
The class- logit is
We write for the full last-layer sign code, where is the last hidden layer width.
Our goal is to split (16) into a part that depends only on and a remainder. Any such split requires choosing, for each neuron , a reference magnitude that stands in for when we know only that . Different choices of yield different decompositions; the question is which choice is best.
Tie-breaking convention. Throughout this appendix, both the full classifier and the sign-only classifier use a fixed deterministic tie-breaking rule (e.g. lowest index). We assume that ties and occur with probability zero under the data distribution . This is a generic nondegeneracy condition; in particular, the sign-only logits depend only on the discrete sign code and therefore take finitely many values, so ties in the sign-only classifier can occur with positive probability unless the weights and biases place distinct logit values on every occupied sign code. In practice this nondegeneracy holds for all trained models we tested (see Section G.4); when it fails, the bound remains valid up to an additive correction equal to the tie probability.
The general decomposition for an arbitrary gauge
Fix any reference-magnitude function for each neuron . Substituting into (16):
The sign-only logit depends on only through ; the residual absorbs everything else. Equation (17) is an exact identity—it holds for every and every choice of , with no approximation.
Remark F.1 (Codomain of ). We define (not ) because for ReLU, , and the gauge must be able to take this value.
Why the conditional mean is the canonical gauge
For each neuron and each sign value , define the conditional mean magnitude
which is well defined whenever .
Proposition F.2 (MMSE optimality of the conditional mean). For each neuron , assuming , the conditional mean minimises the mean squared prediction error
over all functions . The minimiser is unique for every with $\Pr(S_j=s)>0.
Proof. For each fixed with , the bias–variance decomposition gives
The first term is independent of . The second is non-negative and vanishes if and only if . Averaging over completes the proof.
The conditional mean is the unique minimum mean-squared-error (MMSE) predictor of from the single sign bit . It extracts exactly the information about that is available in , no more and no less.
Effect of gauge choice on the residual
Lemma F.3 (Gauge change is a sign code-dependent shift). For any two gauges and ,
Proof. From :
:::
Corollary F.4 (Conditional variance is gauge-invariant). Since is a constant conditional on :
for every gauge .
Activation-specific forms of the canonical gauge
ReLU. , . The sign code recovers the classical gate vector under .
SiLU and GELU. These attenuate but do not zero out the negative side: , with magnitude asymmetry across tested configurations (Appendix § 16).
Tanh. Because tanh is odd and trained networks produce approximately symmetric pre-activations, (i.e. ). The sign-only logit simplifies to where .
The pairwise margin decomposition
From (17) with the canonical gauge , the pairwise margin between classes and decomposes as:
where the sign-only margin depends on only through the sign code , and the pairwise residual . The full network agrees with the sign-only classifier whenever for every competitor class .
Full proof of the gate domination bound
We restate the theorem for convenience and give the complete proof.
Notation and definitions
For a test input with full-model predicted class and each competitor , recall from the main text:
The per-neuron vote bias , so that .
The conditional residual moment .
The pair-specific and overall gate-domination scores:
Why we condition on both S and
The sign-only margin is a deterministic function of S, but the class pair is not: two inputs sharing the same sign code can have different full-model predictions (since the full model also depends on magnitudes). Conditioning on jointly fixes both the threshold and the class pair, making the Markov step valid.
The bound
Theorem F.5 (Gate domination—restated). Let . Assume that ties in both classifiers occur with probability zero under , and that all conditional residual second moments are finite (guaranteed on bounded-input datasets with finite network parameters).
(i) Disagreement bound.
(ii) Width scaling. If for all competitors , then
Proof. The proof has two parts.
Part (i): Disagreement bound.
We proceed in three steps.
Step 1: Disagreement requires a margin violation. Suppose . Let and . Since , we have (strict inequality by the zero-tie assumption). Since and , we have . From with and :
Disagreement therefore implies that at least one class satisfies (25).
Step 2: Conditional Markov’s inequality. Define the -algebra . For each fixed class , define the event
Step 1 shows that , and hence
We now bound for each . Conditional on , the full-model prediction is fixed. If , then . If , the class pair is fixed, the sign-only margin is a deterministic constant (being a function of and the fixed ), and Markov’s inequality on gives:
This step requires only finite conditional second moments.
Step 3: Integrate and combine. Taking expectations of (26) and applying tower property with (27):
where the last inequality uses for each , and the sum over has exactly terms.
Part (ii): Width scaling.
By definition, . The assumption gives . Therefore:
Minimising over gives .
Exponential rate under sub-Gaussian tails
The main theorem uses only Markov’s inequality, yielding a polynomial bound in . Under stronger tail assumptions, the rate improves to exponential. This is not required for the main theorem; we include it to contextualize the empirical contour in Figure 5 uses the exponential form.
Figure 5. (FFNN, SiLU, CIFAR-10; widths 4–4096, depths 1–12, mean over 3 seeds). The yellow line marks the empirical gate-domination region where both the sign gap and sign-only disagreement are small; above it, and . (a) Sign code kNN gap : the sign code matches model test error (gap ) throughout this region. (b) Median : increases with both width (-averaging) and depth (stronger vote bias ). (c) Disagreement rate : mirrors with the same diagonal phase boundary. (d) predicts : the disagreement rate decreases monotonically with across the plotted configurations, independent of how each model achieves its value.
Assumption F.6 (Conditional sub-Gaussianity). Fix and a competitor . Conditional on , the pairwise residual is sub-Gaussian with variance proxy :
The proxy may differ from the conditional second moment ; in general .
Under Assumption F.6, the proof of Part (i) carries through with the sub-Gaussian tail replacing Markov at Step 2, yielding:
where and . This becomes non-vacuous at for . The diagnostics in Section G.5 indicate that sub-Gaussian concentration holds approximately at moderate widths.
The expanded form of for ReLU networks
For ReLU networks, inactive neurons contribute zero magnitude (), so only the active set with contributes. The pair-specific score admits the approximation
where is the normalised gate-only margin and the empirical per-neuron relative-magnitude standard deviation. Width provides averaging; depth provides larger . For general sign-preserving activations, the sum runs over all neurons and replaces .
Empirical Diagnostics Supporting the Theorem Conditions
The disagreement bound in Theorem 6.1 requires only finite conditional second moments and nondegeneracy (no ties). The width-scaling statement (Part ii) additionally requires the residual-scaling condition . The interpretation that grows with width further relies on positive vote bias (). We provide empirical diagnostics supporting each of these conditions across the full SVHN width–depth grid (FFNN, SiLU, 12 depths × 10 widths, 120 models). All diagnostics are computed from two passes: canonical-gauge statistics , from the training split, and residual diagnostics from the test split. Figure 7 summarises the results.
Figure 7. Empirical diagnostics for the gate-domination theorem conditions (FFNN, SiLU, SVHN; widths 4–1024, depths 1–12). Left: Positive vote bias. Each cell shows the fraction of test inputs for which for all competitor classes. In the overparameterized regime (depth , width ), this fraction exceeds 0.80; the sign-only and full classifiers agree on exactly these inputs. Centre: Residual scaling diagnostic. Each cell shows the median of the per-input ratio , where is the diagonal (uncorrelated) variance proxy. Under approximate conditional uncorrelatedness and a CLT approximation over neurons, this ratio is approximately with median . The observed values are consistent with this prediction in the transitional regime (depth , width ), supporting the residual-scaling condition. Right: Finite second moments. All cells show 1.0: every gauge value, residual, and logit is finite across the entire grid, as guaranteed by bounded SVHN inputs and finite network parameters.
Positive vote bias ()
For each test input , we compute the sign-only margin for every competitor and check whether all margins are positive, i.e. whether for every competitor. Figure 7 (left) displays the fraction of test inputs satisfying this condition across the width–depth grid.
Depth is the bottleneck. At depth 1, the all-positive fraction is below 0.35 across all widths: the sign-only classifier disagrees with the full model on most inputs. This is consistent with the theorem’s prediction: at depth 1, no compositional feature extraction has occurred, so per-neuron vote contributions are approximately unbiased () and no amount of width can compensate.
The transition is sharp. Between depth 2 and depth 4, the fraction jumps from to at width 128. By depth 6 and width , the fraction exceeds 0.90 across all tested configurations.
Vote bias tracks agreement exactly. In our diagnostic data, the fraction of inputs where the sign-only classifier agrees with the full model equals the fraction where all vote biases are positive, in every row of the grid. Under the no-ties assumption, this is expected: for all if and only if . This confirms that the mechanism identified by the theorem—disagreement occurs when the residual overwhelms a negative sign-only margin—is the actual mechanism at work.
Residual scaling ()
The theorem’s condition requires that the conditional residual moment grows at most linearly in width. We do not estimate exactly (this would require grouping test inputs by their full sign code, which is infeasible in high dimensions). Instead, we use the diagonal proxy
which equals when the per-neuron residual contributions are exactly uncorrelated conditional on . We examine the per-input ratio .
Calibration benchmark. If the per-neuron residual contributions were exactly uncorrelated conditional on , then by the central limit theorem (over neurons) the standardised residual would be approximately standard normal, so with median and mean . This benchmark requires both approximate uncorrelatedness and the CLT approximation.
Empirical results. Figure 7 (centre) shows the median of across the grid. In the transitional regime (depth , width 32–256), the median is 0.4–0.9, consistent with the prediction. This supports the interpretation that the diagonal proxy correctly captures the typical residual scale, and is therefore consistent with the theorem’s residual-scaling condition . The mean of ranges from 1.5 to 3.0, reflecting a heavy right tail: a small fraction of inputs have . If the condition holds with an effective constant –3 rather than , the width-scaling bound becomes : the pre-factor changes by at most , but the rate is unaffected.
Cross-correlation diagnostic. We directly measure pairwise correlations between per-neuron residual contributions by computing the off-diagonal entries of the sample correlation matrix of the standardised per-unit residuals. The mean absolute off-diagonal correlation satisfies for width across all depths, supporting the approximate uncorrelatedness interpretation. At width , can increase (up to ) because most neurons become effectively always-on or always-off, reducing the number of variable units. This degradation occurs precisely where is already large and the bound is conservative.
At depth 1, the median ratio exceeds 2.0 at width , indicating stronger correlations. However, depth 1 already fails on vote bias ( not positive), so the scaling interpretation is inapplicable regardless.
Finite second moments
Figure 7 (right) confirms that every cell in the grid has value 1.0: all gauge values , , all residuals , all logits, and all magnitudes are finite. This is guaranteed by the bounded support of SVHN images propagated through networks with finite parameters. No special verification is needed beyond confirming the absence of numerical overflow, which we do programmatically.
Nondegeneracy (ties)
The theorem assumes that ties in both classifiers occur with probability zero. We check this with tolerance : the fraction of test inputs where the top two logits differ by less than is exactly 0.0 for both the full model and the sign-only classifier in every cell of the grid.
Summary
The main theorem (Theorem 6.1) requires only finite conditional second moments and nondegeneracy, both of which hold trivially across the entire grid. The diagnostics supporting the width-scaling interpretation and the positive-vote-bias corollary are as follows:
Positive vote bias: the fraction of inputs with for all competitors exceeds 0.85 for depth and width , and exceeds 0.95 for depth . The sign-only and full classifiers agree on precisely these inputs.
Residual scaling: the per-input diagnostic ratio has median 0.4–0.9 (consistent with the benchmark under approximate uncorrelatedness and a CLT approximation) and mean 1.5–3.0 in the transitional regime. Cross-correlations satisfy for width . These diagnostics are consistent with the theorem’s condition , though they do not constitute a direct estimate of the conditional moment .
Finite second moments: trivially satisfied on bounded-input datasets with finite network parameters.
The sub-Gaussian condition required for the exponential remark (Section F.8) holds in the transitional regime (width , tail ratios at ) and degrades at larger widths where the main Markov bound is already sufficient.
Activation Asymmetry and the Limits of Gate Domination
The gate-domination bound (Theorem F.5) is activation-universal: it holds for any sign-preserving activation under the finite-residual-moment and zero-tie conditions stated in the theorem. What does depend on the activation is the size of the gate-domination score —and therefore how useful the bound is in practice.
This appendix makes that dependence precise. We introduce the magnitude asymmetry ratio (§H.1), show how it enters the sign-only margin (§H.2), and use it to explain why is large for ReLU/SiLU/GELU but remains modest for tanh (§H.3), with quantitative validation across 240 trained models (§H.4). We then discuss the distinct mechanism by which residual architectures produce weak (§H.5). Finally, we explain why our repulsion regularizer uses a sigmoid gate proxy for ReLU-family activations but a tanh sign proxy for tanh networks (§§H.6–H.7).
The magnitude asymmetry ratio
Let be the sign-conditional mean magnitude from the canonical gauge (Appendix § 14, Eq. (18)). For any neuron with , define
For dead neurons with we set by convention. The identity
is immediate from the definitions.
The quantity measures how strongly a neuron’s expected magnitude depends on its sign. Three regimes arise:
ReLU ( exactly). Inactive neurons have ; the sign bit completely determines whether the neuron contributes.
SiLU / GELU ( large and positive empirically, typically 0.4–0.95). The negative side is attenuated but not zeroed. Whether holds in a given network depends on the pre-activation distribution, not only on the activation (see §F.5).
Tanh ( empirically). Because tanh is odd, for all . Under the approximately symmetric pre-activation distributions produced by batch-normalised networks, this yields and hence . This is an empirical statement about trained networks, not a consequence of oddness alone (see the discussion in §F.5).
How asymmetry enters the sign-only margin
Under the canonical gauge, the sign-only logit is . Substituting (33) and using :
The pairwise sign-only margin therefore decomposes as
(35) is the key observation. Asymmetry affects gate domination entirely through the numerator of the pair-specific score from Eq. (22); the structure of the disagreement bound itself (Theorem F.5) is unchanged.
Interpretation. The sign-linear term depends on the input through . The asymmetry offset is a constant that depends only on the learned weights and the activation-specific asymmetry profile. When this offset is aligned with the output-weight differences (i.e. has the same sign as for correctly classified inputs), it enlarges the sign-only margin and increases . When for all , the offset vanishes and the sign-only margin is governed entirely by the sign-linear term. There is no general monotone lower bound on in terms of the mean asymmetry alone, because the effect depends on alignment with the class-weight structure.
Why Z1 is strong for SiLU/ReLU but weak for tanh
The gate-domination bound is activation-universal. Asymmetry does not alter the bound; it alters how large typically is.
For ReLU (), inactive neurons contribute zero to the sign-only logit and the margin is dominated by the active set. The asymmetry offset is maximal. For SiLU and GELU, remains strongly positive empirically: positive-sign neurons contribute substantially more than negative-sign neurons, so the offset in (35) amplifies the sign-only margin. This makes large values typical in wide, deep feedforward networks with these activations.
For tanh, trained networks typically satisfy , so and the offset is negligible. The sign-only margin then reduces approximately to the sign-linear term:
Because tanh is odd, every neuron contributes with comparable magnitude regardless of sign. The margin is therefore the difference of two nearly balanced sums of mixed-sign terms, which tends to cancel and yields a typical scale much smaller than in the asymmetric case. Consequently, remains modest even when the sign code is causally dominant under intervention and highly informative.
Empirical validation: tanh versus SiLU
We now verify the predictions of (35) quantitatively. We train 240 FFNN models on CIFAR-10 with each activation (12 depths 10 widths 2 seeds) and compute all decomposition quantities from a single forward pass over the test set.
Notation. To compare across models we report the median gate-only margin
i.e. the median over test points of the minimum pairwise sign-only margin from (35). We abbreviate this as in Table 2. The residual noise is the empirical residual-scale estimator associated with the diagonal proxy in Section G.2; is the layer-mean asymmetry ; and is the median of the overall gate-domination score from Eq. (22).
Table 2 shows representative configurations; Figure 8 displays the full heatmaps across the width–depth grid, and Figure 9 shows that is a strong predictor of the gate-only margin across models.
Figure 8. Activation asymmetry explains the gap between SiLU and tanh. All panels show FFNN on CIFAR-10, widths 4–4096, depths 1–12, averaged over 2 seeds. Top row: the magnitude asymmetry (Eq. (32)) is uniformly large for SiLU and uniformly near zero for tanh. Middle row: gate-only margins (Eq. (36)) are 2–3× larger for SiLU, because the asymmetry offset in (35) amplifies the contribution of correctly-routed neurons. Bottom row: residual noise is comparable or larger for SiLU, confirming that the gap is entirely due to the margin, not the noise.
Figure 9. Asymmetry predicts gate-only margin. Each point is one trained FFNN on CIFAR-10. SiLU models (orange) span with margins up to 3.2; tanh models (blue) cluster at with margins below 1.6.
Key observations.
Tanh has everywhere. Across all 120 (width, depth) configurations, the median is 0.0014, and 95 of 120 cells have gap (Figure 8, top row). This confirms that the magnitude is effectively independent of the sign in trained tanh networks, as predicted by approximate pre-activation symmetry.
SiLU has large . At small widths, (a near-ReLU regime where the negative side is strongly suppressed). At large widths and depths, decreases to – as pre-activations concentrate closer to zero, but remains far above zero (Figure 8, top row).
is smaller for tanh than for SiLU. SiLU has larger in 118 of 120 cells (Figure 8, bottom row). The residual noise is not the bottleneck for tanh—the signal (margin) is.
Gate-only margins are 2–3× larger for SiLU. At (4096, 12), SiLU achieves versus tanh’s 0.95 (Figure 8, middle row; Figure 9). This gap, combined with the ratio, explains the order-of-magnitude difference in .
Despite small , tanh sign codes are causally necessary. Section 4 showed that tanh networks on SVHN retain 78% accuracy (from 80% baseline) under total magnitude replacement, and collapse to chance under 10% sign corruption. The sign code carries the classification signal; the diagnostic cannot certify this because the conditional-mean gauge extracts no asymmetry from an approximately odd activation.
Why residual architectures can have weak
Residual architectures present a distinct mechanism for weak .
In a residual block the output is , and the sign–magnitude decomposition at the block output mixes the skip connection (which carries its own sign–magnitude structure) with the branch output . The last-layer magnitude therefore depends on the entire history of skip connections, creating dependencies that the single-layer conditional mean cannot capture. This inflates the effective residual scale in the denominator of , rather than shrinking the numerator as in the tanh case.
The two mechanisms are thus complementary:
Odd activations (tanh): weak primarily because the sign-only margin is small (the asymmetry offset vanishes).
Residual architectures: weak primarily because the residual scale is large (skip-path magnitude dependencies inflate the denominator).
In both cases, the causal intervention results (§ 4) provide the more robust, architecture- and activation-universal evidence that signs carry the decisive classification signal. For ResNet-18 with
SiLU, replacing every magnitude with a random draw preserves 93–95% accuracy across all four tested activations; flipping 10% of sign bits collapses accuracy to chance.
A multi-layer decomposition that conditions on the sign codes of all preceding blocks—rather than using a single last-layer conditional mean—would yield tighter residual estimates and potentially larger values. We leave such multi-layer certificates to future work, noting that the single-layer is best understood as a diagnostic for feedforward architectures, while the causal intervention framework provides the architecture-universal evidence.

Figure 10. Theoretical quantities across the depth-width grid for a ResNet on Cifar-10 with SiLU activation.
Choice of repulsion regularizer: gate proxy vs. sign proxy
The repulsion loss (Eq. (8)) is designed to destroy same-class sharing of the dominant computational pathway. Which pathway is dominant depends on the activation’s asymmetry profile, so the correct continuous proxy for the regularizer depends on the activation.
ReLU, SiLU, and GELU: sigmoid gate proxy
For these activations, is large and positive: neurons with contribute far more strongly than neurons with . The dominant computational pathway is therefore the active set , where . We regularise the continuous gate proxy
which for small temperature approximates the binary gate. Penalising for same-class pairs directly drives their active-set overlap toward zero.
Why gate repulsion is stronger than sign repulsion for non-odd activations. Two inputs with neurons, each with roughly active, can have orthogonal sign codes in while still sharing approximately co-active neurons. Sign code orthogonality treats agreements on the active side and agreements on the inactive side symmetrically, but only the active side carries substantial forward-pass signal when is large. Gate repulsion, by contrast, can drive the co-active count all the way to zero, destroying the shared computational channel entirely.
Empirical confirmation. On SVHN (FFNN, width 1024, depth 8, SiLU), sigmoid-gate repulsion achieves the intended effect: training accuracy exceeds 97%, test accuracy collapses to approximately 40%, and leave-one-out purity at drops to 0.34. Matched sign-based repulsion at the same nominal strength either destabilises training (SiLU/GELU/ReLU, due to steeper gradients from the tanh proxy) or leaves enough active-set overlap for partial generalization to survive.
Tanh networks: sign proxy
Tanh is the important exception. Because in trained tanh networks, the forward pass does not privilege an active set: positive-sign and negative-sign neurons contribute with comparable magnitude. A sigmoid gate proxy would impose an artificial positive-vs-nonpositive split that is not aligned with the tanh network’s geometry.
For tanh models we therefore use the sign proxy
which for small approximates the binary sign code . This is the correct matched intervention: when the activation treats both sides approximately symmetrically, the relevant binary structure is the sign code itself, not a privileged active set.
Consistency with the rest of the paper. The distinction between gate proxy and sign proxy arises only in the training regularizer. All theoretical diagnostics (the gate-domination score , the error chain, the sub-Gaussian bound), all empirical measurements (sign-kNN, LOO purity), and all causal interventions (sign flip, magnitude replacement) are reported throughout the paper in the common binary sign-code framework . The two frameworks are related by the bijection ; the gate representation appears only inside the regularizer where it provides the stronger intervention for non-odd activations.
Summary
The gate-domination theorem (Theorem F.5) is activation-universal; asymmetry does not change the bound itself.
Asymmetry enters through the sign-only margin via the decomposition (35): large positive amplifies the margin; eliminates the asymmetry offset and leaves only the sign-linear term.
For ReLU, SiLU, and GELU (large ), gate domination is readily achieved in wide, deep feedforward networks.
For tanh () and for residual architectures (large residual scale), can remain modest even when the sign code is causally dominant under intervention and informationally sufficient (Table 2; Figure 8 and Figure 9).
The training regularizer is matched to the activation’s geometry: sigmoid gate proxy (37) for ReLU-family activations (where the active set is the dominant channel), tanh sign proxy (38) for tanh (where no such asymmetric split exists).
| Width | Depth | \multicolumn{4}{c}{SiLU} | \multicolumn{4}{c}{Tanh} | ||||||
| 64 | 6 | 0.94 | 8.39 | 1.46 | 0.007 | 0.84 | 0.86 | ||
| 64 | 12 | 0.93 | 6.53 | 1.44 | 0.003 | 0.89 | 1.00 | ||
| 256 | 6 | 0.86 | 3.68 | 1.40 | 0.000 | 0.87 | 1.26 | ||
| 256 | 12 | 0.71 | 1.82 | 2.53 | 0.001 | 0.75 | 1.17 | ||
| 1024 | 6 | 0.55 | 1.19 | 2.08 | 0.001 | 0.65 | 0.98 | ||
| 1024 | 12 | 0.41 | 0.53 | 3.01 | 0.001 | 0.61 | 0.85 | ||
| 4096 | 6 | 0.37 | 0.49 | 2.71 | 0.000 | 0.60 | 0.92 | ||
| 4096 | 12 | 0.66 | 0.29 | 2.89 | 0.000 | 0.59 | 0.95 |
Table 2. Magnitude asymmetry and gate-domination diagnostics for SiLU versus tanh on CIFAR-10 (FFNN, selected configurations, averaged over 2 seeds). Columns under SiLU and Tanh are , , , and .
Table 3 collects the evidence across activations and architectures.
References
- [1]Sanjeev Arora, Rong Ge, Behnam Neyshabur, and Yi Zhang. Stronger generalization bounds for deep nets via a compression approach. In International conference on machine learning, pages 254–263. PMLR, 2018.arxiv.org/abs/1802.05296
- [2]Randall Balestiero and Richard Baraniuk. A spline theory of deep networks. In International Conference on Machine Learning, 2018. URL https://api.semanticscholar.org/CorpusID: 51882762.
- [3]Peter L Bartlett, Dylan J Foster, and Matus J Telgarsky. Spectrally-normalized margin bounds for neural networks. Advances in neural information processing systems, 30, 2017.arxiv.org/abs/1706.08498
- [4]Mikhail Belkin, Daniel Hsu, Siyuan Ma, and Soumik Mandal. Reconciling modern machine-learning practice and the classical bias–variance trade-off. Proceedings of the National Academy of Sciences, 116(32):15849–15854, 2019.DOI
- [5]Lénaïc Chizat and Francis R. Bach. Implicit bias of gradient descent for wide two-layer neural networks trained with the logistic loss. In Annual Conference Computational Learning Theory, 2020. URL https://api.semanticscholar.org/CorpusID:211076120.
- [6]Laurent Dinh, Razvan Pascanu, Samy Bengio, and Yoshua Bengio. Sharp minima can generalize for deep nets. In International Conference on Machine Learning, 2017. URL https://api.semanticscholar.org/CorpusID:7636159.
- [7]Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, Jakob Uszkoreit, and Neil Houlsby. An image is worth 16x16 words: Transformers for image recognition at scale. ArXiv, abs/2010.11929, 2020. URL https://api.semanticscholar.org/CorpusID:225039882.arxiv.org/abs/2010.11929
- [8]Gintare Karolina Dziugaite and Daniel M Roy. Computing nonvacuous generalization bounds for deep (stochastic) neural networks with many more parameters than training data. arXiv preprint arXiv:1703.11008, 2017.
- [9]Stefan Elfwing, Eiji Uchibe, and Kenji Doya. Sigmoid-weighted linear units for neural network function approximation in reinforcement learning. Neural Networks, 107:3–11, 2018. ISSN 0893-6080. doi: https://doi.org/10.1016/j.neunet.2017.12.012. URL https://www.sciencedirect.com/science/article/pii/S0893608017302976. Special issue on deep reinforcement learning.
- [10]Jonathan Fiat, Eran Malach, and Shai Shalev-Shwartz. Decoupling gating from linearity. ArXiv, abs/1906.05032, 2018. URL https://api.semanticscholar.org/CorpusID:127096892.arxiv.org/abs/1906.05032
- [11]Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. arXiv: Learning, 2018. URL https://api.semanticscholar.org/CorpusID:53388625.arxiv.org/abs/1803.03635
- [12]Matteo Gamba, Adrian Chmielewski-Anders, Josephine Sullivan, Hossein Azizpour, and Marten Bjorkman. Are all linear regions created equal? In International Conference on Artificial Intelligence and Statistics, 2022. URL https://api.semanticscholar.org/CorpusID:247084088.
- [13]Chuqin Geng, Nham Le, Xiaojie Xu, Zhaoyue Wang, Arie Gurfinkel, and Xujie Si. Towards reliable neural specifications. In International Conference on Machine Learning, pages 11196–11212. PMLR, 2023.arxiv.org/abs/2210.16114
- [14]Xavier Glorot, Antoine Bordes, and Yoshua Bengio. Deep sparse rectifier neural networks. In International Conference on Artificial Intelligence and Statistics, 2011. URL https://api.semanticscholar.org/CorpusID:2239473.
- [15]Antoine Gonon, Nicolas Brisebarre, Elisa Riccietti, and Rémi Gribonval. A path-norm toolkit for modern networks: consequences, promises and challenges. ArXiv, abs/2310.01225, 2023. URL https://api.semanticscholar.org/CorpusID:263605441.arxiv.org/abs/2310.01225
- [16]Song Han, Huizi Mao, and William J. Dally. Deep compression: Compressing deep neural network with pruning, trained quantization and huffman coding. arXiv: Computer Vision and Pattern Recognition, 2015. URL https://api.semanticscholar.org/CorpusID:2134321.arxiv.org/abs/1510.00149
- [17]X. Y. Han, Vardan Papyan, and David L. Donoho. Neural collapse under mse loss: Proximity to and dynamics on the central path. ArXiv, abs/2106.02073, 2021. URL https://api.semanticscholar.org/CorpusID:235352583.arxiv.org/abs/2106.02073
- [18]Boris Hanin and David Rolnick. Complexity of linear regions in deep networks. In International Conference on Machine Learning, 2019. URL https://api.semanticscholar.org/CorpusID:59291990.arxiv.org/abs/1901.09021
- [19]Fengxiang He, Shiye Lei, Jianmin Ji, and Dacheng Tao. Neural networks behave as hash encoders: An empirical study. arXiv preprint arXiv:2101.05490, 2021.arxiv.org/abs/2101.05490
- [20]Kaiming He, X. Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 770–778, 2015. URL https://api.semanticscholar.org/CorpusID:206594692.arxiv.org/abs/1512.03385
- [21]Dan Hendrycks and Kevin Gimpel. Gaussian error linear units (gelus). arXiv: Learning, 2016. URL https://api.semanticscholar.org/CorpusID:125617073.
- [22]W. Ronny Huang, Zeyad Ali Sami Emam, Micah Goldblum, Liam H. Fowl, Justin K. Terry, Furong Huang, and Tom Goldstein. Understanding generalization through visualizations. In ICMLBN@NeurIPS, 2019. URL https://api.semanticscholar.org/CorpusID:182952973.arxiv.org/abs/1906.03291
- [23]Yiding Jiang, Behnam Neyshabur, Hossein Mobahi, Dilip Krishnan, and Samy Bengio. Fantastic generalization measures and where to find them. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id=S1gIjJBFvH.
- [24]Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. ArXiv, abs/1609.04836, 2016. URL https://api.semanticscholar.org/CorpusID:5834589.arxiv.org/abs/1609.04836
- [25]Simon Kornblith, Mohammad Norouzi, Honglak Lee, and Geoffrey E. Hinton. Similarity of neural network representations revisited. ArXiv, abs/1905.00414, 2019. URL https://api.semanticscholar.org/CorpusID:141460329.arxiv.org/abs/1905.00414
- [26]Chandrashekar Lakshminarayanan and Amit Singh. Neural path features and neural path kernel : Understanding the role of gates in deep learning. ArXiv, abs/2006.10529, 2020. URL https://api.semanticscholar.org/CorpusID:219792921.arxiv.org/abs/2006.10529
- [27]Arthur Lebeurrier, Titouan Vayer, and Rémi Gribonval. Path-conditioned training: a principled way to rescale relu neural networks. ArXiv, abs/2602.19799, 2026. URL https://api.semanticscholar.org/CorpusID:285973448.
- [28]Kaifeng Lyu and Jian Li. Gradient descent maximizes the margin of homogeneous neural networks. ArXiv, abs/1906.05890, 2019. URL https://api.semanticscholar.org/CorpusID:189898036.arxiv.org/abs/1906.05890
- [29]Guido Montúfar, Razvan Pascanu, Kyunghyun Cho, and Yoshua Bengio. On the number of linear regions of deep neural networks. In Neural Information Processing Systems, 2014. URL https://api.semanticscholar.org/CorpusID:5941770.arxiv.org/abs/1402.1869
- [30]Preetum Nakkiran, Gal Kaplun, Yamini Bansal, Tristan Yang, Boaz Barak, and Ilya Sutskever. Deep double descent: Where bigger models and more data hurt. Journal of Statistical Mechanics: Theory and Experiment, 2021(12):124003, 2021.arxiv.org/abs/1912.02292
- [31]Behnam Neyshabur, Ruslan Salakhutdinov, and Nathan Srebro. Path-sgd: Path-normalized optimization in deep neural networks. ArXiv, abs/1506.02617, 2015a. URL https://api.semanticscholar.org/CorpusID:2101905.arxiv.org/abs/1506.02617
- [32]Behnam Neyshabur, Ryota Tomioka, and Nathan Srebro. Norm-based capacity control in neural networks. In Conference on learning theory, pages 1376–1401. PMLR, 2015b.DOI
- [33]Behnam Neyshabur, Zhiyuan Li, Srinadh Bhojanapalli, Yann LeCun, and Nathan Srebro. Towards understanding the role of over-parametrization in generalization of neural networks. ArXiv, abs/1805.12076, 2018. URL https://api.semanticscholar.org/CorpusID:44130076.arxiv.org/abs/1805.12076
- [34]Vardan Papyan, Xuemei Han, and David L. Donoho. Prevalence of neural collapse during the terminal phase of deep learning training. Proceedings of the National Academy of Sciences of the United States of America, 117:24652 – 24663, 2020. URL https://api.semanticscholar.org/CorpusID:221172897.DOI
- [35]Yookoon Park, Sangho Lee, Gunhee Kim, and David Blei. Unsupervised representation learning via neural activation coding. In International Conference on Machine Learning, pages 8391–8400. PMLR, 2021.arxiv.org/abs/2112.04014
- [36]Razvan Pascanu, Guido Montúfar, and Yoshua Bengio. On the number of response regions of deep feed forward networks with piece-wise linear activations. arXiv: Learning, 2013. URL https://api.semanticscholar.org/CorpusID:9254343.arxiv.org/abs/1312.6098
- [37]Maithra Raghu, Ben Poole, Jon M. Kleinberg, Surya Ganguli, and Jascha Narain Sohl-Dickstein. On the expressive power of deep neural networks. In International Conference on Machine Learning, 2016. URL https://api.semanticscholar.org/CorpusID:2838204.arxiv.org/abs/1606.05336
- [38]Prajit Ramachandran, Barret Zoph, and Quoc V. Le. Searching for activation functions. ArXiv, abs/1710.05941, 2018. URL https://api.semanticscholar.org/CorpusID:10919244.arxiv.org/abs/1710.05941
- [39]Thiago Serra, Christian Tjandraatmadja, and Srikumar Ramalingam. Bounding and counting linear regions of deep neural networks. ArXiv, abs/1711.02114, 2017. URL https://api.semanticscholar.org/CorpusID:34019680.arxiv.org/abs/1711.02114
- [40]Daniel Soudry, Elad Hoffer, Mor Shpigel Nacson, Suriya Gunasekar, and Nathan Srebro. The implicit bias of gradient descent on separable data. J. Mach. Learn. Res., 19(1):2822–2878, January 2018. ISSN 1532-4435.arxiv.org/abs/1710.10345
- [41]Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. In International Conference on Learning Representations, 2017.arxiv.org/abs/1611.03530






