Semantic Lifting in Computational Representations

• Semantic lifting is a process that re-encodes basic representations into enriched spaces supporting advanced compositional operations.
• It is applied across domains including NLP, computer vision, and program analysis to preserve semantic structure for efficient reasoning.
• Empirical studies demonstrate that semantic lifting boosts performance by facilitating inference, verification, and spatial reasoning through tailored target spaces.

Searching arXiv for recent and foundational uses of “semantic lifting” across NLP, vision, programming languages, and semantics. Semantic lifting denotes a family of operations in which a representation that is initially lower-level, lower-type, or structurally restricted is transformed into a space where richer semantic composition, reasoning, or control becomes available. In the literature, the term has been used for lifting word vectors into matrix space for compositional semantics, lifting prompt-relevant image content into 3D scene representations, lifting 2D detections into 3D semantic targets for navigation, lifting coordinates into geographic knowledge-graph entities, lifting low-level code into domain-specific or mathematical specifications, and lifting intensional models or runtime program states into vector spaces or knowledge graphs (Chung et al., 2017, Tang et al., 9 Mar 2025, Schieber et al., 29 May 2026, Mai et al., 2020, Spargo et al., 30 Sep 2025, Quigley, 3 Feb 2026, Kamburjan et al., 3 Sep 2025). Across these uses, the recurring pattern is a map from a source representation into a richer semantic domain together with a notion of preservation: compositionality, observability, spatial consistency, type soundness, or behavioral equivalence.

1. Recurrent structure and scope

Although the phrase appears in multiple research traditions, the underlying schema is strikingly stable. A source object is first embedded, re-encoded, or projected into a target space whose elements support operations unavailable or inconvenient in the source space. Composition, reasoning, querying, planning, or verification is then carried out primarily in that lifted space. In linguistic models, the source may be a lexical vector and the target a matrix that can act as an operator (Chung et al., 2017). In geographic knowledge graphs, the source may be a coordinate and the target an entity embedding compatible with relation-specific inference (Mai et al., 2020). In program analysis, the source may be canonical C, LLVM-level code, or GPU SASS, and the target may be Lustre, SPL, or typed LLVM IR (Spargo et al., 30 Sep 2025, Zhang et al., 15 Jan 2025, Zhao et al., 30 Apr 2026).

Domain	Source representation	Lifted target
Compositional semantics	Word embedding $\vec{c}$	Matrix $H$
3D scene reasoning	Per-view masked features	3D scene representation $R$
Geographic KG inference	Location $x \in A$	KG embedding $P^{(x)}(x,r)$
Reactive systems	Canonical C / Clight	Lustre / SCADE
Scientific computing	C kernel / icode	$\Sigma$-SPL / SPL / $DFT_n$
Runtime reflection	Program configuration	RDF/OWL knowledge graph

The choice of target space is domain-specific. Some targets are algebraic, such as matrices, multilinear maps, or operator factorizations (Chung et al., 2017, Quigley, 3 Feb 2026, Zhang et al., 15 Jan 2025). Others are geometric, such as voxel grids, TSDF-backed semantic waypoints, or 3D feature fields (Chen et al., 2024, Schieber et al., 29 May 2026, Tang et al., 9 Mar 2025). Others remain symbolic and typed, such as Lustre, LLVM IR, conditional values, or refinement fibrations (Spargo et al., 30 Sep 2025, Zhao et al., 30 Apr 2026, Shahin et al., 2020, Kura, 2020). In each case, the lift is not merely a format conversion; it introduces a semantic regime in which domain operations become explicit and analyzable.

A second recurrent feature is that lifted systems usually distinguish a global mechanism from local instances. The Lifted Matrix-Space model uses a single shared lifting transformation for all lexical items (Chung et al., 2017). CoCompiler distinguishes vertical lifting, which inverts a canonical compiler image, from horizontal canonicalization, which moves arbitrary C toward that image (Spargo et al., 30 Sep 2025). LiftNav uses a lightweight semantic layer that is sparse and decoupled from the dense TSDF+GS map (Schieber et al., 29 May 2026). Semantically Reflected Programs separate the direct mapping $\mu(\text{conf})$ of runtime state from the domain ontology that enriches it (Kamburjan et al., 3 Sep 2025).

2. Linguistic and logical lifting

In neural compositional semantics, semantic lifting is explicitly associated with the passage from ordinary lexical vectors to higher-order objects. The Lifted Matrix-Space model maps a pre-trained embedding $\vec{c} \in \mathbb{R}^{d_{emb}}$ to a matrix

$$H = \tanh\big(W_{\text{lift}} \vec{c} + B_{\text{lift}}\big),$$

where $H$0 and $H$1 are shared across the vocabulary. Composition then occurs only in matrix space, with a transformed left child acting on the right child through matrix multiplication. This makes composition multiplicative and order-sensitive, and the paper presents it as a representation-level analogue of type-raising in formal semantics (Chung et al., 2017).

The same work emphasizes that the lift is not lexicon-specific higher-order parameterization of the MV-RNN type. Instead, it is a global transformation from a base lexical space into a matrix space in which every expression can, in principle, play an operator-like role. That design is tied to parameter efficiency: the asymptotic parameter count is $H$2, in contrast to $H$3 for CMS and MV-RNN and $H$4 for RNTN (Chung et al., 2017). Semantic lifting here therefore has two inseparable aspects: a change in representation type and a change in the attainable interaction structure.

A more formal and model-theoretic variant appears in vector logic for intensional semantics. There, an intensional model with compound index space

$H$5

is embedded injectively into a family of vector spaces via maps $H$6. Semantic functions are lifted to (multi)linear maps satisfying

$H$7

Intensions $H$8 become linear operators $H$9, and accessibility relations become linear operators whose outputs are interpreted by threshold conditions for $R$0 and $R$1 (Quigley, 3 Feb 2026).

This line of work is notable because it lifts not only representations but an entire compositional semantics. In finite and countable settings, modal operators reduce to linear accumulation followed by equality or nonzero tests. In the measure-theoretic generalization, necessity becomes truth almost everywhere and possibility becomes truth on a set of positive measure, yielding a non-classical modal semantics for continuous index domains (Quigley, 3 Feb 2026). The common thread with lifted matrix-space models is the movement from first-order objects to operator-like entities; the difference is that one is a learned neural representation and the other a fully explicit semantic embedding.

3. Spatial, visual, and 3D lifting

In 3D vision, semantic lifting often denotes a controlled transfer from 2D observations into 3D scene structure. A general formulation is

$R$2

where $R$3 is a per-image transform, $R$4 is a relevance mask, $R$5 is camera pose, and $R$6 fuses masked per-view outputs into a 3D representation. This formulation generalizes standard lifting by adding prompt-conditioned masks, thereby restricting the lifted content to semantically relevant pixels rather than lifting entire views indiscriminately (Tang et al., 9 Mar 2025).

The Vector-Quantized Feature Field makes that formulation practical by replacing expensive rendered feature maps with a global codebook and per-view index maps. The lifted feature field remains 3D-consistent and pixel-aligned, while allowing on-demand retrieval of relevance masks without repeated rendering. The paper reports high feature fidelity after quantization, including a LERF Clip similarity of $R$7, and memory use of $R$8–$R$9 MB per frame rather than raw feature-map storage on the order of tens of GB (Tang et al., 9 Mar 2025). Semantic lifting in this setting is less about ontology and more about task-conditioned selection before geometric fusion.

A different 2D-to-3D lifting problem appears in semantic occupancy prediction. ALOcc treats lifting as the view transformation

$x \in A$0

where $x \in A$1 is a 2D-to-3D transfer matrix. The paper replaces hard voxel assignment with soft trilinear filling and introduces an occlusion-aware adaptive lifting mechanism. Its depth-to-occluded-length transform

$x \in A$2

spreads feature mass behind visible surfaces rather than concentrating it at a near-$x \in A$3-like surface depth. The model also uses shared semantic prototypes to constrain 2D and 3D features jointly (Chen et al., 2024). Semantic lifting here is a probabilistic geometry-aware operator that explicitly models occlusion.

Point-based multimodal segmentation offers a simpler variant. LVIC projects LiDAR points into image space, samples a texture feature and a depth estimate, and appends $x \in A$4, $x \in A$5, and the texture vector to point features. The stated motivation is that “projection error is the devil in point painting,” and the method uses the discrepancy between LiDAR geometry and image-derived depth as a reliability cue while preferring low-level visual features to high-level 2D semantics (Dong et al., 2024). This is a direct pointwise lift from 2D appearance to 3D points rather than to dense volumetric structure.

Spatial semantic lifting in geographic knowledge graphs abstracts the same move away from 3D reconstruction. SE-KGE defines a task in which an arbitrary location $x \in A$6 and a relation $x \in A$7 are lifted into an embedding

$x \in A$8

after which the predicted entity is

$x \in A$9

The raw signal is a coordinate in $P^{(x)}(x,r)$0; the lifted target is the semantic space of a geographic knowledge graph (Mai et al., 2020). In contrast to vision-centric lifting, the source is already spatial, but semantically untyped.

LiftNav combines both notions. It starts from 2D YOLO detections and lifts pixels to 3D by

$P^{(x)}(x,r)$1

then consolidates lifted points with DBSCAN into 3D semantic waypoints $P^{(x)}(x,r)$2. These sparse centroids are then used as goals in a TSDF-based planner (Schieber et al., 29 May 2026). Here semantic lifting is neither full semantic mapping nor pure geometric reconstruction: it is sparse grounding of object-level targets in 3D.

4. Program, binary, and specification lifting

In programming-language and systems work, semantic lifting typically means recovering a higher-level semantic artifact from lower-level code while preserving behavior. CoCompiler frames this as lifting C into Lustre. Vertical lifting inverts the canonical image of the verified Vélus compiler, while horizontal lifting performs semantics-preserving Clight-to-Clight rewrites so that real-world C approximates that image. The relational compiler $\mu(\text{conf})$5 can be run backward, so that solving compile lustreFile cFile for lustreFile produces a Lustre program observationally equivalent to the input C as a reactive system (Spargo et al., 30 Sep 2025). Semantic lifting here is bidirectional compilation interpreted relationally.

For scientific computing, the same idea becomes domain-theoretic. The FFT case study lifts an LLM-generated C kernel through AST and icode into $P^{(x)}(x,r)$3-SPL and then SPL, eventually identifying the mathematical transform $P^{(x)}(x,r)$4. A representative recurrence is

$P^{(x)}(x,r)$5

and symbolic execution plus algebraic reasoning establish $P^{(x)}(x,r)$6 for the targeted class of inputs (Zhang et al., 15 Jan 2025). The lift therefore reconstructs denotational meaning—linear operators and factorization structure—rather than source syntax alone.

GPU binary lifting makes explicit why “semantic” lifting exceeds opcode translation. CuLifter starts from NVIDIA SASS, where the unified register file erases type distinctions that LLVM IR requires. Its pipeline reconstructs predicated SSA, aggregates multi-instruction patterns, and performs type recovery by constraint propagation with conflict detection. When a register is used as both Float32 and Int32, the lifted IR preserves the definition-site type and inserts explicit bitcasts at conflicting uses (Zhao et al., 30 Apr 2026). The paper argues that type recovery is the central challenge of GPU binary lifting because typed IR is otherwise impossible to produce reliably.

These works share a preservation criterion but differ in target language. CoCompiler targets a synchronous DSL and graphical SCADE models; the FFT work targets operator languages $P^{(x)}(x,r)$7-SPL and SPL; CuLifter targets LLVM IR (Spargo et al., 30 Sep 2025, Zhang et al., 15 Jan 2025, Zhao et al., 30 Apr 2026). The common invariant is that the lift must expose semantic structure that was implicit, compiled away, or obscured by low-level representation. In that sense, semantic lifting acts as semantic recovery.

5. Types, variability, and semantic reflection

Some uses of semantic lifting are not about changing representation media but about changing the semantic universe in which ordinary operations are interpreted. In rank polymorphism, the principal control mechanism is the lifting of functions of array rank $P^{(x)}(x,r)$8 to arguments of higher rank $P^{(x)}(x,r)$9. Remora formalizes this with a dynamic lift rule that computes a principal frame and replicates cells so that application can be mapped across higher-rank arrays. The static rule for application computes the same frame using a shape lattice join, and the resulting soundness theorem guarantees that array shape errors cannot occur at run time in a well-typed program (Slepak et al., 2019). This is semantic lifting as generalized array application.

Variability-aware lifting makes the same point in a software-product-line setting. A single-product analysis $\Sigma$0 is transformed into a variability-aware $\Sigma$1 operating on conditional values

$\Sigma$2

with disjointness and full-coverage invariants over presence conditions. Correctness is expressed by the commuting condition

$\Sigma$3

Shallow lifting wraps the original analysis via apply; deep lifting rewrites the program compositionally so that intermediate computations are shared across configurations (Shahin et al., 2020). The lift therefore changes the semantic domain from single results to configuration-indexed families of results.

At a more abstract level, dependent refinement typing is obtained by lifting a split closed comprehension category $\Sigma$4 with a posetal fibration $\Sigma$5. The pullback construction

$\Sigma$6

yields a new closed comprehension category whose objects are triples $\Sigma$7, combining a base type with context and type-level predicates. The construction lifts dependent products, coproducts, effects, and recursion under stated conditions, and the resulting morphism back to $\Sigma$8 strictly preserves the lifted structure (Kura, 2020). Semantic lifting here is categorical and global: an entire type theory is enriched with refinement logic.

Semantically Reflected Programs push the idea from types to runtime states. A SMOL configuration conf is mapped by a direct mapping $\Sigma$9 into RDF/OWL, and the global graph is

$DFT_n$0

The language then exposes semantic reflection operators such as access(sparql, ...), member(owl), and validate(shacl), allowing running code to query its own lifted state and the surrounding domain ontology (Kamburjan et al., 3 Sep 2025). This is one of the strongest forms of the term: the operational state itself becomes a semantic object.

6. Correctness, efficiency, and limitations

The principal research questions surrounding semantic lifting are preservation, efficiency, and tractability. Preservation is formulated in different ways. CoCompiler requires observational equivalence between recovered Lustre and original C as reactive systems (Spargo et al., 30 Sep 2025). The FFT lifting uses symbolic execution and algebraic equivalence to show that the recovered operator is $DFT_n$1 (Zhang et al., 15 Jan 2025). Remora proves progress and preservation so that shape-based lifting cannot introduce run-time shape errors (Slepak et al., 2019). The categorical refinement construction proves semantic soundness of the refinement system relative to the underlying model (Kura, 2020). Semantically Reflected Programs prove that well-typed programs cannot reach configurations whose lifted graphs are inconsistent with the SMOL ontology and the domain ontology (Kamburjan et al., 3 Sep 2025).

Efficiency pressures often motivate lifting rather than merely accompanying it. The Lifted Matrix-Space model uses a shared tensorized lift so that parameter count is dominated by $DFT_n$2 and remains independent of vocabulary size (Chung et al., 2017). VQ-FF compresses multi-view feature fields so that prompt-conditioned semantic lifting can be performed with codebook lookup rather than repeated rendering, while retaining high cosine similarity to the original fields (Tang et al., 9 Mar 2025). LiftNav avoids dense 3D semantic embeddings and instead lifts only sparse 3D object targets, achieving a $DFT_n$3 feasibility rate in the reported simulations (Schieber et al., 29 May 2026). CuLifter lifts $DFT_n$4 of $DFT_n$5 GPU functions to valid LLVM IR, and its ablation study shows that disabling type recovery drops the x86 pass rate from $DFT_n$6 to $DFT_n$7 (Zhao et al., 30 Apr 2026).

Empirical gains are often task-specific but still illuminate what the lift contributes. On geographic spatial semantic lifting, the full SE-KGE model improves test AUC from $DFT_n$8 to $DFT_n$9 and test APR from $\mu(\text{conf})$0 to $\mu(\text{conf})$1 over the space-only variant (Mai et al., 2020). ALOcc reports an absolute gain of $\mu(\text{conf})$2 in RayIoU on Occ3D without the camera visible mask while using the same input size and ResNet-50 backbone (Chen et al., 2024). LVIC improves a nuScenes LiDAR semantic segmentation baseline from $\mu(\text{conf})$3 to $\mu(\text{conf})$4 mIoU by lifting visual information as cue (Dong et al., 2024). These results suggest that the value of a lift typically lies not in abstraction alone but in exposing a structure that the downstream model or analysis can exploit more directly.

Limitations are equally recurrent. Tree-structured lifting in NLP depends on parse trees and incurs matrix-composition cost (Chung et al., 2017). LiftNav’s target centroids may lie inside objects, producing the “semantic trap” in which the planner is forced toward geometrically infeasible endpoints (Schieber et al., 29 May 2026). SE-KGE represents large spatial entities by bounding boxes rather than full geometry (Mai et al., 2020). CoCompiler’s horizontal lifting is intentionally brittle and currently handles only C that is close to the Vélus image (Spargo et al., 30 Sep 2025). CuLifter still falls back to default integer typing for a small unresolved fraction of values and remains intra-procedural in its type reasoning (Zhao et al., 30 Apr 2026). The vector logic for intensional semantics is injective but not surjective and becomes non-classical in its measure-theoretic modal interpretation (Quigley, 3 Feb 2026). Semantic lifting is thus best understood not as a single mature technique but as a broad design principle whose concrete success depends on how well the target semantic domain matches the downstream reasoning task.

Taken together, these works establish semantic lifting as a unifying methodology for moving from raw, flat, local, or operational representations into semantically structured spaces where composition, inference, planning, verification, and reflection can be made explicit. Its forms differ radically—matrix operators, voxel grids, knowledge graphs, DSLs, typed IR, refinement fibrations—but the central ambition remains the same: to expose latent semantic structure in a representation that can support stronger computation than the source form readily affords.