Reverse Mapping: Methods and Insights

• Reverse mapping is a process that reconstructs latent source representations from observed target data using techniques from reversible logic, inverse problems, and reverse engineering.
• It employs both exact inversion when the forward transformation is bijective and approximate recovery when the process is lossy or ambiguous, balancing mathematical rigor with practical constraints.
• Applications span from DRAM address recovery and molecular backmapping to neural network weight inversion and design-flow synthesis, illustrating its cross-disciplinary impact.

Searching arXiv for additional papers on “reverse mapping” to ground the article and cross-check scope. Reverse mapping denotes a family of operations that reconstruct, infer, or synthesize a source-side representation from a target-side representation, observed behavior, or imposed specification. In the cited literature, the term ranges from exact inversion of a bijection in reversible logic (Saeed et al., 2017) and bijective field translation in cosmological simulations (Andrianomena et al., 2023), to approximate recovery in ill-posed inverse problems such as sRGB-to-RAW reconstruction (Kınlı et al., 2022), coarse-to-fine molecular backmapping (Stieffenhofer et al., 2020), and surface correspondence recovery through coupled forward and backward maps (Ezuz et al., 2018). It also appears in reverse-engineering settings, where the task is to recover hidden structure—such as ancillary-port assignments in reversible circuits (Saeed et al., 2017), DRAM address-scrambling masks (Plin et al., 23 Sep 2025), or neural-network weights from black-box queries (Beiser et al., 25 Nov 2025)—and in design workflows that derive hardware from code requirements rather than mapping code to fixed hardware (Escofet et al., 20 Oct 2025). This suggests that reverse mapping is best treated not as a single algorithmic primitive, but as a recurrent structural idea: recover the latent source, semantics, or implementation that is not directly exposed by the forward mapping.

1. Exact inversion, bijectivity, and semantic ambiguity

A strict form of reverse mapping arises when the forward transformation is bijective. In reversible logic, a circuit has the same number of inputs and outputs and implements a one-to-one mapping on $\{0,1\}^n$, written as

$$f(x_1, x_2, \ldots, x_n) = (y_1, y_2, \ldots, y_n).$$

Because $f$ is bijective, an inverse mapping $f^{-1}$ exists, so the unique input assignment can be reconstructed from the observed output assignment (Saeed et al., 2017). The paper emphasizes that this is stronger than merely tracing wires backward: the realized Boolean transformation is a permutation of all $2^n$ bit-vectors, and every output pattern appears exactly once in the truth table (Saeed et al., 2017).

The same paper also draws the central distinction between invertibility of the implemented reversible wrapper and recoverability of the intended non-reversible function. When a non-reversible function is embedded into a reversible circuit, ancillary inputs are fixed constants and garbage outputs are functionally irrelevant ports added to obtain bijectivity (Saeed et al., 2017). For a full adder, the paper states that $\lceil \log(m)\rceil$ garbage outputs are required, where $m$ is the maximum multiplicity of any repeated output pattern; since three output patterns repeat, $\lceil \log(3)\rceil = 2$ garbage outputs are needed, along with one additional ancillary input to balance input and output counts (Saeed et al., 2017). Reverse mapping of the reversible circuit remains trivial in the mathematical sense, but reverse engineering the intended specification is difficult because the attacker may not know “the value and the location of the ancillary input bits and the location of the garbage output bits” (Saeed et al., 2017).

That ambiguity is formalized by the number of possible embeddings of non-reversible functions into the observed reversible implementation. For output $y_i$, with $k_i$ newly appearing candidate driving variables, the number of possible embedded functions is

$$f(x_1, x_2, \ldots, x_n) = (y_1, y_2, \ldots, y_n).$$0

and for all outputs

$$f(x_1, x_2, \ldots, x_n) = (y_1, y_2, \ldots, y_n).$$1

while the total number of embedded target functions is

$$f(x_1, x_2, \ldots, x_n) = (y_1, y_2, \ldots, y_n).$$2

The paper interprets $$f(x_1, x_2, \ldots, x_n) = (y_1, y_2, \ldots, y_n).$$3 as a security metric: the reversible map is always invertible, but the embedded function may still be semantically ambiguous (Saeed et al., 2017).

An exact inverse also appears in the Theory of Functional Connections extension to non-rectangular domains. There the forward map $$f(x_1, x_2, \ldots, x_n) = (y_1, y_2, \ldots, y_n).$$4 sends the rectangular reference domain $$f(x_1, x_2, \ldots, x_n) = (y_1, y_2, \ldots, y_n).$$5 to the physical domain $$f(x_1, x_2, \ldots, x_n) = (y_1, y_2, \ldots, y_n).$$6, while TFC machinery remains native to $$f(x_1, x_2, \ldots, x_n) = (y_1, y_2, \ldots, y_n).$$7, so reverse mapping $$f(x_1, x_2, \ldots, x_n) = (y_1, y_2, \ldots, y_n).$$8 is required to pull interior and boundary points back to the rectangle (Mortari et al., 2020). For projection mapping, the paper states that inverse mappings always exist and that the inverse transformation is equivalent to the forward algorithm with roles exchanged (Mortari et al., 2020). For 4-point polynomial mapping, an explicit inverse is derived via auxiliary parameters $$f(x_1, x_2, \ldots, x_n) = (y_1, y_2, \ldots, y_n).$$9, followed by

$f$0

whereas no exact inverse is found for the 8-point polynomial mapping (Mortari et al., 2020). This suggests that exact reverse mapping is feasible when bijectivity is structurally built into the representation, but becomes substantially harder when the forward parameterization is more expressive.

2. Approximate reverse mapping in ill-posed inverse problems

A second major meaning of reverse mapping is approximate inversion of a lossy or non-unique forward process. In "Reversing Image Signal Processors by Reverse Style Transferring" (Kınlı et al., 2022), the target is the inverse of camera processing: $f$1 where $f$2 denotes the cumulative ISP transformation. The paper explicitly states that finding $f$3 is ill-posed because tone mapping, gamma correction, color correction, local enhancement, sharpening, denoising, clipping, and demosaicing-related effects are lossy, nonlinear, and potentially camera-dependent (Kınlı et al., 2022). The proposed RST-ISP-Net treats the aggregate ISP effect as a style factor and removes it through adaptive normalization. The style-conditioning mechanism is

$f$4

combined with

$f$5

and the training objective is

$f$6

with $f$7 (Kınlı et al., 2022). The paper reports that the method is workable but substantially behind stronger challenge baselines, and identifies severe blur and loss of high-frequency detail as the primary failure mode (Kınlı et al., 2022). In this setting, reverse mapping means approximate recovery of a RAW-domain image representation, not literal inversion back to sensor measurements (Kınlı et al., 2022).

A related but more explicitly bidirectional learned setting appears in cosmological field translation. "Invertible mapping between fields in CAMELS" (Andrianomena et al., 2023) trains a conditional CycleGAN for three tasks: $f$8, $f$9, and $f^{-1}$0 (Andrianomena et al., 2023). The paper is explicit that “invertible” or “bijective” does not mean a mathematically exact one-to-one inverse; it means learning two maps,

$f^{-1}$1

with cycle consistency

$f^{-1}$2

The relevant loss is

$f^{-1}$3

with $f^{-1}$4 and $f^{-1}$5 in the total objective (Andrianomena et al., 2023). Recovery is evaluated by the statistical agreement of PDFs and 2D power spectra between originals and cycle-recovered maps, with discrepancies increasing for $f^{-1}$6 (Andrianomena et al., 2023). Here reverse mapping is a simulation-calibrated statistical reconstruction rather than an exact physical inverse.

The same approximate-inverse logic appears in the TFC paper when no closed-form inverse exists. For bijective complex or polynomial mappings lacking analytic inversion, the paper proposes a least-squares approximation

$f^{-1}$7

using orthogonal polynomials such as Chebyshev or Legendre bases (Mortari et al., 2020). In the demonstrated complex-mapping test, using $f^{-1}$8 grid points and 20 Chebyshev polynomials, the inverse error $f^{-1}$9 over $2^n$0 Monte Carlo points had

$2^n$1

(Mortari et al., 2020). This suggests a general pattern: when the forward map is bijective but algebraically inconvenient, reverse mapping can be replaced by a fitted surrogate, provided the one-to-one structure remains intact.

3. Reverse mapping as hidden-structure recovery and reverse engineering

In several papers, reverse mapping means not inversion of an exposed function, but recovery of hidden internal structure from indirect observations. The DRAM paper "Knock-Knock: Black-Box, Platform-Agnostic DRAM Address-Mapping Reverse Engineering" (Plin et al., 23 Sep 2025) formulates the physical-to-DRAM mapping as a linear transformation over $2^n$2. For an $2^n$3-bit physical address $2^n$4 and parity mask $2^n$5, each output bit is

$2^n$6

Using high-latency row-buffer conflicts to identify address pairs in the same bank/channel, the paper defines difference words $2^n$7, stacks them into a matrix $2^n$8, and derives the bank/channel masks from

$2^n$9

The key result is that the bank-mask basis is exactly the nullspace of $\lceil \log(m)\rceil$0 (Plin et al., 23 Sep 2025). The method generalizes to a row basis $\lceil \log(m)\rceil$1, leading to a recovered full mapping

$\lceil \log(m)\rceil$2

The paper reports $\lceil \log(m)\rceil$3 recall and precision on all tested platforms, and that the method runs in under a few minutes even on systems with 512 GB of DRAM (Plin et al., 23 Sep 2025). Here reverse mapping means algebraic recovery of undocumented scrambling functions from timing fingerprints.

A related black-box recovery problem is posed in "Data Augmentation Techniques to Reverse-Engineer Neural Network Weights from Input-Output Queries" (Beiser et al., 25 Nov 2025). There the forward map is the teacher network’s parameter-to-function mapping, while the reverse map seeks teacher parameters from sampled input-output behavior. The student is trained by minimizing

$\lceil \log(m)\rceil$4

over teacher queries (Beiser et al., 25 Nov 2025). The paper emphasizes that low train loss does not imply parameter recovery: for a 512-hidden-neuron teacher queried on plain MNIST, train loss can remain small while recovery quality is poor, with

$\lceil \log(m)\rceil$5

(Beiser et al., 25 Nov 2025). The central contribution is query augmentation targeted at hidden-layer pre-activation variability. Biased noise $\lceil \log(m)\rceil$6 yields near-perfect recovery for the same teacher, with

$\lceil \log(m)\rceil$7

(Beiser et al., 25 Nov 2025). This suggests that reverse mapping from function samples back to parameters depends critically on how the forward map is probed.

Reversible-logic reverse engineering also belongs in this category, because the difficulty is not inverting the observable reversible circuit but recovering hidden semantic structure such as which ports are ancillary or garbage (Saeed et al., 2017). The paper shows that structural synthesis, especially BDD-based synthesis, leaks exploitable cues, including that primary inputs are directly connected to garbage outputs and that an intermediate output of a sub-circuit with no control over other gates is a primary output (Saeed et al., 2017). When the attacker knows the synthesis approach, the attacker can identify on average 81.6% of ancillary input bits in BDD-based circuits, whereas for QMDD-based functional synthesis, knowing the synthesis approach does not materially help (Saeed et al., 2017).

A human-centered variant appears in "Enhancing XAI Interpretation through a Reverse Mapping from Insights to Visualizations" (Nuthalapati et al., 26 Aug 2025). There the reverse path is not from outputs to hidden physical variables, but from free-form user interpretations back into visual explanation space. The structured insight representation can be summarized as

$\lceil \log(m)\rceil$8

where $\lceil \log(m)\rceil$9, $m$0 is a set of variables, $m$1 is the asserted relation, and $m$2 is an optional condition (Nuthalapati et al., 26 Aug 2025). GPT-4o is used to parse free-form interpretations into this structure, which is then mapped back to annotation of the original visualization or to an additional coordinated view (Nuthalapati et al., 26 Aug 2025). In that paper, reverse mapping is a verification loop: interpretation becomes machine-readable input, then returns to visualization for validation.

4. Coupled forward–backward maps in geometry and multiscale reconstruction

Reverse mapping is often not a stand-alone inverse, but one member of a coupled pair optimized jointly with the forward map. In "Reversible Harmonic Maps between Discrete Surfaces" (Ezuz et al., 2018), the forward map $m$3 and backward map $m$4 are optimized together. Harmonicity alone is insufficient because a Dirichlet-type energy can collapse large regions, so the paper augments smoothness with reversibility. The reversibility energy is

$m$5

and the full objective is

$m$6

with $m$7 in all experiments (Ezuz et al., 2018). The backward map is an independent optimization variable, not merely the analytical inverse of the forward map (Ezuz et al., 2018). The paper shows that low reversibility error implies approximate injectivity and surjectivity in the smooth setting, while in practice the joint optimization prevents collapse and improves correspondence quality (Ezuz et al., 2018).

In condensed-phase molecular modeling, reverse mapping appears as coarse-to-fine backmapping. "Adversarial Reverse Mapping of Equilibrated Condensed-Phase Molecular Structures" (Stieffenhofer et al., 2020) formulates the target distribution as

$m$8

where $m$9 is the coarse-grained representation and $\lceil \log(3)\rceil = 2$0 is the atomistic representation (Stieffenhofer et al., 2020). The paper is explicit that this is not a deterministic reconstruction problem, because one CG configuration corresponds to many atomistic microstates (Stieffenhofer et al., 2020). The method factorizes the conditional distribution autoregressively,

$\lceil \log(3)\rceil = 2$1

and uses a conditional Wasserstein GAN with gradient penalty to learn local atomistic environments (Stieffenhofer et al., 2020). The physical prior combines force-field discrepancy and center-of-mass consistency: $\lceil \log(3)\rceil = 2$2 The method aims to generate atomistic structures that are already near equilibrium rather than merely valid initial guesses (Stieffenhofer et al., 2020). The follow-up transferability paper extends the same deepBackmap framework across chemistries and shows that the best prior differs between in-domain and transfer settings (Stieffenhofer et al., 2021).

A graphics example is "Reverse Projection: Real-Time Local Space Texture Mapping" (Lim et al., 2024), where reverse projection means iterating over the target texture rather than over projected fragments. Each texel stores a local-space position $\lceil \log(3)\rceil = 2$3 and normal $\lceil \log(3)\rceil = 2$4, obtained by rasterizing the mesh into texture space, and the texel “looks outward” to determine whether it intersects the decal projector (Lim et al., 2024). The conceptual inverse step is

$\lceil \log(3)\rceil = 2$5

which maps a target texel’s 3D point into decal space (Lim et al., 2024). The paper reports local-space texture generation and local-space projection times of

$\lceil \log(3)\rceil = 2$6

on a single-threaded CPU implementation (Lim et al., 2024). This is another case where reverse mapping is traversal from output domain back into source coordinate space.

5. Reverse mapping as a design-flow inversion

Some papers use reverse mapping to invert the direction of synthesis or interpretation rather than to invert a numeric function. "Quantum Reverse Mapping: Synthesizing an Optimal Spin Qubit Shuttling Bus Architecture for the Surface Code" (Escofet et al., 20 Oct 2025) explicitly contrasts standard forward mapping—mapping circuits or codes onto a fixed device graph—with reverse mapping from code requirements to hardware layout. The target is a one-dimensional shuttling-bus architecture tailored to the syndrome-extraction schedule of a rotated surface code (Escofet et al., 20 Oct 2025). For each data qubit, the paper defines a chain interaction

$\lceil \log(3)\rceil = 2$7

and enforces a chain-preserving ordering

$\lceil \log(3)\rceil = 2$8

The architecture is synthesized by a mixed-integer linear program with placement variables $\lceil \log(3)\rceil = 2$9 and objective

$y_i$0

where $y_i$1 prioritizes cycle time over total shuttling distance (Escofet et al., 20 Oct 2025). The Zig-Zag heuristic matches the optimal MILP solutions for code distances $y_i$2, and simulations report logical error rates as low as

$y_i$3

(Escofet et al., 20 Oct 2025). In this usage, reverse mapping means deriving architecture from code, not code from architecture.

The XAI paper also belongs partly in this category because it inverts the usual explanation workflow. Standard XAI is

$y_i$4

whereas Reverse Mapping inserts a return path from interpretation to structured insight and then back to visualization for verification (Nuthalapati et al., 26 Aug 2025). A plausible implication is that reverse mapping can function as a general workflow primitive for turning a terminal representation into an intermediate one.

The quantum annealing paper "Mapping State Transition Susceptibility in Quantum Annealing" (Pelofske, 2022) provides another design-like inversion, though at the level of empirical transition structure. Reverse annealing is used to initialize a specific classical state $y_i$5, and an h-gain schedule biases the system toward a chosen ground state $y_i$6. The modified Hamiltonian is

$y_i$7

and the mapping is quantified by

$y_i$8

The resulting susceptibility maps and state transition networks reveal intermediate pathways, non-monotonic h-gain response curves, and a stronger relation to Hamming-like structure than to energy alone (Pelofske, 2022). Here reverse mapping means empirical reconstruction of state-to-state accessibility under a reverse annealing protocol.

6. Algebraic and operator-theoretic meanings

In ring theory, reverse mapping appears in the form of reverse derivable maps. "Additivity of Reverse Derivable Maps" (Sandhu et al., 2018) studies maps $y_i$9 satisfying

$k_i$0

and aims to prove that, under suitable restrictions on $k_i$1, such maps are additive (Sandhu et al., 2018). The involutive variant, "*-Reverse Derivable Maps" (Sandhu et al., 2020), defines

$k_i$2

and proves that every *-reverse derivable map is additive under conditions

$k_i$3

for a ring with involution containing a nontrivial symmetric idempotent $k_i$4 (Sandhu et al., 2020). The proof uses the Peirce decomposition

$k_i$5

and a normalization step reducing to a map $k_i$6 with $k_i$7 (Sandhu et al., 2020). In this literature, reverse mapping is not inversion but a reverse-order Leibniz-type identity.

The optimization paper "A Nonlinear African Vulture Optimization Algorithm Combining Henon Chaotic Mapping Theory and Reverse Learning Competition Strategy" (Wang et al., 2024) uses reverse learning in a population-based metaheuristic. The reverse candidate is generated as

$k_i$8

after the ordinary position update $k_i$9 (Wang et al., 2024). The paper describes this as simultaneously exploring the positive and negative direction of the search space, increasing diversity, and helping the algorithm jump out of local optima (Wang et al., 2024). Although the paper does not use the phrase reverse mapping formally, the reverse/opposite transformation is a mapping from a current point to a reflected candidate.

Across these algebraic and heuristic settings, the common pattern is that reverse mapping no longer denotes inversion of a known bijection. Instead it denotes a reversed structural relation: reverse-order composition in ring identities (Sandhu et al., 2020), or opposition-style search-point generation in metaheuristics (Wang et al., 2024). This suggests that the term has broadened beyond pure inverse problems into a more general vocabulary for “going against the forward direction” of a construction.

7. Comparative themes and recurring technical tensions

Several recurring technical tensions cut across these uses of reverse mapping. The first is the distinction between exact invertibility and semantic or physical ambiguity. Reversible circuits are mathematically invertible, yet the intended non-reversible function can remain highly ambiguous because ancilla and garbage roles are hidden (Saeed et al., 2017). Cycle-consistent field translation recovers maps only approximately in distribution, not as unique physical inverses (Andrianomena et al., 2023). Backmapping in condensed-phase systems is explicitly one-to-many and must therefore be modeled as conditional sampling rather than exact reconstruction (Stieffenhofer et al., 2020).

The second is the importance of structural assumptions. Knock-Knock depends on linearity over $$f(x_1, x_2, \ldots, x_n) = (y_1, y_2, \ldots, y_n).$$00 and on observable row-buffer timing bimodality (Plin et al., 23 Sep 2025). The TFC inverse-approximation framework requires the forward map to be bijective even when no analytic inverse exists (Mortari et al., 2020). DeepBackmap assumes local coarse-to-fine correlations, while CAMELS field translation relies on cycle consistency and conditional simulation context (Stieffenhofer et al., 2020, Andrianomena et al., 2023). The neural-network recovery paper shows that reverse mapping from outputs to parameters is tractable only when the query distribution excites the right hidden directions (Beiser et al., 25 Nov 2025).

The third is the repeated use of paired forward/backward structures. Surface correspondence is stabilized by optimizing $$f(x_1, x_2, \ldots, x_n) = (y_1, y_2, \ldots, y_n).$$01 and $$f(x_1, x_2, \ldots, x_n) = (y_1, y_2, \ldots, y_n).$$02 together (Ezuz et al., 2018). CycleGAN learns both $$f(x_1, x_2, \ldots, x_n) = (y_1, y_2, \ldots, y_n).$$03 and $$f(x_1, x_2, \ldots, x_n) = (y_1, y_2, \ldots, y_n).$$04 jointly (Andrianomena et al., 2023). Reverse engineering of reversible logic depends on distinguishing the invertible wrapper from the embedded function (Saeed et al., 2017). In XAI, the explanation pipeline becomes bidirectional once user interpretation is fed back into visualization (Nuthalapati et al., 26 Aug 2025).

The fourth is a trade-off between expressivity and invertibility. Projection mapping gives an exact inverse but is not conformal and is generally not differentiable everywhere (Mortari et al., 2020). Higher-order polynomial mappings describe more complicated domains but lose closed-form invertibility (Mortari et al., 2020). Functional synthesis in reversible logic preserves more embedding ambiguity than structural synthesis, but at higher quantum cost (Saeed et al., 2017). The reverse ISP model uses a large 86.3M-parameter network to model style-like ISP effects, yet still fails to recover high-frequency RAW detail faithfully (Kınlı et al., 2022).

Taken together, these works present reverse mapping as a technical strategy for recovering what the forward map suppresses: hidden inputs, latent semantics, lost resolution, architecture implied by code, or transition structure implied by hardware dynamics. Exact inverse mappings are possible when the forward map is bijective and well conditioned (Saeed et al., 2017, Mortari et al., 2020). In the more common case—when the forward process is lossy, ambiguous, scrambled, or only partially observed—reverse mapping becomes a problem of approximation, identifiability, or structured inference (Kınlı et al., 2022, Andrianomena et al., 2023, Plin et al., 23 Sep 2025, Beiser et al., 25 Nov 2025).