From d723f3679a1bebaf2e3e2645a9984d242d33e0a1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Gonz=C3=A1lez=20Paredes?= <enriqueg@cscs.ch>
Date: Thu, 17 Sep 2026 14:17:25 +0200
Subject: [PATCH 1/3] personal/egparedes: connectivities as types

A neighbor connectivity is today spread over three user-authored objects
that must agree by string equality (FieldOffset tag, local Dimension name,
offset_provider key) plus the Python variable name the FieldOffset is bound
to. Propose a connectivity class that contains its local dimension, is its
own provider key, and whose identity is its qualified Python name (also the
IR tag), building on shared/dimensions-as-types and gt4py#2844.

Includes a research appendix with the full constraint catalogue and concept
inventory derived from an audit of gt4py at b3c53fa7e (v1.2.2).
---
 content/index.md                              |   1 +
 .../connectivities-as-types.md                | 473 +++++++++++++++
 .../connectivities-as-types_research.md       | 560 ++++++++++++++++++
 3 files changed, 1034 insertions(+)
 create mode 100644 content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
 create mode 100644 content/personal/egparedes/connectivities-as-types/connectivities-as-types_research.md

diff --git a/content/index.md b/content/index.md
index 450efbe..61ddbc5 100644
--- a/content/index.md
+++ b/content/index.md
@@ -44,6 +44,7 @@ Work-in-progress proposals, organized by contributor.
 
 - [[personal/egparedes/layered-architecture|A layered architecture for gt4py with enforced public/internal decoupling]] — keywords: architecture, layering, tach, modularity, public-api, semi-public, internal, packaging, dependencies, refactoring, infrastructure, over-engineering, otf, workflow, dsl, config, allocators, caching, fingerprint, compiled-program, process-pool, factory-boy, instrumentation, adr, jax, decoupling, migration, tech-debt
 - [[personal/egparedes/otf-toolchain-split|Dissolving gt4py.next.otf into a toolchain core and DSL-agnostic build infrastructure]] — keywords: otf, toolchain, workflow, pipeline, refactoring, architecture, layering, modularity, backend, bindings, build-system, caching, runners, compiled-program, factory-boy, naming, observability, stage-inspection, adr, tach, tech-debt
+- [[personal/egparedes/connectivities-as-types/connectivities-as-types|Connectivities as types: one declaration for offset, local dimension and provider key]] — keywords: type-system, dimensions, local-dimensions, connectivities, offset-provider, unstructured, neighbor-sum, reduction, frontend, foast, gtir, embedded, gtfn, dace, nominal-types, metaclass, serialization, fingerprint, staggering, migration, adr, tech-debt
 - [[personal/egparedes/discretization-independent-fd-syntax|A discretization-independent surface syntax for finite-difference computations]] — keywords: finite-difference, finite-volume, mesh-invariant, structured, unstructured, exterior-calculus, dec, mimetic, de-rham, location-typing, stencil, weight-generation, rbf-fd, gfdm, moment-matching, conservation, field-operators, icon, pace, pmap, fv3, ifs-fvm, arakawa-staggering, c-grid, d-grid, a-grid, dynamical-core, hevi, vertical-solve, elliptic-solve, mpdata, semi-implicit, miura, atlas, prior-art, dsl-design
 
 <!-- Entry format (index only the main proposal; link appendices/implementations
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
new file mode 100644
index 0000000..2720594
--- /dev/null
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
@@ -0,0 +1,473 @@
+---
+title: "Connectivities as types: one declaration for offset, local dimension and provider key"
+author: egparedes
+tags: [type-system, dimensions, local-dimensions, connectivities, offset-provider, unstructured, neighbor-sum, reduction, frontend, foast, gtir, embedded, gtfn, dace, nominal-types, metaclass, serialization, fingerprint, staggering, migration, adr, tech-debt]
+created: 2026-09-17
+status: draft
+---
+
+> **TL;DR** A neighbor connectivity in `gt4py.next` is spread over three
+> user-authored objects that must agree by *string equality* — the
+> `FieldOffset` tag, the local `Dimension` name and the `offset_provider` key —
+> plus a fourth, hidden one: the Python variable the `FieldOffset` is bound to.
+> Make the connectivity a **class** that *contains* its local dimension, is its
+> own provider key, and whose identity — like every dimension after
+> [[shared/dimensions-as-types|dimensions as types]] — is its qualified Python
+> name, which is also its IR tag:
+>
+> ```python
+> class V2E(NeighborConnectivity[V, E], max_neighbors=6): ...
+>
+> neighbor_sum(a(V2E), axis=V2E.Local)
+> program(a, out=out, offset_provider={V2E: v2e_table})
+> ```
+>
+> `FieldOffset`, `ts.OffsetType`, the string-keyed `OffsetProvider` and the
+> `V2EDim`-next-to-`V2E` naming convention disappear. Seven of the ten
+> cross-object identity constraints in the current tree become tautologies.
+
+> **Status**: draft, AI-assisted. Derived from a full audit of the gt4py tree
+> at `b3c53fa7e` (v1.2.2, 2026-09-03); every `file:line` reference was
+> re-derived from that tree, and the two behaviours the proposal leans on
+> hardest were confirmed by *running* them, not by reading. The complete
+> constraint catalogue and concept inventory are in the appendix
+> [[personal/egparedes/connectivities-as-types/connectivities-as-types_research|Tag and name constraints — full catalogue]].
+
+> **Relation to existing proposals.** This is the *single-hop base* that
+> [[personal/havogt/dependent-local-dimensions|Dependent local dimensions and
+> connectivity chains]] §9 calls "the shared core" (stages U0/U1): one typed
+> connectivity declaration, derived local dimension, derived offset tag. It
+> takes no position on chains, reduction order or the path-vs-forest choice.
+> It builds on [[shared/dimensions-as-types|Dimensions as types]] and its
+> implementation in GridTools/gt4py#2844, and **conflicts with one of that
+> proposal's decisions** (identity semantics) — see
+> [Open questions / conflicts](#open-questions--conflicts).
+
+## Problem / motivation
+
+### Four strings, one dict lookup
+
+To use one connectivity on an unstructured mesh, a user today writes:
+
+```python
+V2EDim = Dimension("V2E", kind=DimensionKind.LOCAL)                 # (N3) local dim name
+V2E    = FieldOffset("V2E", source=Edge, target=(Vertex, V2EDim))   # (N1) tag, (N2) variable name
+...
+program(..., offset_provider={"V2E": table})                        # (N4) provider key
+```
+
+Four independently authored strings — N1 the tag, N2 the Python variable
+name, N3 the local dimension's name, N4 the dict key — all of which must be
+identical, none of which is checked against the others at declaration time.
+Every consumer does `common.get_offset(offset_provider, <some string>)`
+(`common.py:1200-1209`), and *which* string it uses depends on the execution
+path and the operation:
+
+| Path | Operation | String used | Where |
+| --- | --- | --- | --- |
+| embedded | shift `a(V2E[1])` | N1 `FieldOffset.value` | `ffront/fbuiltins.py:494` |
+| embedded | `neighbor_sum(..., axis=V2EDim)` | N3 `axis.value` | `embedded/nd_array_field.py:983` — with the comment `# assumes offset and local dimension have same name` |
+| compiled | shift | **N2 `foast.Name.id`** | `ffront/foast_to_gtir.py:305, 331` |
+| compiled | reduction | N3 `ListType.offset_type.value` | `iterator/transforms/unroll_reduce.py:47` |
+| compiled | sparse field *argument* | N3 `dim.value` | `codegens/gtfn/gtfn_module.py:95`; `dace/lowering/gtir_to_sdfg.py:581` |
+
+Two of these were confirmed by execution against v1.2.2:
+
+```text
+# MyOff = FieldOffset("TAGNAME", ...)              -- tag != variable name
+embedded:  offset_provider={"TAGNAME": conn} -> OK ; {"MyOff": conn}   -> KeyError 'TAGNAME'
+roundtrip: offset_provider={"MyOff": conn}   -> OK ; {"TAGNAME": conn} -> KeyError 'MyOff'
+
+# Off = FieldOffset("Off", source=E, target=(V, Neigh))   -- tag != local dim name
+neighbor_sum(a(Off), axis=Neigh), offset_provider={"Off": conn}
+embedded:  KeyError: "Offset 'Neigh' not found in offset provider."
+```
+
+The first shows embedded and compiled execution key the *same* program on
+*different* strings. The second shows that GridTools/gt4py#1789 ("gtfn with
+offset name != local dimension name"), which lifted the N1 = N3 requirement,
+only did so for the *shift* path under gtfn; its regression test
+(`tests/next_tests/regression_tests/ffront_tests/test_offset_dimensions_names.py`)
+covers exactly `a(Off[1])` on `GTFN_CPU` and nothing else. Reductions and
+sparse arguments still require it.
+
+### The declaration duplicates the type
+
+`FieldOffset(value, source=S, target=(T, L))` carries *exactly* the
+information in `NeighborConnectivityType(domain=(T, L), codomain=S)` plus a
+name — with inverted vocabulary (`FieldOffset.source` is the connectivity's
+**codomain**; `target` is its **domain**) and no cross-check between the two.
+Three of the identity constraints in the catalogue exist purely to keep this
+duplicate in sync, and none is validated eagerly: a mismatch surfaces as a
+`KeyError`, a bare `assert`, or — per the #1789 test docstring — silently
+wrong results.
+
+### The Cartesian path already solved this
+
+`field(IDim + 1)` builds a `CartesianConnectivity` (`common.py:1241`) and
+lowers to `itir.CartesianOffset(domain: AxisLiteral, codomain: AxisLiteral)`
+(`iterator/ir.py:99-101`): the IR node carries **dimensions**. No tag, no
+provider entry, no lookup. Unstructured shifts still lower to
+`itir.OffsetLiteral(value: str)` and a dict lookup. Every constraint above
+lives on the unstructured side only, and the reason is not conceptual — it is
+that the neighbor *table* has to be supplied at run time, and a string was
+the easiest key.
+
+### Concept count
+
+The appendix inventories the vocabulary: **~25 distinct concepts** across 10
+layers (5 type-system representations of "an offset", 4 IR node kinds, 8
+runtime connectivity classes, 4 provider aliases, 2 declaration classes) for
+what is one idea — *a mapping between two index spaces, plus a name for it*.
+
+## Proposal
+
+### Five concepts
+
+| Concept | Role | Replaces |
+| --- | --- | --- |
+| `DimensionBaseIndex` | root of all dimension types; `value` is the index position | the `DimensionBase` root [[shared/dimensions-as-types|dimensions as types]] deferred |
+| `DimensionIndex` | user-declarable primary dimension (as in #2844) | `Dimension` instances |
+| `LocalDimensionIndex` | a local dimension; always **owned** by a connectivity; carries `max_neighbors` / `min_neighbors` | `Dimension(..., kind=LOCAL)` + `NeighborConnectivityType.max_neighbors` / `skip_value` |
+| `NeighborConnectivity[Origin, Codomain]` | the connectivity **class**: type, shift handle and provider key in one object; contains its `Local` | `FieldOffset`, `runtime.Offset`, `ts.OffsetType`, the `V2EDim` convention |
+| `MultiDimensionIndex[D, *Ls]` | position in the product of a primary and one or more local dimensions | untyped position dicts keyed by name strings |
+
+`Connectivity` (the runtime protocol), `CartesianConnectivity`,
+`NeighborTable` / `NdArrayConnectivityField` (the data) and
+`NeighborConnectivityType` (the compile-time record) all **stay**. What
+changes is that the compile-time record is *produced by* the class instead
+of being authored in parallel with it.
+
+### Sketch
+
+```python
+# ── dimensions ─────────────────────────────────────────────────────────────
+class DimensionMeta(type):
+    @property
+    def tag(cls) -> Tag:                       # identity, and the IR spelling
+        return f"{cls.__module__}.{cls.__qualname__}"
+    kind: DimensionKind
+    # __eq__/__hash__: default type identity. No registry, no copyreg.
+
+
+class DimensionBaseIndex[T](metaclass=DimensionMeta):
+    value: T
+
+
+class DimensionIndex(DimensionBaseIndex[int]): ...                  # user-declarable
+
+
+class LocalDimensionIndex(DimensionBaseIndex[int]):
+    kind = DimensionKind.LOCAL
+    owner: ClassVar[type[NeighborConnectivity]]
+    max_neighbors: ClassVar[int]
+    min_neighbors: ClassVar[int]           # min == max  <=>  no skip values
+
+
+class MultiDimensionIndex[D: DimensionIndex, *Ls](DimensionBaseIndex[tuple[D, *Ls]]):
+    """Position in the product of a primary dimension and its local dimensions."""
+    value: tuple[D, *Ls]                   # *Ls checked at runtime to be LocalDimensionIndex
+
+
+class Staggered[D: DimensionIndex](DimensionBaseIndex[int]): ...    # replaces the _Staggered prefix
+
+
+# ── connectivities ─────────────────────────────────────────────────────────
+class Connectivity[Src, Dst]: ...                                    # Protocol, as today
+
+class CartesianConnectivity[D: DimensionIndex](Connectivity[D, D]): ...   # unchanged
+
+
+class NeighborConnectivity[Origin: DimensionIndex, Codomain: DimensionIndex](
+    Connectivity[MultiDimensionIndex[Origin, "Local"], Codomain],
+    metaclass=ConnectivityMeta,
+):
+    Local: ClassVar[type[LocalDimensionIndex]]   # generated in __init_subclass__ unless declared
+
+    def __init_subclass__(cls, *, max_neighbors: int, min_neighbors: int | None = None): ...
+    # ConnectivityMeta provides: tag (qualified name), __gt_type__() -> NeighborConnectivityType,
+    # __getitem__ so that V2E[1] is a single-neighbor Connectivity, default type identity.
+
+
+# ── user code ──────────────────────────────────────────────────────────────
+class V(DimensionIndex): ...
+class E(DimensionIndex): ...
+class V2E(NeighborConnectivity[V, E], max_neighbors=6): ...         # V2E.Local generated
+
+
+@field_operator
+def op(a: Field[Dims[E], float]) -> Field[Dims[V], float]:
+    return neighbor_sum(a(V2E), axis=V2E.Local)                      # local axis stays explicit
+
+
+program(a, out=out, offset_provider={V2E: v2e_table})
+```
+
+Vocabulary: `Origin` is the dimension the remapped field lives on
+(`conn.domain[0]`), `Codomain` is what the table entries point into
+(`conn.codomain`) — the terms of ADR 0019 and of
+[[personal/havogt/dependent-local-dimensions|dependent local dimensions]] §3,
+chosen precisely because `FieldOffset.source`/`target` obscure direction.
+
+### Identity is the qualified Python name
+
+A dimension's or connectivity's identity is the Python type; its tag is
+`f"{cls.__module__}.{cls.__qualname__}"`. The static view (checkers see
+nominal types) and the runtime view (equality is `is`) agree by
+construction, and the tag is a valid, unique IR string. This is a deliberate
+departure from [[shared/dimensions-as-types|dimensions as types]] and #2844,
+which chose `(name, kind)` value equality plus an interning registry so that
+the test tree's many independently declared `IDim`s stay interchangeable.
+The position taken here: *existing tests that redeclare dummy dimensions can
+be fixed in other ways; they should not constrain the design of the
+concepts.* The consequences, stated as rules:
+
+1. **Reconstruction from the IR is an import.** `dimension(tag, kind)` is
+   replaced by `resolve(tag)`: `importlib.import_module(module)` then walk
+   the `qualname` (nested classes like `V2E.Local` resolve naturally). The
+   IR references a Python type exactly the way `pickle` references a class.
+   `AxisLiteral.kind` becomes redundant, which the `TODO` at
+   `iterator/ir.py:93` has wanted since the beginning.
+2. **Types reaching the IR must be importable.** Enforced at class creation:
+
+   ```python
+   def __init_subclass__(cls, **kw):
+       if "<locals>" in cls.__qualname__:
+           raise TypeError(f"'{cls.__qualname__}' must be declared at module level.")
+   ```
+
+   A class declared in `__main__` resolves in-process but not in the
+   `spawn`-based compile workers of `otf/runners.py`, where `__main__` is a
+   different module — the same restriction stdlib pickle has, for the same
+   reason. Documented limitation, not fixed.
+3. **No registry, no `copyreg`.** Classes pickle by reference, which is
+   correct for module-level types; #2844's `copyreg.pickle(DimensionMeta, ...)`
+   and `_DIMENSION_REGISTRY` are removed again.
+4. **Cache fingerprints depend on module paths.** ADR 0023's deconstructor
+   keyed dimensions on `(tag, kind)` *specifically so that* a dimension was
+   not fingerprinted by qualified name. Under type identity it is, by
+   definition; renaming a module invalidates compiled artifacts. Correct for
+   this model, and a recorded reversal.
+5. **Codegen names need injective mangling.** `generated::<tag>_t` (gtfn) and
+   DaCe symbols cannot contain dots. One shared `codegen_name(tag)`, injective
+   (escape existing `__` before replacing `.`), used by both backends; gtfn's
+   existing `TagDefinition.alias` mechanism can shorten where needed.
+6. **Staggering comes into scope.** `flip_staggered` builds
+   `Dimension(f"_Staggered{name}")` from a string (`common.py:1452-1457`).
+   There is no such type to import, so ADR 0026's prefix cannot survive
+   type identity; `Staggered[D]` becomes a real parametrized dimension type.
+   This is the `DimensionBase` extension point named in
+   [[shared/dimensions-as-types|dimensions as types]], now with a concrete
+   requirement.
+
+### Binding model
+
+The connectivity *type* conceptually depends on the *table*: two different
+tables assign different neighbors to the same origin element. The model:
+
+- The class `V2E` is a **type constructor**. Its static part — `Origin`,
+  `Codomain`, `Local`, `max_neighbors`, `min_neighbors` — is what compilation
+  sees, and `NeighborConnectivityType` is derived from it. **Static only**:
+  `max_neighbors` is declared on the class, not inferred from data.
+- A **bound connectivity** is the class plus a table. Within one program
+  invocation there is exactly one table per class, so every occurrence of
+  `V2E` in that invocation denotes the same mapping. The provider
+  `{V2E: table}` *is* the binding, and a dict makes one-table-per-class
+  structural.
+- The table is validated against the static part **once, at bind time**:
+  shape `(n, max_neighbors)`, integral dtype, skip values present iff
+  `min_neighbors < max_neighbors`. This one check replaces the whole
+  declaration-vs-provider family of constraints (A6–A8 in the appendix).
+- The class never holds data. `_ConnectivityFileRef` and the compile cache
+  (ADR 0023) keep working unchanged: the type part is fingerprinted by
+  qualified name, the table crosses process boundaries as it does today.
+
+### The local dimension
+
+- `V2E.Local` is **generated** in `__init_subclass__` unless the user declares
+  a nested `class Local(LocalDimensionIndex): ...` — the explicit form gives a
+  *statically* distinct type when a signature needs one; the generated form
+  is annotated `type[LocalDimensionIndex]` on the base and covers everything
+  else. Its tag is `<owner tag>.Local`, unique by construction.
+- `max_neighbors` / `min_neighbors` are class keywords, exactly as #2844 does
+  `kind`. They are *not* type parameters: Python has no integer-valued type
+  parameters, and nothing static needs the count — what must be in the type
+  is *which* local dimension.
+- `_CONST_DIM` (`iterator/embedded.py:220`) becomes a real
+  `LocalDimensionIndex` with no owner and `max_neighbors = 1`, replacing a
+  magic name that is special-cased at seven lookup sites today.
+- `neighbor_sum(..., axis=V2E.Local)` — the local axis stays **explicit**.
+  `axis=V2E` as sugar is deliberately not offered; it would blur the two
+  concepts the design separates.
+
+### `MultiDimensionIndex`
+
+Included so the final picture is complete, even though it is the last piece
+to implement and nothing else depends on it:
+
+- It is the **index type of a sparse-field position**. `V2E.Local(2)` alone
+  cannot address an element; `(V(3), V2E.Local(2))` can. Today that pair is a
+  dict keyed by dimension-name strings (`iterator/embedded.py:597-616`).
+- It is the **domain index of a `NeighborConnectivity`**, which is what makes
+  `Connectivity[MultiDimensionIndex[Origin, Local], Codomain]` a real
+  index-to-index function type.
+- `*Ls` is unconstrained because `TypeVarTuple` cannot carry a bound; a
+  runtime check in `__init_subclass__` covers what the checker cannot.
+
+### Effect per layer
+
+| Layer | Today | Under the proposal |
+| --- | --- | --- |
+| Frontend declaration | `Dimension(LOCAL)` + `FieldOffset` + provider key | one class |
+| Frontend types | `ts.OffsetType(source, target)`, tag dropped | `ConnectivityType`, produced by the class (`TODO` at `type_specifications.py:74`) |
+| FOAST → GTIR | shift tag = **Python variable name** (`foast_to_gtir.py:305, 331`) | tag = `cls.tag`; the variable name is irrelevant |
+| ITIR | `OffsetLiteral(str)` + dict lookup | node carries the local dim's tag, resolved by import — the `CartesianOffset` pattern |
+| ITIR types | `ListType.offset_type: Dimension` | unchanged (already the local dim) |
+| Embedded field | `get_offset(provider, axis.value)` | `axis.owner`, bound table from context |
+| Embedded iterator | positions keyed by name strings; `SparseTag` | `MultiDimensionIndex` positions (last step) |
+| gtfn | `dim.value` lookups for sparse args; `TagDefinition` per tag and per `neighbor_dim` | `local_dim.owner`; `codegen_name(tag)` |
+| DaCe | ~10 `offset_type.value` lookups; `Dimension(offset, LOCAL)` synthesized at `gtir_to_sdfg_lambda.py:1155` | `local_dim.owner`; no synthesis |
+| Provider | `Mapping[str, NeighborTable]` | `Mapping[type[NeighborConnectivity], NeighborTable]`; string keys accepted with a warning during deprecation, resolved by import |
+
+### What it deletes
+
+`FieldOffset`; `runtime.Offset` as its base (the `TODO` at
+`fbuiltins.py:467-470`); `ts.OffsetType`; `is_cartesian_offset` and the
+single-target `FieldOffset` form (Cartesian shifts already use `Dimension + int`
+after GridTools/gt4py#2411); the four `OffsetProvider*` aliases in their
+string-keyed form; `dimension(tag, kind)`, the interning registry and the
+`copyreg` hook from #2844; the `_Staggered` prefix and its string sniffing;
+`_CONST_DIM` as a magic name; and the convention that
+`V2EDim = Dimension("V2E", LOCAL)` must sit next to `V2E = FieldOffset("V2E", ...)`.
+
+### Relation to `Local[V2E]`
+
+[[personal/havogt/dependent-local-dimensions|Dependent local dimensions]]
+spells the local dimension `Local[V2E]` (a generic parametrized by the
+connectivity); this proposal spells it `V2E.Local` (a class nested in the
+connectivity). These should be **the same object**: `Local.__class_getitem__`
+can return `V2E.Local`, so both spellings denote one type and the chain
+proposals (`Local[V2E]` pushed onto a hop stack, or `Local[C, P]` with a
+parent) sit on top unchanged. Nesting is preferred for the *declaration* side
+because the local dimension's `max_neighbors`/`min_neighbors` belong to the
+owner, and because the nested form is what makes the tag unique with no
+registry.
+
+## Alternatives considered
+
+**Keep every concept; fix only which string wins.** Emit `FieldOffset.value`
+instead of `foast.Name.id` in `foast_to_gtir`, validate `value == target[-1].value`
+eagerly, extend the #1789 regression test. Two PRs, low risk — and the
+`foast_to_gtir` part is a real bug that should land regardless. But it
+*enforces* the tangle rather than removing it; no concept goes away.
+
+**A declaration object with a derived local dimension, keeping `Dimension`
+instances** (the "Option B" that led here). Same shape as this proposal minus
+static typing and minus type identity: `local_dim.value == name` by
+construction, provider keyed by the declaration object. Superseded by
+building on dimensions-as-types instead: once dimensions are classes, the
+nested-class form is both simpler and statically meaningful.
+
+**`(name, kind)` value equality with an interning registry** (the #2844
+design). Keeps independently declared same-named dimensions interchangeable
+and avoids the importability rule. Rejected here because it decouples the
+Python type's identity from the IR's, needs a registry plus `copyreg` plus a
+custom fingerprint deconstructor to paper over that gap, and cannot give a
+nested `V2E.Local` a unique name without further convention. See conflicts.
+
+**Integer type parameters for `max_neighbors`** (`LocalDimensionIndex[F: int, M: int]`).
+Would need `Literal[6]` type arguments and `Final[F]` over a `TypeVar`;
+checkers gain nothing. Class keywords instead.
+
+**Data on the class** (`data: ConnectivityField | Unbound`). Process-global
+mutable state; tests bind several meshes per process, and the compile cache
+assumes the table travels separately from the type. Binding per call, keyed by
+the class, keeps the invariant structural.
+
+**`axis=V2E` as sugar.** Rejected for now; keep the local axis explicit.
+
+**Bound (data-inferred) `max_neighbors`.** Rejected for now; static only. Can
+be revisited if a generic-mesh consumer needs it, at the cost that such a
+class's `NeighborConnectivityType` is not derivable before binding.
+
+## Open questions / conflicts
+
+**Conflicts, stated explicitly:**
+
+- **[[shared/dimensions-as-types|Dimensions as types]] / #2844 — identity
+  semantics.** That proposal decides `(name, kind)` equality, an interning
+  factory (`Dimension("I") is Dimension("I")`), and a value-based
+  `__reduce__`. This proposal reverses all three in favour of type identity.
+  If accepted, `shared/dimensions-as-types.md` needs a revision and #2844
+  should stop hardening the registry and `copyreg` paths. The test-tree
+  consequence is real: the many function-local dummy dimensions in
+  `tests/next_tests` must move to module level (a larger sweep than #2845).
+- **ADR 0023 (Fingerprinting).** Dimensions become fingerprinted by
+  qualified name. Deliberate; must be recorded.
+- **ADR 0026 (Staggered dimensions).** The `_Staggered` name prefix cannot
+  survive type identity; `Staggered[D]` is required, not optional.
+- **ADR 0019 (Connectivities).** The part naming `FieldOffset` as the
+  frontend identifier is superseded; the `Connectivity` / `NeighborTable` /
+  `ConnectivityType` vocabulary is kept and strengthened.
+- **[[personal/havogt/closure-variable-resolution|Closure variable
+  resolution]].** The N2 leak (Python variable name becoming the IR tag) is a
+  closure-variable-resolution bug in `foast_to_gtir`; that proposal's
+  resolution mechanism should be the vehicle for the fix.
+
+**Open:**
+
+1. **Naming.** `NeighborConnectivity[Origin, Codomain]` vs the sketch's
+   `StaticMultiConnectivity[F, L, T]`; `Local` vs `Dim`; `min_neighbors` vs
+   `has_skip_values`. Converge with
+   [[personal/havogt/dependent-local-dimensions|dependent local dimensions]]
+   before either lands.
+2. **Declared vs generated `Local`.** Is the optional explicit nested class
+   worth its rule surface, or is `type[LocalDimensionIndex]` on the base
+   enough for every real signature?
+3. **`__main__` in spawn workers.** Document, or detect and fall back to
+   in-process compilation with a warning?
+4. **ICON4Py surface.** `gtx.FieldOffset`, `Dimension(..., LOCAL)` and
+   string-keyed providers are all public. The deprecation window will
+   dominate the schedule; the string-key compatibility shim (resolve via
+   import, warn) is what makes it tolerable.
+5. **Duplicate declarations.** With type identity, two modules declaring
+   `class V2E(...)` are two connectivities. Is a warning on same-`__name__`
+   collisions in one program useful, or noise?
+
+## Staging
+
+Each step is landable separately and leaves the tree green.
+
+0. **Fix the N2 leak now, independently.** `foast_to_gtir.py:305, 331` emit
+   the offset's own tag; extend `test_offset_dimensions_names.py` to
+   `neighbor_sum`, embedded and DaCe so A3 is *visible*. This is a bug today.
+1. **#2844 lands**, then the `DimensionBaseIndex` root and type identity
+   (registry and `copyreg` removed, importability rule added,
+   `resolve(tag)` by import). Revision of `shared/dimensions-as-types.md`.
+2. **`NeighborConnectivity` + `LocalDimensionIndex`** in `common`;
+   `FieldOffset` kept as a deprecated alias that constructs one;
+   object-keyed provider accepted alongside string-keyed.
+3. **`ts.OffsetType` → `ConnectivityType`**; drop Cartesian `FieldOffset`.
+4. **Backends** switch from `local_dim.value` lookups to `local_dim.owner`,
+   one file at a time (`gtfn_module.py`, `unroll_reduce.py`, `gtir_to_sdfg*.py`,
+   `nd_array_field.py`, `iterator/embedded.py`). `codegen_name` introduced.
+5. **`Staggered[D]`**, superseding ADR 0026; `_CONST_DIM` as a real type.
+6. **`MultiDimensionIndex`** and typed embedded positions.
+7. **Typing tests** (`typing_tests/test_next.yaml`, pyright): `Field[Dims[V, V2E.Local], float]`,
+   a `TypeVar` bound to `LocalDimensionIndex`, a negative case mixing two
+   connectivities' locals.
+8. **Test-tree migration** as its own PR (`toy_connectivity.py`,
+   `cases_utils.py`, `fvm_nabla_setup.py` are the fixture modules everything
+   imports).
+
+An ADR in gt4py (next in sequence after 0028) should record steps 1–2, since
+they reverse two recorded decisions and change a public-API shape.
+
+## Appendices
+
+- [[personal/egparedes/connectivities-as-types/connectivities-as-types_research|Tag and name constraints — full catalogue]]:
+  the five name spaces; the 10 cross-object identity constraints (A1–A10),
+  9 name-format constraints (F1–F9) and 7 structural constraints (S1–S7),
+  each with `file:line`; per-context tables for embedded, IR, gtfn and DaCe;
+  the complete concept inventory (L0–L9); class-hierarchy and name-flow
+  diagrams; the two executed experiments.
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_research.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_research.md
new file mode 100644
index 0000000..7416314
--- /dev/null
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_research.md
@@ -0,0 +1,560 @@
+---
+title: "Tag and name constraints for FieldOffset, Dimension and offset providers — full catalogue"
+author: egparedes
+tags: [type-system, dimensions, local-dimensions, connectivities, offset-provider, unstructured, embedded, gtir, gtfn, dace, tech-debt]
+created: 2026-09-17
+status: draft
+---
+
+> **Appendix** to [[personal/egparedes/connectivities-as-types/connectivities-as-types|Connectivities as types]].
+> A descriptive catalogue of the *string-identity* assumptions connecting
+> `FieldOffset` tags, `Dimension` names and `offset_provider` keys in
+> `gt4py.next`, across the embedded, IR and backend contexts. It documents the
+> implementation as it is; the proposal it supports is in the main note.
+
+Line references are against gt4py `main` at `b3c53fa7e` (v1.2.2, 2026-09-03);
+paths are relative to `src/gt4py/next/` unless they start with `tests/`.
+
+Related gt4py records:
+[ADR 0019 Connectivities](https://github.com/GridTools/gt4py/blob/main/docs/development/ADRs/next/0019-Connectivities.md),
+[ADR 0026 Staggered Dimensions](https://github.com/GridTools/gt4py/blob/main/docs/development/ADRs/next/0026-Staggered_Dimensions.md),
+[PR #1789](https://github.com/GridTools/gt4py/pull/1789) (the shift-path fix and its regression test).
+
+## 0. The five name spaces
+
+| #      | Name space                                                         | Type                                                 | Defined at                                                 |
+| ------ | ------------------------------------------------------------------ | ---------------------------------------------------- | ---------------------------------------------------------- |
+| **N1** | `FieldOffset.value` — the *offset tag*                             | `str` (from `runtime.Offset.value: Union[int, str]`) | `iterator/runtime.py:36-37`, `ffront/fbuiltins.py:471-472` |
+| **N2** | The **Python closure-variable name** the `FieldOffset` is bound to | `str`                                                | consumed at `ffront/foast_to_gtir.py:305, 331`             |
+| **N3** | `Dimension.value` — the *dimension tag*                            | `str`                                                | `common.py:79-81`                                          |
+| **N4** | `offset_provider` **dict key**                                     | `str`                                                | `common.py:1200-1209`                                      |
+| **N5** | ITIR `OffsetLiteral.value` / `AxisLiteral.value`                   | `str`                                                | `iterator/ir.py:88-96`                                     |
+
+`ts.OffsetType` carries **only** `source`/`target`
+(`type_system/type_specifications.py:73-76`); N1 is discarded at
+`fbuiltins.py:484-485`. That erasure is the root cause of most rows below.
+
+The only validation `FieldOffset` performs on itself is on the *kind*, never on
+any name (`ffront/fbuiltins.py:470-482`):
+
+```python
+class FieldOffset(runtime.Offset):  # .value is the tag, inherited from runtime.Offset
+    source: common.Dimension
+    target: tuple[Dimension] | tuple[Dimension, Dimension]
+
+    def __post_init__(self) -> None:
+        if len(self.target) == 2 and self.target[1].kind != common.DimensionKind.LOCAL:
+            raise ValueError("Second dimension in offset must be a local dimension.")
+```
+
+## 1. Concept inventory
+
+Every class and type alias in `src/gt4py/next/` that participates in the
+offset/connectivity vocabulary, grouped by layer.
+
+### L0 — Vocabulary (`common.py`)
+
+| Concept                                           | Where                          | Role                                                                       |
+| ------------------------------------------------- | ------------------------------ | -------------------------------------------------------------------------- |
+| `Tag = str`                                       | `common.py:63`                 | the alias that makes every name space stringly-typed                       |
+| `DimensionKind`                                   | `common.py:66-72`              | `HORIZONTAL` / `VERTICAL` / `LOCAL`                                        |
+| `Dimension`                                       | `common.py:79-81`              | `(value: str, kind)`; `__add__`/`__sub__` build Cartesian shifts           |
+| `UnitRange`, `NamedRange`, `NamedIndex`, `Domain` | `common.py:196, 358, 369, 432` | index-space vocabulary; `Domain.dims` is where local dims appear on fields |
+
+### L1 — Connectivity objects (runtime data)
+
+| Concept                       | Where                         | Role                                                                |
+| ----------------------------- | ----------------------------- | ------------------------------------------------------------------- |
+| `Connectivity`                | `common.py:990`               | `Protocol`; a `Field` of indices with a `codomain`                  |
+| `GatherConnectivity`          | `common.py:1099`              | nominal (not a `Protocol`): `premap` is a data-moving gather        |
+| `NeighborTable`               | `common.py:1149`              | `Protocol`; 2-D table-backed neighbor connectivity                  |
+| `NdArrayConnectivityField`    | `nd_array_field.py:516`       | the concrete implementation                                         |
+| `NumPyArrayConnectivityField` | `nd_array_field.py:1032`      | array-library variant                                               |
+| `CuPyArrayConnectivityField`  | `nd_array_field.py:1049`      | array-library variant                                               |
+| `JaxArrayConnectivityField`   | `nd_array_field.py:1087`      | array-library variant                                               |
+| `CartesianConnectivity`       | `common.py:1241`              | affine shift; no `ndarray`, **not** a `GatherConnectivity`          |
+| `StridedConnectivityField`    | `iterator/embedded.py:107`    | incomplete; iterator-view only (`TODO(havogt)`)                     |
+| `_ConnectivityFileRef`        | `otf/compilation_tasks.py:50` | lazy pickling stand-in; dumps to `.npy` to cross process boundaries |
+
+Constructors: `constructors.as_connectivity`, plus the `_field` / `_connectivity`
+`singledispatch` pair at `common.py:1121-1146`.
+
+### L2 — Connectivity *types* (compile time)
+
+| Concept                    | Where               | Contents                                                                    |
+| -------------------------- | ------------------- | --------------------------------------------------------------------------- |
+| `ConnectivityType`         | `common.py:964-973` | `domain`, `codomain`, `skip_value`, `dtype`                                 |
+| `NeighborConnectivityType` | `common.py:976-986` | `+ max_neighbors`; `.source_dim == domain[0]`, `.neighbor_dim == domain[1]` |
+
+### L3 — The provider (name to data binding)
+
+| Concept                                                                  | Where                 |
+| ------------------------------------------------------------------------ | --------------------- |
+| `OffsetProvider = Mapping[Tag, NeighborTable]`                           | `common.py:1177`      |
+| `OffsetProviderType = Mapping[Tag, NeighborConnectivityType]`            | `common.py:1178`      |
+| `OffsetProviderElem`, `OffsetProviderTypeElem`                           | `common.py:1172-1173` |
+| `get_offset`, `get_offset_type`, `has_offset`, `offset_provider_to_type` | `common.py:1193-1221` |
+
+### L4 — Frontend declarations
+
+| Concept                            | Where                       | Contents                                       |
+| ---------------------------------- | --------------------------- | ---------------------------------------------- |
+| `runtime.Offset`                   | `iterator/runtime.py:36-37` | `value: int \| str`                            |
+| `FieldOffset(runtime.Offset)`      | `ffront/fbuiltins.py:472`   | `+ source`, `target`                           |
+| `as_offset` builtin                | `ffront/experimental.py:17` | dynamic Cartesian shift from an index field    |
+| `connectivity_for_cartesian_shift` | `common.py:1467`            | builds a `CartesianConnectivity`; needs no tag |
+
+### L5 — Frontend types
+
+| Concept             | Where                          | Note                                                 |
+| ------------------- | ------------------------------ | ---------------------------------------------------- |
+| `ts.OffsetType`     | `type_specifications.py:73-79` | `source`/`target` only — **the tag is dropped here** |
+| `ts.DimensionType`  | `type_specifications.py:55`    | wraps a `Dimension`                                  |
+| `ts.FieldType.dims` | `type_specifications.py:121`   | sparse fields carry the local dim as a list member   |
+
+### L6 — ITIR nodes
+
+| Node                   | Where                   | Carries                                             |
+| ---------------------- | ----------------------- | --------------------------------------------------- |
+| `itir.OffsetLiteral`   | `iterator/ir.py:88-89`  | a bare `str` tag — unstructured                     |
+| `itir.AxisLiteral`     | `iterator/ir.py:92-96`  | `value` + `kind` — a serialized `Dimension`         |
+| `itir.CartesianOffset` | `iterator/ir.py:99-101` | two `AxisLiteral`s — **no tag, no provider lookup** |
+
+### L7 — ITIR types
+
+| Concept                     | Where                                            | Contents                                          |
+| --------------------------- | ------------------------------------------------ | ------------------------------------------------- |
+| `it_ts.OffsetLiteralType`   | `iterator/type_system/type_specifications.py:19` | `value: ScalarType \| str`                        |
+| `it_ts.CartesianOffsetType` | `…:23`                                           | `domain`, `codomain`                              |
+| `it_ts.NamedRangeType`      | `…:15`                                           | `dim`                                             |
+| `it_ts.IteratorType`        | `…:28`                                           | `position_dims`, `defined_dims`                   |
+| `ts.ListType`               | `type_specifications.py:108-118`                 | `element_type` + `offset_type: Dimension \| None` |
+
+`ListType`'s docstring states the frontend/IR split explicitly: *"not used in the
+frontend. The concept is represented as Field with local Dimension."*
+
+### L8 — Embedded iterator runtime
+
+| Concept                            | Where                             | Role                                                      |
+| ---------------------------------- | --------------------------------- | --------------------------------------------------------- |
+| `SparseTag(Tag)`                   | `iterator/embedded.py:102`        | marks a shift into the sparse axis                        |
+| `MDIterator`, `SparseListIterator` | `iterator/embedded.py:~800, 1507` | iterators; the latter holds `list_offset: Tag`            |
+| `_List`, `_ConstList`              | `iterator/embedded.py:1399, 1420` | neighbor-list values                                      |
+| `_CONST_DIM`                       | `iterator/embedded.py:220`        | reserved LOCAL dim, deliberately absent from the provider |
+| position dicts                     | `iterator/embedded.py:597-616`    | keyed by `Dimension.value` strings                        |
+
+### L9 — Backend representations
+
+| Concept                                     | Where                                       | Role                                                  |
+| ------------------------------------------- | ------------------------------------------- | ----------------------------------------------------- |
+| `gtfn_ir.OffsetLiteral`                     | `gtfn/gtfn_ir.py:52`                        | lowered tag                                           |
+| `gtfn_ir.TagDefinition`                     | `gtfn/gtfn_ir.py:249-251`                   | `name`, optional `alias`; emits `generated::<name>_t` |
+| `gtfn_ir.UnstructuredDomain.connectivities` | `gtfn/gtfn_ir.py:90-93`                     | `SymRef` to an offset declaration                     |
+| `gtfn_ir.TaggedValues`                      | `gtfn/gtfn_ir.py:80-82`                     | tag-keyed sizes/offsets                               |
+| `dace FieldopData`                          | `dace/lowering/gtir_to_sdfg_types.py:27-34` | carries the local-dim/offset-provider association     |
+| `dace connectivity_identifier`              | `dace/sdfg_args.py:56-70`                   | `gt_conn_<key>` array naming                          |
+
+### Concept count
+
+| Kind                                       | Count | Notes                                                                                                                  |
+| ------------------------------------------ | ----- | ---------------------------------------------------------------------------------------------------------------------- |
+| Runtime connectivity classes               | 8     | 3 are array-library variants of one; 1 is incomplete                                                                   |
+| Connectivity type classes                  | 2     |                                                                                                                        |
+| Declaration classes                        | 2     | the subclassing is flagged as a conceptual mismatch at `fbuiltins.py:467`                                              |
+| Type-system representations of "an offset" | 5     | `ts.OffsetType`, `it_ts.OffsetLiteralType`, `it_ts.CartesianOffsetType`, `ts.ListType.offset_type`, `ts.DimensionType` |
+| IR node kinds                              | 4     | 3 ITIR + 1 GTFN                                                                                                        |
+| Provider aliases                           | 4     |                                                                                                                        |
+
+Roughly **25 distinct concepts** for what is conceptually one thing — a mapping
+between two index spaces — plus a name for it.
+
+## 2. How the concepts relate
+
+### 2.1 Connectivity class hierarchy
+
+```text
+Field (Protocol)
+└── Connectivity (Protocol)                              common.py:990
+    ├── GatherConnectivity   <- nominal, gather premap   common.py:1099
+    │   └── NeighborTable (Protocol, 2-D, table-backed)  common.py:1149
+    │       └── NdArrayConnectivityField                 nd_array_field.py:516
+    │           ├── NumPyArrayConnectivityField          nd_array_field.py:1032
+    │           ├── CuPyArrayConnectivityField           nd_array_field.py:1049
+    │           └── JaxArrayConnectivityField            nd_array_field.py:1087
+    ├── CartesianConnectivity  <- affine, no ndarray     common.py:1241
+    └── StridedConnectivityField  <- WIP, iterator only  iterator/embedded.py:107
+```
+
+```mermaid
+classDiagram
+    class Field {
+        <<Protocol>>
+    }
+    class Connectivity {
+        <<Protocol>>
+        +codomain: Dimension
+        +__gt_type__() ConnectivityType
+    }
+    class GatherConnectivity {
+        +ndarray
+    }
+    class NeighborTable {
+        <<Protocol>>
+        +__gt_type__() NeighborConnectivityType
+    }
+    class CartesianConnectivity {
+        +domain_dim
+        +offset: int
+    }
+    class StridedConnectivityField
+    class ConnectivityType {
+        +domain: tuple~Dimension~
+        +codomain: Dimension
+        +skip_value
+        +dtype
+    }
+    class NeighborConnectivityType {
+        +max_neighbors: int
+        +source_dim
+        +neighbor_dim
+    }
+    Field <|-- Connectivity
+    Connectivity <|-- GatherConnectivity
+    Connectivity <|-- CartesianConnectivity
+    Connectivity <|-- StridedConnectivityField
+    GatherConnectivity <|-- NeighborTable
+    NeighborTable <|-- NdArrayConnectivityField
+    NdArrayConnectivityField <|-- NumPyArrayConnectivityField
+    NdArrayConnectivityField <|-- CuPyArrayConnectivityField
+    NdArrayConnectivityField <|-- JaxArrayConnectivityField
+    ConnectivityType <|-- NeighborConnectivityType
+    Connectivity ..> ConnectivityType : __gt_type__()
+    NeighborTable ..> NeighborConnectivityType : __gt_type__()
+```
+
+### 2.2 Declaration vs type vs data — the duplicated triple
+
+`FieldOffset` carries exactly the information in `NeighborConnectivityType` plus
+a name, with **inverted vocabulary** and no cross-check. `FieldOffset.source` is
+the connectivity's *codomain*; `FieldOffset.target` is its *domain*. The
+inversion is because `source`/`target` describe the *field remap* (the field
+lives on `source` and ends up on `target`), while `domain`/`codomain` describe
+the *table*.
+
+```text
+  DECLARATION                TYPE                          DATA
+  ───────────                ────                          ────
+  FieldOffset                ts.OffsetType                 (none — bound later)
+   .value    ─── dropped ──X
+   .target[0] ═══════════════ .target[0] ═══ A8 ═══════════ ConnectivityType.domain[0]
+   .target[1] ═══════════════ .target[1] ═══ A6 ═══════════ ConnectivityType.domain[1]
+   .source    ═══════════════ .source    ═══ A7 ═══════════ ConnectivityType.codomain
+                                                            ^^^^^^^^^^^^^^^^^^^^^^^^^
+                                            the same information, authored twice,
+                                            with inverted vocabulary, never cross-checked
+```
+
+### 2.3 Name flow — where the five name spaces diverge
+
+Four independently-authored strings converge on one dict lookup, and *which* of
+them arrives there depends on the execution path and the operation.
+
+```text
+                    ┌──────────────────────────────────────────────────┐
+                    │  V2EDim = Dimension("V2E", LOCAL)          (N3)  │
+   USER AUTHORS     │  V2E    = FieldOffset("V2E", Edge,(V,V2EDim))    │
+   FOUR STRINGS     │  ^^^                                       (N2)  │
+                    │           ^^^^^                            (N1)  │
+                    │  offset_provider = {"V2E": table}          (N4)  │
+                    └──────────────────────────────────────────────────┘
+                                        │
+              ┌─────────────────────────┴─────────────────────────┐
+              │                                                   │
+        EMBEDDED PATH                                     COMPILED PATH
+              │                                                   │
+   ┌──────────┴──────────┐                          ┌─────────────┴─────────────┐
+   │ shift               │ reduce                   │ FOAST -> GTIR             │
+   │ fbuiltins.py:494    │ nd_array_field.py:983    │ foast_to_gtir.py:305,331  │
+   │   uses N1           │   uses N3 (axis.value)   │   uses N2 (Name.id) -> N5 │
+   └──────────┬──────────┘                          └─────────────┬─────────────┘
+              │                                                   │
+              │                        ┌──────────────────────────┤
+              │                        │ reduce: unroll_reduce.py:47
+              │                        │   uses N3 (ListType.offset_type.value)
+              │                        │
+              │                        │ sparse arg: gtfn_module.py:95
+              │                        │             gtir_to_sdfg.py:581
+              │                        │   uses N3 (dim.value)
+              │                        │
+              └────────────┬───────────┴─────────────┬────────────┘
+                           v                         v
+              get_offset(offset_provider, <string>)  ==  N4
+                           │
+                           v
+                 NeighborTable / NeighborConnectivityType
+```
+
+```mermaid
+flowchart TD
+    subgraph AUTHORED["User authors four strings"]
+        N3["N3 - Dimension('V2E', LOCAL)"]
+        N1["N1 - FieldOffset.value = 'V2E'"]
+        N2["N2 - python variable name V2E"]
+        N4["N4 - offset_provider key 'V2E'"]
+    end
+
+    N1 --> EshiftE["embedded shift<br/>fbuiltins.py:494"]
+    N3 --> EredE["embedded reduce<br/>nd_array_field.py:983"]
+    N2 --> LOW["FOAST to GTIR<br/>foast_to_gtir.py:305, 331"]
+    LOW --> N5["N5 - itir.OffsetLiteral"]
+    N5 --> CshiftC["compiled shift<br/>type_synthesizer.py:748"]
+    N3 --> CredC["compiled reduce<br/>unroll_reduce.py:47"]
+    N3 --> SPARSE["sparse field argument<br/>gtfn_module.py:95<br/>gtir_to_sdfg.py:581"]
+
+    EshiftE --> GET
+    EredE --> GET
+    CshiftC --> GET
+    CredC --> GET
+    SPARSE --> GET
+    N4 -.->|"must equal the string that arrives"| GET
+
+    GET["get_offset(offset_provider, string)<br/>common.py:1200"]
+    GET --> DATA["NeighborTable / NeighborConnectivityType"]
+```
+
+### 2.4 The contrast that suggests the fix
+
+Cartesian shifts carry **dimensions** in the IR node; unstructured shifts carry
+a **string** that must be resolved against a dict. Every constraint A1-A5 exists
+only on the right-hand side.
+
+```text
+  CARTESIAN (already clean)            UNSTRUCTURED (entangled)
+  ─────────────────────────            ────────────────────────
+  field(IDim + 1)                      field(V2E)
+      │                                    │
+      v                                    v
+  CartesianConnectivity                itir.OffsetLiteral("V2E")   <- a string
+  (common.py:1241)                         │
+      │                                    v
+      v                                get_offset(provider, "V2E")
+  itir.CartesianOffset                     │
+    domain:   AxisLiteral                  v
+    codomain: AxisLiteral              NeighborTable
+  (iterator/ir.py:99)
+      │
+      v
+  NO tag. NO provider entry. NO lookup.
+```
+
+This is the concrete precedent behind any consolidation proposal: the Cartesian
+path already eliminated the string indirection, and the unstructured path
+retains it only because the neighbor table data must be supplied at runtime.
+
+## 3. Master table — cross-name-space identity constraints
+
+| #       | Constraint                                                                   | Embedded (field) | Embedded (iterator) | IR / type system | GTFN             | DaCe         | Enforced?                     | Source                                                                                       |
+| ------- | ---------------------------------------------------------------------------- | ---------------- | ------------------- | ---------------- | ---------------- | ------------ | ----------------------------- | -------------------------------------------------------------------------------------------- |
+| **A1**  | `FieldOffset.value` (N1) == provider key (N4)                                | required         | required            | —                | —                | —            | `KeyError`                    | `fbuiltins.py:494, 508`; `common.py:1207-1208`                                               |
+| **A2**  | Python var name (N2) == provider key (N4)                                    | —                | —                   | required         | required         | required     | silent; `KeyError` at runtime | `foast_to_gtir.py:305, 331`                                                                  |
+| **A3**  | local dim `.value` (N3) == provider key (N4), **reductions**                 | required         | required            | required         | required         | required     | `KeyError`                    | `nd_array_field.py:981-985`; `embedded.py:953, 1517, 1776`; `unroll_reduce.py:43-50, 61-65`  |
+| **A4**  | local dim `.value` (N3) == provider key (N4), **sparse field args**          | —                | —                   | —                | required         | required     | `assert` / `ValueError`       | `gtfn_module.py:88-98`; `gtir_to_sdfg.py:572-585, 838-842`; `gtir_to_sdfg_lambda.py:766-770` |
+| **A5**  | `FieldOffset.value` (N1) == local dim `.value` (N3), **shift path**          | n/a (A1 governs) | n/a                 | **not** required | **not** required | inconsistent | codegen branch handles it     | `itir_to_gtfn_ir.py:181-190`; regression test                                                |
+| **A6**  | `target[-1]` == connectivity `neighbor_dim` (full `Dimension` equality)      | required         | required            | required         | required         | required     | no eager check; index error   | `fbuiltins.py:496`; `common.py:984-986`                                                      |
+| **A7**  | `FieldOffset.source` == connectivity `codomain`                              | required         | required            | required         | required         | required     | `assert` only                 | `embedded.py:596-614`; `type_synthesizer.py:748-758`                                         |
+| **A8**  | `FieldOffset.target[0]` == connectivity `domain[0]` (`source_dim`)           | required         | required            | required         | required         | required     | `assert found`                | `type_synthesizer.py:752-758`; `embedded.py:597-599`                                         |
+| **A9**  | `Dimension.value` (N3) is the key of the embedded **iterator position dict** | —                | required            | —                | —                | —            | `assert ... in pos`           | `embedded.py:574-576, 597-616, 941-950`                                                      |
+| **A10** | `Dimension.value` (N3) round-trips through `AxisLiteral.value` (N5)          | —                | —                   | required         | required         | required     | structural                    | `iterator/ir.py:92-96`; `ir_utils/misc.py:234-235`; `inference.py:463-464`                   |
+
+### Notes on A5
+
+A5 is the only row with history. PR #1789 (`fix[next]: gtfn with offset name != local dimension name`) lifted it for shifts and added the
+`if offset_name != connectivity_type.neighbor_dim.value` branch at
+`itir_to_gtfn_ir.py:185-190`. Its regression test is
+`tests/next_tests/regression_tests/ffront_tests/test_offset_dimensions_names.py`,
+whose docstring gives the motivation:
+
+> If the value of the `NeighborConnectivityType.neighbor_dim` did not match the
+> `FieldOffset` value, gtfn would silently ignore the neighbor index, see
+> <https://github.com/GridTools/gridtools/pull/1814>.
+
+That test covers **only** `a(Off[1])` on `GTFN_CPU`. It does not cover
+`neighbor_sum`, embedded execution, or DaCe. A3 and A4 were never lifted, so a
+mismatch still breaks reductions and sparse arguments.
+
+The DaCe "inconsistent" entry: `gtir_to_sdfg_lambda.py:1155` builds
+`Dimension(offset, LOCAL)` — a local dim named after the *tag* — while
+`type_synthesizer.py:327-329` builds the same `ListType` from
+`conn_type.neighbor_dim`. The two agree only when A5 holds.
+
+## 4. Per-context detail
+
+### 4.1 Embedded — field level (`nd_array_field`, `fbuiltins`)
+
+| Site                                             | Key used          | Constraint                                                                     |
+| ------------------------------------------------ | ----------------- | ------------------------------------------------------------------------------ |
+| `fbuiltins.py:491-498` `FieldOffset.__getitem__` | `self.value` (N1) | A1; then `NamedIndex(self.target[-1], offset)` gives A6                        |
+| `fbuiltins.py:502-520` `as_connectivity_field`   | `self.value` (N1) | A1                                                                             |
+| `nd_array_field.py:981-985` reductions           | `axis.value` (N3) | A3 — carries the comment `# assumes offset and local dimension have same name` |
+| `nd_array_field.py:972-979`                      | —                 | `axis.kind == LOCAL`; at most one local dim per field                          |
+| `nd_array_field.py:317-320` `premap`             | —                 | `FieldOffset` to `Connectivity` via A1                                         |
+
+### 4.2 Embedded — iterator level (`iterator/embedded.py`)
+
+| Site                                    | Key used                                                  | Constraint                        |
+| --------------------------------------- | --------------------------------------------------------- | --------------------------------- |
+| `:596-616` `execute_shift`              | tag (N4), then `source_dim.value` / `codomain.value` (N3) | A7, A8, A9                        |
+| `:566-576` sparse shift                 | tag (N4)                                                  | A3                                |
+| `:941-953` `make_in_iterator`           | `sparse_dimensions[0].value` (N3) used as tag             | A3                                |
+| `:1517-1519` `SparseListIterator.deref` | `self.list_offset` (N3-derived)                           | A3                                |
+| `:1005` `field_setitem`                 | `value.offset.value` used as a **field dim name**         | A3 (tag to N3, reverse direction) |
+| `:1410-1416` `_List.__gt_type__`        | tag, then `neighbor_dim`                                  | correct direction, no assumption  |
+| `:1436-1451` `neighbors`                | `offset.value` (N1)                                       | A1                                |
+| `:1776` `_fieldspec_list_to_value`      | `offset_type.value` (N3)                                  | A3                                |
+
+### 4.3 IR / type system
+
+| Site                                                    | Key used                                        | Constraint                                                                           |
+| ------------------------------------------------------- | ----------------------------------------------- | ------------------------------------------------------------------------------------ |
+| `type_synthesizer.py:326-329` `neighbors`               | `OffsetLiteral.value` (N5), then `neighbor_dim` | A2; local dim taken from provider, **not** from the tag                              |
+| `type_synthesizer.py:740-758` `shift`                   | N5, then `domain[0]`/`codomain`                 | A2, A7, A8 (`assert found`, `assert not found`)                                      |
+| `type_synthesizer.py:433-447` `_canonicalize_nb_fields` | field's LOCAL dim to `ListType.offset_type`     | where N3 enters `ListType` and becomes an A3 key downstream                          |
+| `type_synthesizer.py:546-556` `_resolve_dimensions`     | N5, then `get_offset_type`                      | A2                                                                                   |
+| `unroll_reduce.py:43-50, 61-65`                         | `arg.type.offset_type.value` (N3)               | **A3**                                                                               |
+| `domain_utils.py:205-223`                               | `off.value` (N5)                                | A2                                                                                   |
+| `pass_manager.py:55-63`                                 | `source_dim.value`/`codomain.value` (N3)        | domain sizes keyed by dimension name                                                 |
+| `past_to_itir.py:409-410`                               | —                                               | `ValueError: "common.Dimension '{dim.value}' must not be local."` in program domains |
+| `type_deduction.py:459-464`                             | —                                               | `"Second dimension in offset must be a local dimension."`                            |
+| `type_info.py:637-650, 848-878`                         | —                                               | shift typing via `source`/`target` only; the tag is never consulted                  |
+
+### 4.4 GTFN backend
+
+| Site                                  | Name used                                          | Constraint                                                 |
+| ------------------------------------- | -------------------------------------------------- | ---------------------------------------------------------- |
+| `itir_to_gtfn_ir.py:181-190`          | provider key **and** `neighbor_dim.value`          | the only site that anticipates A5 failing; emits both tags |
+| `itir_to_gtfn_ir.py:191-196`          | `source_dim.value`, `codomain.value`               | must be `HORIZONTAL`, else `NotImplementedError`           |
+| `itir_to_gtfn_ir.py:197-200`          | —                                                  | provider entries must be `NeighborConnectivityType`        |
+| `itir_to_gtfn_ir.py:485-492`          | N5 tags                                            | `o in self.offset_provider_type`                           |
+| `itir_to_gtfn_ir.py:139-148, 166-180` | `dim.value` (N3)                                   | every field dim name becomes a C++ tag                     |
+| `gtfn_module.py:88-98`                | `dim.value` (N3)                                   | **A4**                                                     |
+| `gtfn_module.py:126-136`              | `domain[0].value`, `domain[1].value`, provider key | all three become `generated::<name>_t`                     |
+
+### 4.5 DaCe backend
+
+| Site                                                 | Name used                              | Constraint                                                                                                          |
+| ---------------------------------------------------- | -------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |
+| `gtir_to_sdfg.py:572-585`                            | `local_dim.value` (N3)                 | **A4**, explicit: `ValueError("The provided local dimension {local_dim} does not match any offset provider type.")` |
+| `gtir_to_sdfg.py:838-842`                            | `dim.value` (N3)                       | A4 — array shape from `max_neighbors`                                                                               |
+| `gtir_to_sdfg_lambda.py:766-770`                     | `local_dim.value` (N3)                 | A4                                                                                                                  |
+| `gtir_to_sdfg_lambda.py:1312-1319, 1371, 1443, 1455` | `offset_type.value` (N3)               | A3, plus connectivity array name                                                                                    |
+| `gtir_to_sdfg_lambda.py:1155`                        | tag (N5) to `Dimension(offset, LOCAL)` | reverse of A5; conflicts with `type_synthesizer.py:329`                                                             |
+| `gtir_to_sdfg_lambda.py:1718-1727`                   | `offset_provider_arg.value` (N5)       | genuine tag lookup — correct                                                                                        |
+| `gtir_to_sdfg_primitives.py:324-331`                 | `offset_type.value` (N3)               | A3                                                                                                                  |
+| `gtir_to_sdfg_scan.py:385-389`                       | `offset_type.value` (N3)               | A3                                                                                                                  |
+| `sdfg_args.py:73-93`                                 | field name plus `dim.value`            | dim matched against `source_dim`/`neighbor_dim`, else `ValueError`                                                  |
+
+## 5. Constraints on the *format* of names
+
+| #      | Constraint                                                                                                                              | Source                                                                      |
+| ------ | --------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- |
+| **F1** | `_Staggered` is a **reserved prefix**: any `Dimension` whose `value` starts with it is treated as staggered                             | `common.py:1444-1464` (`_STAGGERED_PREFIX = "_Staggered"`)                  |
+| **F2** | GTFN aliases every staggered tag to its base tag by string surgery                                                                      | `itir_to_gtfn_ir.py:703`, `_add_staggered_aliases:204-215`                  |
+| **F3** | `_CONST_DIM` is a reserved LOCAL dimension name, deliberately *absent* from the provider and special-cased at every lookup              | `embedded.py:220, 572, 1513, 1768`; `gtir_to_sdfg_lambda.py:62, 1314, 1355` |
+| **F4** | **Dimension names determine memory layout** — `order_dimensions` sorts by `(kind, as_non_staggered(dim).value)`                         | `common.py:1334-1344`                                                       |
+| **F5** | GTFN: every dim name and provider key becomes a C++ type `generated::<name>_t`, so it must be a valid C++ identifier and collision-free | `gtfn_module.py:97, 130-136`                                                |
+| **F6** | GTFN connectivity params: `gt_conn_<key.lower()>`, so keys must not collide **case-insensitively**                                      | `gtfn_module.py:32, 120, 133`                                               |
+| **F7** | DaCe connectivity arrays: `gt_conn_<key>`, recovered by regex `^gt_conn_(\S+)$`                                                         | `sdfg_args.py:24-25, 56-70`                                                 |
+| **F8** | DaCe map variables: `i_<dim>_gtx_<kind>[dim]`; map fusion/splitting transformations **rely on these strings matching**                  | `gtir_to_sdfg_utils.py:44-54`                                               |
+| **F9** | DaCe field symbols: `__<field>_<dim.value>_size/stride`, `_range_symbol_name(field, dim.value)`                                         | `sdfg_args.py:73-82, 119-122`                                               |
+
+## 6. Structural (kind / arity) constraints
+
+| #   | Constraint                                                                | Enforced                             | Source                                                                        |
+| --- | ------------------------------------------------------------------------- | ------------------------------------ | ----------------------------------------------------------------------------- |
+| S1  | `len(target) == 2` implies `target[1].kind == LOCAL`                      | eager `ValueError`                   | `fbuiltins.py:480-482`; also `type_deduction.py:459-462`                      |
+| S2  | A neighbor table's domain is exactly `(HORIZONTAL, LOCAL)`                | `is_neighbor_table` guard            | `common.py:1160-1168`                                                         |
+| S3  | At most one LOCAL dim per field                                           | `ValueError` / `NotImplementedError` | `common.py:1334-1337`; `nd_array_field.py:976-979`; `gtir_to_sdfg.py:586-589` |
+| S4  | Cartesian offset iff `len(target)==1 and source==target[0]` and not LOCAL | predicate                            | `fbuiltins.py:524-529`                                                        |
+| S5  | Non-Cartesian offset or LOCAL dim implies grid type `UNSTRUCTURED`        | `ValueError`                         | `transform_utils.py:60-77`                                                    |
+| S6  | `as_offset` is Cartesian-only                                             | `DSLError`                           | `type_deduction.py:955-965`                                                   |
+| S7  | Program domains must not contain LOCAL dims                               | `ValueError`                         | `past_to_itir.py:409-410`                                                     |
+
+## 7. Observed behaviour
+
+Two properties above were confirmed by running them, not only by reading.
+
+### 7.1 A1 vs A2 — embedded and compiled key on different strings
+
+```python
+MyOff = gtx.FieldOffset("TAGNAME", source=E, target=(V, Neigh))  # tag != variable name
+
+
+@gtx.field_operator
+def foo(a: Field[Dims[E], float]) -> Field[Dims[V], float]:
+    return a(MyOff[1])
+```
+
+```text
+embedded:  offset_provider={"TAGNAME": conn} -> OK ;  {"MyOff":   conn} -> KeyError 'TAGNAME'
+roundtrip: offset_provider={"MyOff":   conn} -> OK ;  {"TAGNAME": conn} -> KeyError 'MyOff'
+```
+
+The compiled path uses the Python variable name because `foast_to_gtir.py:302-306`
+and `:325-331` emit `im.shift(offset_name.id, ...)` / `im.as_fieldop_neighbors(str(offset_name), ...)`
+from the FOAST `Name.id` — never from `FieldOffset.value`. Lowering the operator
+above yields:
+
+```text
+foo = λ(a) → (⇑(λ(__it) → ·⟪MyOffₒ, 1ₒ⟫(__it)))(a);
+```
+
+### 7.2 A3 — reductions still require tag == local dim name
+
+Reusing the deliberately mismatched declaration from the #1789 regression test
+(`Off` tagged `"Off"`, local dim named `"Neigh"`):
+
+```python
+Off = gtx.FieldOffset("Off", source=E, target=(V, Neigh))
+
+
+@gtx.field_operator
+def bar(a: Field[Dims[E], float]) -> Field[Dims[V], float]:
+    return neighbor_sum(a(Off), axis=Neigh)
+```
+
+```text
+embedded:  FAILED: KeyError: "Offset 'Neigh' not found in offset provider."
+roundtrip: OK -> [30. 50. 40.]
+```
+
+`unroll_reduce.py:43-50` has the same assumption for the compiled pipeline
+(established by reading; the roundtrip backend above does not exercise that pass).
+
+## 8. Practical consequence
+
+To be safe across **all** contexts, four strings must be identical:
+
+```text
+FieldOffset.value  ==  <python variable name>  ==  offset_provider key  ==  target[-1].value
+```
+
+plus `target[0] == conn.domain[0]` and `source == conn.codomain` as `Dimension`
+objects (A6-A8). This is exactly what `tests/next_tests/toy_connectivity.py:18-26`
+encodes:
+
+```python
+V2EDim = gtx.Dimension("V2E", kind=gtx.DimensionKind.LOCAL)  # value is "V2E", not "V2EDim"
+V2E = gtx.FieldOffset("V2E", source=Edge, target=(Vertex, V2EDim))
+```
+
+Relaxing any one of the four is currently supported only in the narrow slice
+PR #1789 covered: shift-only, GTFN, no sparse arguments. Nothing validates the
+full set up front — a violation surfaces as a `KeyError` from `common.py:1208`,
+a bare `assert`, or, per the #1789 test docstring, silently wrong results.
+
+Two existing `TODO`s point at this tangle:
+
+- `common.py:976-977` — `NeighborConnectivityType`: *"refactor towards encoding
+  this information in the local dimensions of the `ConnectivityType.domain`"*.
+- `fbuiltins.py:467-470` — *"`FieldOffset` and `runtime.Offset` are not an exact
+  conceptual match. Revisit if we want to continue subclassing here."*

From 8f992214cc17ae4ebb36c60070da2f9959d65f85 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Gonz=C3=A1lez=20Paredes?= <enriqueg@cscs.ch>
Date: Thu, 17 Sep 2026 14:38:39 +0200
Subject: [PATCH 2/3] connectivities-as-types: address review pass 1 (factual
 and framing fixes)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

No design changes. Fixes from an adversarial review of the proposal:

- Keep the Cartesian FieldOffset form: as_offset() requires it (5 test
  modules, Ioff/Koff/EdgeOffset fixtures, ICON4Py diffusion/dycore).
- Attribute the (tag, kind) fingerprint deconstructor to #2844/ADR 0028,
  not ADR 0023; ADR 0023 is a consequence, not a reversed decision.
- Correct the __main__/spawn claim: file scripts resolve via __mp_main__;
  the limitation is interactive __main__ (REPL, notebooks, python -c).
- "<locals>" check described as a heuristic; pickle's save_global is the
  real check. Note Staggered[D] tags need a grammar for resolve().
- "Cartesian already solved this" narrowed: no *separate* tag and no
  provider lookup; dimension names still cross gtfn/DaCe as strings.
- Hedge the reduction claim in the main note to match what was run
  (embedded fails, roundtrip passes, gtfn by reading).
- Add the roundtrip backend as a source-emitting consumer of dimension
  names; add the compat name-table caveat for string-keyed providers.
- Present both sides of the conflict with shared/dimensions-as-types
  (46 "I" declarations, downstream == reliance, first-declaration-wins;
  and the typing subscription-cache aliasing that type identity removes).
- Link mesh-and-first-class-halos and dimension-generic-fields; fix the
  dependent-local-dimensions citation (shared core is §6, U0/U1 are §9)
  and list the U0/U1 divergences.
- Account for "seven of ten": A1-A5 dissolve, A6-A8 become one bind-time
  check. New open question on what an instance of V2E is.
- Line-reference nits (common.py:62/1176/1177, fbuiltins.py:509,
  gtfn_module.py:118/132), _CONST_DIM has 12 use sites, concept-count
  row clarified, add type-checking tag (index keywords synced).

Deferred to a second pass (design decisions): V2E.Local is not usable in
annotations and Local[V2E] reconciliation is runtime-only (B1); the
string-key shim needs a registry (B2); owner-less local dims such as
ICON4Py's LsqUnkDim (B4); static-only max_neighbors vs generic meshes (S8).
---
 content/index.md                              |   2 +-
 .../connectivities-as-types.md                | 180 +++++++++++++-----
 .../connectivities-as-types_research.md       |  14 +-
 3 files changed, 137 insertions(+), 59 deletions(-)

diff --git a/content/index.md b/content/index.md
index 61ddbc5..5e7a122 100644
--- a/content/index.md
+++ b/content/index.md
@@ -44,7 +44,7 @@ Work-in-progress proposals, organized by contributor.
 
 - [[personal/egparedes/layered-architecture|A layered architecture for gt4py with enforced public/internal decoupling]] — keywords: architecture, layering, tach, modularity, public-api, semi-public, internal, packaging, dependencies, refactoring, infrastructure, over-engineering, otf, workflow, dsl, config, allocators, caching, fingerprint, compiled-program, process-pool, factory-boy, instrumentation, adr, jax, decoupling, migration, tech-debt
 - [[personal/egparedes/otf-toolchain-split|Dissolving gt4py.next.otf into a toolchain core and DSL-agnostic build infrastructure]] — keywords: otf, toolchain, workflow, pipeline, refactoring, architecture, layering, modularity, backend, bindings, build-system, caching, runners, compiled-program, factory-boy, naming, observability, stage-inspection, adr, tach, tech-debt
-- [[personal/egparedes/connectivities-as-types/connectivities-as-types|Connectivities as types: one declaration for offset, local dimension and provider key]] — keywords: type-system, dimensions, local-dimensions, connectivities, offset-provider, unstructured, neighbor-sum, reduction, frontend, foast, gtir, embedded, gtfn, dace, nominal-types, metaclass, serialization, fingerprint, staggering, migration, adr, tech-debt
+- [[personal/egparedes/connectivities-as-types/connectivities-as-types|Connectivities as types: one declaration for offset, local dimension and provider key]] — keywords: type-system, type-checking, dimensions, local-dimensions, connectivities, offset-provider, unstructured, neighbor-sum, reduction, frontend, foast, gtir, embedded, gtfn, dace, nominal-types, metaclass, serialization, fingerprint, staggering, migration, adr, tech-debt
 - [[personal/egparedes/discretization-independent-fd-syntax|A discretization-independent surface syntax for finite-difference computations]] — keywords: finite-difference, finite-volume, mesh-invariant, structured, unstructured, exterior-calculus, dec, mimetic, de-rham, location-typing, stencil, weight-generation, rbf-fd, gfdm, moment-matching, conservation, field-operators, icon, pace, pmap, fv3, ifs-fvm, arakawa-staggering, c-grid, d-grid, a-grid, dynamical-core, hevi, vertical-solve, elliptic-solve, mpdata, semi-implicit, miura, atlas, prior-art, dsl-design
 
 <!-- Entry format (index only the main proposal; link appendices/implementations
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
index 2720594..3fa369a 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
@@ -1,7 +1,7 @@
 ---
 title: "Connectivities as types: one declaration for offset, local dimension and provider key"
 author: egparedes
-tags: [type-system, dimensions, local-dimensions, connectivities, offset-provider, unstructured, neighbor-sum, reduction, frontend, foast, gtir, embedded, gtfn, dace, nominal-types, metaclass, serialization, fingerprint, staggering, migration, adr, tech-debt]
+tags: [type-system, type-checking, dimensions, local-dimensions, connectivities, offset-provider, unstructured, neighbor-sum, reduction, frontend, foast, gtir, embedded, gtfn, dace, nominal-types, metaclass, serialization, fingerprint, staggering, migration, adr, tech-debt]
 created: 2026-09-17
 status: draft
 ---
@@ -23,8 +23,9 @@ status: draft
 > ```
 >
 > `FieldOffset`, `ts.OffsetType`, the string-keyed `OffsetProvider` and the
-> `V2EDim`-next-to-`V2E` naming convention disappear. Seven of the ten
-> cross-object identity constraints in the current tree become tautologies.
+> `V2EDim`-next-to-`V2E` naming convention disappear. Of the ten cross-object
+> identity constraints in the current tree, five (A1–A5) dissolve by
+> construction and three (A6–A8) collapse into a single bind-time check.
 
 > **Status**: draft, AI-assisted. Derived from a full audit of the gt4py tree
 > at `b3c53fa7e` (v1.2.2, 2026-09-03); every `file:line` reference was
@@ -35,13 +36,21 @@ status: draft
 
 > **Relation to existing proposals.** This is the *single-hop base* that
 > [[personal/havogt/dependent-local-dimensions|Dependent local dimensions and
-> connectivity chains]] §9 calls "the shared core" (stages U0/U1): one typed
-> connectivity declaration, derived local dimension, derived offset tag. It
-> takes no position on chains, reduction order or the path-vs-forest choice.
-> It builds on [[shared/dimensions-as-types|Dimensions as types]] and its
-> implementation in GridTools/gt4py#2844, and **conflicts with one of that
-> proposal's decisions** (identity semantics) — see
-> [Open questions / conflicts](#open-questions--conflicts).
+> connectivity chains]] §6 calls "the shared core" and §9 stages as U0/U1: one
+> typed connectivity declaration, derived local dimension, derived offset tag.
+> It takes no position on chains, reduction order or the path-vs-forest
+> choice, but it does diverge from that proposal's U0/U1 in two places
+> (`min_neighbors` instead of `has_skip_values`; a nested `V2E.Local` instead
+> of a generic `Local[C]`) — see [Open questions / conflicts](#open-questions--conflicts).
+> The remap typing it needs is the `Connectivity[NewD, D0]` rule of
+> [[personal/havogt/dimension-generic-fields|Generic dimensions and statically
+> typed staggering]]. It builds on [[shared/dimensions-as-types|Dimensions as
+> types]] and its implementation in GridTools/gt4py#2844, and **conflicts with
+> one of that proposal's decisions** (identity semantics). It also overlaps
+> with [[personal/havogt/mesh-and-first-class-halos|A mesh concept with
+> first-class halos]], which proposes replacing the same `offset_provider`
+> dict with a Mesh object; this note re-types the dict and should be read as
+> the typed substrate that proposal can bind through.
 
 ## Problem / motivation
 
@@ -88,8 +97,11 @@ The first shows embedded and compiled execution key the *same* program on
 offset name != local dimension name"), which lifted the N1 = N3 requirement,
 only did so for the *shift* path under gtfn; its regression test
 (`tests/next_tests/regression_tests/ffront_tests/test_offset_dimensions_names.py`)
-covers exactly `a(Off[1])` on `GTFN_CPU` and nothing else. Reductions and
-sparse arguments still require it.
+covers exactly `a(Off[1])` on `GTFN_CPU` and nothing else. The embedded
+reduction still requires it (run); the roundtrip backend *passes* the same
+program, and the compiled gtfn pipeline is expected to fail through
+`unroll_reduce.py:47` — established by reading, not run. Sparse field
+arguments require it in both gtfn and DaCe (by reading).
 
 ### The declaration duplicates the type
 
@@ -106,9 +118,13 @@ wrong results.
 
 `field(IDim + 1)` builds a `CartesianConnectivity` (`common.py:1241`) and
 lowers to `itir.CartesianOffset(domain: AxisLiteral, codomain: AxisLiteral)`
-(`iterator/ir.py:99-101`): the IR node carries **dimensions**. No tag, no
-provider entry, no lookup. Unstructured shifts still lower to
-`itir.OffsetLiteral(value: str)` and a dict lookup. Every constraint above
+(`iterator/ir.py:99-101`): the IR node carries the two **dimensions**. There
+is no *separate* offset tag and no provider lookup. Dimension *names* still
+cross gtfn and DaCe as strings (`AxisLiteral.value`, `TagDefinition`,
+`i_<dim>_gtx_<kind>` map variables), so the format constraints F5/F8/F9 apply
+to both paths; the identity constraints A1–A5 apply to the unstructured path
+only. Unstructured shifts still lower to `itir.OffsetLiteral(value: str)` and
+a dict lookup. Every constraint above
 lives on the unstructured side only, and the reason is not conceptual — it is
 that the neighbor *table* has to be supplied at run time, and a string was
 the easiest key.
@@ -173,9 +189,9 @@ class Staggered[D: DimensionIndex](DimensionBaseIndex[int]): ...    # replaces t
 
 
 # ── connectivities ─────────────────────────────────────────────────────────
-class Connectivity[Src, Dst]: ...                                    # Protocol, as today
+class Connectivity[Src, Dst]: ...   # Protocol; parametrization changes, see Open Q6
 
-class CartesianConnectivity[D: DimensionIndex](Connectivity[D, D]): ...   # unchanged
+class CartesianConnectivity[D: DimensionIndex](Connectivity[D, D]): ...   # semantics unchanged
 
 
 class NeighborConnectivity[Origin: DimensionIndex, Codomain: DimensionIndex](
@@ -227,8 +243,13 @@ concepts.* The consequences, stated as rules:
    the `qualname` (nested classes like `V2E.Local` resolve naturally). The
    IR references a Python type exactly the way `pickle` references a class.
    `AxisLiteral.kind` becomes redundant, which the `TODO` at
-   `iterator/ir.py:93` has wanted since the beginning.
-2. **Types reaching the IR must be importable.** Enforced at class creation:
+   `iterator/ir.py:93` has wanted since the beginning. Parametrized types
+   (`Staggered[D]`, rule 6) have no importable `qualname`; their tag needs a
+   small grammar (`<qualname>[<tag>]`) and `resolve` must parse it and
+   materialize the class — the one place where "resolution is an import"
+   is not literally true.
+2. **Types reaching the IR must be importable.** An early heuristic at class
+   creation catches the common mistake:
 
    ```python
    def __init_subclass__(cls, **kw):
@@ -236,18 +257,26 @@ concepts.* The consequences, stated as rules:
            raise TypeError(f"'{cls.__qualname__}' must be declared at module level.")
    ```
 
-   A class declared in `__main__` resolves in-process but not in the
-   `spawn`-based compile workers of `otf/runners.py`, where `__main__` is a
-   different module — the same restriction stdlib pickle has, for the same
-   reason. Documented limitation, not fixed.
+   It is neither necessary nor sufficient — `type("Dyn", ...)` inside a
+   function passes, a class `del`'d after creation passes — so the
+   authoritative check remains pickle's own `save_global` at pickle time,
+   exactly as for any class. The `spawn`-based compile workers of
+   `otf/runners.py` re-execute the main script as `__mp_main__`, so classes
+   declared in a *file's* `__main__` resolve there (provided the script has
+   an `if __name__ == "__main__":` guard, which the pool already requires).
+   What does not resolve is *interactive* `__main__`: the REPL, notebooks,
+   `python -c`. Documented limitation, not fixed.
 3. **No registry, no `copyreg`.** Classes pickle by reference, which is
    correct for module-level types; #2844's `copyreg.pickle(DimensionMeta, ...)`
-   and `_DIMENSION_REGISTRY` are removed again.
-4. **Cache fingerprints depend on module paths.** ADR 0023's deconstructor
-   keyed dimensions on `(tag, kind)` *specifically so that* a dimension was
-   not fingerprinted by qualified name. Under type identity it is, by
-   definition; renaming a module invalidates compiled artifacts. Correct for
-   this model, and a recorded reversal.
+   and `_DIMENSION_REGISTRY` are removed again — with the caveat in Open Q4
+   that a *compatibility* name table is needed for as long as string-keyed
+   providers are accepted.
+4. **Cache fingerprints depend on module paths.** #2844 adds a
+   `fingerprinting.py` deconstructor keyed on `(tag, kind)` (recorded in
+   ADR 0028) *specifically so that* a dimension is not fingerprinted by
+   qualified name. Under type identity it is, by definition; renaming a
+   module invalidates compiled artifacts (ADR 0023's cache). Correct for
+   this model; a consequence to record, not a reversal of ADR 0023 itself.
 5. **Codegen names need injective mangling.** `generated::<tag>_t` (gtfn) and
    DaCe symbols cannot contain dots. One shared `codegen_name(tag)`, injective
    (escape existing `__` before replacing `.`), used by both backends; gtfn's
@@ -276,8 +305,9 @@ tables assign different neighbors to the same origin element. The model:
   structural.
 - The table is validated against the static part **once, at bind time**:
   shape `(n, max_neighbors)`, integral dtype, skip values present iff
-  `min_neighbors < max_neighbors`. This one check replaces the whole
-  declaration-vs-provider family of constraints (A6–A8 in the appendix).
+  `min_neighbors < max_neighbors`. This one runtime check replaces the whole
+  declaration-vs-provider family of constraints (A6–A8 in the appendix); they
+  do not vanish, they become a single validated invariant.
 - The class never holds data. `_ConnectivityFileRef` and the compile cache
   (ADR 0023) keep working unchanged: the type part is fingerprinted by
   qualified name, the table crosses process boundaries as it does today.
@@ -295,7 +325,8 @@ tables assign different neighbors to the same origin element. The model:
   is *which* local dimension.
 - `_CONST_DIM` (`iterator/embedded.py:220`) becomes a real
   `LocalDimensionIndex` with no owner and `max_neighbors = 1`, replacing a
-  magic name that is special-cased at seven lookup sites today.
+  magic name that is special-cased at twelve use sites today (six in
+  `iterator/embedded.py`, six in the DaCe lowering).
 - `neighbor_sum(..., axis=V2E.Local)` — the local axis stays **explicit**.
   `axis=V2E` as sugar is deliberately not offered; it would blur the two
   concepts the design separates.
@@ -327,19 +358,29 @@ to implement and nothing else depends on it:
 | Embedded iterator | positions keyed by name strings; `SparseTag` | `MultiDimensionIndex` positions (last step) |
 | gtfn | `dim.value` lookups for sparse args; `TagDefinition` per tag and per `neighbor_dim` | `local_dim.owner`; `codegen_name(tag)` |
 | DaCe | ~10 `offset_type.value` lookups; `Dimension(offset, LOCAL)` synthesized at `gtir_to_sdfg_lambda.py:1155` | `local_dim.owner`; no synthesis |
+| roundtrip backend | emits `gtx.Dimension("<name>", kind=...)` / `offset("<tag>")` as *source text* (`runners/roundtrip.py:175-179`) | emits imports of the qualified names, via `codegen_name` for the Python identifier |
 | Provider | `Mapping[str, NeighborTable]` | `Mapping[type[NeighborConnectivity], NeighborTable]`; string keys accepted with a warning during deprecation, resolved by import |
 
 ### What it deletes
 
-`FieldOffset`; `runtime.Offset` as its base (the `TODO` at
-`fbuiltins.py:467-470`); `ts.OffsetType`; `is_cartesian_offset` and the
-single-target `FieldOffset` form (Cartesian shifts already use `Dimension + int`
-after GridTools/gt4py#2411); the four `OffsetProvider*` aliases in their
+`FieldOffset` as the unstructured declaration; `runtime.Offset` as its base
+(the `TODO` at `fbuiltins.py:467-470`); `ts.OffsetType`; the four
+`OffsetProvider*` aliases in their
 string-keyed form; `dimension(tag, kind)`, the interning registry and the
 `copyreg` hook from #2844; the `_Staggered` prefix and its string sniffing;
 `_CONST_DIM` as a magic name; and the convention that
 `V2EDim = Dimension("V2E", LOCAL)` must sit next to `V2E = FieldOffset("V2E", ...)`.
 
+**Not deleted, deliberately:** the single-target (Cartesian) `FieldOffset`
+form. Cartesian *shifts* already use `Dimension + int` (GridTools/gt4py#2411),
+but `as_offset(offset, field)` (`ffront/experimental.py:17`) requires a
+Cartesian `FieldOffset` (`type_deduction.py:956-967`, S6 in the appendix), is
+used in 5 test modules plus the `Ioff`/`Koff`/`EdgeOffset` fixtures in
+`cases_utils.py:163-169`, and ICON4Py calls it in diffusion and the dycore
+(`as_offset(Koff, ...)`, with `offset_provider={"Koff": KDim}`). A Cartesian
+offset handle therefore stays until `as_offset` gets a replacement signature
+(`as_offset(KDim, field)` is the obvious candidate, out of scope here).
+
 ### Relation to `Local[V2E]`
 
 [[personal/havogt/dependent-local-dimensions|Dependent local dimensions]]
@@ -397,13 +438,33 @@ class's `NeighborConnectivityType` is not derivable before binding.
 - **[[shared/dimensions-as-types|Dimensions as types]] / #2844 — identity
   semantics.** That proposal decides `(name, kind)` equality, an interning
   factory (`Dimension("I") is Dimension("I")`), and a value-based
-  `__reduce__`. This proposal reverses all three in favour of type identity.
-  If accepted, `shared/dimensions-as-types.md` needs a revision and #2844
-  should stop hardening the registry and `copyreg` paths. The test-tree
-  consequence is real: the many function-local dummy dimensions in
-  `tests/next_tests` must move to module level (a larger sweep than #2845).
-- **ADR 0023 (Fingerprinting).** Dimensions become fingerprinted by
-  qualified name. Deliberate; must be recorded.
+  `__reduce__`. Its reasons are concrete and should be weighed, not waved
+  away: `tests/next_tests` declares a dimension named `"I"` 46 times and
+  `IDim` in 45 files (its Step 0); ADR 0028 records that nominal identity
+  "changes the meaning of `Dimension("I") == Dimension("I")`, which downstream
+  code relies on"; and its "first declaration wins" residual means
+  `Dimension("I") is <some module's I>` is already *not* guaranteed today.
+  This proposal reverses all three decisions in favour of type identity. One
+  argument in its favour that the shared note itself raises as a known
+  residual: under `(name, kind)` equality the `typing` subscription cache
+  aliases `Field[Dims[I]] is Field[Dims[I2]]` for two distinct same-named
+  classes, so the static and runtime views disagree exactly there; under type
+  identity that aliasing disappears. If accepted, `shared/dimensions-as-types.md`
+  needs a revision and #2844 should stop hardening the registry and `copyreg`
+  paths. The test-tree consequence is real: the many function-local dummy
+  dimensions in `tests/next_tests` must move to module level (a larger sweep
+  than #2845).
+- **ADR 0028 / #2844 (fingerprinting of dimensions).** #2844 adds a
+  `(tag, kind)` fingerprint deconstructor; under type identity dimensions are
+  fingerprinted by qualified name instead, and ADR 0023's cache invalidates
+  on module renames. A consequence to record in the new ADR.
+- **[[personal/havogt/mesh-and-first-class-halos|A mesh concept with
+  first-class halos]].** Proposes replacing the `offset_provider` dict with a
+  Mesh object and keeps `Koff`/`LsqUnkDim` outside it. This note re-types the
+  same dict. The two are compatible if the Mesh binds typed connectivity
+  classes to tables, but that has to be said in one of the two documents,
+  and the multi-table case (halo variants, rewritten `keep_skip_values`
+  tables, several meshes in one process) is addressed by neither yet.
 - **ADR 0026 (Staggered dimensions).** The `_Staggered` name prefix cannot
   survive type identity; `Staggered[D]` is required, not optional.
 - **ADR 0019 (Connectivities).** The part naming `FieldOffset` as the
@@ -417,8 +478,10 @@ class's `NeighborConnectivityType` is not derivable before binding.
 **Open:**
 
 1. **Naming.** `NeighborConnectivity[Origin, Codomain]` vs the sketch's
-   `StaticMultiConnectivity[F, L, T]`; `Local` vs `Dim`; `min_neighbors` vs
-   `has_skip_values`. Converge with
+   `StaticMultiConnectivity[F, L, T]` vs the existing
+   `NeighborConnectivityType.source_dim`/`neighbor_dim` (a third vocabulary
+   this note would otherwise add to the two it criticizes); `Local` vs `Dim`;
+   `min_neighbors` vs `has_skip_values`. Converge with
    [[personal/havogt/dependent-local-dimensions|dependent local dimensions]]
    before either lands.
 2. **Declared vs generated `Local`.** Is the optional explicit nested class
@@ -426,13 +489,25 @@ class's `NeighborConnectivityType` is not derivable before binding.
    enough for every real signature?
 3. **`__main__` in spawn workers.** Document, or detect and fall back to
    in-process compilation with a warning?
-4. **ICON4Py surface.** `gtx.FieldOffset`, `Dimension(..., LOCAL)` and
-   string-keyed providers are all public. The deprecation window will
-   dominate the schedule; the string-key compatibility shim (resolve via
-   import, warn) is what makes it tolerable.
+4. **ICON4Py surface.** `gtx.FieldOffset`, `Dimension(..., LOCAL)`,
+   `as_offset(Koff, ...)` and string-keyed providers (`{"V2E": ..., "Koff": KDim}`)
+   are all public. The deprecation window will dominate the schedule. Note
+   that ICON4Py's keys are *bare* names, so a string-key shim cannot resolve
+   them by import; it needs a name→class table populated at class creation —
+   a registry in all but name, kept for the deprecation window only. The
+   alternative is object keys from day one with a scripted migration.
 5. **Duplicate declarations.** With type identity, two modules declaring
    `class V2E(...)` are two connectivities. Is a warning on same-`__name__`
    collisions in one program useful, or noise?
+6. **What is an instance of `V2E`?** Today `Connectivity` is
+   `Field[DimsT, IntegralScalar]` parametrized by `Dims` plus a codomain
+   (`common.py:990`), and `CartesianConnectivity` is a dataclass with
+   instances. The sketch's `Connectivity[Src, Dst]` is a different
+   parametrization, and `V2E` is a data-less type constructor subclassing a
+   runtime protocol. Either instances of `V2E` are the bound tables (so
+   `{V2E: table}` becomes `V2E(table)`), or `NeighborConnectivity` is not a
+   `Connectivity` subclass at all and only *produces* one at bind time. The
+   sketch leaves this open and should not.
 
 ## Staging
 
@@ -447,10 +522,13 @@ Each step is landable separately and leaves the tree green.
 2. **`NeighborConnectivity` + `LocalDimensionIndex`** in `common`;
    `FieldOffset` kept as a deprecated alias that constructs one;
    object-keyed provider accepted alongside string-keyed.
-3. **`ts.OffsetType` → `ConnectivityType`**; drop Cartesian `FieldOffset`.
+3. **`ts.OffsetType` → `ConnectivityType`**; the Cartesian `FieldOffset`
+   form stays for `as_offset` until that builtin gets a dimension-based
+   signature.
 4. **Backends** switch from `local_dim.value` lookups to `local_dim.owner`,
    one file at a time (`gtfn_module.py`, `unroll_reduce.py`, `gtir_to_sdfg*.py`,
-   `nd_array_field.py`, `iterator/embedded.py`). `codegen_name` introduced.
+   `nd_array_field.py`, `iterator/embedded.py`, and the source-emitting
+   `runners/roundtrip.py`). `codegen_name` introduced.
 5. **`Staggered[D]`**, superseding ADR 0026; `_CONST_DIM` as a real type.
 6. **`MultiDimensionIndex`** and typed embedded positions.
 7. **Typing tests** (`typing_tests/test_next.yaml`, pyright): `Field[Dims[V, V2E.Local], float]`,
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_research.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_research.md
index 7416314..8f3ce11 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_research.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_research.md
@@ -56,7 +56,7 @@ offset/connectivity vocabulary, grouped by layer.
 
 | Concept                                           | Where                          | Role                                                                       |
 | ------------------------------------------------- | ------------------------------ | -------------------------------------------------------------------------- |
-| `Tag = str`                                       | `common.py:63`                 | the alias that makes every name space stringly-typed                       |
+| `Tag = str`                                       | `common.py:62`                 | the alias that makes every name space stringly-typed                       |
 | `DimensionKind`                                   | `common.py:66-72`              | `HORIZONTAL` / `VERTICAL` / `LOCAL`                                        |
 | `Dimension`                                       | `common.py:79-81`              | `(value: str, kind)`; `__add__`/`__sub__` build Cartesian shifts           |
 | `UnitRange`, `NamedRange`, `NamedIndex`, `Domain` | `common.py:196, 358, 369, 432` | index-space vocabulary; `Domain.dims` is where local dims appear on fields |
@@ -90,8 +90,8 @@ Constructors: `constructors.as_connectivity`, plus the `_field` / `_connectivity
 
 | Concept                                                                  | Where                 |
 | ------------------------------------------------------------------------ | --------------------- |
-| `OffsetProvider = Mapping[Tag, NeighborTable]`                           | `common.py:1177`      |
-| `OffsetProviderType = Mapping[Tag, NeighborConnectivityType]`            | `common.py:1178`      |
+| `OffsetProvider = Mapping[Tag, NeighborTable]`                           | `common.py:1176`      |
+| `OffsetProviderType = Mapping[Tag, NeighborConnectivityType]`            | `common.py:1177`      |
 | `OffsetProviderElem`, `OffsetProviderTypeElem`                           | `common.py:1172-1173` |
 | `get_offset`, `get_offset_type`, `has_offset`, `offset_provider_to_type` | `common.py:1193-1221` |
 
@@ -158,7 +158,7 @@ frontend. The concept is represented as Field with local Dimension."*
 
 | Kind                                       | Count | Notes                                                                                                                  |
 | ------------------------------------------ | ----- | ---------------------------------------------------------------------------------------------------------------------- |
-| Runtime connectivity classes               | 8     | 3 are array-library variants of one; 1 is incomplete                                                                   |
+| Runtime connectivity classes               | 8 (+2 `Protocol`s)     | the L1 table has 10 rows: `Connectivity` and `NeighborTable` are protocols; 3 rows are array-library variants of one class; 1 is incomplete                                                                   |
 | Connectivity type classes                  | 2     |                                                                                                                        |
 | Declaration classes                        | 2     | the subclassing is flagged as a conceptual mismatch at `fbuiltins.py:467`                                              |
 | Type-system representations of "an offset" | 5     | `ts.OffsetType`, `it_ts.OffsetLiteralType`, `it_ts.CartesianOffsetType`, `ts.ListType.offset_type`, `ts.DimensionType` |
@@ -355,7 +355,7 @@ retains it only because the neighbor table data must be supplied at runtime.
 
 | #       | Constraint                                                                   | Embedded (field) | Embedded (iterator) | IR / type system | GTFN             | DaCe         | Enforced?                     | Source                                                                                       |
 | ------- | ---------------------------------------------------------------------------- | ---------------- | ------------------- | ---------------- | ---------------- | ------------ | ----------------------------- | -------------------------------------------------------------------------------------------- |
-| **A1**  | `FieldOffset.value` (N1) == provider key (N4)                                | required         | required            | —                | —                | —            | `KeyError`                    | `fbuiltins.py:494, 508`; `common.py:1207-1208`                                               |
+| **A1**  | `FieldOffset.value` (N1) == provider key (N4)                                | required         | required            | —                | —                | —            | `KeyError`                    | `fbuiltins.py:494, 509`; `common.py:1207-1208`                                               |
 | **A2**  | Python var name (N2) == provider key (N4)                                    | —                | —                   | required         | required         | required     | silent; `KeyError` at runtime | `foast_to_gtir.py:305, 331`                                                                  |
 | **A3**  | local dim `.value` (N3) == provider key (N4), **reductions**                 | required         | required            | required         | required         | required     | `KeyError`                    | `nd_array_field.py:981-985`; `embedded.py:953, 1517, 1776`; `unroll_reduce.py:43-50, 61-65`  |
 | **A4**  | local dim `.value` (N3) == provider key (N4), **sparse field args**          | —                | —                   | —                | required         | required     | `assert` / `ValueError`       | `gtfn_module.py:88-98`; `gtir_to_sdfg.py:572-585, 838-842`; `gtir_to_sdfg_lambda.py:766-770` |
@@ -459,10 +459,10 @@ The DaCe "inconsistent" entry: `gtir_to_sdfg_lambda.py:1155` builds
 | ------ | --------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- |
 | **F1** | `_Staggered` is a **reserved prefix**: any `Dimension` whose `value` starts with it is treated as staggered                             | `common.py:1444-1464` (`_STAGGERED_PREFIX = "_Staggered"`)                  |
 | **F2** | GTFN aliases every staggered tag to its base tag by string surgery                                                                      | `itir_to_gtfn_ir.py:703`, `_add_staggered_aliases:204-215`                  |
-| **F3** | `_CONST_DIM` is a reserved LOCAL dimension name, deliberately *absent* from the provider and special-cased at every lookup              | `embedded.py:220, 572, 1513, 1768`; `gtir_to_sdfg_lambda.py:62, 1314, 1355` |
+| **F3** | `_CONST_DIM` is a reserved LOCAL dimension name, deliberately *absent* from the provider and special-cased at every lookup (12 use sites)              | defined `embedded.py:220`, `gtir_to_sdfg_lambda.py:62`; used `embedded.py:571, 1009, 1431, 1513, 1768, 1770`; `gtir_to_sdfg_lambda.py:595, 1142, 1314, 1355, 1386, 1682` |
 | **F4** | **Dimension names determine memory layout** — `order_dimensions` sorts by `(kind, as_non_staggered(dim).value)`                         | `common.py:1334-1344`                                                       |
 | **F5** | GTFN: every dim name and provider key becomes a C++ type `generated::<name>_t`, so it must be a valid C++ identifier and collision-free | `gtfn_module.py:97, 130-136`                                                |
-| **F6** | GTFN connectivity params: `gt_conn_<key.lower()>`, so keys must not collide **case-insensitively**                                      | `gtfn_module.py:32, 120, 133`                                               |
+| **F6** | GTFN connectivity params: `gt_conn_<key.lower()>`, so keys must not collide **case-insensitively**                                      | `gtfn_module.py:32, 118, 132`                                               |
 | **F7** | DaCe connectivity arrays: `gt_conn_<key>`, recovered by regex `^gt_conn_(\S+)$`                                                         | `sdfg_args.py:24-25, 56-70`                                                 |
 | **F8** | DaCe map variables: `i_<dim>_gtx_<kind>[dim]`; map fusion/splitting transformations **rely on these strings matching**                  | `gtir_to_sdfg_utils.py:44-54`                                               |
 | **F9** | DaCe field symbols: `__<field>_<dim.value>_size/stride`, `_range_symbol_name(field, dim.value)`                                         | `sdfg_args.py:73-82, 119-122`                                               |

From 8123a44309b70bf0b42ea4387566c79c5e73e969 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Gonz=C3=A1lez=20Paredes?= <enriqueg@cscs.ch>
Date: Thu, 17 Sep 2026 15:49:27 +0200
Subject: [PATCH 3/3] connectivities-as-types: address review pass 2 (design
 decisions)

Resolves the four items deferred from pass 1, with the typing probes that
settle the first one added as typing_probe.py.

- Local must be declared explicitly as a nested class. mypy --strict and
  pyright both accept `Field[V, V2E.Local]` for an explicit nested class
  and distinguish two connectivities' locals; both reject a ClassVar-typed
  generated Local as "not valid as a type". The generated form is dropped.
- `Local[C]` and `C.Local` are distinct types for both checkers, so the
  __class_getitem__ reconciliation is removed; `C.Local` is the spelling
  and the cost to the chain proposals' static encodings is stated.
- Local is not passed through the base subscription (pyright: "Class
  definition depends on itself"); the metaclass reads it after the body,
  or a PEP 696 default on 3.13 (new open question 2).
- No deprecation window: string-keyed providers and FieldOffset removed
  outright with a scripted ICON4Py migration; no compat name table, so
  the "no registry" claim now holds without caveat. as_offset gets its
  dimension-based signature in the same release.
- Owner-less local dimensions with a fixed `size` (ICON4Py's LsqUnkDim,
  RBFDimension); _CONST_DIM becomes the owner-less ConstList(size=1).
- max_neighbors / min_neighbors optional on the class and completed at
  bind time (from the table, or from a NeighborConnectivityType in the
  AOT `connectivities=` path), because arity varies per mesh in
  fvm_nabla_setup.py and skip-value presence is configuration-dependent
  in ICON (icon.py:130, keep_skip_values). Declared counts remain a
  validated constraint.
---
 .../connectivities-as-types.md                | 225 +++++++++++++-----
 .../connectivities-as-types/typing_probe.py   | 115 +++++++++
 2 files changed, 274 insertions(+), 66 deletions(-)
 create mode 100644 content/personal/egparedes/connectivities-as-types/typing_probe.py

diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
index 3fa369a..8be895d 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
@@ -16,7 +16,8 @@ status: draft
 > name, which is also its IR tag:
 >
 > ```python
-> class V2E(NeighborConnectivity[V, E], max_neighbors=6): ...
+> class V2E(NeighborConnectivity[V, E]):
+>     class Local(LocalDimensionIndex): ...
 >
 > neighbor_sum(a(V2E), axis=V2E.Local)
 > program(a, out=out, offset_provider={V2E: v2e_table})
@@ -144,7 +145,7 @@ what is one idea — *a mapping between two index spaces, plus a name for it*.
 | --- | --- | --- |
 | `DimensionBaseIndex` | root of all dimension types; `value` is the index position | the `DimensionBase` root [[shared/dimensions-as-types|dimensions as types]] deferred |
 | `DimensionIndex` | user-declarable primary dimension (as in #2844) | `Dimension` instances |
-| `LocalDimensionIndex` | a local dimension; always **owned** by a connectivity; carries `max_neighbors` / `min_neighbors` | `Dimension(..., kind=LOCAL)` + `NeighborConnectivityType.max_neighbors` / `skip_value` |
+| `LocalDimensionIndex` | a local dimension: either **owned**, declared nested in its connectivity, or **owner-less** with a fixed `size`; carries `max_neighbors` / `min_neighbors` when they are known statically | `Dimension(..., kind=LOCAL)`, `_CONST_DIM`, and `NeighborConnectivityType.max_neighbors` / `skip_value` |
 | `NeighborConnectivity[Origin, Codomain]` | the connectivity **class**: type, shift handle and provider key in one object; contains its `Local` | `FieldOffset`, `runtime.Offset`, `ts.OffsetType`, the `V2EDim` convention |
 | `MultiDimensionIndex[D, *Ls]` | position in the product of a primary and one or more local dimensions | untyped position dicts keyed by name strings |
 
@@ -175,9 +176,11 @@ class DimensionIndex(DimensionBaseIndex[int]): ...                  # user-decla
 
 class LocalDimensionIndex(DimensionBaseIndex[int]):
     kind = DimensionKind.LOCAL
-    owner: ClassVar[type[NeighborConnectivity]]
-    max_neighbors: ClassVar[int]
-    min_neighbors: ClassVar[int]           # min == max  <=>  no skip values
+    owner: ClassVar[type[NeighborConnectivity] | None]   # None: owner-less, fixed extent
+    max_neighbors: ClassVar[int | None]    # None: completed at bind time
+    min_neighbors: ClassVar[int | None]    # min == max  <=>  no skip values
+
+    def __init_subclass__(cls, *, size: int | None = None): ...   # owner-less form
 
 
 class MultiDimensionIndex[D: DimensionIndex, *Ls](DimensionBaseIndex[tuple[D, *Ls]]):
@@ -195,20 +198,30 @@ class CartesianConnectivity[D: DimensionIndex](Connectivity[D, D]): ...   # sema
 
 
 class NeighborConnectivity[Origin: DimensionIndex, Codomain: DimensionIndex](
-    Connectivity[MultiDimensionIndex[Origin, "Local"], Codomain],
+    Connectivity[MultiDimensionIndex[Origin, LocalDimensionIndex], Codomain],
     metaclass=ConnectivityMeta,
 ):
-    Local: ClassVar[type[LocalDimensionIndex]]   # generated in __init_subclass__ unless declared
+    Local: type[LocalDimensionIndex]   # MUST be declared nested by every subclass (see below)
 
-    def __init_subclass__(cls, *, max_neighbors: int, min_neighbors: int | None = None): ...
-    # ConnectivityMeta provides: tag (qualified name), __gt_type__() -> NeighborConnectivityType,
-    # __getitem__ so that V2E[1] is a single-neighbor Connectivity, default type identity.
+    def __init_subclass__(
+        cls, *, max_neighbors: int | None = None, min_neighbors: int | None = None
+    ): ...   # verifies `cls.Local` exists and is a LocalDimensionIndex; sets Local.owner = cls
+    # ConnectivityMeta provides: tag (qualified name), __gt_type__() -> NeighborConnectivityType
+    # (complete only once the counts are known), __getitem__ so that V2E[1] is a
+    # single-neighbor Connectivity, default type identity.
 
 
 # ── user code ──────────────────────────────────────────────────────────────
 class V(DimensionIndex): ...
 class E(DimensionIndex): ...
-class V2E(NeighborConnectivity[V, E], max_neighbors=6): ...         # V2E.Local generated
+
+
+class V2E(NeighborConnectivity[V, E], max_neighbors=6, min_neighbors=5):   # counts optional
+    class Local(LocalDimensionIndex): ...                            # explicit, always
+
+
+class LsqUnk(LocalDimensionIndex, size=3): ...                       # owner-less local axis
+class ConstList(LocalDimensionIndex, size=1): ...                    # replaces _CONST_DIM
 
 
 @field_operator
@@ -268,9 +281,9 @@ concepts.* The consequences, stated as rules:
    `python -c`. Documented limitation, not fixed.
 3. **No registry, no `copyreg`.** Classes pickle by reference, which is
    correct for module-level types; #2844's `copyreg.pickle(DimensionMeta, ...)`
-   and `_DIMENSION_REGISTRY` are removed again — with the caveat in Open Q4
-   that a *compatibility* name table is needed for as long as string-keyed
-   providers are accepted.
+   and `_DIMENSION_REGISTRY` are removed again. Nothing equivalent creeps
+   back in, because string-keyed providers are not accepted at all (there is
+   no deprecation window), so no name→class table is ever needed.
 4. **Cache fingerprints depend on module paths.** #2844 adds a
    `fingerprinting.py` deconstructor keyed on `(tag, kind)` (recorded in
    ADR 0028) *specifically so that* a dimension is not fingerprinted by
@@ -295,9 +308,28 @@ The connectivity *type* conceptually depends on the *table*: two different
 tables assign different neighbors to the same origin element. The model:
 
 - The class `V2E` is a **type constructor**. Its static part — `Origin`,
-  `Codomain`, `Local`, `max_neighbors`, `min_neighbors` — is what compilation
-  sees, and `NeighborConnectivityType` is derived from it. **Static only**:
-  `max_neighbors` is declared on the class, not inferred from data.
+  `Codomain`, `Local`, and *optionally* `max_neighbors` / `min_neighbors` —
+  is what compilation sees. When the counts are declared, they are a
+  constraint the table must satisfy. When they are not, they are **completed
+  at bind time**: from the table's shape and skip value in the JIT flow, or
+  from a `NeighborConnectivityType` supplied through `connectivities=` in the
+  AOT flow (`ffront/decorator.py:188-208`), which already passes exactly that
+  record without any data. `NeighborConnectivityType` is derived from class
+  plus binding, and is complete only once both are known.
+- Why the counts are not static-only. Two in-tree and in-ICON facts: the
+  arity of the same connectivity varies per mesh (`fvm_nabla_setup.py:99`
+  sizes `V2E` from `edges_per_node`, computed from the atlas mesh), so a
+  static count binds the DSL source to one mesh family and makes
+  `Field[Dims[Vertex, V2E.Local]]` signatures unshareable across meshes; and
+  skip-value presence is *configuration*-dependent in ICON (`icon.py:130`:
+  pentagon offsets have skip values on the icosahedron but not on the torus;
+  boundary offsets only on limited-area or distributed grids), so a static
+  `min_neighbors` would force ICON4Py to either declare two classes per
+  boundary offset or always compile skip-mask handling, defeating its
+  `keep_skip_values=False` table rewrite (`base.py:180`). Declared counts
+  remain the right choice for fixed-arity meshes, and the compile cache is
+  unaffected either way: `NeighborConnectivityType` is part of the key today
+  and stays so.
 - A **bound connectivity** is the class plus a table. Within one program
   invocation there is exactly one table per class, so every occurrence of
   `V2E` in that invocation denotes the same mapping. The provider
@@ -314,19 +346,44 @@ tables assign different neighbors to the same origin element. The model:
 
 ### The local dimension
 
-- `V2E.Local` is **generated** in `__init_subclass__` unless the user declares
-  a nested `class Local(LocalDimensionIndex): ...` — the explicit form gives a
-  *statically* distinct type when a signature needs one; the generated form
-  is annotated `type[LocalDimensionIndex]` on the base and covers everything
-  else. Its tag is `<owner tag>.Local`, unique by construction.
+- `V2E.Local` **must be declared explicitly** as a nested
+  `class Local(LocalDimensionIndex): ...`; `__init_subclass__` verifies it
+  and sets `Local.owner`. There is no generated form. This is settled by
+  running both checkers on
+  [`typing_probe.py`](connectivities-as-types/typing_probe.py): an explicitly
+  declared nested `Local` is a real, distinct type under mypy `--strict` and
+  pyright (`Field[V, V_E2E.Local]` vs `Field[E, E_V2V.Local]` is an
+  `arg-type` error), while a `Local` generated in `__init_subclass__` and
+  annotated `ClassVar[type[LocalDimensionIndex]]` on the base is rejected by
+  both as *not valid as a type* — the very error class
+  [[shared/dimensions-as-types|dimensions as types]] exists to remove. Two
+  lines per connectivity buy a real type; ICON4Py has 16 declarations. Its
+  tag is `<owner tag>.Local`, unique by construction.
+- `Local` is **not** passed through the base subscription
+  (`NeighborConnectivity[V, "V2E.Local", E]`): mypy accepts that string
+  forward reference, pyright reports `Class definition for "V2E" depends on
+  itself`. The metaclass reads `cls.Local` after the class body has run; on
+  Python 3.13 a PEP 696 default type parameter is the typed alternative.
 - `max_neighbors` / `min_neighbors` are class keywords, exactly as #2844 does
-  `kind`. They are *not* type parameters: Python has no integer-valued type
-  parameters, and nothing static needs the count — what must be in the type
-  is *which* local dimension.
-- `_CONST_DIM` (`iterator/embedded.py:220`) becomes a real
-  `LocalDimensionIndex` with no owner and `max_neighbors = 1`, replacing a
-  magic name that is special-cased at twelve use sites today (six in
-  `iterator/embedded.py`, six in the DaCe lowering).
+  `kind`, and optional (see Binding model). They are *not* type parameters:
+  Python has no integer-valued type parameters, and nothing static needs the
+  count — what must be in the type is *which* local dimension.
+- **Owner-less local dimensions** exist: `class LsqUnk(LocalDimensionIndex, size=3)`
+  has `owner = None`, `min == max == size`, no skip values, and never appears
+  in the provider. ICON4Py needs this today: `LsqUnkDim` (`dimension.py:18`,
+  LOCAL kind, "number of least-squares unknowns") is the middle axis of a
+  coefficient field over `(CellDim, LsqUnkDim, C2E2CDim)` and indexes no
+  table; `RBFDimension` is an enum of stencil sizes that plays the same role.
+  Such axes want the *storage and layout* treatment of a sparse dimension,
+  not a connectivity; declaring them non-LOCAL instead would make them domain
+  dimensions requiring a range in every program domain and would change
+  ICON4Py's memory layout for those fields. Backends handle the owner-less
+  form exactly as they handle `_CONST_DIM` today, generalized from size 1 to
+  size *n*.
+- `_CONST_DIM` (`iterator/embedded.py:220`) is therefore the owner-less
+  `ConstList(LocalDimensionIndex, size=1)`, replacing a magic name that is
+  special-cased at twelve use sites today (six in `iterator/embedded.py`,
+  six in the DaCe lowering).
 - `neighbor_sum(..., axis=V2E.Local)` — the local axis stays **explicit**.
   `axis=V2E` as sugar is deliberately not offered; it would blur the two
   concepts the design separates.
@@ -359,7 +416,7 @@ to implement and nothing else depends on it:
 | gtfn | `dim.value` lookups for sparse args; `TagDefinition` per tag and per `neighbor_dim` | `local_dim.owner`; `codegen_name(tag)` |
 | DaCe | ~10 `offset_type.value` lookups; `Dimension(offset, LOCAL)` synthesized at `gtir_to_sdfg_lambda.py:1155` | `local_dim.owner`; no synthesis |
 | roundtrip backend | emits `gtx.Dimension("<name>", kind=...)` / `offset("<tag>")` as *source text* (`runners/roundtrip.py:175-179`) | emits imports of the qualified names, via `codegen_name` for the Python identifier |
-| Provider | `Mapping[str, NeighborTable]` | `Mapping[type[NeighborConnectivity], NeighborTable]`; string keys accepted with a warning during deprecation, resolved by import |
+| Provider | `Mapping[str, NeighborTable]` | `Mapping[type[NeighborConnectivity], NeighborTable]`; **no string keys** and no deprecation window (a scripted migration for ICON4Py instead) |
 
 ### What it deletes
 
@@ -371,28 +428,38 @@ string-keyed form; `dimension(tag, kind)`, the interning registry and the
 `_CONST_DIM` as a magic name; and the convention that
 `V2EDim = Dimension("V2E", LOCAL)` must sit next to `V2E = FieldOffset("V2E", ...)`.
 
-**Not deleted, deliberately:** the single-target (Cartesian) `FieldOffset`
-form. Cartesian *shifts* already use `Dimension + int` (GridTools/gt4py#2411),
-but `as_offset(offset, field)` (`ffront/experimental.py:17`) requires a
-Cartesian `FieldOffset` (`type_deduction.py:956-967`, S6 in the appendix), is
-used in 5 test modules plus the `Ioff`/`Koff`/`EdgeOffset` fixtures in
-`cases_utils.py:163-169`, and ICON4Py calls it in diffusion and the dycore
-(`as_offset(Koff, ...)`, with `offset_provider={"Koff": KDim}`). A Cartesian
-offset handle therefore stays until `as_offset` gets a replacement signature
-(`as_offset(KDim, field)` is the obvious candidate, out of scope here).
+**Deleted only together with its replacement:** the single-target
+(Cartesian) `FieldOffset` form. Cartesian *shifts* already use
+`Dimension + int` (GridTools/gt4py#2411), but `as_offset(offset, field)`
+(`ffront/experimental.py:17`) requires a Cartesian `FieldOffset`
+(`type_deduction.py:956-967`, S6 in the appendix), is used in 5 test modules
+plus the `Ioff`/`Koff`/`EdgeOffset` fixtures in `cases_utils.py:163-169`, and
+ICON4Py calls it in diffusion and the dycore (`as_offset(Koff, ...)`, with
+`offset_provider={"Koff": KDim}`). Since there is no deprecation window, a
+dimension-based signature — `as_offset(KDim, field)` is the obvious
+candidate — must land in the **same release** that removes `FieldOffset`,
+and the migration script must rewrite these call sites too.
 
 ### Relation to `Local[V2E]`
 
 [[personal/havogt/dependent-local-dimensions|Dependent local dimensions]]
 spells the local dimension `Local[V2E]` (a generic parametrized by the
 connectivity); this proposal spells it `V2E.Local` (a class nested in the
-connectivity). These should be **the same object**: `Local.__class_getitem__`
-can return `V2E.Local`, so both spellings denote one type and the chain
-proposals (`Local[V2E]` pushed onto a hop stack, or `Local[C, P]` with a
-parent) sit on top unchanged. Nesting is preferred for the *declaration* side
-because the local dimension's `max_neighbors`/`min_neighbors` belong to the
-owner, and because the nested form is what makes the tag unique with no
-registry.
+connectivity). They **cannot be reconciled for a type checker**: making
+`Local.__class_getitem__` return `V2E.Local` unifies them at runtime only.
+[`typing_probe.py`](connectivities-as-types/typing_probe.py) shows both mypy
+and pyright treating `Field[V, V2E.Local]` and `Field[V, Local[V2E]]` as
+incompatible in both directions. One spelling has to win, and this proposal
+picks `V2E.Local`: the nested form is what makes the tag unique with no
+registry, and the counts belong to the owner. The cost is honest and falls
+on the chain proposals: their mypy-verified encodings
+(`static_hops.py`: `Local[NeighborTable[O, C]]`, `Local[ConnT]`) are built
+on subscripting `Local`, and a `TypeVar` cannot be subscripted for a nested
+attribute (`Local[ConnT]` fails at runtime with `'TypeVar' object has no
+attribute 'Local'`). Those encodings need rewriting to `C.Local`, which
+works for concrete `C` and needs a protocol or overloads for the generic
+hop-stack case. The semantics of the chain proposals are unaffected; their
+static encoding is.
 
 ## Alternatives considered
 
@@ -427,9 +494,24 @@ the class, keeps the invariant structural.
 
 **`axis=V2E` as sugar.** Rejected for now; keep the local axis explicit.
 
-**Bound (data-inferred) `max_neighbors`.** Rejected for now; static only. Can
-be revisited if a generic-mesh consumer needs it, at the cost that such a
-class's `NeighborConnectivityType` is not derivable before binding.
+**Static-only `max_neighbors` / `min_neighbors`.** Simplest, and correct for
+fixed-arity meshes. Rejected as the *only* mode because it binds DSL source
+to one mesh family (`fvm_nabla_setup.py` sizes `V2E` from the atlas mesh) and
+because skip-value presence is configuration-dependent in ICON, so a static
+`min_neighbors` forces either duplicate classes or always-on skip handling.
+Declared counts stay available as a constraint; see Binding model.
+
+**A generated `Local` as the default, explicit declaration optional.**
+Rejected after running the checkers: a `ClassVar`-typed generated `Local` is
+not usable in an annotation under mypy or pyright
+([`typing_probe.py`](connectivities-as-types/typing_probe.py), probe P2).
+
+**`Local[C]` as the spelling, with `V2E.Local` an alias.** Rejected: the two
+are distinct types for every checker (probe P3); see Relation to `Local[V2E]`.
+
+**Owner-less local axes as non-LOCAL dimensions.** Rejected: they would
+become domain dimensions with a range in every program domain and lose the
+sparse storage treatment, changing ICON4Py's layout for `LsqUnkDim` fields.
 
 ## Open questions / conflicts
 
@@ -484,18 +566,23 @@ class's `NeighborConnectivityType` is not derivable before binding.
    `min_neighbors` vs `has_skip_values`. Converge with
    [[personal/havogt/dependent-local-dimensions|dependent local dimensions]]
    before either lands.
-2. **Declared vs generated `Local`.** Is the optional explicit nested class
-   worth its rule surface, or is `type[LocalDimensionIndex]` on the base
-   enough for every real signature?
+2. **How `Local` reaches the base's parametrization.** Discovered by the
+   metaclass after the class body (works on 3.12, untyped in the base), or a
+   PEP 696 default type parameter (3.13, typed)? AGENTS.md invites 3.13
+   features where they improve a design; this is a candidate.
 3. **`__main__` in spawn workers.** Document, or detect and fall back to
    in-process compilation with a warning?
-4. **ICON4Py surface.** `gtx.FieldOffset`, `Dimension(..., LOCAL)`,
+4. **ICON4Py migration.** `gtx.FieldOffset`, `Dimension(..., LOCAL)`,
    `as_offset(Koff, ...)` and string-keyed providers (`{"V2E": ..., "Koff": KDim}`)
-   are all public. The deprecation window will dominate the schedule. Note
-   that ICON4Py's keys are *bare* names, so a string-key shim cannot resolve
-   them by import; it needs a name→class table populated at class creation —
-   a registry in all but name, kept for the deprecation window only. The
-   alternative is object keys from day one with a scripted migration.
+   are all public and all change in **one release, with no deprecation
+   window**. ICON4Py's keys are bare names, so no import-based shim could
+   have resolved them anyway; the migration is a script over
+   `dimension.py` (16 offsets, 15 local dims), the `offset_provider`
+   construction in `grid/base.py`, and the `as_offset` call sites. `LsqUnkDim`
+   becomes an owner-less `LocalDimensionIndex` with `size=`. What the script
+   cannot decide is whether each connectivity declares its counts or leaves
+   them to bind time; the ICON skip-value rules (`icon.py:130`) suggest
+   leaving `min_neighbors` open for the boundary offsets.
 5. **Duplicate declarations.** With type identity, two modules declaring
    `class V2E(...)` are two connectivities. Is a warning on same-`__name__`
    collisions in one program useful, or noise?
@@ -519,21 +606,24 @@ Each step is landable separately and leaves the tree green.
 1. **#2844 lands**, then the `DimensionBaseIndex` root and type identity
    (registry and `copyreg` removed, importability rule added,
    `resolve(tag)` by import). Revision of `shared/dimensions-as-types.md`.
-2. **`NeighborConnectivity` + `LocalDimensionIndex`** in `common`;
-   `FieldOffset` kept as a deprecated alias that constructs one;
-   object-keyed provider accepted alongside string-keyed.
-3. **`ts.OffsetType` → `ConnectivityType`**; the Cartesian `FieldOffset`
-   form stays for `as_offset` until that builtin gets a dimension-based
-   signature.
+2. **`NeighborConnectivity` + `LocalDimensionIndex`** (owned and owner-less)
+   in `common`; object-keyed provider; `FieldOffset` and string keys removed
+   outright; bind-time completion and validation of the counts.
+3. **`ts.OffsetType` → `ConnectivityType`**; `as_offset` gets its
+   dimension-based signature in the same step, so the Cartesian `FieldOffset`
+   form can go with the rest.
 4. **Backends** switch from `local_dim.value` lookups to `local_dim.owner`,
    one file at a time (`gtfn_module.py`, `unroll_reduce.py`, `gtir_to_sdfg*.py`,
    `nd_array_field.py`, `iterator/embedded.py`, and the source-emitting
    `runners/roundtrip.py`). `codegen_name` introduced.
-5. **`Staggered[D]`**, superseding ADR 0026; `_CONST_DIM` as a real type.
+5. **`Staggered[D]`**, superseding ADR 0026; `_CONST_DIM` becomes the
+   owner-less `ConstList` local dimension.
 6. **`MultiDimensionIndex`** and typed embedded positions.
 7. **Typing tests** (`typing_tests/test_next.yaml`, pyright): `Field[Dims[V, V2E.Local], float]`,
    a `TypeVar` bound to `LocalDimensionIndex`, a negative case mixing two
-   connectivities' locals.
+   connectivities' locals — the probes in
+   [`typing_probe.py`](connectivities-as-types/typing_probe.py) are the
+   starting set.
 8. **Test-tree migration** as its own PR (`toy_connectivity.py`,
    `cases_utils.py`, `fvm_nabla_setup.py` are the fixture modules everything
    imports).
@@ -549,3 +639,6 @@ they reverse two recorded decisions and change a public-API shape.
   each with `file:line`; per-context tables for embedded, IR, gtfn and DaCe;
   the complete concept inventory (L0–L9); class-hierarchy and name-flow
   diagrams; the two executed experiments.
+- [`typing_probe.py`](connectivities-as-types/typing_probe.py): the mypy /
+  pyright probes behind the `Local` decisions (explicit nested class works;
+  generated `ClassVar` form and `Local[C]` reconciliation do not).
diff --git a/content/personal/egparedes/connectivities-as-types/typing_probe.py b/content/personal/egparedes/connectivities-as-types/typing_probe.py
new file mode 100644
index 0000000..379be6b
--- /dev/null
+++ b/content/personal/egparedes/connectivities-as-types/typing_probe.py
@@ -0,0 +1,115 @@
+"""Typing probe for the `V2E.Local` question (B1 in the adversarial review).
+
+Run with `mypy --strict --python-version 3.12` and `pyright --pythonversion 3.12`.
+Expected: P1 accepts the explicit nested `Local` and rejects the cross-connectivity
+mismatch on line `p1(Field[E, E_V2V.Local]())`; P2 rejects the generated `ClassVar` form
+as "not valid as a type"; P3 rejects each spelling where the other is expected.
+pyright additionally reports "Class definition for V_E2E depends on itself" on the
+string forward reference in the base subscription, which is why the proposal does
+not pass `Local` through the bases.
+"""
+
+from __future__ import annotations
+
+import sys
+import typing
+from collections.abc import Iterator, Mapping
+from types import MappingProxyType, get_original_bases
+
+
+class DimensionIndex(int): ...
+
+class LocalDimensionIndex(int): ...
+
+type MultiLevelDimensionIndex[D: DimensionIndex, L: LocalDimensionIndex] = tuple[D, *tuple[L, ...], L]   #  (V(0), LocalV_E(2))
+
+
+class StaticMultiLevelMapping[D: DimensionIndex, L: LocalDimensionIndex, V](
+    Mapping[MultiLevelDimensionIndex[D, L], V]
+):
+    """Read-only mapping fixed at class-definition time; one instance per class.
+
+    `data` uses plain ints; keys and values are converted to the D, L, V types
+    given in the subclass's base subscription (every tail element becomes L).
+    """
+
+    __slots__ = ()
+    _data: Mapping[MultiLevelDimensionIndex[D, L], V]
+    _instance: typing.ClassVar[typing.Any]
+
+    def __init_subclass__(
+        cls, *, data: Mapping[tuple[int, ...], int] | None = None, **kwargs: typing.Any
+    ) -> None:
+        super().__init_subclass__(**kwargs)
+        if data is not None:
+            dim, local, value = cls._resolve_type_args()
+            cls._data = MappingProxyType(
+                {(dim(k[0]), *map(local, k[1:])): value(v) for k, v in data.items()}
+            )
+
+    @classmethod
+    def _resolve_type_args(cls) -> tuple[type, type, type]:
+        base = next(
+            b for b in get_original_bases(cls)
+            if typing.get_origin(b) is StaticMultiLevelMapping
+        )
+        # cls isn't bound in its module yet, so forward refs like "V_V2V.Local"
+        # need it injected explicitly.
+        ns = vars(sys.modules[cls.__module__]) | {cls.__name__: cls}
+        args = tuple(eval(a, ns) if isinstance(a, str) else a for a in typing.get_args(base))
+        assert len(args) == 3, args
+        return args
+
+    def __new__(cls) -> typing.Self:
+        if "_instance" not in cls.__dict__:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __getitem__(self, key: MultiLevelDimensionIndex[D, L]) -> V:
+        return self._data[key]
+
+    def __iter__(self) -> Iterator[MultiLevelDimensionIndex[D, L]]:
+        return iter(self._data)
+
+    def __len__(self) -> int:
+        return len(self._data)
+
+
+class V(DimensionIndex): ...
+
+class E(DimensionIndex): ...
+
+
+class V_E2E(StaticMultiLevelMapping[V, "V_E2E.Local", E], data={(0, 0): 1, (0, 1): 2}):
+    class Local(LocalDimensionIndex): ...
+
+
+class E_V2V(StaticMultiLevelMapping[E, "E_V2V.Local", V], data={(0, 0): 1, (0, 1): 2}):
+    class Local(LocalDimensionIndex): ...
+
+
+
+# ---------------- probes appended by reviewer ----------------
+class Field[*Ds]: ...
+
+# P1: explicitly declared nested Local used in an annotation
+def p1(a: Field[V, V_E2E.Local]) -> None: ...
+p1(Field[V, V_E2E.Local]())
+p1(Field[E, E_V2V.Local]())   # expected error: distinct locals
+
+# P2: generated Local (ClassVar on the base), as the proposal's default form
+class Base2:
+    Local: typing.ClassVar[type[LocalDimensionIndex]]
+    def __init_subclass__(cls, **kw: typing.Any) -> None:
+        cls.Local = type("Local", (LocalDimensionIndex,), {})
+class G2E(Base2): ...
+def p2(a: Field[V, G2E.Local]) -> None: ...   # does mypy accept this annotation?
+
+# P3: reconciliation Local[C] == C.Local via __class_getitem__
+class Local[C]:
+    def __class_getitem__(cls, item: typing.Any) -> typing.Any:
+        return item.Local
+def p3a(a: Field[V, V_E2E.Local]) -> None: ...
+def p3b(a: Field[V, Local[V_E2E]]) -> None: ...
+p3a(Field[V, Local[V_E2E]]())    # same type for the checker?
+p3b(Field[V, V_E2E.Local]())