@@ -31,6 +31,7 @@
 from enum import IntEnum
 from typing import (
     Any,
+    Callable,
     cast,
     get_args,
     get_origin,
@@ -1487,42 +1488,62 @@ def _iter_graph_args(value: object) -> Iterator[GraphArg]:
             yield from _iter_graph_args(item)
 
 
-def collect_data_keys(program: Program) -> set[str]:
-    """Return every out-of-line data key the program references.
+def _map_data_keys(method: Method, fn: Callable[[str], str]) -> None:
+    """Replace every out-of-line data key in ``method`` with ``fn(key)``, in place.
 
     Covers constant references (NamedTensorRef.data_key) plus the quant keys
     (AffineGroup scale and zero-point) carried on any TensorMeta.quant, whether
     it is attached to a constant or to a graph value (intermediates and I/O),
     recursing into HOP subgraphs wherever a schema field carries a ``GraphArg``.
     PackedQuant carries no external keys.
     """
-    keys: set[str] = set()
 
-    def add_meta(meta: Optional[TensorMeta]) -> None:
+    def map_meta(meta: Optional[TensorMeta]) -> None:
         if meta is None or meta.quant is None:
             return
         scheme = meta.quant.scheme
         if isinstance(scheme, AffineGroup):
-            keys.add(scheme.scale_data_key)
+            scheme.scale_data_key = fn(scheme.scale_data_key)
             if scheme.zero_point_data_key:
-                keys.add(scheme.zero_point_data_key)
+                scheme.zero_point_data_key = fn(scheme.zero_point_data_key)
 
     def visit_graph(graph: Graph) -> None:
         for value in graph.tensor_values or []:
-            add_meta(value.meta)
+            map_meta(value.meta)
         for node in graph.nodes:
             for graph_arg in _iter_graph_args(node):
                 visit_graph(graph_arg.graph)
 
-    for method in program.methods:
-        for constant in method.constants or []:
-            keys.add(constant.data_key)
-            add_meta(constant.meta)
-        visit_graph(method.graph)
+    for constant in method.constants or []:
+        constant.data_key = fn(constant.data_key)
+        map_meta(constant.meta)
+    visit_graph(method.graph)
+
+
+def collect_data_keys(program: Program) -> set[str]:
+    """Return every out-of-line data key the program references."""
+    keys: set[str] = set()
 
+    def add(key: str) -> str:
+        keys.add(key)
+        return key
+
+    for method in program.methods:
+        _map_data_keys(method, add)
     return keys
 
 
+def rename_data_keys(
+    program: Program, method_name: str, mapping: dict[str, str]
+) -> None:
+    """Rename one method's data keys in place; keys absent from ``mapping`` stay."""
+    for method in program.methods:
+        if method.name == method_name:
+            _map_data_keys(method, lambda key: mapping.get(key, key))
+            return
+    raise ValueError(f"rename_data_keys: no method named {method_name!r}.")
+
+
 def _check_optional_tensor_list_refs(
     value: OptionalTensorListArg, ctx: str, check_ref: Any
 ) -> None:
 
@@ -45,7 +45,8 @@ needed in the future like `constant_methods` and ETRecord integration.
 Raises `TypeError` for the wrong input or method-value types. Raises `ValueError`
 for an empty method mapping or method name, if a method does not fully delegate to
 the native backend, if a constant differs between methods, or if a data key the
-graph references has no backing tensor.
+graph references has no backing tensor. Conflicting generated
+`_lifted_tensor_constant{i}` keys are namespaced as `<method>/<name>`.
 
 ## Current limitations: one complete delegate per method
 
 
@@ -37,10 +37,12 @@
 
 from executorch.backends.native.preprocess import NativeDelegateInfo
 from executorch.backends.native.serialization.graph_serialize import (
+    _compile_to_bytes,
     _same_tensor,
     collect_data_keys,
     deserialize_program,
     merge_programs,
+    rename_data_keys,
     validate_program,
 )
 from executorch.backends.native.serialization.schema import Program
@@ -278,6 +280,46 @@ def _merge_constants(
     return merged
 
 
+# Edge lowering generates these names independently for each method.
+_LIFTED_CONSTANT_PREFIX = "_lifted_tensor_constant"
+
+
+def _plan_lifted_constant_renames(
+    per_method: dict[str, dict[str, torch.Tensor]],
+    program: Program,
+) -> dict[str, dict[str, str]]:
+    """Plan ``<method>/<key>`` names for conflicting immutable lifted constants.
+
+    Equal tensors stay shared; keys mutated by any method are never renamed.
+    """
+    mutated_keys = _mutable_data_keys(program)
+    taken = {key for constants in per_method.values() for key in constants}
+    seen: dict[str, torch.Tensor] = {}
+    renames: dict[str, dict[str, str]] = {}
+    for method_name, constants in per_method.items():
+        mapping: dict[str, str] = {}
+        for key, tensor in constants.items():
+            existing = seen.get(key)
+            if existing is None:
+                seen[key] = tensor
+                continue
+            if _same_tensor(existing, tensor):
+                continue
+            if not key.startswith(_LIFTED_CONSTANT_PREFIX) or key in mutated_keys:
+                continue
+            new_key = f"{method_name}/{key}"
+            suffix = 1
+            while new_key in taken:
+                suffix += 1
+                new_key = f"{method_name}/{key}#{suffix}"
+            mapping[key] = new_key
+            taken.add(new_key)
+            seen[new_key] = tensor
+        if mapping:
+            renames[method_name] = mapping
+    return renames
+
+
 def _check_shared_mutable_buffers(program: Program) -> None:
     """Hold the merged Program to serialize_program's cross-method guarantee.
 
@@ -380,7 +422,8 @@ def to_native(
         ValueError: If the method dictionary is empty, a method name is empty, a
             method does not fully delegate to the native backend, a constant
             differs between methods, or a data key the graph references has no
-            backing tensor.
+            backing tensor. Conflicting generated ``_lifted_tensor_constant{i}``
+            keys are namespaced per method.
     """
     method_programs = _normalize_programs(programs)
 
@@ -435,12 +478,23 @@ def to_native(
             method_name,
         )
         method_blobs[method_name] = module.processed_bytes
-        method_constants[method_name] = _delegate_info(module, method_name).constants
+        method_constants[method_name] = dict(
+            _delegate_info(module, method_name).constants
+        )
 
     ptg_blob = merge_programs(method_blobs)
-    constants = _merge_constants(method_constants)
-
     program = deserialize_program(ptg_blob)
+
+    renames = _plan_lifted_constant_renames(method_constants, program)
+    if renames:
+        for method_name, mapping in renames.items():
+            rename_data_keys(program, method_name, mapping)
+            constants_for_method = method_constants[method_name]
+            for old_key, new_key in mapping.items():
+                constants_for_method[new_key] = constants_for_method.pop(old_key)
+        ptg_blob = _compile_to_bytes(program)
+
+    constants = _merge_constants(method_constants)
     _validate_merged_program(program, constants)
 
     return NativeProgramManager(ptg=ptg_blob, constants=constants)
 
@@ -27,7 +27,12 @@
     Program,
 )
 from executorch.exir import to_edge_transform_and_lower
-from executorch.exir._serialize._ptn import ALIASES_ENTRY, PTG_ENTRY, SAFETENSORS_ENTRY
+from executorch.exir._serialize._ptn import (
+    ALIASES_ENTRY,
+    PTG_ENTRY,
+    read_ptn,
+    SAFETENSORS_ENTRY,
+)
 from executorch.exir.lowered_backend_module import (
     executorch_call_delegate,
     get_lowered_submodules,
@@ -393,6 +398,58 @@ def test_dropped_public_input_is_rejected(self):
             self._check(self._graph_module(drop_input=True))
 
 
+class LiftedConstantCollisionTest(unittest.TestCase):
+    def _scalar_shift(self, offset: float):
+        class Shift(nn.Module):
+            def forward(self, x):
+                return x + offset
+
+        return torch.export.export(Shift(), (torch.randn(2, 4),))
+
+    def _read(self, native) -> tuple[Program, dict[str, torch.Tensor]]:
+        with tempfile.TemporaryDirectory() as td:
+            path = os.path.join(td, "m.ptn")
+            native.save(path)
+            ptg, constants = read_ptn(path)
+        return deserialize_program(ptg), constants
+
+    def _lifted_keys(self, program: Program, method_name: str) -> list[str]:
+        (method,) = [m for m in program.methods if m.name == method_name]
+        return [c.data_key for c in method.constants or [] if "lifted" in c.data_key]
+
+    def test_distinct_lifted_constants_are_namespaced(self):
+        programs = {"a": self._scalar_shift(1.0), "b": self._scalar_shift(2.0)}
+        native = to_native(programs)
+        self.assertEqual(native.methods, {"a", "b"})
+        program, constants = self._read(native)
+        (a_key,) = self._lifted_keys(program, "a")
+        (b_key,) = self._lifted_keys(program, "b")
+        self.assertEqual(b_key, f"b/{a_key}")
+        torch.testing.assert_close(
+            constants[a_key], torch.full_like(constants[a_key], 1.0), rtol=0, atol=0
+        )
+        torch.testing.assert_close(
+            constants[b_key], torch.full_like(constants[b_key], 2.0), rtol=0, atol=0
+        )
+
+    def test_identical_lifted_constants_stay_shared(self):
+        programs = {"a": self._scalar_shift(1.0), "b": self._scalar_shift(1.0)}
+        program, constants = self._read(to_native(programs))
+        self.assertEqual(
+            self._lifted_keys(program, "a"), self._lifted_keys(program, "b")
+        )
+        lifted = {k for k in constants if "lifted" in k}
+        self.assertEqual(len(lifted), 1, lifted)
+
+    def test_parameter_fqn_collision_is_still_rejected(self):
+        programs = {
+            "a": torch.export.export(nn.Linear(4, 4), (torch.randn(1, 4),)),
+            "b": torch.export.export(nn.Linear(4, 4), (torch.randn(1, 4),)),
+        }
+        with self.assertRaisesRegex(ValueError, "differs between methods"):
+            to_native(programs)
+
+
 class MutableBufferDedupTest(unittest.TestCase):
     def test_identical_mutable_buffers_stay_separate(self):
         """Equal bytes must not make two independently mutable buffers one.