---
title: 'Name Abstraction: Cross-Domain Techniques'
url: https://www.emergentmind.com/topics/name-abstraction
type: topic
---

# Name Abstraction: Cross-Domain Techniques

Searching arXiv for the specified papers and closely related work to ground the article.
arXiv search: 1401.0114 name abstraction Internames

Name abstraction denotes a family of mechanisms in which names are treated as primary objects while operational detail is delegated to a separate layer of resolution, instantiation, or logical reasoning. In the arXiv literature, the term spans several technically distinct settings: the Internames architecture for future Internet communication; the higher-order process calculus $\Pi^d$ with name-parameterization; type abstraction for open relation and event type discovery; nominal abstraction in proof theory; and program logics that reason about fresh names and hidden names [1401.0114] [1508.04855] [2212.00178] [0908.1390] [2101.10720]. This suggests that “name abstraction” is not a single formal doctrine but a recurrent design pattern: visible names are separated from locators, process implementations, lexical realizations, or concrete binders, and a runtime or proof-theoretic mechanism mediates between the name and its realization.

## 1. Conceptual range of the term

In Internames, name abstraction is “the discipline of using only $n$ at the application/API level,” where a named-entity $NE$ is a pair $(n, SD)$, $n \in N$ is a name drawn from a global namespace, and $SD$ is a Service Descriptor containing the information needed to reach that entity over some network technology [1401.0114]. In $\Pi^d$, the construct $\langle x_1,\dots,x_n\rangle E$ “plays the role of a $\lambda$-abstraction over names,” mapping an $n$-tuple of names to a process and yielding $E[\tilde m/\tilde x]$ on application [1508.04855]. In open information extraction, type abstraction maps an instance $x$ to the hidden state at the masked position in a prompted BERT input, so that the representation lies in “the embedding space of predicted type names” [2212.00178]. In proof theory, nominal abstraction is the logical relation $s \unrhd t$, which holds when $s$ $\lambda$-converts to an $n$-fold abstraction over distinct nominal constants yielding $t$ [0908.1390]. In the $\nu$-calculus program logic, the salient issue is that “hidden names produced by interactions between generation and abstraction are captured logically with a second-order quantifier over type contexts” [2101.10720].

These uses share vocabulary but differ in object language, semantics, and proof obligations. A common misconception is that name abstraction always concerns binding in the style of $\lambda$-calculus. The supplied literature shows a broader picture: in networking it concerns identifier/locator separation, in machine learning it concerns induced semantic labels, and in logic it concerns freshness, binding structure, and name-sensitive reasoning.

## 2. Identifier/locator separation in Internames

Internames proposes “a name-to-name principle” in which “names are used to identify all entities involved in communication: contents, users, devices, logical as well as physical points involved in the communication, and services” [1401.0114]. Its basic building blocks are “a name-based Application Programming Interface,” “a separation of identifiers (names) and locators,” “a powerful Name Resolution Service (NRS) that dynamically maps names to locators, as a function of time/location/context/service,” and “a built-in capacity of evolution” supporting migration from current IP infrastructure to a future Information Centric Network.

The architecture formalizes a named-entity as $(n,SD)$ and treats applications as speaking only in names. The API exposes four core primitives: `fetch(name n)`, `publish(n, data, metadata)`, `subscribe(n, callback)`, and `push(n, data)`. None of these calls mention IP addresses, MACs, or frame headers. Instead, each primitive triggers three stages: lookup in the NRS, translation of the resulting service descriptor into a next-hop request in a particular network realm, and payload transport via technologies such as HTTP, CCN, SIP, raw IP, or 802.15.4 [1401.0114].

The NRS is presented as
$$
\mathrm{NRS}: \mathrm{Name} \times \mathrm{Context} \to \{SD\},
$$
where context may include time of day, requester location, service class, or other policy variables. A service descriptor is exemplified as
$$
SD=\langle \mathrm{protocol}, \mathrm{FCN}, \mathrm{phyType}, \mathrm{nextHop}\rangle,
$$
with `protocol` naming the communication protocol, `FCN` the forwarding component name, `phyType` the underlying network technology, and `nextHop` the network attachment point. In the simplest case,
$$
\mathrm{NRS}(n)=\{\langle \mathrm{HTTP}, "/videos/1234.mp4", \mathrm{IP}, 200.1.2.3\rangle\},
$$
so that `fetch(n)` becomes an HTTP GET to `200.1.2.3` at path `/videos/1234.mp4` [1401.0114].

The architectural consequences stated in the paper are mobility, anycast and multicast, contextual binding, multi-technology interworking, disconnected operation, and gradual migration from IP. Mobility follows because “as a device or service endpoint moves, only its NRS entry changes; applications keep talking to the same name.” Anycast or multicast follows because “NRS can map a single name to multiple locators.” Contextual binding follows because “depending on requester’s location, time of day or load, NRS can return different locators for the same name.” The same separation also allows “the co-existence of multiple network ‘realms’, including current IP and non-IP networks, glued together by a name-to-name overarching communication primitive” [1401.0114].

The paper’s examples make the abstraction concrete. A content name may resolve to the nearest cache; a device name such as `n2n://nriA:Alice.com/cell` may be rebound every few seconds to Alice’s current attachment point; a user-group name may expand to multiple locators in a disaster-management scenario; and a service name may support subscription and push-based notification. Internames therefore uses name abstraction not as a purely symbolic layer but as the top-level addressing model of a heterogeneous network.

## 3. Name-parameterization in higher-order processes

In the higher-order process calculus $\Pi^d$, name abstraction is a syntactic and semantic construct. The processes include higher-order input $a(X).E$, higher-order output $\overline a\,E\,.E$, parallel composition, restriction, name-abstraction $\langle \tilde x\rangle E$, and name-application $E\,\tilde m$ [1508.04855]. Structural congruence includes
$$
(\langle \tilde x\rangle E)\,\tilde m \equiv E[\tilde m/\tilde x]
$$
when the arities match. The paper characterizes $\langle x_1,\dots,x_n\rangle E$ as analogous to $\lambda$-abstraction over names: it is “a process-value which, when applied to a tuple $\tilde m$ of $n$ name constants, yields the process $E[\tilde m/\tilde x]$.”

This construct is not merely notational. The paper states two expressiveness results. First, “name parameterization brings up a complete model,” in the sense that $\Pi^d$ can embed an elementary interactive model $\mathcal C$ with built-in recursive functions. Natural numbers are encoded as
$$
\underline 0 \triangleq \langle x,y\rangle\,\overline y\,0,\qquad
\underline{n+1} \triangleq \langle x,y\rangle\,\overline x\,\underline n.
$$
Using such encodings, the paper gives realizations of the zero function, successor, projection, composition, primitive recursion, and minimization, and concludes that $\Pi^d$ is “computation-complete (Turing-complete)” [1508.04855].

Second, the paper gives mutual encodings between $\Pi^d$ and the first-order $\pi$-calculus. In the direction $\pi \to \Pi^d$, each $\pi$-name $u$ is represented by a 3-ary abstraction called a “pipe”:
$$
\mathit{pipe}_u \triangleq
\langle i,o,c\rangle\bigl(i.u(Z).\overline c\,Z \mid o.c(Z).\overline u\,Z\bigr).
$$
This simulates name-passing by higher-order process mobility. In the reverse direction, the encoding uses Sangiorgi’s “trigger” technique, where a name-abstraction is represented by a trigger channel over which the continuation can be re-instantiated when actual parameters arrive. The main theorem is full abstraction:
$$
P \approx Q \quad\Longleftrightarrow\quad \llbracket P\rrbracket \sim \llbracket Q\rrbracket,
$$
where $\sim$ is standard weak bisimilarity in $\pi$ [1508.04855].

The paper also records a limitation: the $\pi \to \Pi^d$ encoding “is not known to be sound w.r.t. full context bisimilarity,” and only a weaker “pipe-bisimilarity” is proved. This matters because it distinguishes equality up to the full observational theory from equality up to a specialized simulation invariant. In this literature, then, name abstraction is a computationally expressive mechanism for parameterizing processes by names and transporting such abstractions through communication.

## 4. Type abstraction and inferred names in information extraction

In open relation and event type discovery, Li et al. define type abstraction by prompting a masked language model to predict the relation or event name [2212.00178]. For relations, the prompt is `"<tail> is the [MASK] of <head>"`; for events, `"<trigger> is a [MASK] event"`. An instance $x$ has two views: the token-view representation
$$
x_1 = \mathrm{BERT}(x)[s]
$$
and the abstraction-view representation
$$
x_2 = \mathrm{BERT}(x; p)[s_{\text{mask}}],
$$
where $s_{\text{mask}}$ is the position of the `[MASK]` token. Symbolically,
$$
A : X \to \mathbb R^d,\qquad
A(x) \triangleq \mathrm{BERT\_embedding\_of\_[MASK]}(x+\mathrm{prompt}).
$$
The paper explicitly states that $x_2$ “lives in the embedding space of predicted type names” [2212.00178].

The overall model uses a shared BERT encoder, two projection networks reducing 768-dimensional BERT vectors to 256-dimensional features, and classification heads for known and unknown classes in each view. Training combines three losses: a supervised loss on known types, an unsupervised co-training loss on unknown instances, and a view-consistency loss. Unknown-type supervision is generated by running K-means on the projected features of each view, converting cluster assignments into pairwise labels, and then using Jensen–Shannon divergence with a hinge-contrastive loss so that each view supervises the other. The full objective is
$$
\mathcal L = \mathcal L^l + \mathcal L^u + \beta\cdot \mathcal L^c,
$$
with $\alpha$ set to $2$ in the hinge margin and $\beta \approx 0.2$ [2212.00178].

The paper emphasizes complementarity between the token-level view and the abstraction view. During analysis, one may decode the top-$k$ BERT predictions at the mask position to inspect likely names such as “birthday,” “year,” “appointed,” or “elected.” These words are used to interpret clusters and to confirm that the abstraction embedding captures type semantics. The stated similarity and clustering machinery is heterogeneous: K-means uses Euclidean distance on projected features, early probing uses k-NN accuracy under cosine similarity of raw BERT embeddings, and co-training uses Jensen–Shannon divergence between prediction distributions [2212.00178].

The empirical results are substantial. On relation discovery, unknown-type accuracy improves from RoCORE’s $0.8468$ to TAbs’ $0.8896$ on TACRED and from $0.7801$ to $0.8022$ on FewRel. On event discovery in ACE, the controlled setting reports $0.7732$ for TAbs versus $0.3830$ for Spherical-Clustering and $0.2951$ for SS-VQ-VAE; the end-to-end setting reports $0.5089$ for TAbs versus approximately $0.46$ for ETypeClus. Human annotation of end-to-end ACE cluster coherence rises from $59\%$ for ETypeClus to $70\%$ for TAbs. Ablations further show that token-only or mask-only views yield approximately $0.85$ accuracy versus $0.90$ for the full model, that removing supervised warm-start pretraining drops TACRED accuracy from $0.90$ to $0.86$, and that removing $\mathcal L^c$ has a smaller effect, from $0.90$ to $0.896$ [2212.00178]. In this setting, name abstraction is neither routing nor binding; it is a semantic induction mechanism in which inferred names structure the latent space for clustering unknown types.

## 5. Nominal abstraction in proof theory

Nominal abstraction, introduced as a new relation between terms, addresses “dynamic aspects related to binding” that were not expressible in earlier logics combining recursive definitions and generic judgments [0908.1390]. Let $s$ have type $\tau_1\to\cdots\to\tau_n\to\tau$ and $t$ type $\tau$. The formula
$$
s\unrhd t
$$
holds iff there exist distinct nominal constants $c_1:\tau_1,\dots,c_n:\tau_n$ such that
$$
s \Longrightarrow_{\beta\eta} \lambda c_1\cdots c_n.\,t.
$$
When $n=0$, $s\unrhd t$ is ordinary equality modulo $\lambda$-conversion and name-permutation [0908.1390].

The sequent-calculus treatment introduces `NomAbs-R` and `NomAbs-L`. The left rule quantifies over substitutions solving the nominal abstraction judgment, using nominal-capture-avoiding application of substitutions. Because the full solution space may be infinite, the paper allows the use of a complete set of nominal-abstraction solutions. Semantically, the relation differs from ordinary $\lambda$-abstraction: $\lambda x.M$ binds variables, whereas nominal abstraction “characterizes occurrences of nominal constants” inside terms. The logic internalizes freshness, and equivariance under finite permutations of nominal constants is a central property [0908.1390].

Nominal abstraction is integrated into a richer logic $\mathcal L$ that also contains the $\nabla$-quantifier, recursive definitions, induction, and co-induction. The definition rules `Def-L` and `Def-R`, the induction rule `IL` for least fixed points, and the co-induction rule `CIR` for greatest fixed points are all presented subject to the condition that the invariant $S$ must not contain nominal constants. The main meta-theoretic theorem is cut-elimination, with consistency as a corollary: “All cuts can be eliminated; hence the logic is consistent” [0908.1390].

The paper’s examples show how nominal abstraction supports direct reasoning about binding-heavy formal systems. For simply typed $\lambda$-calculus typing contexts, the predicate `cntx` is defined so that each assumption begins with a fresh nominal constant, enabling clean proofs of type uniqueness. For arbitrarily cascading substitutions, the predicate `subst` recursively pulls off a pair $(x,V)$, abstracts $x$ from a term, substitutes $V$ for $x$, and recurses on the tail. The stated meta-properties include cut-elimination, consistency, equivariance, substitution stability, and adequacy of encodings [0908.1390]. In this literature, name abstraction is a logical primitive for inspecting and constraining named occurrences in higher-order syntax.

## 6. Fresh names, hidden names, and program logic

The program logic for Pitts and Stark’s $\nu$-calculus operates in a call-by-value simply-typed $\lambda$-calculus extended with a base type `Nm` of names and a mechanism `gensym()` for generating fresh names [2101.10720]. Configurations are pairs $(G,M)$, where $G$ is the set of names in scope and $M$ is a closed term whose names lie in $G$. The key reduction rule for generation is
$$
(G,\mathrm{gensym}()) \Rightarrow (G\cup\{n\}, n)
\qquad (n\notin G\ \text{fresh}),
$$
together with equality rules distinguishing $n=n$ from $n_1=n_2$ when $n_1\neq n_2$ [2101.10720].

The distinctive contribution is a Hoare-style logic that captures subtle observational behavior caused by equality testing on names and by interactions between name generation and abstraction. The logic adds two quantifiers to first-order logic. A restricted quantifier ranges over values “derived” from the current type-context while not exposing freshly generated or hidden names. A second-order quantifier over type-contexts asserts that a formula holds in every future extension of the current typing context. The evaluation formula
$$
\#\langle e_1\rangle\langle e_2\rangle m \{A\}
$$
internalizes Hoare triples, allowing specifications of application results [2101.10720].

The proof system includes rules for variables, constants, `gensym`, abstraction, application, equality, `let`, pairing, projection, consequence, invariance, and a derived `LetFresh` rule. The soundness theorem states that every derivable judgment is semantically valid, and the conservativity theorem states that without `gensym` and the restricted quantifiers, the logic coincides exactly with the standard Hoare-style logic for STLC of the cited earlier work [2101.10720].

The worked example
$$
M \equiv \text{let }x=\mathrm{gensym}()\text{ in }\lambda y.\,(x=y)
$$
shows the relevance of hidden names. The paper states that $M$ is contextually equivalent to a constant-false test because the fresh $x$ is never exposed. The proof uses `gensym`, abstraction, invariance, consequence, and `LetFresh`, ending with a specification that for arbitrary name arguments the result is always `f`. This is not nominal abstraction in the specific sense of $s\unrhd t$, but it is directly concerned with how abstraction can hide generated names and thereby alter observable behavior.

## 7. Comparative perspective

The supplied literature supports a precise separation of several notions that are often conflated. In Internames, a name is a location-independent identifier whose operational meaning is supplied by the NRS and a service descriptor [1401.0114]. In $\Pi^d$, a name-abstraction is a higher-order process value, and application performs explicit instantiation by substitution [1508.04855]. In type discovery, abstraction is a representation-learning map from an instance to a masked-token embedding that behaves like an induced type name [2212.00178]. In nominal abstraction, the central issue is whether a term can be viewed as an abstraction over distinct nominal constants, which enables logical treatment of freshness and binding contexts [0908.1390]. In the $\nu$-calculus logic, the key phenomenon is the existence of hidden names created by generation and kept inaccessible by abstraction [2101.10720].

This suggests two broad axes of variation. One axis concerns what names denote: network entities, communicated processes, semantic types, nominal constants, or generated atoms. The other concerns what abstraction does: deferred resolution, parameterization, semantic generalization, logical characterization of binding, or encapsulation of freshness. A further implication is that names are not merely passive labels in any of these systems. In the networking case, names determine routing and inter-realm communication; in process calculi, they determine computational expressiveness and equivalence; in information extraction, they determine clustering structure and interpretability; and in the logical settings, they determine provability, adequacy, and observable program behavior.

The main controversies or limitations recorded in the data are domain-specific rather than universal. The $\pi \to \Pi^d$ encoding is not known to be sound with respect to full context bisimilarity [1508.04855]. In type discovery, the method depends on warm-start supervised pretraining for best performance, and the consistency loss has only a modest numerical effect relative to the full co-training design [2212.00178]. In Internames, deployment is explicitly framed as gradual migration rather than wholesale replacement of IP [1401.0114]. These points reinforce that “name abstraction” is best understood as a cross-domain family of formal and architectural techniques rather than a single theory.

Source: https://www.emergentmind.com/topics/name-abstraction