Where two languages overlap

What is a "shared" space between two languages? It isn't a place you can point to. It helps to start from a more honest picture of a category: not a point, but a cloud — a distribution of realizations scattered through acoustic space (Pierrehumbert, 2016). Each language keeps its own cloud. Project two of them onto the axis that best separates them and you get two Gaussians, each with its own centre.

"Shared", then, is just the name we give to the region where the two clouds stop being separable — the ambiguous band where a realization could belong to either. Bring the centres together and that band grows; pull them apart and it shrinks. Notice that there's no point at which the two categories "become one": there's only an overlap that rises and falls with the distance between them:

None of this is exotic. Two varieties can be laid side by side in acoustic space and compared cue by cue — formant by formant, say (Escudero et al., 2009). And on the listener's side, categorizing is mapping those cues onto categories, a job a perception grammar does by weighing cue constraints (Boersma, 2009). When the cue lands near a prototype, the call is easy:

But when it lands right in the middle, in the overlap, the grammar has no way to decide — and splits its bet down the middle:

And bilinguals? The twist is that they tend to compress the gap: their two categories drift toward each other, and the shared band swells. It's no defect at all; it's the same curve, only at a smaller separation. You can check the sum — the overlap of a monolingual gap against a bilingual one, and the exact tie in the middle:

import math
def Phi(z): return 0.5 * (1 + math.erf(z / math.sqrt(2)))
overlap = lambda dp: 2 * Phi(-dp / 2)           # overlapping coefficient (equal sigma)

for name, dp in [("monolingual", 3.0), ("bilingual", 1.5)]:
    print(f"{name:12s} d'={dp}  overlap = {100 * overlap(dp):.0f}%")

# the same cloud, seen as a decision: prototypes at -1.5 and +1.5, sigma 1
def classify(x, mA=-1.5, mB=1.5):
    hA, hB = math.exp(-(x - mA) ** 2 / 2), math.exp(-(x - mB) ** 2 / 2)
    Z = hA + hB
    return hA / Z, hB / Z

for name, x in [("peripheral x=-1.5", -1.5), ("ambiguous x=0", 0.0)]:
    pA, pB = classify(x)
    print(f"{name:18s} -> P(A)={pA:.2f}  P(B)={pB:.2f}")

In the end, a "shared space" isn't an address; it's a measurement. It's the region where telling the two apart stops being easy. Say how far apart they are, and you'll already have said how much, in the end, they share.

@misc{barroso2025wheretwolanguagesoverlap,
  author       = {Alexandre Menezes Barroso},
  title        = {Where two languages overlap},
  year         = {2025},
  howpublished = {alexandrebarroso.com},
  url          = {https://alexandrebarroso.com/notes/where-two-languages-overlap.html},
  note         = {alexandrebarroso.com}
}