Name Abstraction: Cross-Domain Techniques

• Name abstraction is a design pattern that separates visible names from their operational details, enabling deferred resolution in various systems.
• It is utilized in network architectures like Internames to achieve identifier/locator separation, supporting mobility and contextual binding.
• In process calculi and logical frameworks, name abstraction facilitates higher-order reasoning, semantic generalization, and handling of fresh or hidden names.

Searching arXiv for the specified papers and closely related work to ground the article. arXiv search: (Melazzi et al., 2013) 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 (Melazzi et al., 2013, Xu et al., 2015, Li et al., 2022, 0908.1390, Eliott et al., 2021). 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 (Melazzi et al., 2013). 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 $n$0 on application (Xu et al., 2015). In open information extraction, type abstraction maps an instance $n$1 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” (Li et al., 2022). In proof theory, nominal abstraction is the logical relation $n$2, which holds when $n$3 $n$4-converts to an $n$5-fold abstraction over distinct nominal constants yielding $n$6 (0908.1390). In the $n$7-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” (Eliott et al., 2021).

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 $n$8-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” (Melazzi et al., 2013). 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$9 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 field, and payload transport via technologies such as HTTP, CCN, SIP, raw IP, or 802.15.4 (Melazzi et al., 2013).

The NRS is presented as

$NE$0

where context may include time of day, requester location, service class, or other policy variables. A service descriptor is exemplified as

$NE$1

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,

$NE$2

so that fetch(n) becomes an HTTP GET to 200.1.2.3 at path /videos/1234.mp4 (Melazzi et al., 2013).

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” (Melazzi et al., 2013).

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 $NE$3, name abstraction is a syntactic and semantic construct. The processes include higher-order input $NE$4, higher-order output $NE$5, parallel composition, restriction, name-abstraction $NE$6, and name-application $NE$7 (Xu et al., 2015). Structural congruence includes

$NE$8

when the arities match. The paper characterizes $NE$9 as analogous to $(n, SD)$0-abstraction over names: it is “a process-value which, when applied to a tuple $(n, SD)$1 of $(n, SD)$2 name constants, yields the process $(n, SD)$3.”

This construct is not merely notational. The paper states two expressiveness results. First, “name parameterization brings up a complete model,” in the sense that $(n, SD)$4 can embed an elementary interactive model $(n, SD)$5 with built-in recursive functions. Natural numbers are encoded as

$(n, SD)$6

Using such encodings, the paper gives realizations of the zero function, successor, projection, composition, primitive recursion, and minimization, and concludes that $(n, SD)$7 is “computation-complete (Turing-complete)” (Xu et al., 2015).

Second, the paper gives mutual encodings between $(n, SD)$8 and the first-order $(n, SD)$9-calculus. In the direction $n \in N$0, each $n \in N$1-name $n \in N$2 is represented by a 3-ary abstraction called a “pipe”:

$n \in N$3

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:

$n \in N$4

where $n \in N$5 is standard weak bisimilarity in $n \in N$6 (Xu et al., 2015).

The paper also records a limitation: the $n \in N$7 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 LLM to predict the relation or event name (Li et al., 2022). For relations, the prompt is "<tail> is the [MASK] of <head>"; for events, "<trigger> is a [MASK] event". An instance $n \in N$8 has two views: the token-view representation

$n \in N$9

and the abstraction-view representation

$SD$0

where $SD$1 is the position of the [MASK] token. Symbolically,

$SD$2

The paper explicitly states that $SD$3 “lives in the embedding space of predicted type names” (Li et al., 2022).

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

$SD$4

with $SD$5 set to $SD$6 in the hinge margin and $SD$7 (Li et al., 2022).

The paper emphasizes complementarity between the token-level view and the abstraction view. During analysis, one may decode the top-$SD$8 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 (Li et al., 2022).

The empirical results are substantial. On relation discovery, unknown-type accuracy improves from RoCORE’s $SD$9 to TAbs’ $\Pi^d$0 on TACRED and from $\Pi^d$1 to $\Pi^d$2 on FewRel. On event discovery in ACE, the controlled setting reports $\Pi^d$3 for TAbs versus $\Pi^d$4 for Spherical-Clustering and $\Pi^d$5 for SS-VQ-VAE; the end-to-end setting reports $\Pi^d$6 for TAbs versus approximately $\Pi^d$7 for ETypeClus. Human annotation of end-to-end ACE cluster coherence rises from $\Pi^d$8 for ETypeClus to $\Pi^d$9 for TAbs. Ablations further show that token-only or mask-only views yield approximately $\langle x_1,\dots,x_n\rangle E$0 accuracy versus $\langle x_1,\dots,x_n\rangle E$1 for the full model, that removing supervised warm-start pretraining drops TACRED accuracy from $\langle x_1,\dots,x_n\rangle E$2 to $\langle x_1,\dots,x_n\rangle E$3, and that removing $\langle x_1,\dots,x_n\rangle E$4 has a smaller effect, from $\langle x_1,\dots,x_n\rangle E$5 to $\langle x_1,\dots,x_n\rangle E$6 (Li et al., 2022). 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 $\langle x_1,\dots,x_n\rangle E$7 have type $\langle x_1,\dots,x_n\rangle E$8 and $\langle x_1,\dots,x_n\rangle E$9 type $\lambda$0. The formula

$\lambda$1

holds iff there exist distinct nominal constants $\lambda$2 such that

$\lambda$3

When $\lambda$4, $\lambda$5 is ordinary equality modulo $\lambda$6-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$7-abstraction: $\lambda$8 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 $\lambda$9 that also contains the $n$0-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 $n$1 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 $n$2-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 $n$3, abstracts $n$4 from a term, substitutes $n$5 for $n$6, 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 $n$7-calculus operates in a call-by-value simply-typed $n$8-calculus extended with a base type Nm of names and a mechanism gensym() for generating fresh names (Eliott et al., 2021). Configurations are pairs $n$9, where $n$00 is the set of names in scope and $n$01 is a closed term whose names lie in $n$02. The key reduction rule for generation is

$n$03

together with equality rules distinguishing $n$04 from $n$05 when $n$06 (Eliott et al., 2021).

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

$n$07

internalizes Hoare triples, allowing specifications of application results (Eliott et al., 2021).

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 (Eliott et al., 2021).

The worked example

$n$08

shows the relevance of hidden names. The paper states that $n$09 is contextually equivalent to a constant-false test because the fresh $n$10 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 $n$11, 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 (Melazzi et al., 2013). In $n$12, a name-abstraction is a higher-order process value, and application performs explicit instantiation by substitution (Xu et al., 2015). In type discovery, abstraction is a representation-learning map from an instance to a masked-token embedding that behaves like an induced type name (Li et al., 2022). 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 $n$13-calculus logic, the key phenomenon is the existence of hidden names created by generation and kept inaccessible by abstraction (Eliott et al., 2021).

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-field 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 $n$14 encoding is not known to be sound with respect to full context bisimilarity (Xu et al., 2015). 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 (Li et al., 2022). In Internames, deployment is explicitly framed as gradual migration rather than wholesale replacement of IP (Melazzi et al., 2013). These points reinforce that “name abstraction” is best understood as a cross-domain family of formal and architectural techniques rather than a single theory.