Identifiability: Why Accuracy Never Certifies Meaning

📍 Where we are: Part II · Identifiability and Reasoning Shortcuts — Chapter 5. Reasoning Shortcuts counted the label-perfect ways for a model's concepts to be wrong; this chapter explains why every one of them is invisible, and what it costs to make them visible.

The previous chapter ended with a census. On the XOR (exclusive-or) task, sixteen relabelings of the four concept states survive every label the task can ever produce; fifteen are wrong about the concepts; twenty label-perfect training runs each landed inside the census, exactly as the count said they could. A census answers how many. This chapter answers why, and the answer has algebraic structure: the label-preserving relabelings are not a loose collection of accidents, they are organized by a group, the symmetry group of the knowledge, and the question "can labels pin down concept meaning?" has a clean criterion, derived in this chapter as a corollary of the optimum characterization of [1]: they can if and only if that group is trivial. Every nontrivial group element is a complete, self-consistent, wrong semantics that the label distribution cannot distinguish from the right one, not because the test set is too small, but because the map from concepts to labels destroyed the distinction before any data was drawn. The companion module makes each clause of that sentence a committed, asserted number, and the chapter ends where honesty demands: with the two levers that break the symmetry, priced exactly, and the recognition that the same mathematics governs concept-bottleneck models, latent-variable models, and disentanglement far outside neuro-symbolic (NeSy) AI.

The simple version

Imagine two department clerks who each keep the university's records in a private shorthand. Clerk A writes every advising record advisor-first; Clerk B swapped the two columns years ago and has been perfectly consistent ever since. Every report the department publishes (how many advising pairs, whether two people are in the same research group, who has co-authored with whom) comes out identical from both ledgers, because every published question happens to be symmetric in the two columns. Auditing the reports harder cannot reveal the swap; a thousand more reports are a thousand more identical numbers. Only two things ever expose Clerk B: a new report whose question is not symmetric (ask specifically about the left column), or opening the ledger at an entry whose true value you already know. This chapter is that story made mathematical. The ledger is the model's concept vector, the published reports are its labels, the consistent swap is an element of a symmetry group, and the two exposures are, precisely, a second task and a concept label.

What this chapter covers

• From counting to structure: the previous chapter's admissible relabelings revisited as a group, with closure and inverses proved in two lines; the definition of identifiability (trivial group if and only if labels pin the concepts) and the fiber and orbit language that makes it usable.
• The group computed, not asserted: the companion enumerates XOR's symmetries, verifies the group axioms by brute force, and predicts the previous chapter's sixteen-optimum count from the orbits, with the agreement between algebra and enumeration guarded by an assert.
• Blindness at machine precision: two hand-set parameterizations whose label likelihoods agree exactly on all 520 inputs while their concept readouts disagree on half the space; why no label metric on any test set, however large, can separate them.
• The fiber bound beyond NeSy: a many-to-one concept-to-label map with a fiber of size $k$ admits at least $k!$ label-equivalent concept assignments, and the same symmetry argument underlies the impossibility of unsupervised disentanglement, non-identifiable latent-variable models, and underspecification at industrial scale.
• Two levers, counted as symmetry breaking: factorized concept heads collapse the joint relabeling space by a measured factor, and $k$ concept-labeled examples cut the surviving relabelings down a committed curve that reaches exactly one; both counts asserted, both caveats stated.
• The third lever and the frontier: multi-task knowledge as intersecting symmetry groups, argued on the group table; and the open questions, from non-enumerable concept spaces to the conjecture that calibration tracks identifiability.

From counting to structure: the optima form a group

Recall the objects from the previous chapter. The knowledge $\mathsf{K}$ is deterministic, so it acts as a label map $\beta_{\mathsf{K}}$ sending each concept state $c$ to its label; on our task $\beta_{\mathsf{K}}(c) = c_1 \oplus c_2$, the exclusive or of the two concept bits. A relabeling $\alpha : \mathcal{G} \to \mathcal{C}$ is a function from ground-truth states to model states, a candidate systematic error, and $\alpha$ is admissible (an exact optimum of the label likelihood) when it commutes with the knowledge on every observed state: $\beta_{\mathsf{K}}(\alpha(g)) = \beta_{\mathsf{K}}(g)$ for all $g$ in the support. Writing $\circ$ for function composition ("apply the right function first, then the left"), admissibility on the full support is the single functional equation $\beta_{\mathsf{K}} \circ \alpha = \beta_{\mathsf{K}}$.

Now restrict attention to the admissible relabelings that are also bijections: maps that pair states one-to-one, so each has an inverse $\alpha^{-1}$ undoing it. Call this set $G$. The claim is that $G$ is a group under composition, meaning it contains the identity, is closed under $\circ$, and contains an inverse for each element. The identity map satisfies $\beta_{\mathsf{K}} \circ \mathrm{id} = \beta_{\mathsf{K}}$ because the identity leaves every input unchanged, so composing with it changes nothing. The other two axioms each take one line. For closure, take $\alpha, \alpha' \in G$, where $\in$ reads "is a member of", so $\alpha$ and $\alpha'$ are any two elements of $G$; composition is associative, so

$$\beta_{\mathsf{K}} \circ (\alpha \circ \alpha') = (\beta_{\mathsf{K}} \circ \alpha) \circ \alpha' = \beta_{\mathsf{K}} \circ \alpha' = \beta_{\mathsf{K}},$$

where the middle step substituted the admissibility of $\alpha$ and the last substituted the admissibility of $\alpha'$; and a composition of bijections is a bijection. For inverses, compose both sides of $\beta_{\mathsf{K}} \circ \alpha = \beta_{\mathsf{K}}$ with $\alpha^{-1}$ on the right:

$$\beta_{\mathsf{K}} \circ \alpha^{-1} = (\beta_{\mathsf{K}} \circ \alpha) \circ \alpha^{-1} = \beta_{\mathsf{K}} \circ (\alpha \circ \alpha^{-1}) = \beta_{\mathsf{K}} \circ \mathrm{id} = \beta_{\mathsf{K}}.$$

So $G$ is a group: the symmetry group of the knowledge. The name is earned in the physicist's sense. A symmetry of an object is a transformation that leaves it unchanged; here the object is the label behavior of $\mathsf{K}$, and each element of $G$ is a way of permuting concept meanings that the labels provably cannot feel. Two remarks keep the bookkeeping honest. First, $G$ is not the whole sixteen-element optimum set: non-bijective survivors, such as the map collapsing state $11$ onto $00$, have no inverse and so cannot belong to any group. $G$ is the optimum set's structural core, and we will see in a moment that it predicts the full count. Second, on the full support the group depends only on $\beta_{\mathsf{K}}$, never on the architecture, the optimizer, or the amount of data: it is a property of the task. (Under a partial support the admissible bijections need not even form a group: the closure proof above used the commuting condition at every state, and a bijection may carry an observed state to an unobserved one where the condition was never imposed, so a composition of two admissible bijections can violate admissibility on an observed state. The biased support of the previous chapter breaks this structure too.)

The criterion this chapter is named for now states itself. Concepts are identifiable from labels when the label distribution determines the concept semantics uniquely, that is, when the only admissible relabeling is the identity. On the full support this holds exactly when $G$ is trivial (the one-element group), because every fiber (the set of concept states sharing one label; the word is defined fully just below) of size two or more donates a nontrivial permutation to $G$, and conversely a trivial group forces every fiber to be a singleton, which makes the identity the only admissible map of any kind. The group packaging is this chapter's, following SATORI's grounding notes; the criterion itself is an immediate corollary of the optimum characterization of [1], the Theorem 2 the previous chapter evaluated. Each nontrivial element of $G$ is not noise and not error in the statistical sense; it is a distinct, internally consistent assignment of meanings to the model's symbols that induces exactly the same distribution over labels. The label likelihood is a function on parameter space that is constant along $G$'s action whenever the architecture can express the relabeling, as the unrestricted extractor of this chapter's exhibit can (the factorized architecture of escape route one works precisely by making some elements inexpressible), so maximizing it, with any amount of data, selects an orbit (an entire family of solutions linked by the group's action; the word is also defined just below), never a point.

Two words of vocabulary make the geometry speakable, and the clerks of the opening analogy decode both. The fiber of a label $y$ is the preimage $\beta_{\mathsf{K}}^{-1}(y)$, the set of concept states that tell the same observable story: for XOR, the parity classes $\{00, 11\}$ (label $0$) and $\{01, 10\}$ (label $1$). A fiber is "many internal stories, one published report": within a fiber, the ledger entries differ and the reports agree. The orbit of a state $g$ under $G$ is $\{\alpha(g) : \alpha \in G\}$, every state that some symmetry can relabel $g$ to, which is to say every alternative meaning the model could secretly assign to $g$ without any label noticing. Identifiability fails exactly on the states whose orbit is bigger than the singleton $\{g\}$.

Identifiability in one picture: the knowledge's symmetry group (left) makes two parameterizations exactly indistinguishable in label likelihood (center), and the repairs work precisely by shrinking the group to the identity (right). Original diagram by the authors, created with AI assistance.

The group, computed and cross-checked

Everything above is definition and two lines of algebra; the companion refuses to leave it there. examples/frontier/identifiability.py imports the task, the data, and the Eq. 1 likelihood from shortcuts.py unchanged, then enumerates the group rather than asserting it (identifiability.py, lines 94–101):

def symmetry_group() -> list[tuple[int, ...]]:
    """The symmetry group G of the knowledge: every relabeling α that is
    (i) admissible on the FULL support — β_K(α(g)) = β_K(g) for all g,
    the same indicator ``shortcuts.admissible_alphas`` enumerates — and
    (ii) a bijection, so it has an inverse and G is a group.  Sorted, so
    the identity (0,1,2,3) comes first."""
    return sorted(a for a in admissible_alphas(list(COMBOS))
                  if len(set(a)) == len(COMBOS))

Note the discipline: the admissibility test is not re-implemented; it is literally shortcuts.admissible_alphas, the previous chapter's Theorem 2 indicator, filtered by the bijection condition len(set(a)) == len(COMBOS) (a four-tuple of images is a bijection exactly when its images are all distinct). The group axioms are then verified by enumeration, not trusted: check_group_axioms walks every pair, confirming the identity is present, that $\alpha \circ \alpha'$ stays inside the set for all pairs, and that every element has an inverse inside (identifiability.py, lines 115–125), with the result guarded by an assert (line 286). The committed run prints the whole object:

[1] the symmetry group of K: bijections alpha with beta_K(alpha(g)) = beta_K(g) on ALL g
      fibers of beta_K (the parity classes):  y=0 <- {00, 11}   y=1 <- {01, 10}
      element                                   images
      identity                                  00->00 01->01 10->10 11->11
      swap        (c1,c2) -> (c2,c1)            00->00 01->10 10->01 11->11
      swap.negate (c1,c2) -> (1-c2,1-c1)        00->11 01->01 10->10 11->00
      negate      (c1,c2) -> (1-c1,1-c2)        00->11 01->10 10->01 11->00
      order |G| = 4 = 2!*2! (one factorial per fiber); closure/identity/inverses verified by enumeration
      G is NOT trivial => concepts are NOT identifiable from labels (immediate from the paper's Theorem 2)

Four elements: the identity; the swap, exchanging the two concepts (admissible because XOR is symmetric in its arguments); the negate, flipping both bits (admissible because negating both inputs of XOR cancels); and their composition. Each element is its own inverse, and the group is the Klein four-group, written $\mathbb{Z}_2 \times \mathbb{Z}_2$, the direct product of two two-element groups: one $\mathbb{Z}_2$ generated by the swap, one by the negation. The printed order has a formula in it worth decoding. Within each fiber, any permutation (any one-to-one shuffling) of the fiber's states preserves labels by construction, and a bijective symmetry is exactly an independent choice of one permutation per fiber; a set of $k$ elements has $k!$ permutations ($k$ factorial, the product $k \cdot (k-1) \cdots 1$), so the group order is the product of one factorial per fiber, here $\lvert G \rvert = 2! \cdot 2! = 4$, with $\lvert \cdot \rvert$ denoting the number of elements in a set. The assert at lines 291–293 pins this identity, and line 294 pins the four names to the four enumerated tuples.

Now the cross-check that makes the theory earn its keep. The orbits of $G$ ought to coincide with the fibers of $\beta_{\mathsf{K}}$ (a symmetry can move a state anywhere in its own fiber and nowhere else), and if they do, the previous chapter's full optimum count follows in closed form: an arbitrary admissible function (bijective or not) may send each state independently anywhere in that state's orbit, so the count is the product of the orbit sizes,

$$N_{\mathrm{opt}} \;=\; \prod_{g \in \mathcal{G}} \lvert \mathrm{orbit}(g) \rvert \;=\; 2 \cdot 2 \cdot 2 \cdot 2 \;=\; 16,$$

where $\prod_g$ multiplies one factor per ground-truth state. The module computes the orbits, asserts they equal the fibers as index sets (lines 296–297), computes the product, and asserts it against the brute-force enumeration shortcuts.admissible_alphas returned in the previous chapter (lines 302–306):

[2] the group-orbit prediction of shortcuts.py's Theorem-2 count (full support)
      orbit of each state (= its fiber): 00->{00,11}  01->{01,10}  10->{01,10}  11->{00,11}
      N_opt = prod_g |orbit(g)| = 2*2*2*2 = 16 = the count enumerated by shortcuts.admissible_alphas
      reasoning shortcuts beside the intended identity: N_opt - 1 = 15

This is the volume's oracle discipline applied to its own theory. Volume 2 checked a hand-built reasoner against ELK; Volume 4 checked a four-world sum against a compiled circuit; here group theory and exhaustive enumeration compute the same number by unrelated routes, and the agreement is a committed assert, not a sentence. Sixteen optima, fifteen shortcuts, and now a reason: the count is the group's orbit structure, and the group is nontrivial because XOR's fibers are.

Two models, one likelihood: blindness at machine precision

The group lives on the abstract concept space. The next exhibit realizes one of its elements in weight space and lets the likelihood try, and fail, to see it. No training is involved anywhere: both parameterizations are hand-set in closed form, so every digit below is arithmetic, not luck. The extractor reads the raw input coordinates (the task's geometry puts concept $j$ on coordinate $j$), one $2 \times 2$ weight matrix per head, with a hand-set logit scale $s = 4$ (identifiability.py, lines 141–152):

S: float = 4.0                       # hand-set logit scale s
# W_READ0: z = s·(−x₀, +x₀), so π[1] = e^{s x₀}/(e^{s x₀}+e^{−s x₀})
#        = σ(2 s x₀) — the head says c = 1 exactly when x₀ > 0.
W_READ0: np.ndarray = S * np.array([[-1.0, 0.0], [1.0, 0.0]])
# W_READ1: the same readout off coordinate x₁.
W_READ1: np.ndarray = S * np.array([[0.0, -1.0], [0.0, 1.0]])

# θ_A — the INTENDED parameterization: head j reads coordinate j.
THETA_A: tuple[np.ndarray, np.ndarray] = (W_READ0, W_READ1)
# θ_B — the group's swap element realized in weight space: the SAME two
# matrices with the heads exchanged, so head 1 reads x₁ and head 2 reads x₀.
THETA_B: tuple[np.ndarray, np.ndarray] = (W_READ1, W_READ0)

$\theta_A$ is the intended semantics: head $j$ reads coordinate $j$. $\theta_B$ contains the same two matrices with the heads exchanged: it is the group's swap element, realized as weights. Downstream, both feed the unchanged Eq. 1 likelihood predict_eq1 from shortcuts.py (lines 158–163 there): the four-world sum $p_\theta(y \mid x; \mathsf{K}) = \sum_{c_1 \oplus c_2 = y} \pi_1[c_1]\, \pi_2[c_2]$, where $\pi_j[v]$ is head $j$'s probability that concept $j$ has value $v$.

Why must the two label likelihoods agree? Write $\pi^A_j$ for $\theta_A$'s heads. Exchanging the heads means $\pi^B_1 = \pi^A_2$ and $\pi^B_2 = \pi^A_1$ as functions of $x$. Substitute into the sum for $y = 1$:

$$p_B(1 \mid x) = \sum_{c_1 \oplus c_2 = 1} \pi^A_2[c_1]\, \pi^A_1[c_2] = \sum_{c_1' \oplus c_2' = 1} \pi^A_1[c_1']\, \pi^A_2[c_2'] = p_A(1 \mid x),$$

where the middle step renames the summation indices by $(c_1', c_2') = (c_2, c_1)$: the index set is unchanged because $c_1 \oplus c_2 = c_2 \oplus c_1$ (this is exactly where XOR's symmetry enters), and each summand is unchanged because multiplication of numbers commutes. The same computation with $y = 0$ handles the other label. The equality is exact, not approximate, and the committed run reflects that: the maximum absolute difference over all 520 train and test points, both labels, is not merely below the asserted tolerance of $10^{-12}$ but exactly zero, because the two floating-point sums contain the same products (IEEE-754 floating-point multiplication and addition are commutative) in swapped order (identifiability.py, lines 318–320). The output:

[3] distribution equivalence: two hand-set weightings one likelihood cannot split
      theta_A: head j reads coordinate j (intended); theta_B: the SAME matrices, heads exchanged (the swap element)
      on all 520 train+test points, both labels:
        max |p_A(y|x;K) - p_B(y|x;K)| = 0.0e+00   (tolerance 1e-12);  label predictions identical
      quantity               theta_A    theta_B
      label accuracy         1.000      1.000
      mean NLL of true y     0.0042     0.0042
      concept accuracy       1.000      0.500
      induced map alpha-hat  identity   swap
      same likelihood everywhere, concepts 0.5 apart: label accuracy is provably blind to the difference

Read the table from top to bottom, because it is a demolition in four rows. Label accuracy: both perfect. Mean negative log-likelihood (the table's NLL) of the true label, a strictly finer instrument that sees the full predicted probability rather than a thresholded decision: identical to every printed digit, and identical in fact, by the equality above. Concept accuracy: $1.000$ against $0.500$. The concept readouts of $\theta_B$ are wrong on both bits of every input from states $01$ and $10$, which is half the balanced data, and the induced relabeling, recovered from the confusion of predicted against true states, is asserted to be exactly the group's swap element (identifiability.py, lines 325–329).

State the consequence as sharply as it deserves. Every label-based quantity, accuracy, F1 (the harmonic mean of precision and recall), calibration on $y$, held-out likelihood, any proper scoring rule, is a function of the map $x \mapsto p_\theta(y \mid x; \mathsf{K})$, the arrow $\mapsto$ reading "maps to": the function sending each input $x$ to its predicted label distribution. And that map is identical for $\theta_A$ and $\theta_B$: not close, identical. A larger test set evaluates the same two identical functions at more points. A cleverer label metric evaluates a different functional of the same two identical functions. The impossibility is not statistical, to be worn down by data volume; it lives in the non-injectivity of the map from concept semantics to label behavior, and no quantity computed downstream of that map can recover what the map destroyed. Accuracy never certifies meaning because accuracy is measured on the far side of $\beta_{\mathsf{K}}$.

The fiber bound: where this bites beyond NeSy

The XOR analysis generalizes, and the general statement is worth having in portable form. SATORI's grounding notes state it in the factored form this series has used since Volume 4: a NeSy predictor is a composition $\rho \circ g_\theta$, perception $g_\theta$ mapping inputs to concepts, then fixed reasoning $\rho$ mapping concepts to outputs. If $\rho$ is not injective and some fiber $\rho^{-1}(y)$ contains $k$ concept states, then every permutation of that fiber, extended by the identity elsewhere, is a bijection commuting with $\rho$; there are $k!$ such permutations, so there are at least $k!$ distinct concept semantics with identical output behavior, and the intended one is at most one of them, a corollary of the optimum characterization of [1]. The proof is the two-line closure argument from earlier plus counting: a permutation that moves states only within one fiber changes no label by definition. This is the $\lvert G \rvert = 2! \cdot 2!$ the committed run printed, read as a lower bound rather than an equality.

Nothing in that argument mentions logic, knowledge bases, or neuro-symbolic architecture. It needs only a model whose internal vocabulary is read through a many-to-one map, and that description covers a startling share of machine learning. In representation learning, the impossibility of unsupervised disentanglement is the same mathematics: for any purportedly disentangled representation of an unlabeled dataset there exist transformed representations, entangling the factors, with exactly the same marginal likelihood, so the objective cannot prefer the disentangled one [2]. In latent-variable models, a variational autoencoder's latents are unidentifiable for the same reason, and the modern repair conditions the prior on an auxiliary observed variable precisely to shrink the symmetry set [3]. At industrial scale the phenomenon has a name without the algebra: underspecification, where training pipelines return many predictors with equivalent test metrics and divergent deployment behavior, the fiber explored by random seed rather than enumerated by hand [4]. And concept-bottleneck models, architectures built so that a human can read and edit the concept layer, are governed by this arithmetic whenever their concept supervision is partial, because every unpinned fiber is a place where the readable concepts can consistently mean something other than their names [5]. The slogan version: wherever a model's internal vocabulary is read through a many-to-one map, the fiber is where accountability goes to die.

Escape route one: factorize the concept heads

If the disease is a too-large space of relabelings, one cure is architectural: make the wrong relabelings inexpressible. A factorized (per-concept) extractor computes each concept with its own head, so any systematic error it can realize must act coordinate-wise: $\alpha(c_1, c_2) = (f_1(c_1), f_2(c_2))$, where each $f_j$ is a function from one bit to one bit. There are $2^2 = 4$ such functions per head (each of the two inputs independently assigned one of two outputs), hence $4^2 = 16$ factorized relabelings, against the $4^4 = 256$ unrestricted joint maps. The companion enumerates both spaces in the same encoding so they compare directly, and the key exclusion is visible before any counting. Writing the four states $00, 01, 10, 11$ as indices $0$ through $3$ in that order, and a relabeling as the four-tuple of its image indices (so the identity is $(0, 1, 2, 3)$), the swap is $(0, 2, 1, 3)$: it exchanges states $1$ and $2$, that is, $01$ and $10$. That tuple is not of the factorized form, because its first output bit depends on $c_2$, which a per-concept head cannot see (identifiability.py, lines 202–214).

Which factorized maps survive the admissibility test? The module's derivation (lines 217–227) is short enough to complete here. A one-bit function is either constant or of the form $f_j(c) = c \oplus b_j$ for a bit $b_j$ ($b_j = 0$ is the identity, $b_j = 1$ the negation). A constant $f_1 \equiv a$ ($\equiv$ meaning identically equal: a head whose output is the same bit $a$ for both inputs) can never survive: fixing $c_2$ and toggling $c_1$ changes the true label but not the output $a \oplus f_2(c_2)$, so some state violates the commuting condition, and the same argument with the roles of the two heads exchanged rules out a constant $f_2$. With both heads non-constant,

$$f_1(c_1) \oplus f_2(c_2) = (c_1 \oplus b_1) \oplus (c_2 \oplus b_2) = (c_1 \oplus c_2) \oplus (b_1 \oplus b_2),$$

by the associativity and commutativity of $\oplus$, and this equals $c_1 \oplus c_2$ for all inputs exactly when $b_1 \oplus b_2 = 0$, that is, $b_1 = b_2$. Exactly two survivors: the identity ($b_1 = b_2 = 0$) and the double negation ($b_1 = b_2 = 1$). The committed counts, each asserted (lines 333–342):

[4] mitigation = symmetry breaking, counted
      joint maps 4^4 = 256  ->  factorized (per-concept) maps 4^2 = 16   (16x smaller)
      admissible joint 16  ->  admissible factorized 2   (8x smaller)
      factorized survivors: the identity and the double negation; the swap is not expressible per-concept

Factorization shrinks the space of expressible systematic errors sixteenfold and the space of admissible ones eightfold, and it kills the sweep's favorite shortcut, the swap, outright. Two honesty clauses temper the celebration. First, the surviving count is $2$, not $1$: the double negation acts within each head, so no per-concept architecture can exclude it, and the concepts remain unidentifiable until some other lever fires. Architecture prunes the group; here it does not trivialize it. Second, and more fundamental: factorization helps because the true concepts of this task factorize, one per coordinate. Declaring per-concept heads is an inductive bet that the world's generative factors align with the designer's decomposition. When the bet is wrong, the restricted architecture cannot represent the intended semantics at all, and the "mitigation" trades an invisible error for an unfixable one. Factorization is a good bet bought with domain knowledge, not a free lunch.

Escape route two: supervision as symmetry breaking

The previous chapter measured concept supervision, the mitigation lever analyzed in [1], as a repair: 12 stratified concept labels lifted the caught seed's concept F1 from $0.500$ to $1.000$. The group picture explains the mechanism and prices it exactly. A concept-labeled example whose true state is $g$ reveals $\alpha(g) = g$: any relabeling that moves $g$ is no longer an optimum of the combined objective. So each labeled example pins one state, and a relabeling survives $k$ labeled examples exactly when it fixes every labeled state (identifiability.py, lines 238–248). Only distinct states matter, since a repeated state re-imposes a constraint already in force. Among the sixteen admissible joint maps, every unpinned state retains an independent choice within its two-element fiber, so the survivor count after $k$ labels obeys the closed form

$$\lvert A_k \rvert \;=\; 2^{\,4 - d(k)},$$

where $d(k)$ is the number of distinct states covered by the first $k$ labels. The module tabulates two labeling orders against this formula and asserts every entry (lines 345–352): round-robin, which covers a new state each time, and block, which spends three labels per state before moving on (the raw index order of shortcuts.py's supervised subset). The committed curve:

      concept labels pin states, |A_k| = 2^(4 - #distinct states seen):
      k   state labeled (rr)   joint, round-robin   joint, block   factorized, rr
      0   -                                   16             16                2
      1   00                                   8              8                1
      2   01                                   4              8                1
      3   10                                   2              8                1
      4   11                                   1              4                1
      the block order (3 labels per state) reaches 1 only at k = 10: coverage, not volume, breaks symmetry

The same numbers as a table, with the information reading alongside:

$k$	state labeled (round-robin)	joint, round-robin	$\log_2$ survivors	joint, block	factorized, round-robin
$0$	—	$16$	$4$ bits	$16$	$2$
$1$	$00$	$8$	$3$ bits	$8$	$1$
$2$	$01$	$4$	$2$ bits	$8$	$1$
$3$	$10$	$2$	$1$ bit	$8$	$1$
$4$	$11$	$1$	$0$ bits	$4$	$1$

Read the round-robin column as information: the ambient ambiguity is $\log_2 16 = 4$ bits, and each label on a new state removes exactly $\log_2 2 = 1$ bit, the logarithm of the fiber size, until at $k = 4$ the count reaches exactly $1$ and the identity stands alone. At that point the symmetry group is trivial and the concepts are identifiable; this is precisely why the previous chapter's stratified 12 labels (three per state, so all four states covered) restored the semantics, and why its closed form "supervising all four states takes $2^4$ to $1^4$" is this table's last row. The block column is the cautionary twin: after $k = 3$ labels all spent on state $00$, the survivor count still reads $8$, and the asserted crossing point to a single survivor is $k = 10$, the first index at which the block order has finally touched all four states (lines 352–356). Supervision buys identifiability by coverage, not volume; a labeling budget spent on redundant states buys nothing. And the factorized column compounds the levers: with the swap already inexpressible, a single concept label on any state kills the double negation, and the count reaches $1$ at $k = 1$ (line 351). Architecture and supervision multiply because each removes group elements the other cannot.

Escape route three: change the task

The third lever needs no concept labels at all: change what the model is asked to predict. Two tasks over the same concept vocabulary have two label maps, $\beta_{\mathsf{K}}$ and $\beta_{\mathsf{K}'}$, hence two symmetry groups, and a relabeling survives joint training only if it commutes with both: the surviving set is the intersection $G \cap G'$. Multi-task knowledge identifies concepts, without a single concept label, exactly when that intersection is trivial; this is the multi-task mitigation of the reasoning-shortcuts analysis [1], and it is the same escape that restores identifiability in latent-variable models by conditioning on an auxiliary observed variable, another observable whose dependence on the latents breaks their symmetries [3].

The companion module contains no multi-task exhibit, so we argue the mechanism directly on the printed group table, which is small enough to check by eye. Add a second task on the same two concepts: $y_2 = \beta_{\mathsf{K}'}(c) = c_1$, "report the first concept" (in the academic world of the running example: alongside "do these two records disagree?", also publish one report that is not symmetric in the columns). Test each nontrivial element of XOR's group, using its printed image row, against preservation of $c_1$. The swap sends $01 \to 10$: the first bit changes from $0$ to $1$, so the swap fails. The negate sends $00 \to 11$: the first bit changes, fail. The composite sends $00 \to 11$: fail. Every nontrivial symmetry of XOR alters the first bit of some state, so $G \cap G' = \{\mathrm{id}\}$, and the two tasks jointly pin both concepts with zero concept supervision. The lever's price is stated just as plainly: it requires a second task whose knowledge is known and correct, and whose symmetries are provably transverse to the first task's (the two symmetry groups share only the identity). Knowledge engineering, the oldest cost in this series, buys identifiability here.

The unsolved part

Everything in this chapter was exact because everything was small: four states, 256 maps, a group of order four. Real systems break each of those conveniences at once. Their concept spaces are combinatorial ($2^{20}$ states for twenty binary concepts) and often not even known in advance, so the group can be neither enumerated nor written down; successor work (the rsbench suite of the next chapter) counts admissible relabelings with #SAT solvers, model counters that count the satisfying assignments of a Boolean satisfiability (SAT) formula rather than finding one, which extends the reach but not to vocabularies that are themselves learned. Their predictors are soft, so exact symmetries give way to approximate ones: parameterizations whose label behaviors differ only by some small tolerance $\varepsilon$ (epsilon) while their concepts differ by half, and the clean trivial-or-not dichotomy becomes a spectrum with no agreed measure. Their knowledge is noisy or partly wrong, so the commuting condition itself is defined against a $\beta_{\mathsf{K}}$ that may misdescribe the world. And the diagnostic this volume keeps reaching for, uncertainty, remains a conjecture at exactly this joint: if an optimum is one of many in a fiber, a well-calibrated model should be uncertain about concepts precisely where the group acts, so calibration should track identifiability; SATORI's claim C5 bets on the operational version of this conjecture (calibrated confidence robust to reasoning shortcuts), and no theorem currently delivers it. What the theory does deliver is a hard negative: within the reach of its assumptions, no label metric can certify concept meaning. If measurement is to certify anything, benchmarks must therefore measure something other than labels, which is exactly the mandate of the next chapter.

Why it matters

This chapter is the volume's central impossibility result, and it earns its title. The series has climbed from Volume 1's proofs, through ontologies, embeddings, and differentiable logic, to Volume 4's promise that task labels can train symbol-level meaning; Part II is the fine print on that promise, and the fine print is now precise: label likelihood determines concept semantics only up to the symmetry group of the knowledge, so accuracy certifies meaning exactly when the group is trivial, which the designer can check, on enumerable tasks, before training anything. For the reader's own research the operational content is a checklist. Compute or bound the group before trusting concepts: fibers of the label map are readable off the task definition. Treat architecture as group pruning and say which elements it removes and which bets it makes. Spend concept labels on coverage, never volume, and account for them in bits against the group's order. Prefer a transverse second task (one whose symmetry group meets the first task's only at the identity) to a thousand more labels of the first. And distrust any claim, in NeSy or beyond, that a model's internals are right because its outputs are: underspecified pipelines ship every day on exactly that inference, and the fiber is where it fails.

Key terms

• Symmetry group of the knowledge $G$: the bijective relabelings $\alpha$ with $\beta_{\mathsf{K}} \circ \alpha = \beta_{\mathsf{K}}$ on the full support, a group under composition; the algebraic object that decides identifiability.
• Identifiability (of concepts from labels): the label distribution determines concept semantics uniquely; holds if and only if the symmetry group is trivial, equivalently every fiber is a singleton.
• Fiber: the preimage $\beta_{\mathsf{K}}^{-1}(y)$, the concept states sharing one label; a fiber of size $k$ donates at least $k!$ label-equivalent semantics.
• Orbit: the set $\{\alpha(g) : \alpha \in G\}$ of states a symmetry can carry $g$ to; here orbits coincide with fibers, and the optimum count is the product of orbit sizes.
• Klein four-group ($\mathbb{Z}_2 \times \mathbb{Z}_2$): the four-element group generated by two commuting self-inverse elements; XOR's symmetry group, generated by the concept swap and the double negation.
• Distribution equivalence: two parameterizations inducing the identical map $x \mapsto p_\theta(y \mid x; \mathsf{K})$; no functional of label behavior, on any amount of data, separates them.
• Symmetry breaking: any intervention that removes group elements: factorized heads (inexpressibility), concept labels (pinning states), or a second task (intersecting groups).
• Underspecification: the industrial-scale form of the fiber, where pipelines return many test-equivalent predictors with divergent deployment behavior.

Where this leads

The theory just proved that the difference between right and wrong concepts is invisible to every label metric, and the companion exhibited the invisibility at machine precision. That verdict redraws the job description of evaluation: a benchmark that reports label accuracy on a NeSy system is measuring a quantity this chapter proved constant across semantics, so benchmarks must expose what labels cannot, concept quality against ground truth, support bias, and shortcut deliberately built in. Measuring Shortcuts: rsbench is the next chapter, and it walks the benchmark suite designed to do exactly that: tasks whose admissible relabelings are known in advance, so that a model's concepts can be scored against the census rather than taken on faith.

---

Companion code: examples/frontier/identifiability.py enumerates the symmetry group and verifies its axioms, predicts the previous chapter's optimum count from the orbits, constructs the distribution-equivalent pair, and counts both symmetry-breaking levers, importing the task, data, and likelihood unchanged from examples/frontier/shortcuts.py. Run python3 examples/frontier/identifiability.py to reproduce every number in this chapter; the run is deterministic and every claim is guarded by an assert.