From 2504216ec91606257df4a49de145c2d17f0ad78b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Gonz=C3=A1lez=20Paredes?= <enriqueg@cscs.ch>
Date: Thu, 1 Oct 2026 09:48:45 +0200
Subject: [PATCH 01/19] =?UTF-8?q?personal/egparedes:=20connectivities=20as?=
 =?UTF-8?q?=20types=20=E2=80=94=20Cartesian=20axis=20dimensions?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add two levels below `DimensionIndex` — `AnyCartesianAxisIndex` (either cell
class of a Cartesian axis) and `CartesianAxisIndex` (a declared axis) — and
bound `Staggered[D: CartesianAxisIndex]` on the declared one. Doubly staggered
dimensions, staggered local dimensions and staggered mesh locations become
static `[type-var]` errors instead of runtime `TypeError`s, and because the
levels sit below the root no `type[DimensionIndex]` annotation widens and
`LocalDimensionIndex` keeps its position. Verified in `staggered_probe.py`
with mypy 2.3.1 and pyright 1.1.414.

Motivate the levels as a domain concept rather than a typing trick: a declared
axis and its `Staggered[.]` are the two cell classes of a 1-dimensional CW
complex, `Staggered` is the involution that swaps them, and in more than one
dimension `Dims[...]` is the per-axis bit vector of the product complex. Record
that this is finer than a form degree, that the absence of orientation data
follows from the product structure, and that mesh locations are separate
classes because the complex does not factor.

Also decided: extents are declared and never derived (absolute `UnitRange`s
already carry the degree assignment and the periodic case; the interleaving
invariant belongs to the grid); the alignment convention is antisymmetric, so
both conventions are reachable by choosing which member of the pair to declare;
`DimensionKind.LOCAL` leaves the enum in PR B, derived from the class.

Rejected in the note: a sibling root above `DimensionIndex`, a `Protocol` +
`Literal` discriminator, a second partner constructor (`StaggeredAbove[D]`
makes `flip_staggered` partial), declaring both members of a pair, and a static
cell `degree` for now. Open questions added for parameterizing the alignment,
`kind`'s remaining two jobs, and a `degree` conditioned on an exterior-calculus
consumer. Reserve `dual`/`Dual` for the full Hodge dual; the per-axis swap keeps
`flip_staggered`. Cross-links both ways with the surface-syntax note.
---
 content/index.md                              |   4 +-
 .../connectivities-as-types.md                | 353 ++++++++++++++++--
 .../staggered_probe.py                        | 145 +++++++
 .../discretization-independent-fd-syntax.md   |   4 +-
 4 files changed, 473 insertions(+), 33 deletions(-)
 create mode 100644 content/personal/egparedes/connectivities-as-types/staggered_probe.py

diff --git a/content/index.md b/content/index.md
index cf9d353..7689cd8 100644
--- a/content/index.md
+++ b/content/index.md
@@ -44,8 +44,8 @@ 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, type-checking, dimensions, local-dimensions, connectivities, offset-provider, unstructured, neighbor-sum, reduction, frontend, foast, gtir, embedded, gtfn, dace, nominal-types, dependent-types, metaclass, serialization, fingerprint, staggering, migration, adr, tech-debt, shared-local-dimensions, implemented
-- [[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
+- [[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, dependent-types, metaclass, serialization, fingerprint, staggering, axis-dimensions, cw-complex, exterior-calculus, domain, dimension-kind, migration, adr, tech-debt, shared-local-dimensions, implemented
+- [[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, cw-complex, 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
      from within the proposal document itself, not here):
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 0c8158b..5001857 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
@@ -1,9 +1,9 @@
 ---
 title: "Connectivities as types: one declaration for offset, local dimension and provider key"
 author: egparedes
-tags: [type-system, type-checking, dimensions, local-dimensions, connectivities, offset-provider, unstructured, neighbor-sum, reduction, frontend, foast, gtir, embedded, gtfn, dace, nominal-types, dependent-types, metaclass, serialization, fingerprint, staggering, migration, adr, tech-debt, shared-local-dimensions, implemented]
+tags: [type-system, type-checking, dimensions, local-dimensions, connectivities, offset-provider, unstructured, neighbor-sum, reduction, frontend, foast, gtir, embedded, gtfn, dace, nominal-types, dependent-types, metaclass, serialization, fingerprint, staggering, axis-dimensions, cw-complex, exterior-calculus, domain, dimension-kind, migration, adr, tech-debt, shared-local-dimensions, implemented]
 created: 2026-09-17
-updated: 2026-09-23
+updated: 2026-10-01
 status: draft
 ---
 
@@ -60,7 +60,12 @@ status: draft
 > [[personal/havogt/mesh-and-first-class-halos/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.
+> the typed substrate that proposal can bind through. The staggering half
+> draws its vocabulary from
+> [[personal/egparedes/discretization-independent-fd-syntax|A discretization-independent surface
+> syntax for finite-difference computations]] §3.3 and §6.4, where the same
+> two-cell-class structure appears as half-index notation and as the Arakawa
+> placement map; that note's location types sit above this one.
 
 ## Problem / motivation
 
@@ -155,8 +160,9 @@ what is one idea — *a mapping between two index spaces, plus a name for it*.
 
 | Concept | Role | Replaces |
 | --- | --- | --- |
-| `DimensionIndex` | a dimension is a subclass, an index along it an instance (ADR 0028) | `Dimension` instances |
-| `Staggered[D]` | the dimension at the half-integer positions of `D`; a real, interned class (see [`Staggered[D]`](#staggeredd)) | the `_Staggered` name prefix |
+| `DimensionIndex` | a dimension is a subclass, an index along it an instance (ADR 0028); the root — mesh locations, axes and local dimensions are all subclasses, so every `type[DimensionIndex]` annotation in the tree keeps its meaning | `Dimension` instances |
+| `CartesianAxisIndex(AnyCartesianAxisIndex)` | a **declared Cartesian axis**: an index space with integer index arithmetic and exactly one staggered partner (see [Cartesian axis dimensions](#cartesian-axis-dimensions)). `AnyCartesianAxisIndex` is either cell class of such an axis, declared or derived | — (new; today `kind != LOCAL` is the nearest approximation, and it does not separate a Cartesian axis from a mesh location) |
+| `Staggered[D: CartesianAxisIndex]` | the axis's derived partner, at the half-integer positions of `D`; a real, interned class (see [`Staggered[D]`](#staggeredd)) | the `_Staggered` name prefix |
 | `LocalDimensionIndex(DimensionIndex)` | a local dimension: **owned** (declared nested in, or adopted by, its connectivity), or **owner-less** (optionally with `size=n`, which sets `max_neighbors = min_neighbors = n`); carries the neighbor counts | `Dimension(..., kind=LOCAL)`, `_CONST_DIM` |
 | `NeighborConnectivity[Domain, Codomain]` | the **static part of a neighbor table's type**: the shift handle in DSL code and the provider key; contains its `Local`; holds no data and is never instantiated | `FieldOffset`, the `V2EDim` convention |
 | `MultiDimensionIndex[D, *Ls]` | a position in the product of a primary and local dimensions, a tuple of indices; user-facing, nothing in the toolchain requires it | — (new; the iterator-embedded position dicts are keyed by dimension classes, not name strings) |
@@ -189,8 +195,10 @@ root: `Dimension` is `type[DimensionIndex]` and eve validates `type[X]` by
 annotation in the tree to widen and then admit local dimensions everywhere
 anyway. The tree tells local dimensions apart by a runtime `kind` check, and
 constructors whose parameter must be a primary dimension
-(`NeighborConnectivity[Domain, Codomain]`, `Staggered[D]`,
-`MultiDimensionIndex`) check that it is not local.
+(`NeighborConnectivity[Domain, Codomain]`, `MultiDimensionIndex`) check that
+it is not local. `Staggered[D]` instead takes its parameter from a narrower
+level *below* the root, which is what lets it reject a local dimension
+statically at no widening cost — see [Cartesian axis dimensions](#cartesian-axis-dimensions).
 
 ### What stays, and why
 
@@ -217,7 +225,9 @@ class DimensionMeta(type):
         return f"{cls.__module__}.{cls.__qualname__}"
     kind: DimensionKind
     __hash__ = type.__hash__                   # __eq__ stays for `I == 5` -> Domain
-    def __add__(cls, offset: int | float) -> Connectivity: ...   # I + 1, K + 0.5
+    def __add__(                               # I + 1, K + 0.5; a Cartesian axis only
+        cls: type[AnyCartesianAxisIndex], offset: int | float
+    ) -> Connectivity: ...
 
 
 class DimensionIndex(metaclass=DimensionMeta):
@@ -226,6 +236,14 @@ class DimensionIndex(metaclass=DimensionMeta):
 type Dimension = type[DimensionIndex]          # PEP 695: `Dimension("I")` is not callable
 
 
+class AnyCartesianAxisIndex(DimensionIndex):   # either cell class of a Cartesian axis;
+    ...                                        #   `D + 1`, `as_offset`, ranges need this
+
+
+class CartesianAxisIndex(AnyCartesianAxisIndex):
+    ...                                        # a *declared* axis; `Staggered` takes these
+
+
 class LocalDimensionIndex(DimensionIndex):     # kind is LOCAL; `kind=LOCAL` elsewhere is an error
     owner: ClassVar[type[NeighborConnectivity] | None]   # None: owner-less; set by the owner
     sharers: ClassVar[tuple[type[NeighborConnectivity], ...]]   # later declarations over it
@@ -236,7 +254,11 @@ class LocalDimensionIndex(DimensionIndex):     # kind is LOCAL; `kind=LOCAL` els
 
 class MultiDimensionIndex[D: DimensionIndex, *Ls](tuple[D, *Ls]): ...   # shape checked at runtime
 
-Staggered[KDim]                                # an interned, real dimension class (ADR 0026)
+
+class Staggered[D: CartesianAxisIndex](AnyCartesianAxisIndex): ...  # interned (ADR 0026)
+
+Staggered[KDim]                                # KDim's derived partner;
+                                               #   Staggered[Staggered[KDim]] is a type error
 
 
 # ── connectivities (ADR 0029) ─────────────────────────────────────────────
@@ -264,11 +286,13 @@ def check_neighbor_table(connectivity, table_or_type) -> NeighborTableType: ...
 
 
 # ── user code ──────────────────────────────────────────────────────────────
-class V(DimensionIndex): ...
-class E(DimensionIndex): ...
+class V(DimensionIndex): ...                   # mesh locations: no index arithmetic and
+class E(DimensionIndex): ...                   #   no staggered partner
 class C(DimensionIndex): ...
 class CE(DimensionIndex): ...                  # flattened (cell, edge-of-cell) pairs
 
+class KDim(CartesianAxisIndex): ...            # a Cartesian axis: `KDim + 1`, Staggered[KDim]
+
 
 class V2E(NeighborConnectivity[V, E], max_neighbors=6, min_neighbors=5):   # counts optional
     class Local(LocalDimensionIndex): ...                            # explicit, always
@@ -356,7 +380,8 @@ stated as rules:
    to length 4.
 6. **Staggering is part of the dimension change.** The `_Staggered` name
    prefix needs the name→class lookup that type identity removes, so
-   `Staggered[D]` is a real class and part of ADR 0028 (PR A); see
+   `Staggered[D]` is a real class and part of ADR 0028 (PR A), together with
+   the [Cartesian axis dimensions](#cartesian-axis-dimensions) its parameter is bounded on; see
    [`Staggered[D]`](#staggeredd).
 7. **The IR names a connectivity by its `offset_tag`.** That is its local
    dimension's tag when it declares the local dimension: shifts, reductions
@@ -371,6 +396,151 @@ stated as rules:
    `check_neighbor_table` hints "was the declaration redefined?" when a table
    built for one is bound to the other.
 
+### Cartesian axis dimensions
+
+A **Cartesian axis** is an index space with integer index arithmetic and
+exactly one staggered partner — the dimensions `CartesianConnectivity` acts on.
+Read one axis of a Cartesian grid as a
+1-dimensional CW complex — a path when the axis is bounded, a cycle when it is
+periodic. Such a complex has exactly two cell classes, of degree 0 and 1, and a
+declared axis together with its `Staggered[·]` name those two classes.
+`Staggered` is the **involution that swaps them**. The types do not say which
+class has degree 0, and they need not: the ADR 0026 position convention
+(`Staggered[X](i)` at `i - 1/2`, so `Staggered[X](i)` is the cell
+`[X(i-1), X(i)]`) fixes only their *relative* alignment. Both assignments
+occur — a cell-centred field makes the declared axis the 1-cells and its
+partner the faces, and ICON's Lorenz grid makes `KDim` (full levels, layer
+midpoints) the 1-cells while `Staggered[KDim]` (half levels, interfaces) are
+the 0-cells.
+
+In more than one dimension the grid is the **product** complex of its axes, so
+a cell class is a bit vector over axes — one bit per axis, "does this cell span
+it?" — and the cell degree is the number of set bits. `Dims[...]` *is* that bit
+vector:
+
+| `Dims[...]` | cell | degree |
+| --- | --- | --- |
+| `Dims[I, J]` | vertex | 0 |
+| `Dims[Staggered[I], J]` | edge along `I` | 1 |
+| `Dims[I, Staggered[J]]` | edge along `J` | 1 |
+| `Dims[Staggered[I], Staggered[J]]` | face | 2 |
+
+Per-axis staggering is therefore *more* informative than a form degree, which
+in two dimensions conflates the two edge families a C-grid must keep apart —
+the distinction that has to be recovered by hand, as a component label, wherever
+no product structure exists (`EDGE_N` vs `EDGE_T` in
+[[personal/egparedes/discretization-independent-fd-syntax|the surface-syntax note]]
+§7.1). It is also why the structured and unstructured cases are encoded
+differently here at all: a per-axis bit exists exactly when the complex factors
+as a product, and mesh locations (`V`, `E`, `C`) are separate dimension classes
+because it does not.
+
+Two consequences shape the hierarchy:
+
+- **A staggered dimension is itself a discretized axis.** It is the other cell
+  class of the same complex: it carries fields, has a range, and takes integer
+  offsets. So the asymmetry between `D` and `Staggered[D]` is not semantic but
+  *declarational* — one is written by the user, the other derived from it, and
+  there is exactly one partner to derive. That is what makes the derivation
+  well-founded, and it is the level `Staggered`'s parameter must name.
+- **`Staggered[D]` needs no orientation data.** A 1-cell in a complex is
+  oriented, which is what makes the coboundary signed. A product of intervals
+  has a canonical orientation per axis (increasing index), so the sign is
+  implicit in the stencil the user writes. The unstructured side has no such
+  canonical choice, which is why incidence signs are materialized there (ICON's
+  `geofac_div` carries them). The absence is a consequence of the product
+  structure, not an omission.
+
+**The alignment is antisymmetric, so the convention is the user's to pick.** The
+ADR 0026 convention places `Staggered[D](i)` at `i - 1/2` in `D`'s coordinates;
+equivalently, it places `D(j)` at `j + 1/2` in `Staggered[D]`'s. Both conventions
+appear in production codes — whether `u(i)` is the west or the east face of cell
+`i` differs between codebases, as does whether half level `k` sits above or below
+full level `k` — and either is reachable by choosing *which member of the pair to
+declare*. The default puts the partner half a cell *below*; to have it half a cell
+*above* your main field, declare the axis the **partner** lives on and alias your
+main field onto the derived member. With `class IFace(CartesianAxisIndex)` and
+`ICell: TypeAlias = Staggered[IFace]`, an `IFace` field sits half a cell above the
+`ICell` field of the same index. The pair is symmetric in the implementation —
+`order_dimensions` orders by the base either way, `check_dims` is symmetric,
+fingerprints go through the base, gtfn aliases the staggered tag to its base — so
+the only residual cost is cosmetic: the derived member's *tag* reads
+`...Staggered[IFace]` in the IR, in codegen names and in error messages. Stencil
+code built from relative shifts is convention-independent in any case
+(`p(S + 1/2) - p(S - 1/2)` is the same difference either way, and `±1/2` reaches
+both neighbours); the convention bites only on absolute index correspondence with
+a reference implementation and on boundary index ranges.
+
+**Extents are declared, never derived.** A path complex has `n` 0-cells and
+`n - 1` 1-cells; a cycle has `n` and `n`. So the two members of a pair do not in
+general have the same range, and *which one is wider is the degree assignment*:
+with `I` the 0-cells on `[0, n)`, the interior 1-cells are `[I(i-1), I(i)]` for
+`i` in `[1, n)`, and `Staggered[I](0)` is the first cell outside the complex —
+exactly where a halo cell goes; with `K` the 1-cells on `[0, n)` (ICON's layers),
+the interfaces run `[0, n+1)`. Both are expressible without any new type-level
+concept because a `Domain` holds absolute `UnitRange(start, stop)`s rather than
+sizes — see
+[[personal/havogt/field-data-protocol/field-data-protocol|the field data protocol]]
+for why absolute addressing is the right domain model — and the periodic case
+needs nothing extra, the two ranges simply coincide in size. The invariant a grid
+builder owes is that the two ranges *interleave*, hence differ in size by exactly
+one when the axis is bounded and are equal when it is periodic. No component of
+this design sees both ranges at once, so enforcing it belongs to whatever
+constructs both
+([[personal/havogt/mesh-and-first-class-halos/mesh-and-first-class-halos|a mesh
+concept with first-class halos]]). Note also that `order_dimensions` giving a
+staggered field the *layout order* of its base says nothing about its *shape*:
+the two are independent.
+
+Hence three levels, all *below* `DimensionIndex`, so that no
+`type[DimensionIndex]` annotation in the tree changes and `LocalDimensionIndex`
+keeps its position:
+
+```
+DimensionIndex                            # the root; the tree's annotations say this
+├── AnyCartesianAxisIndex                 # a cell class of a Cartesian axis
+│   ├── CartesianAxisIndex                # ← declared; what users subclass
+│   └── Staggered[D: CartesianAxisIndex]  # derived
+├── LocalDimensionIndex                   # a neighbor index; not an axis
+└── (direct subclasses)                   # mesh locations V/E/C, and index spaces
+                                          #   with no geometry (tracer, ensemble)
+```
+
+Four checks the tree performs at runtime, or not at all, become static:
+
+| Rejected | Today | With `CartesianAxisIndex` |
+| --- | --- | --- |
+| `Staggered[Staggered[K]]` | runtime `TypeError` | static, at the bound |
+| `Staggered[V2E.Local]` | runtime `TypeError` | static, at the bound |
+| `Staggered[C]` — no half-cells on an unstructured mesh | nothing rejects it | static, at the bound |
+| `C + 1`, `V2E.Local + 1` — index arithmetic off an axis | runtime `kind` check, or a late failure | static, via `DimensionMeta.__add__`'s self-type |
+
+The last row needs `__add__` declared with `cls: type[AnyCartesianAxisIndex]`, which
+mypy accepts at every call site but flags at the *definition* site ("Self
+argument missing for a non-static method") — the same suppressed
+definition-site restriction
+[[personal/havogt/dimension-generic-fields/dimension-generic-fields|generic dimensions]]
+documents for its overload pairs.
+
+`kind` **shrinks.** It carries four jobs today: `LOCAL` marks a neighbor axis;
+`order_dimensions` sorts by `(kind, as_non_staggered(dim).value)`, so it decides
+memory layout order (constraint F4); `order_dimensions` also uses it to enforce
+at most one `LOCAL` dimension; and `VERTICAL` names the scan axis and, by
+convention, the undecomposed one. The first and third are now class facts —
+`kind == LOCAL` iff `issubclass(d, LocalDimensionIndex)` — so **`LOCAL` leaves the
+enum**: `kind` becomes `HORIZONTAL | VERTICAL` and `order_dimensions` sorts by
+`(is_local, kind, base.tag)` with `is_local` read from the class (PR B, where
+`LocalDimensionIndex` lands). What is left is the layout key and the "vertical"
+role, which belong to the field and to the program respectively — see
+[Open questions](#open-questions--follow-ups).
+
+The class level also draws a distinction `kind` never did: `IDim` and `CellDim`
+are both `HORIZONTAL` and only the first is an axis. That is why the migration
+cannot be inferred from the source — whether a dimension is an axis or a mesh
+location is a decision per declaration (about ten in ICON4Py's `dimension.py`;
+near-uniformly `CartesianAxisIndex` in `tests/next_tests`). The migration script
+rewrites what it can and reports the rest.
+
 ### `Staggered[D]`
 
 A staggered dimension sits at the **half-integer positions** of a base
@@ -379,21 +549,35 @@ dimension (ADR 0026): `Staggered[K](0)` is the point half a cell *below*
 different dimensions and cannot be combined by accident. The semantics of
 ADR 0026 — the position convention, the shift rule and the backend treatment
 — are unchanged; what changes is the *encoding*, from a reserved `_Staggered`
-prefix on the dimension name to a class.
+prefix on the dimension name to a class, whose parameter is the declared axis
+of [Cartesian axis dimensions](#cartesian-axis-dimensions).
 
 - **Runtime representation.** `Staggered[K]` is a real, interned class:
   `Staggered` has a metaclass whose `__getitem__` builds one class per base
   and caches it by base identity (with `setdefault`, so concurrent
-  compilation threads see one class). It is deliberately *not* a subclass of
-  `K`, so a `Field[Dims[Staggered[K]]]` is rejected where a `Field[Dims[K]]`
-  is required; it has `base = K` and `K`'s kind. Staggering a local
-  dimension, staggering twice, or subclassing a staggered class directly is a
-  `TypeError`. A PEP 695 generic cannot serve here — it would be a `typing`
-  alias, failing `issubclass` and eve's `type[...]` validation — but under
-  `TYPE_CHECKING` `Staggered` *is* declared as one, so mypy and pyright accept
-  `Staggered[K]` in annotations and in `Field[Dims[Staggered[K]], float]`.
-  `is_staggered`, `flip_staggered` and `as_non_staggered` keep their meaning
-  and read `base`.
+  compilation threads see one class). Its base is `AnyCartesianAxisIndex`, and it is
+  deliberately *not* a subclass of `K`, so a `Field[Dims[Staggered[K]]]` is
+  rejected where a `Field[Dims[K]]` is required; it has `base = K` and `K`'s
+  kind. Staggering anything that is not a declared `CartesianAxisIndex` — a local
+  dimension, a mesh location, an already-staggered class — and subclassing a
+  staggered class directly are `TypeError`s. A PEP 695 generic cannot serve
+  here — it would be a `typing` alias, failing `issubclass` and eve's
+  `type[...]` validation — but under `TYPE_CHECKING` `Staggered` *is* declared
+  as one, so mypy and pyright accept `Staggered[K]` in annotations and in
+  `Field[Dims[Staggered[K]], float]`. `is_staggered`, `flip_staggered` and
+  `as_non_staggered` keep their meaning and read `base`.
+- **Doubly staggered dimensions are unrepresentable, statically.** The
+  `TYPE_CHECKING` declaration is `class Staggered[D: CartesianAxisIndex](AnyCartesianAxisIndex)`,
+  and `Staggered[K]` is an `AnyCartesianAxisIndex` but not a `CartesianAxisIndex`, so
+  `Staggered[Staggered[K]]` is a `[type-var]` error for both checkers rather
+  than only a runtime `TypeError` — as are `Staggered[V2E.Local]` and
+  `Staggered[C]`. Because the extra levels sit below `DimensionIndex`,
+  `Staggered[K]` stays a `DimensionIndex` and no annotation widens; verified in
+  [`staggered_probe.py`](staggered_probe.py). Nothing stronger is claimed: the
+  equation `Staggered[Staggered[K]] = K` is not expressible (Python typing has
+  no type-level reduction), and it is not the right equation either — the two
+  cell classes of an axis are swapped by an involution, not collapsed, and
+  composing two half-shifts is a full offset (`K + 1`), not the identity.
 - **Embedded.** `K + 0.5` builds, through `connectivity_for_cartesian_shift`,
   a `CartesianConnectivity` whose codomain is `flip_staggered(K)`, with the
   `+1` index correction the position convention requires when shifting *out
@@ -418,9 +602,23 @@ prefix on the dimension name to a class.
   iteration space for a field and its staggered counterpart.
 
 [[personal/havogt/dimension-generic-fields/dimension-generic-fields|Generic dimensions and statically typed staggering]]
-Part II proposed this `Staggered[D]` shape with the same shift convention.
-Its static involution overloads (typing `Staggered[K] + 0.5` as landing on
-`K` for the checkers) are not part of the stack.
+Part II proposed this `Staggered[D]` shape with the same shift convention, and
+the root/user split that makes the doubly staggered type unrepresentable; here
+that split is motivated as the axis concept above and placed below
+`DimensionIndex` so that no annotation widens. Its static involution overloads
+(typing `Staggered[K] + 0.5` as landing on `K` for the checkers) are not part
+of the stack, so statically a half-integer shift is a plain `Connectivity`. Its
+`gradient_to_staggered` example, `p(Staggered[I] + 1/2) - p(Staggered[I] - 1/2)`,
+is the coboundary of a 0-cochain, which is why it lands on the partner class.
+
+**One naming constraint.** That prototype spells the partner-swapping operation
+`dual()` / `Dual[X]`. In a complex the Hodge dual flips *every* axis bit (a
+primal k-cell pairs with a dual (n−k)-cell) while `Staggered[D]` flips one, so
+the two coincide only in one dimension. `dual` stays reserved for the full
+Hodge dual — the sense
+[[personal/egparedes/discretization-independent-fd-syntax|the surface-syntax note]]
+§6.5 uses for the primal/dual C↔D grid swap — and the per-axis operation keeps
+gt4py's existing name, `flip_staggered`.
 
 ### Binding model
 
@@ -630,7 +828,8 @@ at the strict entry points); the `_Staggered` prefix and its string sniffing
 (replaced by the `Staggered[D]` class and a small `<owner>[<base>]` tag
 grammar); `_CONST_DIM` as a magic name; the stored `AxisLiteral.kind`;
 `SparseTag`; `NamedIndex` and the dimension half of the mypy plugin;
-`DimensionIndex(kind=LOCAL)` as a way to declare a local dimension; and the
+`DimensionIndex(kind=LOCAL)` as a way to declare a local dimension, and the
+`LOCAL` member of `DimensionKind` itself (derived from `LocalDimensionIndex`); and the
 convention that `V2EDim = Dimension("V2E", LOCAL)` must sit next to
 `V2E = FieldOffset("V2E", ...)`; the names `ts.OffsetType` (now
 `ts.ShiftType`, with `domain`/`codomain` instead of the inverted
@@ -725,13 +924,54 @@ be a `typing` alias, not a class, failing `issubclass` and eve's `type[...]`
 validation and unable to carry a tag. The metaclass subscription builds a
 real class; the PEP 695 form is used only under `TYPE_CHECKING`.
 
+**A sibling root above `DimensionIndex`** — `AnyDimensionIndex` with
+`DimensionIndex` and `Staggered[D]` as siblings, which is where
+[[personal/havogt/dimension-generic-fields/dimension-generic-fields|generic dimensions]]
+puts the split. Gives the same static ban, but `Staggered[K]` then stops being
+a `DimensionIndex`, so every annotation and `issubclass` guard that must accept
+a staggered dimension has to widen, and the static and runtime lattices diverge
+unless the widening is mirrored at runtime. The `AnyCartesianAxisIndex` / `CartesianAxisIndex`
+levels sit below the root instead and cost nothing at those sites.
+
+**A structural discriminator instead of the axis levels** — bound `Staggered`'s
+parameter to a `Protocol` carrying `__gt_staggered__: ClassVar[Literal[False]]`
+that the staggered class overrides with `Literal[True]`. Rejected: it needs a
+suppressed incompatible-override, reports an opaque diagnostic, hangs a
+meaningless attribute on every dimension, and buys only the ban — there is no
+axis concept, so `C + 1` and `Staggered[C]` stay unchecked.
+
+**A second partner constructor** — `Staggered[D]` for `i - 1/2` and
+`StaggeredAbove[D]` for `i + 1/2`, instead of a per-axis alignment. Rejected: it
+gives three cell classes per axis where an axis has two, so
+`Field[Dims[Staggered[I], StaggeredAbove[I]]]` — the same physical axis twice —
+becomes expressible and needs a new `check_dims` rule; and it makes
+`flip_staggered` partial, since `flip_staggered(I)` would have two candidate
+answers, so `I + 0.5` could not compute its own codomain and neither
+`as_non_staggered` nor the typed `dual()` would be well defined. It also spells a
+per-*pair* fact at every use site, so two modules can disagree about one grid, and
+it duplicates the whole bracketed-tag apparatus (a second interned family, tag
+grammar, `copyreg` hook and codegen escape). Parameterizing the alignment, if it
+is done at all, is one class keyword on the declared axis — see
+[Open questions](#open-questions--follow-ups).
+
+**Declaring both members of a pair** (`class ICell(CartesianAxisIndex, dual_of=IFace,
+offset=+0.5)`). The explicit form, rejected for the reason this note exists: it
+reintroduces a two-object agreement, loses the property that a partner needs no
+separate declaration, and loses the involution by construction.
+
+**`Staggered[D: AnyCartesianAxisIndex]`**, bounding on any cell class rather than on a
+declared axis. The semantically tempting reading, since a staggered dimension
+*is* an axis — but it re-admits `Staggered[Staggered[K]]`. The bound has to name
+the declared level.
+
 ## Relation to gt4py ADRs
 
 - **ADR 0019 (Connectivities).** The part naming `FieldOffset` as the frontend
   identifier is superseded by ADR 0029; the `Connectivity` / `NeighborTable` /
   `ConnectivityType` vocabulary is kept ([What stays](#what-stays-and-why)).
 - **ADR 0026 (Staggered dimensions).** Its encoding is superseded by
-  `Staggered[D]` ([above](#staggeredd)); its semantics are unchanged.
+  `Staggered[D]` ([above](#staggeredd)); its semantics are unchanged, and
+  [Cartesian axis dimensions](#cartesian-axis-dimensions) states the structure they encode.
 - **ADR 0028 (Dimensions as nominal types)** and **ADR 0029 (Connectivities
   as types)** record this design in the gt4py tree.
 - **ADR 0023 (build cache).** Fingerprints depend on qualified names, so the
@@ -760,6 +1000,52 @@ real class; the PEP 695 form is used only under `TYPE_CHECKING`.
    would be its natural home.
 4. **Chain proposals.** Their static encodings need rewriting to `C.Local`
    ([Relation to `Local[V2E]`](#relation-to-localv2e)).
+5. **Parameterizing the alignment.** The ADR 0026 convention is hard-coded. The
+   antisymmetry above makes both conventions reachable by choosing which member of
+   the pair to declare, at a cosmetic cost in the derived member's tag; a per-axis
+   class keyword (`class X(CartesianAxisIndex, stagger=Align.ABOVE)`) would remove
+   even that. It would have to be **static, on the axis**: it changes the integer
+   correction `connectivity_for_cartesian_shift` bakes into the
+   `CartesianConnectivity`, hence the emitted stencil, so unlike periodicity and
+   extents it cannot be a grid property. Its footprint is one `ClassVar` plus `+1`
+   vs `+0` in that one function — the backends only ever see an integer offset
+   along an axis — against three costs: `a(Staggered[I] + 1/2)` stops being
+   readable without the declaration, the frontend and embedded shift test matrix
+   doubles, and Identity rule 4 bites, since dimensions fingerprint *by reference*
+   and flipping the keyword in place would not invalidate the ADR 0023 cache. That
+   last hole is pre-existing (`kind` has it too) and would argue for folding
+   declaration-time dimension attributes into the fingerprint. Not in this stack.
+6. **`kind`'s remaining two jobs.** Once `LOCAL` leaves the enum, `kind` is a
+   layout sort key and a name for the scan axis. Layout is a property of the field,
+   not of the dimension, and that coupling is why dimension *names* currently
+   determine memory layout (F4); what `order_dimensions` actually wants is an
+   *order* — innermost to outermost, `I, J, K` for a box, `(CellDim, KDim)` for
+   ICON — which a per-grid dimension ordering would supply and which would retire
+   F4. "Vertical" is a role, not a geometry: in a Cartesian box the three axes are
+   alike, and what singles out `K` is that the numerics is sequential along it and
+   that it is not decomposed, properties of the program and of the decomposition.
+   [[personal/havogt/scan-redesign/scan-redesign|Scan redesign]] already takes the
+   scan range from the output domain rather than from `kind`. Every candidate
+   *addition* to `kind` — periodic, distributed, sequential, cell degree — likewise
+   belongs to the grid, the program or the range, so `kind` should shrink rather
+   than grow.
+7. **A cell `degree` on the axis.** Making the degree assignment static
+   (`degree=0|1`) would let a coboundary be typed generically
+   (`d⁰: Field[deg 0] -> Field[deg 1]`) and make the range invariant derivable
+   rather than declared. Left out for now: it duplicates what the absolute ranges
+   already say, creating exactly the cross-object agreement this note removes; it
+   does not fix the extent relation without periodicity, which cannot be static;
+   and nothing consumes it until an exterior-calculus surface exists (Proposal 1
+   of
+   [[personal/egparedes/discretization-independent-fd-syntax|the surface-syntax note]]).
+   Revisit if that surface lands.
+8. **A `LocationIndex` level for mesh locations.** `CartesianAxisIndex` separates
+   Cartesian axes from everything else, but `V`, `E`, `C` stay direct
+   `DimensionIndex` subclasses, so "a primary, non-local dimension" — what
+   `NeighborConnectivity[Domain, Codomain]` and `MultiDimensionIndex` actually
+   want, and check at runtime — is still not a type. A fourth level would give
+   it, at the cost of a second per-declaration migration decision. Out of scope
+   here.
 
 ## Implementation
 
@@ -772,8 +1058,10 @@ on its own, each based on the previous one:
 
 | PR | Branch | What |
 | --- | --- | --- |
-| A: GridTools/gt4py#2899 | `connectivities-as-types-2-dimension-classes` | `feat[next]`: a concrete dimension is a class identified by its qualified name (ADR 0028); `codegen_name`; `Staggered[D]`; interactive-`__main__` fallback; `NamedIndex` and the dimension half of the mypy plugin removed; `ConstList` with `size=1` replaces the `_CONST_DIM` aliases; `AxisLiteral` drops `kind`; printing IR never imports (`resolve_loaded`); offset tag = local dimension tag = provider key in the tree |
-| B: GridTools/gt4py#2907 | `connectivities-as-types-3-neighbor-connectivity` | `feat[next]`: `NeighborConnectivity[Domain, Codomain]`, `LocalDimensionIndex`, `check_neighbor_table`, `local_dimension_of`, declaration fingerprinting; usable in the DSL; shared local dimensions, in the declarations and in the backends (`connectivity_key_over`, DaCe `local_dimension_size`); `NeighborTableType` and `ts.ShiftType`; pyright in the typing nox session; ADR 0029 |
+| A: GridTools/gt4py#2899 | `connectivities-as-types-2-dimension-classes` | `feat[next]`: a concrete dimension is a class identified by its qualified name (ADR 0028); `codegen_name`; `CartesianAxisIndex` / `AnyCartesianAxisIndex` and
+`Staggered[D: CartesianAxisIndex]`; interactive-`__main__` fallback; `NamedIndex` and the dimension half of the mypy plugin removed; `ConstList` with `size=1` replaces the `_CONST_DIM` aliases; `AxisLiteral` drops `kind`; printing IR never imports (`resolve_loaded`); offset tag = local dimension tag = provider key in the tree |
+| B: GridTools/gt4py#2907 | `connectivities-as-types-3-neighbor-connectivity` | `feat[next]`: `NeighborConnectivity[Domain, Codomain]`, `LocalDimensionIndex`
+(and `DimensionKind.LOCAL` removed, derived from the class), `check_neighbor_table`, `local_dimension_of`, declaration fingerprinting; usable in the DSL; shared local dimensions, in the declarations and in the backends (`connectivity_key_over`, DaCe `local_dimension_size`); `NeighborTableType` and `ts.ShiftType`; pyright in the typing nox session; ADR 0029 |
 | C: GridTools/gt4py#2910 | `connectivities-as-types-6-class-keyed-providers` | `feat[next]!`: the tree and docs declare connectivities as classes; class-keyed offset providers with `check_offset_provider` at every entry point; `FieldOffset` removed; `as_offset(dim, field)`; `table_types` replaces `offset_provider_type`; migration script |
 | D: GridTools/gt4py#2912 | `connectivities-as-types-8-typed-positions` | `refactor[next]`: `MultiDimensionIndex` and typed embedded positions |
 
@@ -811,3 +1099,8 @@ ICON4Py.
   also when only the local dimension differs; generated `ClassVar` form and
   `Local[C]` reconciliation do not). Last run with mypy 2.3.1 and pyright
   1.1.414.
+- [`staggered_probe.py`](staggered_probe.py): the mypy / pyright probes behind
+  [Cartesian axis dimensions](#cartesian-axis-dimensions) — `Staggered[Staggered[I]]`,
+  `Staggered[V2E.Local]` and `Staggered[C]` are `[type-var]` errors, while
+  `Staggered[I]` stays usable where `type[DimensionIndex]` is required and in
+  `Dims[...]`, so no annotation in the tree widens.
diff --git a/content/personal/egparedes/connectivities-as-types/staggered_probe.py b/content/personal/egparedes/connectivities-as-types/staggered_probe.py
new file mode 100644
index 0000000..a78e30a
--- /dev/null
+++ b/content/personal/egparedes/connectivities-as-types/staggered_probe.py
@@ -0,0 +1,145 @@
+"""Typing probe for the Cartesian-axis levels and the `Staggered[D]` bound.
+
+Run with `mypy --strict --python-version 3.12` and `pyright --pythonversion 3.12`.
+
+Expected: every line marked `EXPECT-ERROR` reported (the `Staggered[...]`
+subscriptions as `[type-var]`, "Type argument ... must be a subtype of
+CartesianAxisIndex"), and nothing else. The `must be ACCEPTED` lines are the
+point of placing the two axis levels *below* `DimensionIndex` rather than above
+it: a staggered dimension stays a `DimensionIndex`, so no `type[DimensionIndex]`
+annotation in the gt4py tree widens, and `LocalDimensionIndex` keeps its
+position.
+
+Only the *static* declarations are modelled. At runtime `Staggered` is a
+metaclass subscription building one interned class per base, and
+`LocalDimensionIndex` is a real subclass of `DimensionIndex` so that eve's
+`type[...]` validation is unaffected — see the main note.
+
+Last run: mypy 2.3.1 and pyright 1.1.414 (2026-10-01). Both report exactly the
+nine `EXPECT-ERROR` lines and nothing else (mypy emits two diagnostics for the
+`Doubly` alias, pyright one), so every `must be ACCEPTED` line holds.
+"""
+
+from __future__ import annotations
+
+from typing import ClassVar, TypeAlias
+
+# ---------------- the hierarchy ----------------
+
+
+class DimensionIndex:
+    """The root. Mesh locations and geometry-less index spaces are direct subclasses."""
+
+    value: int
+
+
+class AnyCartesianAxisIndex(DimensionIndex):
+    """Either cell class of a Cartesian axis: declared or derived."""
+
+
+class CartesianAxisIndex(AnyCartesianAxisIndex):
+    """A *declared* Cartesian axis. Only these have a staggered partner."""
+
+
+class Staggered[D: CartesianAxisIndex](AnyCartesianAxisIndex):
+    """The derived partner cell class of a declared axis."""
+
+    base: ClassVar[type[CartesianAxisIndex]]
+
+
+class LocalDimensionIndex(DimensionIndex):
+    """A neighbor index. Not an axis, and unmoved relative to the root."""
+
+    owner: ClassVar[type | None]
+
+
+class Dims[*Ds]: ...
+
+
+class Field[DimsT, DT]: ...
+
+
+# ---------------- user declarations ----------------
+
+
+class I(CartesianAxisIndex): ...  # noqa: E742  # single-letter dimension names are the domain convention
+
+
+class J(CartesianAxisIndex): ...
+
+
+class K(CartesianAxisIndex): ...
+
+
+class C(DimensionIndex): ...  # a mesh location: no index arithmetic, no partner
+
+
+class E(DimensionIndex): ...
+
+
+class V2E:
+    class Local(LocalDimensionIndex): ...
+
+
+Khalf: TypeAlias = Staggered[K]  # a domain name for the partner is just an alias
+
+
+# ---------------- P1: the rejections ----------------
+
+
+def p1_doubly_staggered(
+    f: Field[Dims[Staggered[Staggered[I]]], float],  # EXPECT-ERROR: [type-var]
+) -> None: ...
+
+
+def p1_staggered_local(
+    f: Field[Dims[Staggered[V2E.Local]], float],  # EXPECT-ERROR: [type-var]
+) -> None: ...
+
+
+def p1_staggered_mesh_location(
+    f: Field[Dims[Staggered[C]], float],  # EXPECT-ERROR: [type-var]
+) -> None: ...
+
+
+# also in alias position, not only in an annotation
+Doubly: TypeAlias = Staggered[Staggered[K]]  # EXPECT-ERROR: [type-var]
+
+
+# ---------------- P2: what must keep working (no widening) ----------------
+
+
+def p2_any_dimension(d: type[DimensionIndex]) -> None: ...
+
+
+p2_any_dimension(Staggered[I])  # must be ACCEPTED: staggered dims are still dimensions
+p2_any_dimension(V2E.Local)  # must be ACCEPTED: locals unmoved
+p2_any_dimension(C)  # must be ACCEPTED: mesh locations unmoved
+p2_any_dimension(I)  # must be ACCEPTED
+
+
+def p2_in_dims(f: Field[Dims[I, J, Staggered[K]], float]) -> None: ...  # ACCEPTED
+
+
+def p2_through_alias(f: Field[Dims[Khalf], float]) -> None: ...  # ACCEPTED
+
+
+# ---------------- P3: the axis levels discriminate ----------------
+
+
+def p3_any_axis(d: type[AnyCartesianAxisIndex]) -> None: ...  # e.g. flip_staggered, check_dims
+
+
+p3_any_axis(I)  # must be ACCEPTED
+p3_any_axis(Staggered[I])  # must be ACCEPTED
+p3_any_axis(C)  # EXPECT-ERROR: a mesh location is not an axis
+p3_any_axis(V2E.Local)  # EXPECT-ERROR: a local dimension is not an axis
+
+
+def p3_declared_axis(d: type[CartesianAxisIndex]) -> None: ...  # e.g. the Staggered constructor
+
+
+p3_declared_axis(I)  # must be ACCEPTED
+p3_declared_axis(Staggered[I])  # EXPECT-ERROR: derived, not declared
+p3_declared_axis(C)  # EXPECT-ERROR: mesh location
+p3_declared_axis(V2E.Local)  # EXPECT-ERROR: local dimension
diff --git a/content/personal/egparedes/discretization-independent-fd-syntax.md b/content/personal/egparedes/discretization-independent-fd-syntax.md
index b94c7ee..0a271a3 100644
--- a/content/personal/egparedes/discretization-independent-fd-syntax.md
+++ b/content/personal/egparedes/discretization-independent-fd-syntax.md
@@ -1,7 +1,7 @@
 ---
 title: A discretization-independent surface syntax for finite-difference computations
 author: egparedes
-tags: [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]
+tags: [finite-difference, finite-volume, mesh-invariant, structured, unstructured, exterior-calculus, dec, mimetic, de-rham, cw-complex, 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]
 created: 2026-06-30
 status: draft
 ---
@@ -130,6 +130,8 @@ Its companion in documentation is the **stencil molecule** — a figure that *on
 
 There is no analogous molecule for an unstructured operator: the "stencil" is a variable-valence patch, so unstructured papers draw a representative hexagon/triangle and rely on the connectivity-sum form instead.
 
+Per axis, the half-index pair is the two cell classes of a 1-dimensional CW complex — the 0-cells and 1-cells of a path, or of a cycle if the axis is periodic — and in more than one dimension the grid is their **product** complex, so a cell class is one staggering bit per axis and the cell degree is the number of set bits. That is the structure [[personal/egparedes/connectivities-as-types/connectivities-as-types|Connectivities as types]] encodes in the type system, as `Staggered[D]` over a declared axis dimension; the `HLoc`/`VLoc` location types of §7.1 sit above it, and a per-axis bit vector is strictly finer than a form degree (it keeps the two edge families of §6.4 apart, which `k = 1` alone does not).
+
 ### 3.4 Connectivity-sum notation — *FV / mimetic FD on unstructured grids*
 
 The explicit-topology form, with an orientation array doing the work the index sign did above. ICON-class papers (Wan et al. 2013; Zängl et al. 2015) and MPAS/TRiSK papers (Ringler et al. 2010) write essentially:

From 94d17260a318cac48bbae5ef64dfe26b781dd150 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Gonz=C3=A1lez=20Paredes?= <enriqueg@cscs.ch>
Date: Thu, 1 Oct 2026 16:53:58 +0200
Subject: [PATCH 02/19] =?UTF-8?q?personal/egparedes:=20connectivities=20as?=
 =?UTF-8?q?=20types=20=E2=80=94=20UGRID/SGRID=20alignment=20appendix?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Audit the design against the two community conventions for describing mesh
topology and grid staggering in netCDF/CF: UGRID for unstructured meshes and
SGRID for structured staggered grids.

The structural finding: UGRID's locations are cell *degrees*
(node/edge/face/volume) while SGRID's are per-axis *bit vectors*
(node/edge1/edge2/face in 2D, eight values in 3D). The two conventions split
exactly along the product-versus-non-product line the Cartesian-axis section
derives from the CW complex — SGRID must distinguish edge1 from edge2, UGRID
cannot — which arrives as external evidence for encoding the two cases
differently. `Dims[Staggered[I], J]` derives what SGRID enumerates as 2^n names.

SGRID's four `padding` values decode into single absolute `UnitRange`s under one
alignment convention, so the decision that extents are declared and never
derived is vindicated and the range model is strictly more expressive than the
enum (`padding: low` is exactly the halo cell the note already names). The same
decoding shows `low`/`both` use ADR 0026's alignment and `none`/`high` the other
one, which is standardized evidence for the alignment follow-up.

Enhancements recorded: UGRID's location vocabulary gives `LocationIndex` content
and is where a cell `degree` belongs, since a degree is canonical for a mesh
location and only declarational for a Cartesian axis; `check_neighbor_table`
could validate a bound table against the codomain's absolute range, making
UGRID's `start_index` a non-issue; UGRID's anticlockwise node ordering would make
incidence signs derivable rather than supplied. Two findings for havogt's mesh
and field-data proposals (fields on a non-contiguous subset of a location, and a
field knowing its mesh) are recorded in the appendix rather than edited into
another contributor's working area.

New open question 9 on the index origin of a bound table; open questions 5-8
updated with the convention evidence.
---
 content/index.md                              |   2 +-
 .../connectivities-as-types.md                |  54 ++++-
 .../connectivities-as-types_conventions.md    | 221 ++++++++++++++++++
 3 files changed, 265 insertions(+), 12 deletions(-)
 create mode 100644 content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md

diff --git a/content/index.md b/content/index.md
index 7689cd8..05d6647 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, type-checking, dimensions, local-dimensions, connectivities, offset-provider, unstructured, neighbor-sum, reduction, frontend, foast, gtir, embedded, gtfn, dace, nominal-types, dependent-types, metaclass, serialization, fingerprint, staggering, axis-dimensions, cw-complex, exterior-calculus, domain, dimension-kind, migration, adr, tech-debt, shared-local-dimensions, implemented
+- [[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, dependent-types, metaclass, serialization, fingerprint, staggering, axis-dimensions, cw-complex, exterior-calculus, domain, dimension-kind, ugrid, sgrid, migration, adr, tech-debt, shared-local-dimensions, implemented
 - [[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, cw-complex, 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 5001857..45fe4e7 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, type-checking, dimensions, local-dimensions, connectivities, offset-provider, unstructured, neighbor-sum, reduction, frontend, foast, gtir, embedded, gtfn, dace, nominal-types, dependent-types, metaclass, serialization, fingerprint, staggering, axis-dimensions, cw-complex, exterior-calculus, domain, dimension-kind, migration, adr, tech-debt, shared-local-dimensions, implemented]
+tags: [type-system, type-checking, dimensions, local-dimensions, connectivities, offset-provider, unstructured, neighbor-sum, reduction, frontend, foast, gtir, embedded, gtfn, dace, nominal-types, dependent-types, metaclass, serialization, fingerprint, staggering, axis-dimensions, cw-complex, exterior-calculus, domain, dimension-kind, ugrid, sgrid, migration, adr, tech-debt, shared-local-dimensions, implemented]
 created: 2026-09-17
 updated: 2026-10-01
 status: draft
@@ -454,9 +454,11 @@ Two consequences shape the hierarchy:
 **The alignment is antisymmetric, so the convention is the user's to pick.** The
 ADR 0026 convention places `Staggered[D](i)` at `i - 1/2` in `D`'s coordinates;
 equivalently, it places `D(j)` at `j + 1/2` in `Staggered[D]`'s. Both conventions
-appear in production codes — whether `u(i)` is the west or the east face of cell
-`i` differs between codebases, as does whether half level `k` sits above or below
-full level `k` — and either is reachable by choosing *which member of the pair to
+appear in production codes — the SGRID convention's four `padding` values
+enumerate both, `low` and `both` placing a cell at `j - 1/2` while `none` and
+`high` place it at `j + 1/2`
+([[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions appendix]]
+§3) — and either is reachable by choosing *which member of the pair to
 declare*. The default puts the partner half a cell *below*; to have it half a cell
 *above* your main field, declare the axis the **partner** lives on and alias your
 main field onto the derived member. With `class IFace(CartesianAxisIndex)` and
@@ -484,8 +486,11 @@ sizes — see
 for why absolute addressing is the right domain model — and the periodic case
 needs nothing extra, the two ranges simply coincide in size. The invariant a grid
 builder owes is that the two ranges *interleave*, hence differ in size by exactly
-one when the axis is bounded and are equal when it is periodic. No component of
-this design sees both ranges at once, so enforcing it belongs to whatever
+one when the axis is bounded and are equal when it is periodic. An absolute range
+is strictly more expressive than SGRID's `padding` enum here: each of its four
+values is one `UnitRange` under a single alignment convention, and
+`padding: low` is exactly the halo cell named above. No component of this design
+sees both ranges at once, so enforcing it belongs to whatever
 constructs both
 ([[personal/havogt/mesh-and-first-class-halos/mesh-and-first-class-halos|a mesh
 concept with first-class halos]]). Note also that `order_dimensions` giving a
@@ -1000,8 +1005,11 @@ the declared level.
    would be its natural home.
 4. **Chain proposals.** Their static encodings need rewriting to `C.Local`
    ([Relation to `Local[V2E]`](#relation-to-localv2e)).
-5. **Parameterizing the alignment.** The ADR 0026 convention is hard-coded. The
-   antisymmetry above makes both conventions reachable by choosing which member of
+5. **Parameterizing the alignment.** The ADR 0026 convention is hard-coded, while
+   SGRID's `padding` attribute exists precisely because production codes use both
+   alignments
+   ([[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions appendix]]
+   §3). The antisymmetry above makes both conventions reachable by choosing which member of
    the pair to declare, at a cosmetic cost in the derived member's tag; a per-axis
    class keyword (`class X(CartesianAxisIndex, stagger=Align.ABOVE)`) would remove
    even that. It would have to be **static, on the axis**: it changes the integer
@@ -1025,7 +1033,9 @@ the declared level.
    alike, and what singles out `K` is that the numerics is sequential along it and
    that it is not decomposed, properties of the program and of the decomposition.
    [[personal/havogt/scan-redesign/scan-redesign|Scan redesign]] already takes the
-   scan range from the output domain rather than from `kind`. Every candidate
+   scan range from the output domain rather than from `kind`, and SGRID describes
+   vertical staggering with the *same* `padding` syntax as horizontal, so it needs
+   no vertical kind at all. Every candidate
    *addition* to `kind` — periodic, distributed, sequential, cell degree — likewise
    belongs to the grid, the program or the range, so `kind` should shrink rather
    than grow.
@@ -1038,14 +1048,29 @@ the declared level.
    and nothing consumes it until an exterior-calculus surface exists (Proposal 1
    of
    [[personal/egparedes/discretization-independent-fd-syntax|the surface-syntax note]]).
-   Revisit if that surface lands.
+   Revisit if that surface lands — but note that a degree is *canonical* for a mesh
+   location and only *declarational* for a Cartesian axis, so it belongs on the
+   `LocationIndex` of the next item rather than here
+   ([[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions appendix]]
+   §4a).
 8. **A `LocationIndex` level for mesh locations.** `CartesianAxisIndex` separates
    Cartesian axes from everything else, but `V`, `E`, `C` stay direct
    `DimensionIndex` subclasses, so "a primary, non-local dimension" — what
    `NeighborConnectivity[Domain, Codomain]` and `MultiDimensionIndex` actually
    want, and check at runtime — is still not a type. A fourth level would give
    it, at the cost of a second per-declaration migration decision. Out of scope
-   here.
+   here, but it has a ready-made vocabulary: UGRID's `node`/`edge`/`face`/`volume`
+   gated by `topology_dimension`, whose location names *are* cell degrees
+   ([[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions appendix]]
+   §4a).
+9. **The index origin of a bound table.** `NeighborTableType` records `dtype`,
+   `skip_value` and `max_neighbors` but no index origin, while UGRID standardizes
+   `start_index` ∈ {0, 1} and ICON4Py's tables come from Fortran. Since a codomain
+   dimension carries an absolute range, `check_neighbor_table` could validate
+   entries against that range instead of against `[0, size)`, making a 1-based
+   table a codomain over `[1, n+1)` and `start_index` a non-issue
+   ([[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions appendix]]
+   §4b).
 
 ## Implementation
 
@@ -1099,6 +1124,13 @@ ICON4Py.
   also when only the local dimension differs; generated `ClassVar` form and
   `Local[C]` reconciliation do not). Last run with mypy 2.3.1 and pyright
   1.1.414.
+- [[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|Alignment with the UGRID and SGRID conventions]]:
+  an audit against the two community conventions for mesh topology and grid
+  staggering — why UGRID's locations are cell degrees while SGRID's are per-axis
+  bit vectors, how SGRID's four `padding` values decode into single absolute
+  ranges, and the enhancements that follow (a UGRID vocabulary for
+  `LocationIndex`, validating a bound table against its codomain's range,
+  deriving incidence signs from a recorded node ordering).
 - [`staggered_probe.py`](staggered_probe.py): the mypy / pyright probes behind
   [Cartesian axis dimensions](#cartesian-axis-dimensions) — `Staggered[Staggered[I]]`,
   `Staggered[V2E.Local]` and `Staggered[C]` are `[type-var]` errors, while
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md
new file mode 100644
index 0000000..73ff1c3
--- /dev/null
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md
@@ -0,0 +1,221 @@
+---
+title: "Connectivities as types — alignment with the UGRID and SGRID conventions"
+author: egparedes
+tags: [type-system, dimensions, local-dimensions, connectivities, unstructured, staggering, cw-complex, domain, ugrid, sgrid, conventions, interop, halos, prior-art]
+created: 2026-10-01
+status: draft
+---
+
+> **Appendix** to [[personal/egparedes/connectivities-as-types/connectivities-as-types|Connectivities as types]].
+> An audit of this design against the two established community conventions for
+> describing mesh topology and grid staggering in netCDF/CF data: **UGRID** for
+> unstructured meshes and **SGRID** for structured staggered grids. It records
+> where the design already agrees with them, the one place a convention is
+> sharper than this note, and the concrete enhancements that follow. Some
+> findings land on
+> [[personal/havogt/mesh-and-first-class-halos/mesh-and-first-class-halos|a mesh concept with
+> first-class halos]] and
+> [[personal/havogt/field-data-protocol/field-data-protocol|the field data protocol]]
+> rather than here; they are listed in [For the mesh and field-data
+> proposals](#5-for-the-mesh-and-field-data-proposals) rather than edited into
+> those notes.
+
+Sources: [UGRID conventions](https://ugrid-conventions.github.io/ugrid-conventions/)
+and [SGRID conventions](https://sgrid.github.io/sgrid/) (v0.3), read 2026-10-01.
+
+**A caution before anything else.** Both are netCDF *interchange* conventions.
+A location is a string attribute on a data variable and a mesh is a dummy
+variable referenced by name — the exact pattern this proposal replaces with
+types. What transfers is the **vocabulary and the invariants**, not the
+mechanism. Nothing below suggests adopting netCDF attributes into the DSL.
+
+## 1. The two conventions, structurally
+
+**UGRID.** A dummy variable with `cf_role = "mesh_topology"`,
+`topology_dimension` ∈ {1, 2, 3}, `node_coordinates`, and connectivity arrays
+named by *entity pair*: `edge_node_connectivity` (required for 1D),
+`face_node_connectivity` (2D), `volume_node_connectivity` (3D), plus optional
+`face_edge_connectivity`, `face_face_connectivity`, `edge_face_connectivity`,
+`boundary_node_connectivity`. Ragged connectivity is padded to a maximum
+(`nMaxMesh2_face_nodes`) with a required `_FillValue`; each connectivity carries
+`start_index` ∈ {0, 1}. A data variable carries `mesh = "Mesh2"` and
+`location` ∈ {`node`, `edge`, `face`, `volume`}, or `location_index_set` for
+data on a subset. Face corner nodes are required to be ordered anticlockwise as
+viewed from above.
+
+**SGRID.** A variable with `cf_role = "grid_topology"`, `topology_dimension` ∈
+{2, 3}, `node_dimensions`, and `face_dimensions` (2D) or `volume_dimensions`
+(3D); optionally `edge1_dimensions`, `edge2_dimensions`, `vertical_dimensions`,
+and per-location coordinate attributes. A data variable carries
+`grid = "MyGrid"` and `location` ∈ {`node`, `edge1`, `edge2`, `face`} in 2D, or
+eight values in 3D. 1D is not specified, and the spec states the 3D option
+"should not be used for layered grids, such as typical ocean and atmosphere
+models. Use the 2d grid with vertical dimensions instead."
+
+### The structural observation
+
+**UGRID's locations are cell degrees; SGRID's are per-axis bit vectors.**
+
+| | locations | reading |
+| --- | --- | --- |
+| UGRID | `node`, `edge`, `face`, `volume` | degree 0, 1, 2, 3 |
+| SGRID 2D | `node`, `edge1`, `edge2`, `face` | 2² bit vectors over the two axes |
+| SGRID 3D | `node`, `edge1`–`edge3`, `face1`–`face3`, `volume` | 2³ bit vectors |
+
+Two standards bodies, working independently, split exactly along the
+product-versus-non-product line that
+[[personal/egparedes/connectivities-as-types/connectivities-as-types#cartesian-axis-dimensions|Cartesian axis dimensions]]
+derives from the CW complex. SGRID **must** distinguish `edge1` from `edge2`
+because a product complex has two edge families per 2D cell; UGRID **cannot**,
+because an unstructured complex does not factor and only the degree survives.
+That is the note's claim arriving as external evidence, and it is the reason the
+two cases are encoded differently here: `Staggered[D]` per axis for the product
+case, separate dimension classes for mesh locations.
+
+On encoding, this design is ahead: `Dims[Staggered[I], J]` *derives* what SGRID
+enumerates as 2ⁿ location names, and it does not stop at three axes.
+
+## 2. Where the design already agrees
+
+| Convention feature | This design | Verdict |
+| --- | --- | --- |
+| Connectivities named by entity pair (`face_node_connectivity`) | `NeighborConnectivity[Domain, Codomain]` — `face_node_connectivity` ≡ `NeighborConnectivity[Face, Node]` | isomorphic. The `Domain`/`Codomain` naming matches UGRID's reading direction, where `source`/`target` did not |
+| `_FillValue` required on ragged arrays; its *absence* means fixed valence; `nMaxMesh2_face_nodes` | `skip_value`, `max_neighbors`, `min_neighbors` on `NeighborTableType` | strictly more informative. ICON's icosahedron carries 12 pentagons among hexagons, so `V2E` is `min_neighbors=5, max_neighbors=6`; UGRID can only record max 6 plus fill. That is the sketch's example verbatim |
+| `vertical_dimensions` uses **the same** padding syntax as `face_dimensions` | — | the vertical is just another axis pair. SGRID needs no "vertical kind", which supports the conclusion that `DimensionKind.VERTICAL` is a layout and scan artefact, not geometry (main note, open question 6) |
+| `face_dimensions` specifies a padding **per axis** | a per-axis alignment, never grid-wide | supports the shape of the alignment follow-up (open question 5): a class keyword on the axis |
+| 3D topology forbidden for layered grids; use 2D + `vertical_dimensions` | horizontal topology plus a separate vertical axis | validates the existing split |
+| `topology_dimension` gates which locations exist | — | see [§4(a)](#a-take-ugrids-location-vocabulary-for-locationindex-and-move-degree-there) |
+
+## 3. SGRID padding versus "extents are declared, never derived"
+
+This is the sharpest interaction. Verbatim from the SGRID spec:
+
+> the padding type may be one of the four literal strings: "none", "low",
+> "high", or "both" depending on whether the face_dimension is one shorter than
+> the corresponding node_dimension (padding:none), one longer than the
+> corresponding node_dimension (padding:both), or of equal length with one extra
+> value stored on the low or high end of the dimension
+
+The format is `face_dimension1: node_dimension1 (padding: type1) …`, and
+`layer_dimension: layer_interface_dimension (padding: type)` — derived dimension
+first, node dimension second. Decoding each value into array positions (netCDF
+dimensions are always 0-based) with `n` the node count:
+
+| padding | cells | cell `j` spans nodes | cell `j` at node-position | as one absolute `UnitRange` under ADR 0026 |
+| --- | --- | --- | --- | --- |
+| `none` | n−1 | (j, j+1) | j + ½ | `[1, n)` |
+| `low` | n | (j−1, j) | j − ½ | `[0, n)` |
+| `high` | n | (j, j+1) | j + ½ | `[1, n+1)` |
+| `both` | n+1 | (j−1, j) | j − ½ | `[0, n+1)` |
+
+Three conclusions, and they do not all point the same way.
+
+**(i) The decision that extents are declared rather than derived is vindicated,
+and the range model is strictly more expressive than the padding enum.** Each of
+the four values is one absolute `UnitRange` under a *single* alignment
+convention, and that works precisely because a gt4py range carries a `start`
+while a netCDF dimension does not. The range model also reaches arbitrary halo
+depth, which `padding` cannot express at all. Had the design derived
+`Staggered[D]`'s extent from `D`'s, it would have been wrong for three of
+SGRID's four cases.
+
+**(ii) `padding: low` is this note's halo remark, standardized.** The main note
+observes that `Staggered[I](0)` "is the first cell outside the complex — exactly
+where a halo cell goes". That is `low`: equal length, one extra value stored at
+the low end.
+
+**(iii) Both alignments are standardized and in production, which strengthens
+the alignment follow-up.** `low` and `both` place cell `j` at `j − ½`, which is
+ADR 0026's convention; `none` and `high` place it at `j + ½`, the other one. The
+`padding` attribute exists *because* real codes use both — ROMS, Delft3D and
+WRF-ARW are the spec's own examples. Note the asymmetry this exposes: absolute
+ranges give the right *point set* under either convention but not matching
+*labels*, which is why parameterizing the alignment is about porting and
+validation fidelity rather than expressiveness.
+
+## 4. Enhancements for this proposal
+
+### (a) Take UGRID's location vocabulary for `LocationIndex`, and move `degree` there
+
+Open question 8 proposes a `LocationIndex` level without saying what it would
+contain. UGRID supplies it: `Node`, `Edge`, `Face`, `Volume`, gated by
+`topology_dimension`. The non-obvious part is where the cell degree belongs:
+
+- For a **mesh location**, the degree is **canonical** — UGRID's four location
+  names *are* degrees 0–3, and `topology_dimension` is the maximum present.
+- For a **Cartesian axis**, the degree is **declarational** — nothing in the
+  types says whether `KDim` indexes layers or interfaces, and SGRID does not
+  record a degree either; it records `padding` instead.
+
+So the static `degree` of open question 7, rejected there for a Cartesian axis,
+belongs on `LocationIndex` instead. That redirects the question rather than
+answering it, and it gives `LocationIndex` content worth having: a typed
+`Node`/`Edge`/`Face`/`Volume` vocabulary with degrees makes a UGRID mesh bind by
+construction, and makes "a primary, non-local dimension" expressible.
+
+### (b) Validate a bound table against the codomain's range, not against `[0, size)`
+
+UGRID standardizes `start_index` ∈ {0, 1} on every connectivity array, and
+ICON4Py's tables come from Fortran. `NeighborTableType` carries `dtype`,
+`skip_value` and `max_neighbors` but no index origin. Since a codomain dimension
+has an absolute range, `check_neighbor_table` can validate entries against
+`codomain`'s `UnitRange` rather than against `[0, size)`, and a 1-based table is
+then simply a codomain with range `[1, n+1)`. That makes `start_index` a
+non-issue at the cost of one comparison in one function, and it is the same
+absolute-range argument as §3(i).
+
+### (c) Record the orientation guarantee so incidence signs become derivable
+
+UGRID requires face corner nodes "in anticlockwise … direction as viewed from
+above". That makes the incidence signs — the `d` of `div = ⋆d⋆` — **derivable
+from `face_node_connectivity`** instead of supplied. The main note explains why
+the Cartesian side needs no orientation data (a product of intervals is
+canonically oriented per axis) and points at ICON's `geofac_div` for the
+unstructured side, where the signs are materialized. UGRID shows the
+unstructured side can be canonical too if a declaration records the ordering
+guarantee — an `orientation=` marker on a `C2V`-shaped connectivity would let
+[[personal/egparedes/discretization-independent-fd-syntax|the surface-syntax note]]
+compute mimetic weights rather than receive them. Out of scope for the PR stack;
+it is the cheapest bridge between the two notes.
+
+### (d) External evidence for open question 6
+
+UGRID had to add `face_dimension` and `edge_dimension` attributes purely to
+disambiguate which netCDF dimension indexes the mesh element, because a global
+ordering rule proved insufficient. That is the same failure mode as constraint
+F4 — dimension *names* determining memory layout through `order_dimensions` —
+and it supports the conclusion that layout belongs to the field or the grid
+rather than to a global rule keyed on `kind`.
+
+## 5. For the mesh and field-data proposals
+
+Two findings land outside this note. They are recorded here rather than edited
+into another contributor's working area.
+
+**Fields on a non-contiguous subset of a location.** UGRID's
+`location_index_set` (a variable with `cf_role = "location_index_set"`, plus
+`mesh` and `location`) exists exactly for data defined on a subset of an entity
+type. A gt4py `Domain` is a dense `UnitRange`, so this is inexpressible — yet
+ICON needs it: owned versus halo entities, and per-region index lists. Neither
+[[personal/havogt/mesh-and-first-class-halos/mesh-and-first-class-halos|the mesh proposal]]
+nor
+[[personal/havogt/field-data-protocol/field-data-protocol|the field data protocol]]
+names it as a requirement, and the halo proposal's ownership metadata is the
+natural home.
+
+**A field should know its mesh.** Both conventions put `mesh=` / `grid=` on
+*every* data variable. A gt4py field knows its dimensions but not its mesh,
+which is precisely the unresolved multi-table case of the main note's open
+question 2 — halo variants, rewritten `keep_skip_values` tables, several meshes
+in one process. The conventions' answer is uniform: carry the grid identity with
+the data, not only in a side dict.
+
+## 6. The practical payoff
+
+Aligning on vocabulary rather than mechanism makes a UGRID/SGRID reader on the
+`gtx` side straightforward: entity classes and connectivity declarations come
+from the convention, `start_index` resolves into the codomain range (b), ragged
+valence into `min_neighbors`/`max_neighbors`/`skip_value`, SGRID `padding` into
+the two members' absolute ranges (§3), and SGRID `location` into a `Dims[...]`
+bit vector. That is downstream of the whole PR stack and is a goal, not a
+deliverable of it.

From e74326937184a6c291328b5de194f8d5ed7e8de1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Gonz=C3=A1lez=20Paredes?= <enriqueg@cscs.ch>
Date: Thu, 1 Oct 2026 17:45:37 +0200
Subject: [PATCH 03/19] =?UTF-8?q?personal/egparedes:=20connectivities=20as?=
 =?UTF-8?q?=20types=20=E2=80=94=20correctness=20pass=20after=20review?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fixes found by an independent review of the whole proposal.

Wrong claims:
- `Staggered[Staggered[K]] = K` is semantically *right* — `Staggered` is an
  involution on the two cell classes, as the note itself states. Only its
  expressibility is in question, so the two would be incompatible nominal types.
  The previous "not the right equation either" argument conflated the type
  constructor with the index shift.
- The extent invariant said the two ranges "differ in size by exactly one when
  bounded", which the conventions appendix disproves: SGRID's `low` and `high`
  are bounded with equal sizes. Interleaving gives at most one, and halo
  extension relaxes even that.
- "Both assignments occur" was supported by two examples of the *same*
  assignment. Replaced the first with a vertex-indexed structured grid.
- The degree bit-vector table silently assumed the declared axis indexes its
  0-cells, contradicting "the types do not say which class has degree 0" two
  paragraphs earlier. The assumption is now stated.
- Both checkers reject the `__add__` self-type at the definition site, not only
  mypy, and with different diagnostics, so it costs two separately-spelled
  suppressions. `staggered_probe.py` gains P4 covering the fourth row of the
  "four checks become static" table — the one row it did not reach — and both
  suppressions. The mypy wording quoted from `dimension-generic-fields` was stale.
- Scan redesign never appeals to `kind`; "rather than from `kind`" was this
  note's inference presented as that note's position.
- The surface-syntax citation moved from §6.4 to §6.5 for the placement map, and
  now says its §3.3 cross-link was added alongside this note, so it is a pointer
  and not independent corroboration.
- UGRID *recommends* anticlockwise face nodes ("should"), not requires, which
  weakens the derivable-incidence-signs suggestion accordingly. SGRID does have
  absolute numbering via integer coordinate variables, so the `UnitRange` column
  is a correct relative decoding and "more expressive" is qualified. The
  `_FillValue` and F4-analogy readings are corrected.

Rendering and accounting:
- The Implementation table rows for PRs A and B spanned two source lines, so GFM
  truncated both. Back onto single lines.
- "PR 1" was never defined; it is GridTools/gt4py#2898.
- The concept-count parenthetical summed to 23, not 25; the appendix's
  "connectivity type classes" row was missing.
- The A1-A10 accounting left two constraints unexplained: A9 also dissolves, A10
  remains, re-expressed over `tag`.
- The Sketch showed the PEP 695 `Staggered` as if it were the runtime form.
- `ts.ShiftType` appeared in both "What it deletes" and "Kept"; the provider-key
  rule for `{V2E.tag: table}` was unparseable as written.
- `typing_probe.py` is not error-clean and now says so.

New open question 9 on `DimensionMeta.__eq__` versus the "equality is `is`"
identity rule, which the note asserts in one place and overrides in another.
---
 .../connectivities-as-types.md                | 100 +++++++++++-------
 .../connectivities-as-types_conventions.md    |  48 +++++----
 .../staggered_probe.py                        |  41 ++++++-
 .../connectivities-as-types/typing_probe.py   |  14 ++-
 4 files changed, 139 insertions(+), 64 deletions(-)

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 45fe4e7..001209b 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
@@ -27,8 +27,10 @@ status: draft
 >
 > `FieldOffset`, bare-name provider keys (`{"V2E": ...}`) and the
 > `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.
+> identity constraints in the current tree, six (A1–A5 and A9, the embedded
+> position-dict key) dissolve by construction, three (A6–A8) collapse into a
+> single bind-time check, and one (A10, the `AxisLiteral` round-trip) remains,
+> re-expressed over `tag` instead of `Dimension.value`.
 
 > **Implementation.** The design below is implemented on the stacked
 > GridTools/gt4py PRs listed in [Implementation](#implementation) (top branch
@@ -63,9 +65,10 @@ status: draft
 > the typed substrate that proposal can bind through. The staggering half
 > draws its vocabulary from
 > [[personal/egparedes/discretization-independent-fd-syntax|A discretization-independent surface
-> syntax for finite-difference computations]] §3.3 and §6.4, where the same
-> two-cell-class structure appears as half-index notation and as the Arakawa
-> placement map; that note's location types sit above this one.
+> syntax for finite-difference computations]] §3.3 (half-index notation) and
+> §6.5 (the Arakawa placement map); that note's location types sit above this
+> one, and its §3.3 cross-link back to here was added alongside this note, so it
+> is a pointer rather than independent corroboration.
 
 ## Problem / motivation
 
@@ -151,7 +154,8 @@ the easiest key.
 
 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
+runtime connectivity classes, 4 provider aliases, 2 connectivity type classes,
+2 declaration classes) for
 what is one idea — *a mapping between two index spaces, plus a name for it*.
 
 ## Proposal
@@ -255,7 +259,9 @@ class LocalDimensionIndex(DimensionIndex):     # kind is LOCAL; `kind=LOCAL` els
 class MultiDimensionIndex[D: DimensionIndex, *Ls](tuple[D, *Ls]): ...   # shape checked at runtime
 
 
-class Staggered[D: CartesianAxisIndex](AnyCartesianAxisIndex): ...  # interned (ADR 0026)
+# the TYPE_CHECKING form; at runtime a metaclass subscription builds the
+# interned classes, since a PEP 695 alias fails `issubclass` (ADR 0026)
+class Staggered[D: CartesianAxisIndex](AnyCartesianAxisIndex): ...
 
 Staggered[KDim]                                # KDim's derived partner;
                                                #   Staggered[Staggered[KDim]] is a type error
@@ -406,12 +412,11 @@ periodic. Such a complex has exactly two cell classes, of degree 0 and 1, and a
 declared axis together with its `Staggered[·]` name those two classes.
 `Staggered` is the **involution that swaps them**. The types do not say which
 class has degree 0, and they need not: the ADR 0026 position convention
-(`Staggered[X](i)` at `i - 1/2`, so `Staggered[X](i)` is the cell
-`[X(i-1), X(i)]`) fixes only their *relative* alignment. Both assignments
-occur — a cell-centred field makes the declared axis the 1-cells and its
-partner the faces, and ICON's Lorenz grid makes `KDim` (full levels, layer
-midpoints) the 1-cells while `Staggered[KDim]` (half levels, interfaces) are
-the 0-cells.
+(`Staggered[X](i)` at `i - 1/2`) fixes only their *relative* alignment. Both
+assignments occur. A vertex-indexed structured grid declares the 0-cells, so
+`Staggered[I](i)` is the 1-cell `[I(i-1), I(i)]`; ICON's Lorenz grid declares
+the 1-cells, `KDim` being the full levels (layer midpoints) while
+`Staggered[KDim]` are the half levels (interfaces, the 0-cells).
 
 In more than one dimension the grid is the **product** complex of its axes, so
 a cell class is a bit vector over axes — one bit per axis, "does this cell span
@@ -425,6 +430,10 @@ vector:
 | `Dims[I, Staggered[J]]` | edge along `J` | 1 |
 | `Dims[Staggered[I], Staggered[J]]` | face | 2 |
 
+The `cell` and `degree` columns assume the first assignment above — every
+declared axis indexes its 0-cells. Under the other assignment the column reads
+upside down on that axis; the *encoding* is unaffected, which is the point.
+
 Per-axis staggering is therefore *more* informative than a form degree, which
 in two dimensions conflates the two edge families a C-grid must keep apart —
 the distinction that has to be recovered by hand, as a component label, wherever
@@ -485,8 +494,9 @@ sizes — see
 [[personal/havogt/field-data-protocol/field-data-protocol|the field data protocol]]
 for why absolute addressing is the right domain model — and the periodic case
 needs nothing extra, the two ranges simply coincide in size. The invariant a grid
-builder owes is that the two ranges *interleave*, hence differ in size by exactly
-one when the axis is bounded and are equal when it is periodic. An absolute range
+builder owes is that the two ranges *interleave*; their sizes then differ by at
+most one when the complex is closed, and halo extension relaxes even that (two of
+SGRID's four bounded cases, `low` and `high`, have equal sizes). An absolute range
 is strictly more expressive than SGRID's `padding` enum here: each of its four
 values is one `UnitRange` under a single alignment convention, and
 `padding: low` is exactly the halo cell named above. No component of this design
@@ -520,12 +530,16 @@ Four checks the tree performs at runtime, or not at all, become static:
 | `Staggered[C]` — no half-cells on an unstructured mesh | nothing rejects it | static, at the bound |
 | `C + 1`, `V2E.Local + 1` — index arithmetic off an axis | runtime `kind` check, or a late failure | static, via `DimensionMeta.__add__`'s self-type |
 
-The last row needs `__add__` declared with `cls: type[AnyCartesianAxisIndex]`, which
-mypy accepts at every call site but flags at the *definition* site ("Self
-argument missing for a non-static method") — the same suppressed
-definition-site restriction
+The last row needs `__add__` declared with `cls: type[AnyCartesianAxisIndex]`.
+Both checkers bind that signature correctly at every call site and both reject it
+at the *definition* site, with different diagnostics — mypy `[misc]` ("self"
+parameter missing for a non-static method), pyright
+`reportGeneralTypeIssues` ("Type of parameter `cls` must be a supertype of its
+class `DimensionMeta`") — so it costs two separately-spelled suppressions. P4 of
+[`staggered_probe.py`](staggered_probe.py) pins this down; the same restriction
+is what
 [[personal/havogt/dimension-generic-fields/dimension-generic-fields|generic dimensions]]
-documents for its overload pairs.
+suppresses for its overload pairs.
 
 `kind` **shrinks.** It carries four jobs today: `LOCAL` marks a neighbor axis;
 `order_dimensions` sorts by `(kind, as_non_staggered(dim).value)`, so it decides
@@ -578,11 +592,13 @@ of [Cartesian axis dimensions](#cartesian-axis-dimensions).
   than only a runtime `TypeError` — as are `Staggered[V2E.Local]` and
   `Staggered[C]`. Because the extra levels sit below `DimensionIndex`,
   `Staggered[K]` stays a `DimensionIndex` and no annotation widens; verified in
-  [`staggered_probe.py`](staggered_probe.py). Nothing stronger is claimed: the
-  equation `Staggered[Staggered[K]] = K` is not expressible (Python typing has
-  no type-level reduction), and it is not the right equation either — the two
-  cell classes of an axis are swapped by an involution, not collapsed, and
-  composing two half-shifts is a full offset (`K + 1`), not the identity.
+  [`staggered_probe.py`](staggered_probe.py). Nothing stronger is claimed. The
+  equation `Staggered[Staggered[K]] = K` is semantically right — `Staggered` is
+  an involution on the two cell classes — but Python typing has no type-level
+  reduction, so `Field[Dims[K]]` and a hypothetical
+  `Field[Dims[Staggered[Staggered[K]]]]` would be mutually incompatible nominal
+  types. Making the nested form unrepresentable sidesteps the equation instead
+  of asserting it.
 - **Embedded.** `K + 0.5` builds, through `connectivity_for_cartesian_shift`,
   a `CartesianConnectivity` whose codomain is `flip_staggered(K)`, with the
   `+1` index correction the position convention requires when shifting *out
@@ -691,8 +707,8 @@ tables assign different neighbors to the same domain element. The model:
   and skip-value presence and — where a program is compiled — on the skip
   positions of the concrete tables, compared on the device the tables live on.
   A key that names the *connectivity* instead of the declaration (`{V2E.tag:
-  table}`, which is the IR name only of a connectivity that shares a local
-  dimension) is rejected with a pointer to `{V2E: table}`. A string key that is
+  table}`, which is the IR name of a declaration only when it shares another's
+  local dimension) is rejected with a pointer to `{V2E: table}`. A string key that is
   not a qualified name at all is remembered as such, so it costs one import
   attempt in total rather than one per call.
 - The class never holds data; the table crosses process boundaries as it did.
@@ -816,7 +832,7 @@ tables assign different neighbors to the same domain element. The model:
 | --- | --- | --- |
 | Frontend declaration | `Dimension(LOCAL)` + `FieldOffset` + provider key | one class |
 | Frontend types | `ts.OffsetType(source, target)`, tag dropped | `ts.ShiftType(domain, codomain, tag)` produced by the class (`__gt_type__`), `tag` set to `offset_tag`; `V2E.Local` in DSL code types as the local dimension |
-| FOAST → GTIR | shift tag = **Python variable name** | tag = `offset_tag`; the variable name is irrelevant (PR 1) |
+| FOAST → GTIR | shift tag = **Python variable name** | tag = `offset_tag`; the variable name is irrelevant (GridTools/gt4py#2898) |
 | ITIR | `OffsetLiteral(str)` + dict lookup; `AxisLiteral(value, kind)` | `OffsetLiteral(offset_tag)`, unchanged node; `AxisLiteral(value)` with `kind` derived |
 | ITIR types | `ListType.offset_type: Dimension` | unchanged (already the local dim) |
 | Embedded field | `get_offset(provider, axis.value)` | table over the local dimension (`connectivity_key_over`); `V2E.bound_table()` |
@@ -841,7 +857,9 @@ convention that `V2EDim = Dimension("V2E", LOCAL)` must sit next to
 `source`/`target`), `NeighborConnectivityType` (now `NeighborTableType`) and
 the parameter `offset_provider_type` (now `table_types`).
 
-**Kept**: `ts.ShiftType` and the runtime connectivity objects (see
+**Kept** (the concepts, not always the names — `ts.ShiftType` is the renamed and
+re-fielded `ts.OffsetType`): the frontend shift type and the runtime
+connectivity objects (see
 [What stays, and why](#what-stays-and-why)); `iterator.runtime.offset("...")`
 (the iterator-level API names offsets by string, like the IR); and
 string-keyed providers *below* the entry points.
@@ -876,7 +894,7 @@ static encoding is.
 **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 is fixed regardless (PR 1).
+`foast_to_gtir` part is a real bug, fixed regardless, in GridTools/gt4py#2898.
 But it *enforces* the tangle rather than removing it; no concept goes away.
 
 **A declaration object with a derived local dimension, keeping `Dimension`
@@ -999,7 +1017,7 @@ the declared level.
    (halo variants, rewritten `keep_skip_values` tables, several meshes in one
    process) is addressed by neither yet.
 3. **Closure variable resolution.** The N2 leak (Python variable name
-   becoming the IR tag) is fixed in `foast_to_gtir` (PR 1); the resolution
+   becoming the IR tag) is fixed in `foast_to_gtir` (GridTools/gt4py#2898); the resolution
    mechanism of
    [[personal/havogt/closure-variable-resolution|Closure variable resolution]]
    would be its natural home.
@@ -1032,8 +1050,8 @@ the declared level.
    F4. "Vertical" is a role, not a geometry: in a Cartesian box the three axes are
    alike, and what singles out `K` is that the numerics is sequential along it and
    that it is not decomposed, properties of the program and of the decomposition.
-   [[personal/havogt/scan-redesign/scan-redesign|Scan redesign]] already takes the
-   scan range from the output domain rather than from `kind`, and SGRID describes
+   [[personal/havogt/scan-redesign/scan-redesign|Scan redesign]] takes the scan
+   range from the output domain and never appeals to `kind` at all, and SGRID describes
    vertical staggering with the *same* `padding` syntax as horizontal, so it needs
    no vertical kind at all. Every candidate
    *addition* to `kind` — periodic, distributed, sequential, cell degree — likewise
@@ -1063,7 +1081,15 @@ the declared level.
    gated by `topology_dimension`, whose location names *are* cell degrees
    ([[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions appendix]]
    §4a).
-9. **The index origin of a bound table.** `NeighborTableType` records `dtype`,
+9. **`DimensionMeta.__eq__` versus "equality is `is`".** [Identity](#identity-is-the-qualified-python-name)
+   states that the runtime view of identity is `is`, while the sketch keeps
+   `__eq__` overridden so that `I == 5` builds a `Domain` (with
+   `__hash__ = type.__hash__`). A metaclass `__eq__` that does not return a bool
+   makes `I == J` not a comparison, and dict lookups on a hash collision would
+   call `bool(Domain)`. Class-keyed providers (`{V2E: table}`) and the `is`-based
+   identity story both depend on this being benign; it is not established here,
+   and the ADR 0028 implementation should say which of the two rules wins.
+10. **The index origin of a bound table.** `NeighborTableType` records `dtype`,
    `skip_value` and `max_neighbors` but no index origin, while UGRID standardizes
    `start_index` ∈ {0, 1} and ICON4Py's tables come from Fortran. Since a codomain
    dimension carries an absolute range, `check_neighbor_table` could validate
@@ -1083,10 +1109,8 @@ on its own, each based on the previous one:
 
 | PR | Branch | What |
 | --- | --- | --- |
-| A: GridTools/gt4py#2899 | `connectivities-as-types-2-dimension-classes` | `feat[next]`: a concrete dimension is a class identified by its qualified name (ADR 0028); `codegen_name`; `CartesianAxisIndex` / `AnyCartesianAxisIndex` and
-`Staggered[D: CartesianAxisIndex]`; interactive-`__main__` fallback; `NamedIndex` and the dimension half of the mypy plugin removed; `ConstList` with `size=1` replaces the `_CONST_DIM` aliases; `AxisLiteral` drops `kind`; printing IR never imports (`resolve_loaded`); offset tag = local dimension tag = provider key in the tree |
-| B: GridTools/gt4py#2907 | `connectivities-as-types-3-neighbor-connectivity` | `feat[next]`: `NeighborConnectivity[Domain, Codomain]`, `LocalDimensionIndex`
-(and `DimensionKind.LOCAL` removed, derived from the class), `check_neighbor_table`, `local_dimension_of`, declaration fingerprinting; usable in the DSL; shared local dimensions, in the declarations and in the backends (`connectivity_key_over`, DaCe `local_dimension_size`); `NeighborTableType` and `ts.ShiftType`; pyright in the typing nox session; ADR 0029 |
+| A: GridTools/gt4py#2899 | `connectivities-as-types-2-dimension-classes` | `feat[next]`: a concrete dimension is a class identified by its qualified name (ADR 0028); `codegen_name`; `CartesianAxisIndex` / `AnyCartesianAxisIndex` and `Staggered[D: CartesianAxisIndex]`; interactive-`__main__` fallback; `NamedIndex` and the dimension half of the mypy plugin removed; `ConstList` with `size=1` replaces the `_CONST_DIM` aliases; `AxisLiteral` drops `kind`; printing IR never imports (`resolve_loaded`); offset tag = local dimension tag = provider key in the tree |
+| B: GridTools/gt4py#2907 | `connectivities-as-types-3-neighbor-connectivity` | `feat[next]`: `NeighborConnectivity[Domain, Codomain]`, `LocalDimensionIndex` (and `DimensionKind.LOCAL` removed, derived from the class), `check_neighbor_table`, `local_dimension_of`, declaration fingerprinting; usable in the DSL; shared local dimensions, in the declarations and in the backends (`connectivity_key_over`, DaCe `local_dimension_size`); `NeighborTableType` and `ts.ShiftType`; pyright in the typing nox session; ADR 0029 |
 | C: GridTools/gt4py#2910 | `connectivities-as-types-6-class-keyed-providers` | `feat[next]!`: the tree and docs declare connectivities as classes; class-keyed offset providers with `check_offset_provider` at every entry point; `FieldOffset` removed; `as_offset(dim, field)`; `table_types` replaces `offset_provider_type`; migration script |
 | D: GridTools/gt4py#2912 | `connectivities-as-types-8-typed-positions` | `refactor[next]`: `MultiDimensionIndex` and typed embedded positions |
 
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md
index 73ff1c3..c9713b5 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md
@@ -40,8 +40,8 @@ named by *entity pair*: `edge_node_connectivity` (required for 1D),
 (`nMaxMesh2_face_nodes`) with a required `_FillValue`; each connectivity carries
 `start_index` ∈ {0, 1}. A data variable carries `mesh = "Mesh2"` and
 `location` ∈ {`node`, `edge`, `face`, `volume`}, or `location_index_set` for
-data on a subset. Face corner nodes are required to be ordered anticlockwise as
-viewed from above.
+data on a subset. Face corner nodes *should* be ordered anticlockwise as viewed
+from above — a recommendation, not a requirement.
 
 **SGRID.** A variable with `cf_role = "grid_topology"`, `topology_dimension` ∈
 {2, 3}, `node_dimensions`, and `face_dimensions` (2D) or `volume_dimensions`
@@ -80,7 +80,7 @@ enumerates as 2ⁿ location names, and it does not stop at three axes.
 | Convention feature | This design | Verdict |
 | --- | --- | --- |
 | Connectivities named by entity pair (`face_node_connectivity`) | `NeighborConnectivity[Domain, Codomain]` — `face_node_connectivity` ≡ `NeighborConnectivity[Face, Node]` | isomorphic. The `Domain`/`Codomain` naming matches UGRID's reading direction, where `source`/`target` did not |
-| `_FillValue` required on ragged arrays; its *absence* means fixed valence; `nMaxMesh2_face_nodes` | `skip_value`, `max_neighbors`, `min_neighbors` on `NeighborTableType` | strictly more informative. ICON's icosahedron carries 12 pentagons among hexagons, so `V2E` is `min_neighbors=5, max_neighbors=6`; UGRID can only record max 6 plus fill. That is the sketch's example verbatim |
+| `_FillValue` required wherever an entry may be absent — ragged valence, but also a missing boundary neighbour in `edge_face_connectivity` / `face_face_connectivity`; `nMaxMesh2_face_nodes` | `skip_value`, `max_neighbors`, `min_neighbors` on `NeighborTableType` | strictly more informative. ICON's icosahedron carries 12 pentagons among hexagons, so `V2E` is `min_neighbors=5, max_neighbors=6`; UGRID can only record max 6 plus fill. That is the sketch's example verbatim |
 | `vertical_dimensions` uses **the same** padding syntax as `face_dimensions` | — | the vertical is just another axis pair. SGRID needs no "vertical kind", which supports the conclusion that `DimensionKind.VERTICAL` is a layout and scan artefact, not geometry (main note, open question 6) |
 | `face_dimensions` specifies a padding **per axis** | a per-axis alignment, never grid-wide | supports the shape of the alignment follow-up (open question 5): a class keyword on the axis |
 | 3D topology forbidden for layered grids; use 2D + `vertical_dimensions` | horizontal topology plus a separate vertical axis | validates the existing split |
@@ -99,7 +99,7 @@ This is the sharpest interaction. Verbatim from the SGRID spec:
 The format is `face_dimension1: node_dimension1 (padding: type1) …`, and
 `layer_dimension: layer_interface_dimension (padding: type)` — derived dimension
 first, node dimension second. Decoding each value into array positions (netCDF
-dimensions are always 0-based) with `n` the node count:
+dimension indices are 0-based; see the qualification under (i)) with `n` the node count:
 
 | padding | cells | cell `j` spans nodes | cell `j` at node-position | as one absolute `UnitRange` under ADR 0026 |
 | --- | --- | --- | --- | --- |
@@ -111,13 +111,20 @@ dimensions are always 0-based) with `n` the node count:
 Three conclusions, and they do not all point the same way.
 
 **(i) The decision that extents are declared rather than derived is vindicated,
-and the range model is strictly more expressive than the padding enum.** Each of
-the four values is one absolute `UnitRange` under a *single* alignment
-convention, and that works precisely because a gt4py range carries a `start`
-while a netCDF dimension does not. The range model also reaches arbitrary halo
-depth, which `padding` cannot express at all. Had the design derived
-`Staggered[D]`'s extent from `D`'s, it would have been wrong for three of
-SGRID's four cases.
+and the range model is the more expressive of the two.** Each of the four values
+is one absolute `UnitRange` under a *single* alignment convention. The range model
+also reaches arbitrary halo depth, which `padding` cannot express at all, and had
+the design derived `Staggered[D]`'s extent from `D`'s it would have been wrong for
+three of SGRID's four cases.
+
+Two qualifications on "more expressive". The `UnitRange` column above is a correct
+*relative* decoding; its absolute origin is a choice, because SGRID does have a
+mechanism for absolute numbering that `padding` alone does not show — integer
+coordinate variables (`face(face)`, `node(node)`), which the Delft3D example uses
+to number layer interfaces `0 … KMAX` while everything else counts from 1. So
+netCDF *dimensions* are 0-based but SGRID *labels* need not be. What a `UnitRange`
+still adds is that the origin travels with the dimension in one object rather than
+in a separate coordinate variable, and that halo depth is unbounded.
 
 **(ii) `padding: low` is this note's halo remark, standardized.** The main note
 observes that `Staggered[I](0)` "is the first cell outside the complex — exactly
@@ -166,9 +173,13 @@ absolute-range argument as §3(i).
 
 ### (c) Record the orientation guarantee so incidence signs become derivable
 
-UGRID requires face corner nodes "in anticlockwise … direction as viewed from
-above". That makes the incidence signs — the `d` of `div = ⋆d⋆` — **derivable
-from `face_node_connectivity`** instead of supplied. The main note explains why
+UGRID says face corner nodes "should be specified in anticlockwise (also referred
+to as counterclockwise) direction as viewed from above". Where that holds, the
+incidence signs — the `d` of `div = ⋆d⋆` — are **derivable from
+`face_node_connectivity`** instead of supplied. Note the modal verb: the
+convention *recommends* the ordering rather than mandating it, so a consumer
+cannot assume it — which is exactly why a gt4py-side declaration would have to
+record the guarantee rather than infer it. The main note explains why
 the Cartesian side needs no orientation data (a product of intervals is
 canonically oriented per axis) and points at ICON's `geofac_div` for the
 unstructured side, where the signs are materialized. UGRID shows the
@@ -182,10 +193,11 @@ it is the cheapest bridge between the two notes.
 
 UGRID had to add `face_dimension` and `edge_dimension` attributes purely to
 disambiguate which netCDF dimension indexes the mesh element, because a global
-ordering rule proved insufficient. That is the same failure mode as constraint
-F4 — dimension *names* determining memory layout through `order_dimensions` —
-and it supports the conclusion that layout belongs to the field or the grid
-rather than to a global rule keyed on `kind`.
+ordering rule proved insufficient. The mechanisms differ — UGRID has to *record*
+which stored axis is the element axis, whereas F4 *derives* layout from dimension
+names through `order_dimensions` — but the premise that failed is the same in
+both: that one global rule can fix dimension order. It supports the conclusion
+that layout belongs to the field or the grid.
 
 ## 5. For the mesh and field-data proposals
 
diff --git a/content/personal/egparedes/connectivities-as-types/staggered_probe.py b/content/personal/egparedes/connectivities-as-types/staggered_probe.py
index a78e30a..f7ee4cd 100644
--- a/content/personal/egparedes/connectivities-as-types/staggered_probe.py
+++ b/content/personal/egparedes/connectivities-as-types/staggered_probe.py
@@ -8,7 +8,10 @@
 point of placing the two axis levels *below* `DimensionIndex` rather than above
 it: a staggered dimension stays a `DimensionIndex`, so no `type[DimensionIndex]`
 annotation in the gt4py tree widens, and `LocalDimensionIndex` keeps its
-position.
+position. P4 covers the fourth row of the note's "four checks become static"
+table — index arithmetic restricted to an axis by a self-type on
+`DimensionMeta.__add__` — including the two definition-site suppressions that
+restriction costs (see the comment on `DimensionMeta`).
 
 Only the *static* declarations are modelled. At runtime `Staggered` is a
 metaclass subscription building one interned class per base, and
@@ -16,8 +19,8 @@
 `type[...]` validation is unaffected — see the main note.
 
 Last run: mypy 2.3.1 and pyright 1.1.414 (2026-10-01). Both report exactly the
-nine `EXPECT-ERROR` lines and nothing else (mypy emits two diagnostics for the
-`Doubly` alias, pyright one), so every `must be ACCEPTED` line holds.
+eleven `EXPECT-ERROR` lines and nothing else — mypy 12 diagnostics (two for the
+`Doubly` alias), pyright 11 — so every `must be ACCEPTED` line holds.
 """
 
 from __future__ import annotations
@@ -27,7 +30,27 @@
 # ---------------- the hierarchy ----------------
 
 
-class DimensionIndex:
+class Connectivity: ...
+
+
+class DimensionMeta(type):
+    # Restricting index arithmetic to an axis needs a self-type on a metaclass
+    # method. BOTH checkers reject that at the *definition* site, with different
+    # diagnostics, so two separately-spelled suppressions are required:
+    #   mypy    : "self" parameter missing for a non-static method
+    #             (or an invalid type for self)            [misc]
+    #   pyright : Type of parameter "cls" must be a supertype of its class
+    #             "DimensionMeta"       (reportGeneralTypeIssues)
+    # Both bind the annotated signature correctly at every call site — which is
+    # what P4 below checks.
+    def __add__(  # type: ignore[misc]
+        cls: type[AnyCartesianAxisIndex],  # pyright: ignore[reportGeneralTypeIssues]
+        offset: int | float,
+    ) -> Connectivity:
+        raise NotImplementedError
+
+
+class DimensionIndex(metaclass=DimensionMeta):
     """The root. Mesh locations and geometry-less index spaces are direct subclasses."""
 
     value: int
@@ -143,3 +166,13 @@ def p3_declared_axis(d: type[CartesianAxisIndex]) -> None: ...  # e.g. the Stagg
 p3_declared_axis(Staggered[I])  # EXPECT-ERROR: derived, not declared
 p3_declared_axis(C)  # EXPECT-ERROR: mesh location
 p3_declared_axis(V2E.Local)  # EXPECT-ERROR: local dimension
+
+
+# ---------------- P4: the `__add__` self-type restricts index arithmetic ----------------
+
+
+_ok_axis = I + 1  # must be ACCEPTED
+_ok_staggered = Staggered[I] + 1  # must be ACCEPTED: a staggered dim is still an axis
+_ok_half = K + 0.5  # must be ACCEPTED
+_bad_location = C + 1  # EXPECT-ERROR: a mesh location has no index arithmetic
+_bad_local = V2E.Local + 1  # EXPECT-ERROR: a local dimension has no index arithmetic
diff --git a/content/personal/egparedes/connectivities-as-types/typing_probe.py b/content/personal/egparedes/connectivities-as-types/typing_probe.py
index fcc74dd..425efea 100644
--- a/content/personal/egparedes/connectivities-as-types/typing_probe.py
+++ b/content/personal/egparedes/connectivities-as-types/typing_probe.py
@@ -6,13 +6,19 @@
 dimension alone (`Field[V, E_V2V.Local]`), so the nested classes are distinct types
 in their own right; 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.
+pyright additionally reports "Class definition ... depends on itself" on the string
+forward reference in the base subscription — for both `V_E2E` and `E_V2V` — which is
+why the proposal does not pass `Local` through the bases.
+
+Unlike `staggered_probe.py`, this file is not error-clean and makes no "and nothing
+else" claim: mypy also reports `Returning Any from function declared to return "Self"
+[no-any-return]` in the `StaticMultiLevelMapping` scaffolding, which is an artifact of
+the stand-in rather than a finding.
 
 `StaticMultiLevelMapping` is a stand-in that stores the table on the class, which the
 design rejects (see "Data on the class" in the main note); only the probes at the
-end matter. Last run: mypy 2.3.1 and pyright 1.1.414 (2026-09-23).
+end matter. Last run: mypy 2.3.1 and pyright 1.1.414 (2026-09-23; re-checked
+2026-10-01).
 """
 
 from __future__ import annotations

From 21e6b8f0573ace44086ae2d5f6c8887715e93fd2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Gonz=C3=A1lez=20Paredes?= <enriqueg@cscs.ch>
Date: Thu, 1 Oct 2026 20:16:04 +0200
Subject: [PATCH 04/19] =?UTF-8?q?personal/egparedes:=20connectivities=20as?=
 =?UTF-8?q?=20types=20=E2=80=94=20split=20the=20note=20into=20core=20+=20a?=
 =?UTF-8?q?ppendices?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Restructure following the review: a shorter core that can be accepted or rejected
on its own, with the derivations, mechanics and rejected options moved out. All
moved text is verbatim; the core keeps a one-paragraph statement plus a wikilink
wherever a block left.

Four new appendices:
- `_staggering.md` — the CW-complex derivation, the product-complex bit vector,
  the alignment convention and its antisymmetry, why extents are declared, the
  axis-versus-mesh-location decision, the relation to `dimension-generic-fields`
  and the `dual`/`flip_staggered` naming constraint, the six axis-level
  alternatives, and the alignment / `kind` / `degree` follow-ups.
- `_identity.md` — the mechanics behind Identity rules 1 and 3-6: reconstruction
  by import, the one `copyreg` hook, fingerprinting, the injective codegen
  mangling, and the `Staggered[D]` tag grammar. The eight rules keep their numbers
  in the core, each reduced to its statement.
- `_typing.md` — every decision made by running a checker: why `Local` is
  annotated nowhere and must be a `TypeAlias` when shared, what the `__add__`
  self-type costs, the relation to `Local[V2E]`, and the two alternatives those
  settled. The probes are its attachments.
- `_alternatives.md` — the alternatives rejected on grounds other than the axis
  levels.

Also in the core:
- The two 240- and 190-word cells of *What stays, and why* become prose; the table
  keeps one line each.
- The two executed experiments are a six-line summary plus a link; the transcripts
  were already in the constraints appendix verbatim.
- Open questions 5-8 and 10 are statements with links rather than arguments.
- The closed-PR sentence goes (history, not design), as does `Domain` from the
  "lands in B" list — it is a type-parameter name, never an artifact.

Core 1162 -> 874 lines. Verified: no dangling wikilink, anchor or table row across
all seven documents; Identity rules 1-8 and open questions 1-10 keep their
numbering; index keywords still byte-identical to the note's tags; appendices
correctly absent from the index; both probes unchanged (mypy 12 diagnostics over
11 marked lines, pyright 11).
---
 .../connectivities-as-types.md                | 556 +++++-------------
 .../connectivities-as-types_alternatives.md   |  58 ++
 .../connectivities-as-types_identity.md       |  57 ++
 .../connectivities-as-types_staggering.md     | 240 ++++++++
 .../connectivities-as-types_typing.md         | 108 ++++
 5 files changed, 597 insertions(+), 422 deletions(-)
 create mode 100644 content/personal/egparedes/connectivities-as-types/connectivities-as-types_alternatives.md
 create mode 100644 content/personal/egparedes/connectivities-as-types/connectivities-as-types_identity.md
 create mode 100644 content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md
 create mode 100644 content/personal/egparedes/connectivities-as-types/connectivities-as-types_typing.md

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 001209b..b0bd1c0 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
@@ -101,28 +101,14 @@ path and the operation:
 | 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. 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).
+Two of these were confirmed by execution against v1.2.2: embedded and compiled
+execution key the *same* program on *different* strings, and a reduction whose
+offset tag differs from its local-dimension name raises
+`KeyError: "Offset 'Neigh' not found in offset provider."` in embedded while the
+roundtrip backend passes it. GridTools/gt4py#1789 lifted the tag = local-dimension
+requirement only for the *shift* path under gtfn. The transcripts, the
+regression-test coverage and what was read rather than run are in
+[[personal/egparedes/connectivities-as-types/connectivities-as-types_research|the constraints appendix]] §7.
 
 ### The declaration duplicates the type
 
@@ -216,8 +202,33 @@ and slimmed so that each owns only what the others cannot know:
 | `Connectivity` | the runtime protocol: a `Field` of integer indices with a `codomain`, which `field(conn)` / `Field.premap` dispatch on | unchanged. It unifies neighbor tables, Cartesian shifts and `as_offset` index fields, so embedded execution has one remap entry point. Essential. |
 | `CartesianConnectivity` | the `Connectivity` behind `I + 1` and `I + 0.5`; carries the ADR 0026 index arithmetic | unchanged. The Cartesian counterpart of a bound table: it needs no declaration and no provider. Essential. |
 | `NeighborTable` / `NdArrayConnectivityField` | the data: a 2-D table over `(Domain, Local)` with values in `Codomain` | unchanged; `check_neighbor_table` checks it against the declaration. Essential. |
-| `NeighborTableType` (was `NeighborConnectivityType`) | the type of a table *bound to a declaration*: `connectivity` (the declaration), `dtype`, `skip_value`, `max_neighbors`; `domain` and `codomain` are derived from the declaration. Built where a table is bound (`check_neighbor_table` returns it; `offset_provider_to_type`) or given directly for ahead-of-time compilation (`table_types`), never authored next to the declaration. A table alone cannot name its declaration — a sharer's table has the owner's domain dims and a different codomain — so the record is built from the provider key: a local dimension records its `owner` and its `sharers`, and the record takes whichever of them the key names. `NeighborTable.__gt_type__()` returns the structural base `ConnectivityType`. A table bound under a name no declaration answers to (hand-written IR) has no declaration: its `connectivity` is then that structural type | what compilation consumes instead of data (ADR 0019), what `compile(table_types=...)` takes when no table exists yet, and what fingerprints a compiled variant (the owner's and a sharer's record over one table fingerprint differently). It owns exactly the facts a declaration may leave open: element dtype, skip-value sentinel and width. Essential; the name says what it types. The base `ConnectivityType` (structural `domain`, `codomain`, `dtype`, `skip_value`) keeps its name and types general connectivity values such as the index field of `as_offset`. |
-| `ts.ShiftType` (was `ts.OffsetType`) | the frontend type of a shift *argument* in DSL code — what `V2E`, `V2E[1]`, `I + 1`, `K + 0.5` and `as_offset(K, f)` type as during FOAST type deduction, and what the lowering reads to emit `OffsetLiteral` / `CartesianOffset`. A `ts.TypeSpec` like `FieldType`, not a description of a connectivity | produced by `V2E.__gt_type__()`; fields `domain` (a tuple: one dimension for Cartesian shifts and `V2E[i]`, two for `V2E`), `codomain` and `tag` (`None` for untagged Cartesian shifts), printed as `Shift[tag: E -> (V, V2E.Local)]`. It carries no counts, dtype or skip value because the frontend never needs them, and it is gone after `foast_to_gtir` reads its `tag`. The literal name `ts.ConnectivityType` is avoided because `common.ConnectivityType` exists; "shift" is the word the note, the frontend errors and users use for `a(V2E)`. The iterator-level `it_ts.OffsetLiteralType` / `it_ts.CartesianOffsetType` keep their names: they type IR literals. |
+| `NeighborTableType` (was `NeighborConnectivityType`) | the type of a table *bound to a declaration* | renamed and slimmed; see below |
+| `ts.ShiftType` (was `ts.OffsetType`) | the frontend type of a shift *argument* in DSL code | renamed and re-fielded; see below |
+
+`NeighborTableType` holds exactly the facts a declaration may leave open: element
+`dtype`, the skip-value sentinel and `max_neighbors`; `domain` and `codomain` are
+derived from the declaration. It is built where a table is bound
+(`check_neighbor_table`, `offset_provider_to_type`) or given directly for
+ahead-of-time compilation (`table_types`), never authored next to the declaration.
+A table alone cannot name its declaration — a sharer's table has the owner's domain
+dims and a different codomain — so the record is built from the provider key,
+taking whichever of the local dimension's `owner` or `sharers` the key names. A
+table bound under a name no declaration answers to (hand-written IR) gets the
+structural base `ConnectivityType`, which is also what `NeighborTable.__gt_type__()`
+returns and what types general connectivity values such as the index field of
+`as_offset`. It is what fingerprints a compiled variant: the owner's and a sharer's
+record over one table fingerprint differently.
+
+`ts.ShiftType` is what `V2E`, `V2E[1]`, `I + 1`, `K + 0.5` and `as_offset(K, f)`
+type as during FOAST deduction, and what the lowering reads to emit `OffsetLiteral`
+/ `CartesianOffset`. Fields: `domain` (a tuple — one dimension for Cartesian shifts
+and `V2E[i]`, two for `V2E`), `codomain`, and `tag` (`None` for untagged Cartesian
+shifts), printed as `Shift[tag: E -> (V, V2E.Local)]`. It carries no counts, dtype
+or skip value because the frontend never needs them, and it is gone once
+`foast_to_gtir` has read its `tag`. The name avoids `ts.ConnectivityType`, which
+`common` already uses; "shift" is the word this note, the frontend errors and users
+use for `a(V2E)`. The iterator-level `it_ts.OffsetLiteralType` /
+`it_ts.CartesianOffsetType` keep their names: they type IR literals.
 
 ### Sketch
 
@@ -354,14 +365,10 @@ dimensions in `tests/next_tests` move to module level. The consequences,
 stated as rules:
 
 1. **Reconstruction from the IR is an import.** `resolve(tag)` imports the
-   longest importable module prefix and walks the rest as attributes (nested
-   classes like `V2E.Local` resolve naturally), the way `pickle` references a
-   class. Only where the module path ends is memoized: the attribute walk is
-   repeated, so a declaration redefined under the same name (a re-run
-   notebook cell) resolves to the new class. `AxisLiteral` stores only the tag
-   and derives `kind` and `dim` from it (the `TODO` at `iterator/ir.py:93`);
-   printing IR never imports (`resolve_loaded`). `Staggered[D]` tags use the
-   small grammar `<owner tag>[<base tag>]`, resolved by subscripting the owner.
+   longest importable module prefix and walks the rest as attributes, the way
+   `pickle` references a class, so a nested `V2E.Local` resolves naturally and a
+   redefined declaration resolves to the new class. `AxisLiteral` stores only the
+   tag. Memoization, `resolve_loaded` and the `Staggered[D]` grammar: [[personal/egparedes/connectivities-as-types/connectivities-as-types_identity|the identity appendix]].
 2. **Types reaching the IR must be importable.** `<locals>` in a qualname is
    rejected at class creation (for dimensions and connectivities); pickle's
    own `save_global` stays the authoritative check. Interactive `__main__`
@@ -369,26 +376,21 @@ stated as rules:
    dimensions there — so the process-pool runner (`BUILD_JOBS_MODE=process`)
    detects a job that references such a class and, with a warning,
    **compiles it in the calling thread** instead of failing in a spawn worker.
-3. **No registry.** Classes pickle by reference. One narrow `copyreg` hook
-   exists, for `Staggered[D]`, whose bracketed qualname `save_global` cannot
-   look up; it reduces to the base dimension and re-interns.
-4. **Fingerprints depend on qualified names.** Dimensions are fingerprinted by
-   reference (`Staggered[D]` through its base); a connectivity declaration
-   additionally by its domain, codomain, `Local` and counts, so a redefinition
-   under the same name does not reuse artifacts. Consequently the ADR 0023
-   build cache invalidates on module renames.
+3. **No registry.** Classes pickle by reference. The one narrow `copyreg` hook is
+   for `Staggered[D]`, whose bracketed qualname `save_global` cannot look up.
+4. **Fingerprints depend on qualified names**, so a redefinition under the same
+   name does not reuse artifacts and the ADR 0023 build cache invalidates on
+   module renames.
 5. **Codegen names need injective mangling.** `codegen_name(tag)` is a prefix
-   escape — `_`→`_u`, `.`→`_d`, `[`→`_l`, `]`→`_r` — used by gtfn, DaCe, the
-   roundtrip backend and the nanobind bindings; its inverse
-   `from_codegen_name` is used by DaCe to parse names back. The simpler
-   "escape `__`, then replace `.`" is **not** injective (`".."` and `"_"`
-   collide); the prefix escape is tested exhaustively over its alphabet up
-   to length 4.
-6. **Staggering is part of the dimension change.** The `_Staggered` name
-   prefix needs the name→class lookup that type identity removes, so
-   `Staggered[D]` is a real class and part of ADR 0028 (PR A), together with
-   the [Cartesian axis dimensions](#cartesian-axis-dimensions) its parameter is bounded on; see
-   [`Staggered[D]`](#staggeredd).
+   escape (`_`→`_u`, `.`→`_d`, `[`→`_l`, `]`→`_r`); the obvious alternative is
+   not injective.
+6. **Staggering is part of the dimension change.** The `_Staggered` name prefix
+   needs the name→class lookup that type identity removes, so `Staggered[D]` is a
+   real class and part of ADR 0028 (PR A), with its parameter bounded on a
+   declared [Cartesian axis](#cartesian-axis-dimensions).
+
+   Rules 3–6 in full — the hook, the fingerprint deconstructors, the exhaustive
+   mangling test and the `_Staggered` history — are in [[personal/egparedes/connectivities-as-types/connectivities-as-types_identity|the identity appendix]].
 7. **The IR names a connectivity by its `offset_tag`.** That is its local
    dimension's tag when it declares the local dimension: shifts, reductions
    and sparse arguments then all find the table under **one** string, so the
@@ -405,107 +407,26 @@ stated as rules:
 ### Cartesian axis dimensions
 
 A **Cartesian axis** is an index space with integer index arithmetic and
-exactly one staggered partner — the dimensions `CartesianConnectivity` acts on.
-Read one axis of a Cartesian grid as a
-1-dimensional CW complex — a path when the axis is bounded, a cycle when it is
-periodic. Such a complex has exactly two cell classes, of degree 0 and 1, and a
-declared axis together with its `Staggered[·]` name those two classes.
-`Staggered` is the **involution that swaps them**. The types do not say which
-class has degree 0, and they need not: the ADR 0026 position convention
-(`Staggered[X](i)` at `i - 1/2`) fixes only their *relative* alignment. Both
-assignments occur. A vertex-indexed structured grid declares the 0-cells, so
-`Staggered[I](i)` is the 1-cell `[I(i-1), I(i)]`; ICON's Lorenz grid declares
-the 1-cells, `KDim` being the full levels (layer midpoints) while
-`Staggered[KDim]` are the half levels (interfaces, the 0-cells).
-
-In more than one dimension the grid is the **product** complex of its axes, so
-a cell class is a bit vector over axes — one bit per axis, "does this cell span
-it?" — and the cell degree is the number of set bits. `Dims[...]` *is* that bit
-vector:
-
-| `Dims[...]` | cell | degree |
-| --- | --- | --- |
-| `Dims[I, J]` | vertex | 0 |
-| `Dims[Staggered[I], J]` | edge along `I` | 1 |
-| `Dims[I, Staggered[J]]` | edge along `J` | 1 |
-| `Dims[Staggered[I], Staggered[J]]` | face | 2 |
-
-The `cell` and `degree` columns assume the first assignment above — every
-declared axis indexes its 0-cells. Under the other assignment the column reads
-upside down on that axis; the *encoding* is unaffected, which is the point.
-
-Per-axis staggering is therefore *more* informative than a form degree, which
-in two dimensions conflates the two edge families a C-grid must keep apart —
-the distinction that has to be recovered by hand, as a component label, wherever
-no product structure exists (`EDGE_N` vs `EDGE_T` in
-[[personal/egparedes/discretization-independent-fd-syntax|the surface-syntax note]]
-§7.1). It is also why the structured and unstructured cases are encoded
-differently here at all: a per-axis bit exists exactly when the complex factors
-as a product, and mesh locations (`V`, `E`, `C`) are separate dimension classes
-because it does not.
-
-Two consequences shape the hierarchy:
-
-- **A staggered dimension is itself a discretized axis.** It is the other cell
-  class of the same complex: it carries fields, has a range, and takes integer
-  offsets. So the asymmetry between `D` and `Staggered[D]` is not semantic but
-  *declarational* — one is written by the user, the other derived from it, and
-  there is exactly one partner to derive. That is what makes the derivation
-  well-founded, and it is the level `Staggered`'s parameter must name.
-- **`Staggered[D]` needs no orientation data.** A 1-cell in a complex is
-  oriented, which is what makes the coboundary signed. A product of intervals
-  has a canonical orientation per axis (increasing index), so the sign is
-  implicit in the stencil the user writes. The unstructured side has no such
-  canonical choice, which is why incidence signs are materialized there (ICON's
-  `geofac_div` carries them). The absence is a consequence of the product
-  structure, not an omission.
-
-**The alignment is antisymmetric, so the convention is the user's to pick.** The
-ADR 0026 convention places `Staggered[D](i)` at `i - 1/2` in `D`'s coordinates;
-equivalently, it places `D(j)` at `j + 1/2` in `Staggered[D]`'s. Both conventions
-appear in production codes — the SGRID convention's four `padding` values
-enumerate both, `low` and `both` placing a cell at `j - 1/2` while `none` and
-`high` place it at `j + 1/2`
-([[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions appendix]]
-§3) — and either is reachable by choosing *which member of the pair to
-declare*. The default puts the partner half a cell *below*; to have it half a cell
-*above* your main field, declare the axis the **partner** lives on and alias your
-main field onto the derived member. With `class IFace(CartesianAxisIndex)` and
-`ICell: TypeAlias = Staggered[IFace]`, an `IFace` field sits half a cell above the
-`ICell` field of the same index. The pair is symmetric in the implementation —
-`order_dimensions` orders by the base either way, `check_dims` is symmetric,
-fingerprints go through the base, gtfn aliases the staggered tag to its base — so
-the only residual cost is cosmetic: the derived member's *tag* reads
-`...Staggered[IFace]` in the IR, in codegen names and in error messages. Stencil
-code built from relative shifts is convention-independent in any case
-(`p(S + 1/2) - p(S - 1/2)` is the same difference either way, and `±1/2` reaches
-both neighbours); the convention bites only on absolute index correspondence with
-a reference implementation and on boundary index ranges.
-
-**Extents are declared, never derived.** A path complex has `n` 0-cells and
-`n - 1` 1-cells; a cycle has `n` and `n`. So the two members of a pair do not in
-general have the same range, and *which one is wider is the degree assignment*:
-with `I` the 0-cells on `[0, n)`, the interior 1-cells are `[I(i-1), I(i)]` for
-`i` in `[1, n)`, and `Staggered[I](0)` is the first cell outside the complex —
-exactly where a halo cell goes; with `K` the 1-cells on `[0, n)` (ICON's layers),
-the interfaces run `[0, n+1)`. Both are expressible without any new type-level
-concept because a `Domain` holds absolute `UnitRange(start, stop)`s rather than
-sizes — see
-[[personal/havogt/field-data-protocol/field-data-protocol|the field data protocol]]
-for why absolute addressing is the right domain model — and the periodic case
-needs nothing extra, the two ranges simply coincide in size. The invariant a grid
-builder owes is that the two ranges *interleave*; their sizes then differ by at
-most one when the complex is closed, and halo extension relaxes even that (two of
-SGRID's four bounded cases, `low` and `high`, have equal sizes). An absolute range
-is strictly more expressive than SGRID's `padding` enum here: each of its four
-values is one `UnitRange` under a single alignment convention, and
-`padding: low` is exactly the halo cell named above. No component of this design
-sees both ranges at once, so enforcing it belongs to whatever
-constructs both
-([[personal/havogt/mesh-and-first-class-halos/mesh-and-first-class-halos|a mesh
-concept with first-class halos]]). Note also that `order_dimensions` giving a
-staggered field the *layout order* of its base says nothing about its *shape*:
-the two are independent.
+exactly one staggered partner — the dimensions `CartesianConnectivity` acts
+on. One axis of a Cartesian grid is a 1-dimensional CW complex and has exactly
+two cell classes; a declared axis and its `Staggered[·]` name those two, and
+`Staggered` is the involution that swaps them. The types do not fix which class
+has degree 0. In more than one dimension the grid is the product complex of its
+axes, so a cell class is one bit per axis and `Dims[...]` *is* that bit vector —
+finer than a form degree, and the reason mesh locations are separate classes
+instead: a per-axis bit exists exactly when the complex factors as a product.
+
+Two facts shape the hierarchy. A staggered dimension **is itself** a Cartesian
+axis — the other cell class of the same complex — so the asymmetry between `D`
+and `Staggered[D]` is *declarational*, not semantic: one is written by the user,
+the other derived, and there is exactly one partner to derive. And `Staggered[D]`
+needs no orientation data, because a product of intervals is canonically
+oriented per axis.
+
+That derivation, the alignment convention and its antisymmetry, why extents are
+declared rather than derived, and the per-declaration axis-versus-mesh-location
+decision are in [[personal/egparedes/connectivities-as-types/connectivities-as-types_staggering|the staggering appendix]]; its external
+corroboration is in [[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|the conventions appendix]].
 
 Hence three levels, all *below* `DimensionIndex`, so that no
 `type[DimensionIndex]` annotation in the tree changes and `LocalDimensionIndex`
@@ -530,16 +451,9 @@ Four checks the tree performs at runtime, or not at all, become static:
 | `Staggered[C]` — no half-cells on an unstructured mesh | nothing rejects it | static, at the bound |
 | `C + 1`, `V2E.Local + 1` — index arithmetic off an axis | runtime `kind` check, or a late failure | static, via `DimensionMeta.__add__`'s self-type |
 
-The last row needs `__add__` declared with `cls: type[AnyCartesianAxisIndex]`.
-Both checkers bind that signature correctly at every call site and both reject it
-at the *definition* site, with different diagnostics — mypy `[misc]` ("self"
-parameter missing for a non-static method), pyright
-`reportGeneralTypeIssues` ("Type of parameter `cls` must be a supertype of its
-class `DimensionMeta`") — so it costs two separately-spelled suppressions. P4 of
-[`staggered_probe.py`](staggered_probe.py) pins this down; the same restriction
-is what
-[[personal/havogt/dimension-generic-fields/dimension-generic-fields|generic dimensions]]
-suppresses for its overload pairs.
+The last row costs two definition-site suppressions, one per checker. P4 of
+[`staggered_probe.py`](staggered_probe.py) pins it down and
+[[personal/egparedes/connectivities-as-types/connectivities-as-types_typing|the typing appendix]] records both diagnostics.
 
 `kind` **shrinks.** It carries four jobs today: `LOCAL` marks a neighbor axis;
 `order_dimensions` sorts by `(kind, as_non_staggered(dim).value)`, so it decides
@@ -553,12 +467,6 @@ enum**: `kind` becomes `HORIZONTAL | VERTICAL` and `order_dimensions` sorts by
 role, which belong to the field and to the program respectively — see
 [Open questions](#open-questions--follow-ups).
 
-The class level also draws a distinction `kind` never did: `IDim` and `CellDim`
-are both `HORIZONTAL` and only the first is an axis. That is why the migration
-cannot be inferred from the source — whether a dimension is an axis or a mesh
-location is a decision per declaration (about ten in ICON4Py's `dimension.py`;
-near-uniformly `CartesianAxisIndex` in `tests/next_tests`). The migration script
-rewrites what it can and reports the rest.
 
 ### `Staggered[D]`
 
@@ -609,13 +517,10 @@ of [Cartesian axis dimensions](#cartesian-axis-dimensions).
   `K + 0.5` is a plain `Connectivity`. `check_dims` rejects a dimension and
   its staggered counterpart in one field or domain, and `order_dimensions`
   orders by the base, so a staggered field has the layout of its base.
-- **IR and serialization.** The tag is
+- **IR, serialization and fingerprints.** The tag is
   `gt4py.next.common.Staggered[<base tag>]` — the one tag that is not a
-  qualified name. `resolve` parses the `<owner>[<base>]` grammar and
-  subscripts the owner, the IR pretty-parser accepts it, and `codegen_name`
-  escapes the brackets. `pickle` cannot look up a bracketed qualname, so one
-  `copyreg` hook reduces a staggered class to its base and re-subscripts on
-  load; fingerprints are likewise taken through the base.
+  qualified name. Its grammar, the `copyreg` hook and fingerprinting through
+  the base are in [[personal/egparedes/connectivities-as-types/connectivities-as-types_identity|the identity appendix]].
 - **Backends.** gtfn emits the staggered tag as a C++ alias of its base tag
   (`_add_staggered_aliases`), since its shift primitive can offset along an
   axis but not rename it. DaCe names map variables by the base
@@ -623,23 +528,9 @@ of [Cartesian axis dimensions](#cartesian-axis-dimensions).
   iteration space for a field and its staggered counterpart.
 
 [[personal/havogt/dimension-generic-fields/dimension-generic-fields|Generic dimensions and statically typed staggering]]
-Part II proposed this `Staggered[D]` shape with the same shift convention, and
-the root/user split that makes the doubly staggered type unrepresentable; here
-that split is motivated as the axis concept above and placed below
-`DimensionIndex` so that no annotation widens. Its static involution overloads
-(typing `Staggered[K] + 0.5` as landing on `K` for the checkers) are not part
-of the stack, so statically a half-integer shift is a plain `Connectivity`. Its
-`gradient_to_staggered` example, `p(Staggered[I] + 1/2) - p(Staggered[I] - 1/2)`,
-is the coboundary of a 0-cochain, which is why it lands on the partner class.
-
-**One naming constraint.** That prototype spells the partner-swapping operation
-`dual()` / `Dual[X]`. In a complex the Hodge dual flips *every* axis bit (a
-primal k-cell pairs with a dual (n−k)-cell) while `Staggered[D]` flips one, so
-the two coincide only in one dimension. `dual` stays reserved for the full
-Hodge dual — the sense
-[[personal/egparedes/discretization-independent-fd-syntax|the surface-syntax note]]
-§6.5 uses for the primal/dual C↔D grid swap — and the per-axis operation keeps
-gt4py's existing name, `flip_staggered`.
+Part II proposed this `Staggered[D]` shape and the root/user split that makes the
+doubly staggered type unrepresentable. What differs here, and the constraint
+reserving `dual` for the full Hodge dual, are in [[personal/egparedes/connectivities-as-types/connectivities-as-types_staggering|the staggering appendix]].
 
 ### Binding model
 
@@ -733,52 +624,10 @@ tables assign different neighbors to the same domain element. The model:
   (`NeighborConnectivity[V, "V2E.Local", E]`): mypy accepts that string
   forward reference, pyright reports `Class definition for "V2E" depends on
   itself`. `__init_subclass__` reads it from the class body instead.
-- **`Local` is annotated nowhere**, and that is load-bearing. An annotation on
-  the base (`Local: ClassVar[type[LocalDimensionIndex]]`) or on the metaclass
-  makes a declaration's `Local` a *variable* for the checkers, so
-  `Field[Dims[V, V2E.Local], float]` is rejected — by pyright for a nested
-  `Local` ("Variable not allowed in type expression"), by mypy for an adopted
-  or shared one ("not valid as a type"). A real nested `Local` on the base is
-  not an option either: pyright reports an incompatible override in every
-  declaration. With no annotation anywhere, all three spellings are types for
-  both checkers.
-  The cost is that `conn.Local` is not an attribute the checkers know for a
-  *generic* `conn`: library code reads it through
-  `common.local_dimension_of(conn)`, and code that must name a local dimension
-  generically uses a `TypeVar` bound to `LocalDimensionIndex`. This is checked
-  for both checkers in CI: the mypy cases in `typing_tests/test_next.yaml`, and
-  a pyright run over `typing_tests/pyright_probes.py` in the same nox session
-  (pyright is what catches the annotation regression; mypy accepts it).
-- A declaration can instead **adopt** a module-level local dimension, written
-  `Local: typing.TypeAlias = V2EDim`; the local keeps its own tag, which is then
-  the connectivity's `offset_tag`. This is also how the migration script
-  rewrites existing `FieldOffset`s without renaming anything. Adopting is *not*
-  side-effect free: the adopter becomes the local's `owner` and writes its
-  counts onto the module-level class, and ownership is first-come — the first
-  connectivity declared over a local dimension owns it, later ones share it and
-  are recorded in its `sharers`. A
-  declaration *redefined* under the same tag (a re-run notebook cell) takes
-  ownership over again rather than becoming a sharer, and the counts it repeats
-  are then checked against the local dimension's own `size=`, not against what
-  the stale owner wrote. `ConstList` cannot be adopted: it belongs to no
-  connectivity.
-- A connectivity can **share** another one's local dimension
-  (`class C2CE(NeighborConnectivity[C, CE]): Local: typing.TypeAlias =
-  C2E.Local`). ICON4Py's flattened sparse offsets (`C2CE`, `E2ECV`, `E2EC`,
-  `C2CEC`) need exactly this, because their results must combine with
-  `C2E`-shaped sparse fields. The
-  owner stays the first declaration over the local (here `C2E`); the sharer
-  must have the same domain (its codomain is free), any counts it repeats must
-  equal the owner's, and reductions over the shared axis take the neighbor
-  structure from any bound table over it (`connectivity_key_over`: the owner's
-  key if bound, else the smallest bound key over that local, which raises
-  `KeyError` if there is none).
-- **Write an adopted or shared `Local` as a `TypeAlias`.** `Local: TypeAlias =
-  C2E.Local` is what keeps mypy treating `C2CE.Local` as a type; with a plain
-  assignment it is "not valid as a type" there (pyright accepts either, but
-  widens the plain form to `LocalDimensionIndex`). With the alias, annotations
-  may name the local dimension through any of its spellings — `C2CE.Local`,
-  `C2E.Local`, `V2EDim` — and they are one type.
+- **`Local` is annotated nowhere**, and an adopted or shared `Local` must be a
+  `TypeAlias`. Both are forced by what mypy and pyright accept in an annotation
+  position; [[personal/egparedes/connectivities-as-types/connectivities-as-types_typing|the typing appendix]] has the diagnostics, and
+  [`typing_probe.py`](typing_probe.py) the probes.
 - `max_neighbors` / `min_neighbors` are class keywords, like `kind` on a
   dimension, and optional (see Binding model). They are *not* type
   parameters: Python has no integer-valued type parameters, and nothing
@@ -868,124 +717,15 @@ The Cartesian `FieldOffset` goes together with the unstructured one:
 Cartesian shifts were already `Dim + i`, and `as_offset` takes the
 dimension, `as_offset(KDim, field)`.
 
-### Relation to `Local[V2E]`
-
-[[personal/havogt/dependent-local-dimensions/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). They **cannot be reconciled for a type checker**: making
-`Local.__class_getitem__` return `V2E.Local` unifies them at runtime only.
-[`typing_probe.py`](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
 
-**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, fixed regardless, in GridTools/gt4py#2898.
-But it *enforces* the tangle rather than removing it; no concept goes away.
-
-**A declaration object with a derived local dimension, keeping `Dimension`
-instances.** 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 design of
-[[shared/dimensions-as-types|dimensions as types]] and GridTools/gt4py#2844).
-Keeps independently declared same-named dimensions interchangeable and
-avoids the importability rule. Rejected 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 *Identity*.
-
-**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.
-
-**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`](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.
-
-**A `PEP 695` generic for `Staggered[D]`.** Rejected: the subscription would
-be a `typing` alias, not a class, failing `issubclass` and eve's `type[...]`
-validation and unable to carry a tag. The metaclass subscription builds a
-real class; the PEP 695 form is used only under `TYPE_CHECKING`.
-
-**A sibling root above `DimensionIndex`** — `AnyDimensionIndex` with
-`DimensionIndex` and `Staggered[D]` as siblings, which is where
-[[personal/havogt/dimension-generic-fields/dimension-generic-fields|generic dimensions]]
-puts the split. Gives the same static ban, but `Staggered[K]` then stops being
-a `DimensionIndex`, so every annotation and `issubclass` guard that must accept
-a staggered dimension has to widen, and the static and runtime lattices diverge
-unless the widening is mirrored at runtime. The `AnyCartesianAxisIndex` / `CartesianAxisIndex`
-levels sit below the root instead and cost nothing at those sites.
-
-**A structural discriminator instead of the axis levels** — bound `Staggered`'s
-parameter to a `Protocol` carrying `__gt_staggered__: ClassVar[Literal[False]]`
-that the staggered class overrides with `Literal[True]`. Rejected: it needs a
-suppressed incompatible-override, reports an opaque diagnostic, hangs a
-meaningless attribute on every dimension, and buys only the ban — there is no
-axis concept, so `C + 1` and `Staggered[C]` stay unchecked.
-
-**A second partner constructor** — `Staggered[D]` for `i - 1/2` and
-`StaggeredAbove[D]` for `i + 1/2`, instead of a per-axis alignment. Rejected: it
-gives three cell classes per axis where an axis has two, so
-`Field[Dims[Staggered[I], StaggeredAbove[I]]]` — the same physical axis twice —
-becomes expressible and needs a new `check_dims` rule; and it makes
-`flip_staggered` partial, since `flip_staggered(I)` would have two candidate
-answers, so `I + 0.5` could not compute its own codomain and neither
-`as_non_staggered` nor the typed `dual()` would be well defined. It also spells a
-per-*pair* fact at every use site, so two modules can disagree about one grid, and
-it duplicates the whole bracketed-tag apparatus (a second interned family, tag
-grammar, `copyreg` hook and codegen escape). Parameterizing the alignment, if it
-is done at all, is one class keyword on the declared axis — see
-[Open questions](#open-questions--follow-ups).
-
-**Declaring both members of a pair** (`class ICell(CartesianAxisIndex, dual_of=IFace,
-offset=+0.5)`). The explicit form, rejected for the reason this note exists: it
-reintroduces a two-object agreement, loses the property that a partner needs no
-separate declaration, and loses the involution by construction.
-
-**`Staggered[D: AnyCartesianAxisIndex]`**, bounding on any cell class rather than on a
-declared axis. The semantically tempting reading, since a staggered dimension
-*is* an axis — but it re-admits `Staggered[Staggered[K]]`. The bound has to name
-the declared level.
+Eleven alternatives are recorded in [[personal/egparedes/connectivities-as-types/connectivities-as-types_alternatives|the alternatives appendix]],
+and the six concerning the axis levels and `Staggered[D]` in
+[[personal/egparedes/connectivities-as-types/connectivities-as-types_staggering|the staggering appendix]]. The three a reviewer is most likely
+to raise: keep every concept and fix only which string wins; `(name, kind)` value
+equality with an interning registry; and static-only `max_neighbors` /
+`min_neighbors`.
 
 ## Relation to gt4py ADRs
 
@@ -1022,65 +762,28 @@ the declared level.
    [[personal/havogt/closure-variable-resolution|Closure variable resolution]]
    would be its natural home.
 4. **Chain proposals.** Their static encodings need rewriting to `C.Local`
-   ([Relation to `Local[V2E]`](#relation-to-localv2e)).
-5. **Parameterizing the alignment.** The ADR 0026 convention is hard-coded, while
-   SGRID's `padding` attribute exists precisely because production codes use both
-   alignments
-   ([[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions appendix]]
-   §3). The antisymmetry above makes both conventions reachable by choosing which member of
-   the pair to declare, at a cosmetic cost in the derived member's tag; a per-axis
-   class keyword (`class X(CartesianAxisIndex, stagger=Align.ABOVE)`) would remove
-   even that. It would have to be **static, on the axis**: it changes the integer
-   correction `connectivity_for_cartesian_shift` bakes into the
-   `CartesianConnectivity`, hence the emitted stencil, so unlike periodicity and
-   extents it cannot be a grid property. Its footprint is one `ClassVar` plus `+1`
-   vs `+0` in that one function — the backends only ever see an integer offset
-   along an axis — against three costs: `a(Staggered[I] + 1/2)` stops being
-   readable without the declaration, the frontend and embedded shift test matrix
-   doubles, and Identity rule 4 bites, since dimensions fingerprint *by reference*
-   and flipping the keyword in place would not invalidate the ADR 0023 cache. That
-   last hole is pre-existing (`kind` has it too) and would argue for folding
-   declaration-time dimension attributes into the fingerprint. Not in this stack.
+   ([[personal/egparedes/connectivities-as-types/connectivities-as-types_typing#3-relation-to-localv2e|typing appendix]] §3).
+5. **Parameterizing the alignment.** A per-axis `stagger=` class keyword would
+   remove the one cosmetic cost of choosing which member of a pair to declare. It
+   has to be static — it changes the integer correction
+   `connectivity_for_cartesian_shift` bakes in, hence the emitted stencil — and it
+   hits the rule-4 fingerprint hole. See [[personal/egparedes/connectivities-as-types/connectivities-as-types_staggering|the staggering appendix]].
+   Not in this stack.
 6. **`kind`'s remaining two jobs.** Once `LOCAL` leaves the enum, `kind` is a
-   layout sort key and a name for the scan axis. Layout is a property of the field,
-   not of the dimension, and that coupling is why dimension *names* currently
-   determine memory layout (F4); what `order_dimensions` actually wants is an
-   *order* — innermost to outermost, `I, J, K` for a box, `(CellDim, KDim)` for
-   ICON — which a per-grid dimension ordering would supply and which would retire
-   F4. "Vertical" is a role, not a geometry: in a Cartesian box the three axes are
-   alike, and what singles out `K` is that the numerics is sequential along it and
-   that it is not decomposed, properties of the program and of the decomposition.
-   [[personal/havogt/scan-redesign/scan-redesign|Scan redesign]] takes the scan
-   range from the output domain and never appeals to `kind` at all, and SGRID describes
-   vertical staggering with the *same* `padding` syntax as horizontal, so it needs
-   no vertical kind at all. Every candidate
-   *addition* to `kind` — periodic, distributed, sequential, cell degree — likewise
-   belongs to the grid, the program or the range, so `kind` should shrink rather
-   than grow.
-7. **A cell `degree` on the axis.** Making the degree assignment static
-   (`degree=0|1`) would let a coboundary be typed generically
-   (`d⁰: Field[deg 0] -> Field[deg 1]`) and make the range invariant derivable
-   rather than declared. Left out for now: it duplicates what the absolute ranges
-   already say, creating exactly the cross-object agreement this note removes; it
-   does not fix the extent relation without periodicity, which cannot be static;
-   and nothing consumes it until an exterior-calculus surface exists (Proposal 1
-   of
-   [[personal/egparedes/discretization-independent-fd-syntax|the surface-syntax note]]).
-   Revisit if that surface lands — but note that a degree is *canonical* for a mesh
-   location and only *declarational* for a Cartesian axis, so it belongs on the
-   `LocationIndex` of the next item rather than here
-   ([[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions appendix]]
-   §4a).
-8. **A `LocationIndex` level for mesh locations.** `CartesianAxisIndex` separates
-   Cartesian axes from everything else, but `V`, `E`, `C` stay direct
-   `DimensionIndex` subclasses, so "a primary, non-local dimension" — what
-   `NeighborConnectivity[Domain, Codomain]` and `MultiDimensionIndex` actually
-   want, and check at runtime — is still not a type. A fourth level would give
-   it, at the cost of a second per-declaration migration decision. Out of scope
-   here, but it has a ready-made vocabulary: UGRID's `node`/`edge`/`face`/`volume`
-   gated by `topology_dimension`, whose location names *are* cell degrees
-   ([[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions appendix]]
-   §4a).
+   layout sort key and a name for the scan axis — properties of the field and of
+   the program, not of the dimension. Every candidate *addition* belongs to the
+   grid, the program or the range, so `kind` should shrink rather than grow; see
+   [[personal/egparedes/connectivities-as-types/connectivities-as-types_staggering|the staggering appendix]] §7.
+7. **A cell `degree` on the axis.** Left out: it duplicates what the absolute
+   ranges already say, needs periodicity (which cannot be static), and has no
+   consumer until an exterior-calculus surface exists. A degree is *canonical* for
+   a mesh location and only *declarational* for an axis, so it belongs on the
+   `LocationIndex` of the next item; see [[personal/egparedes/connectivities-as-types/connectivities-as-types_staggering|the staggering appendix]]
+   and [[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions]] §4a.
+8. **A `LocationIndex` level for mesh locations.** `V`, `E`, `C` stay direct
+   `DimensionIndex` subclasses, so "a primary, non-local dimension" is still not a
+   type. UGRID supplies the vocabulary and the degrees
+   ([[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions appendix]] §4a). Out of scope here.
 9. **`DimensionMeta.__eq__` versus "equality is `is`".** [Identity](#identity-is-the-qualified-python-name)
    states that the runtime view of identity is `is`, while the sketch keeps
    `__eq__` overridden so that `I == 5` builds a `Domain` (with
@@ -1089,14 +792,10 @@ the declared level.
    call `bool(Domain)`. Class-keyed providers (`{V2E: table}`) and the `is`-based
    identity story both depend on this being benign; it is not established here,
    and the ADR 0028 implementation should say which of the two rules wins.
-10. **The index origin of a bound table.** `NeighborTableType` records `dtype`,
-   `skip_value` and `max_neighbors` but no index origin, while UGRID standardizes
-   `start_index` ∈ {0, 1} and ICON4Py's tables come from Fortran. Since a codomain
-   dimension carries an absolute range, `check_neighbor_table` could validate
-   entries against that range instead of against `[0, size)`, making a 1-based
-   table a codomain over `[1, n+1)` and `start_index` a non-issue
-   ([[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions appendix]]
-   §4b).
+10. **The index origin of a bound table.** `NeighborTableType` records no index
+    origin, while UGRID standardizes `start_index` ∈ {0, 1}. `check_neighbor_table`
+    could validate entries against the codomain's absolute range instead of
+    `[0, size)` ([[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions appendix]] §4b).
 
 ## Implementation
 
@@ -1114,10 +813,9 @@ on its own, each based on the previous one:
 | C: GridTools/gt4py#2910 | `connectivities-as-types-6-class-keyed-providers` | `feat[next]!`: the tree and docs declare connectivities as classes; class-keyed offset providers with `check_offset_provider` at every entry point; `FieldOffset` removed; `as_offset(dim, field)`; `table_types` replaces `offset_provider_type`; migration script |
 | D: GridTools/gt4py#2912 | `connectivities-as-types-8-typed-positions` | `refactor[next]`: `MultiDimensionIndex` and typed embedded positions |
 
-The four PRs form GitHub stack GridTools/gt4py#2917. #2908 (absorbed by C),
-#2909 (absorbed by B) and #2911 (absorbed by A) are closed. `Domain`,
-`NeighborTableType`, `TableTypes` and `ts.ShiftType` land in B; `table_types`
-in C; ADR 0028 and ADR 0029 are in A and B respectively.
+The four PRs form GitHub stack GridTools/gt4py#2917. `NeighborTableType`,
+`TableTypes` and `ts.ShiftType` land in B, `table_types` in C; ADR 0028 and
+ADR 0029 are in A and B respectively.
 
 **ICON4Py migration.** `scripts/python/migrate_connectivities.py` (PR C)
 rewrites `Dimension(...)` and `FieldOffset(...)` declarations (connectivities
@@ -1132,6 +830,20 @@ ICON4Py.
 
 ## Appendices
 
+- [[personal/egparedes/connectivities-as-types/connectivities-as-types_staggering|Cartesian axes, the CW-complex reading and alignment]]:
+  why an axis has exactly two cell classes and `Dims[...]` is the product complex's
+  bit vector; the alignment convention and its antisymmetry; why extents are
+  declared; the six axis-level alternatives and the staggering follow-ups.
+- [[personal/egparedes/connectivities-as-types/connectivities-as-types_identity|What type identity costs the IR, pickle and codegen]]:
+  the mechanics behind Identity rules 1 and 3–6 — reconstruction by import, the one
+  `copyreg` hook, fingerprinting, the injective codegen mangling and the
+  `Staggered[D]` tag grammar.
+- [[personal/egparedes/connectivities-as-types/connectivities-as-types_typing|Decisions made by running mypy and pyright]]:
+  why `Local` is annotated nowhere and must be a `TypeAlias` when shared, what the
+  `__add__` self-type costs, and why `Local[C]` and `V2E.Local` cannot be
+  reconciled. The two probes are its attachments.
+- [[personal/egparedes/connectivities-as-types/connectivities-as-types_alternatives|Alternatives considered]]:
+  the alternatives rejected on grounds other than the axis levels.
 - [[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),
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_alternatives.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_alternatives.md
new file mode 100644
index 0000000..e16fe2d
--- /dev/null
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_alternatives.md
@@ -0,0 +1,58 @@
+---
+title: "Connectivities as types — alternatives considered"
+author: egparedes
+tags: [type-system, connectivities, local-dimensions, offset-provider, nominal-types]
+created: 2026-10-01
+status: draft
+---
+
+> **Appendix** to [[personal/egparedes/connectivities-as-types/connectivities-as-types|Connectivities as types]].
+> The alternatives rejected on grounds other than the axis levels, which are in the
+> [[personal/egparedes/connectivities-as-types/connectivities-as-types_staggering|staggering appendix]]. Each entry states the alternative, then why
+> it loses.
+
+## Alternatives
+
+**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, fixed regardless, in GridTools/gt4py#2898.
+But it *enforces* the tangle rather than removing it; no concept goes away.
+
+**A declaration object with a derived local dimension, keeping `Dimension`
+instances.** 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 design of
+[[shared/dimensions-as-types|dimensions as types]] and GridTools/gt4py#2844).
+Keeps independently declared same-named dimensions interchangeable and
+avoids the importability rule. Rejected 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 *Identity*.
+
+**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.
+
+**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.
+
+
+**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.
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_identity.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_identity.md
new file mode 100644
index 0000000..21cdb20
--- /dev/null
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_identity.md
@@ -0,0 +1,57 @@
+---
+title: "Connectivities as types — what type identity costs the IR, pickle and codegen"
+author: egparedes
+tags: [type-system, dimensions, nominal-types, serialization, fingerprint, metaclass, tech-debt]
+created: 2026-10-01
+status: draft
+---
+
+> **Appendix** to [[personal/egparedes/connectivities-as-types/connectivities-as-types|Connectivities as types]].
+> The mechanics behind rules 1 and 3-6 of *Identity is the qualified Python name*:
+> reconstruction by import, the one `copyreg` hook, fingerprinting, the injective
+> codegen mangling, and the `Staggered[D]` tag grammar.
+
+## Rule 1 — reconstruction from the IR is an import
+
+1. **Reconstruction from the IR is an import.** `resolve(tag)` imports the
+   longest importable module prefix and walks the rest as attributes (nested
+   classes like `V2E.Local` resolve naturally), the way `pickle` references a
+   class. Only where the module path ends is memoized: the attribute walk is
+   repeated, so a declaration redefined under the same name (a re-run
+   notebook cell) resolves to the new class. `AxisLiteral` stores only the tag
+   and derives `kind` and `dim` from it (the `TODO` at `iterator/ir.py:93`);
+   printing IR never imports (`resolve_loaded`). `Staggered[D]` tags use the
+   small grammar `<owner tag>[<base tag>]`, resolved by subscripting the owner.
+
+## Rules 3-6 — registry, fingerprints, mangling, staggering
+
+3. **No registry.** Classes pickle by reference. One narrow `copyreg` hook
+   exists, for `Staggered[D]`, whose bracketed qualname `save_global` cannot
+   look up; it reduces to the base dimension and re-interns.
+4. **Fingerprints depend on qualified names.** Dimensions are fingerprinted by
+   reference (`Staggered[D]` through its base); a connectivity declaration
+   additionally by its domain, codomain, `Local` and counts, so a redefinition
+   under the same name does not reuse artifacts. Consequently the ADR 0023
+   build cache invalidates on module renames.
+5. **Codegen names need injective mangling.** `codegen_name(tag)` is a prefix
+   escape — `_`→`_u`, `.`→`_d`, `[`→`_l`, `]`→`_r` — used by gtfn, DaCe, the
+   roundtrip backend and the nanobind bindings; its inverse
+   `from_codegen_name` is used by DaCe to parse names back. The simpler
+   "escape `__`, then replace `.`" is **not** injective (`".."` and `"_"`
+   collide); the prefix escape is tested exhaustively over its alphabet up
+   to length 4.
+6. **Staggering is part of the dimension change.** The `_Staggered` name
+   prefix needs the name→class lookup that type identity removes, so
+   `Staggered[D]` is a real class and part of ADR 0028 (PR A), together with
+   the [Cartesian axis dimensions]([[personal/egparedes/connectivities-as-types/connectivities-as-types#cartesian-axis-dimensions) its parameter is bounded on; see
+   [`Staggered[D]`]([[personal/egparedes/connectivities-as-types/connectivities-as-types#staggeredd).
+
+## The `Staggered[D]` tag
+
+- **IR and serialization.** The tag is
+  `gt4py.next.common.Staggered[<base tag>]` — the one tag that is not a
+  qualified name. `resolve` parses the `<owner>[<base>]` grammar and
+  subscripts the owner, the IR pretty-parser accepts it, and `codegen_name`
+  escapes the brackets. `pickle` cannot look up a bracketed qualname, so one
+  `copyreg` hook reduces a staggered class to its base and re-subscripts on
+  load; fingerprints are likewise taken through the base.
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md
new file mode 100644
index 0000000..ac9eb79
--- /dev/null
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md
@@ -0,0 +1,240 @@
+---
+title: "Connectivities as types — Cartesian axes, the CW-complex reading and alignment"
+author: egparedes
+tags: [type-system, dimensions, staggering, cw-complex, exterior-calculus, domain, dimension-kind, type-checking]
+created: 2026-10-01
+status: draft
+---
+
+> **Appendix** to [[personal/egparedes/connectivities-as-types/connectivities-as-types|Connectivities as types]].
+> Background and full derivations for the staggering half of the design: why a
+> Cartesian axis has exactly two cell classes, what the product complex buys over a
+> form degree, why the alignment convention is the user's to pick, why extents are
+> declared rather than derived, and the alternatives and follow-ups that follow from
+> all of it. External corroboration from the UGRID and SGRID conventions is in the
+> [[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions appendix]].
+
+## 1. A Cartesian axis is two cell classes
+
+A **Cartesian axis** is an index space with integer index arithmetic and
+exactly one staggered partner — the dimensions `CartesianConnectivity` acts on.
+Read one axis of a Cartesian grid as a
+1-dimensional CW complex — a path when the axis is bounded, a cycle when it is
+periodic. Such a complex has exactly two cell classes, of degree 0 and 1, and a
+declared axis together with its `Staggered[·]` name those two classes.
+`Staggered` is the **involution that swaps them**. The types do not say which
+class has degree 0, and they need not: the ADR 0026 position convention
+(`Staggered[X](i)` at `i - 1/2`) fixes only their *relative* alignment. Both
+assignments occur. A vertex-indexed structured grid declares the 0-cells, so
+`Staggered[I](i)` is the 1-cell `[I(i-1), I(i)]`; ICON's Lorenz grid declares
+the 1-cells, `KDim` being the full levels (layer midpoints) while
+`Staggered[KDim]` are the half levels (interfaces, the 0-cells).
+
+In more than one dimension the grid is the **product** complex of its axes, so
+a cell class is a bit vector over axes — one bit per axis, "does this cell span
+it?" — and the cell degree is the number of set bits. `Dims[...]` *is* that bit
+vector:
+
+| `Dims[...]` | cell | degree |
+| --- | --- | --- |
+| `Dims[I, J]` | vertex | 0 |
+| `Dims[Staggered[I], J]` | edge along `I` | 1 |
+| `Dims[I, Staggered[J]]` | edge along `J` | 1 |
+| `Dims[Staggered[I], Staggered[J]]` | face | 2 |
+
+The `cell` and `degree` columns assume the first assignment above — every
+declared axis indexes its 0-cells. Under the other assignment the column reads
+upside down on that axis; the *encoding* is unaffected, which is the point.
+
+Per-axis staggering is therefore *more* informative than a form degree, which
+in two dimensions conflates the two edge families a C-grid must keep apart —
+the distinction that has to be recovered by hand, as a component label, wherever
+no product structure exists (`EDGE_N` vs `EDGE_T` in
+[[personal/egparedes/discretization-independent-fd-syntax|the surface-syntax note]]
+§7.1). It is also why the structured and unstructured cases are encoded
+differently here at all: a per-axis bit exists exactly when the complex factors
+as a product, and mesh locations (`V`, `E`, `C`) are separate dimension classes
+because it does not.
+
+Two consequences shape the hierarchy:
+
+- **A staggered dimension is itself a discretized axis.** It is the other cell
+  class of the same complex: it carries fields, has a range, and takes integer
+  offsets. So the asymmetry between `D` and `Staggered[D]` is not semantic but
+  *declarational* — one is written by the user, the other derived from it, and
+  there is exactly one partner to derive. That is what makes the derivation
+  well-founded, and it is the level `Staggered`'s parameter must name.
+- **`Staggered[D]` needs no orientation data.** A 1-cell in a complex is
+  oriented, which is what makes the coboundary signed. A product of intervals
+  has a canonical orientation per axis (increasing index), so the sign is
+  implicit in the stencil the user writes. The unstructured side has no such
+  canonical choice, which is why incidence signs are materialized there (ICON's
+  `geofac_div` carries them). The absence is a consequence of the product
+  structure, not an omission.
+
+## 2. Alignment
+
+**The alignment is antisymmetric, so the convention is the user's to pick.** The
+ADR 0026 convention places `Staggered[D](i)` at `i - 1/2` in `D`'s coordinates;
+equivalently, it places `D(j)` at `j + 1/2` in `Staggered[D]`'s. Both conventions
+appear in production codes — the SGRID convention's four `padding` values
+enumerate both, `low` and `both` placing a cell at `j - 1/2` while `none` and
+`high` place it at `j + 1/2`
+([[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions appendix]]
+§3) — and either is reachable by choosing *which member of the pair to
+declare*. The default puts the partner half a cell *below*; to have it half a cell
+*above* your main field, declare the axis the **partner** lives on and alias your
+main field onto the derived member. With `class IFace(CartesianAxisIndex)` and
+`ICell: TypeAlias = Staggered[IFace]`, an `IFace` field sits half a cell above the
+`ICell` field of the same index. The pair is symmetric in the implementation —
+`order_dimensions` orders by the base either way, `check_dims` is symmetric,
+fingerprints go through the base, gtfn aliases the staggered tag to its base — so
+the only residual cost is cosmetic: the derived member's *tag* reads
+`...Staggered[IFace]` in the IR, in codegen names and in error messages. Stencil
+code built from relative shifts is convention-independent in any case
+(`p(S + 1/2) - p(S - 1/2)` is the same difference either way, and `±1/2` reaches
+both neighbours); the convention bites only on absolute index correspondence with
+a reference implementation and on boundary index ranges.
+
+## 3. Extents
+
+**Extents are declared, never derived.** A path complex has `n` 0-cells and
+`n - 1` 1-cells; a cycle has `n` and `n`. So the two members of a pair do not in
+general have the same range, and *which one is wider is the degree assignment*:
+with `I` the 0-cells on `[0, n)`, the interior 1-cells are `[I(i-1), I(i)]` for
+`i` in `[1, n)`, and `Staggered[I](0)` is the first cell outside the complex —
+exactly where a halo cell goes; with `K` the 1-cells on `[0, n)` (ICON's layers),
+the interfaces run `[0, n+1)`. Both are expressible without any new type-level
+concept because a `Domain` holds absolute `UnitRange(start, stop)`s rather than
+sizes — see
+[[personal/havogt/field-data-protocol/field-data-protocol|the field data protocol]]
+for why absolute addressing is the right domain model — and the periodic case
+needs nothing extra, the two ranges simply coincide in size. The invariant a grid
+builder owes is that the two ranges *interleave*; their sizes then differ by at
+most one when the complex is closed, and halo extension relaxes even that (two of
+SGRID's four bounded cases, `low` and `high`, have equal sizes). An absolute range
+is strictly more expressive than SGRID's `padding` enum here: each of its four
+values is one `UnitRange` under a single alignment convention, and
+`padding: low` is exactly the halo cell named above. No component of this design
+sees both ranges at once, so enforcing it belongs to whatever
+constructs both
+([[personal/havogt/mesh-and-first-class-halos/mesh-and-first-class-halos|a mesh
+concept with first-class halos]]). Note also that `order_dimensions` giving a
+staggered field the *layout order* of its base says nothing about its *shape*:
+the two are independent.
+
+
+## 4. Axis versus mesh location is a per-declaration decision
+
+The class level also draws a distinction `kind` never did: `IDim` and `CellDim`
+are both `HORIZONTAL` and only the first is an axis. That is why the migration
+cannot be inferred from the source — whether a dimension is an axis or a mesh
+location is a decision per declaration (about ten in ICON4Py's `dimension.py`;
+near-uniformly `CartesianAxisIndex` in `tests/next_tests`). The migration script
+rewrites what it can and reports the rest.
+
+## 5. Relation to `dimension-generic-fields`, and one naming constraint
+
+[[personal/havogt/dimension-generic-fields/dimension-generic-fields|Generic dimensions and statically typed staggering]]
+Part II proposed this `Staggered[D]` shape with the same shift convention, and
+the root/user split that makes the doubly staggered type unrepresentable; here
+that split is motivated as the axis concept above and placed below
+`DimensionIndex` so that no annotation widens. Its static involution overloads
+(typing `Staggered[K] + 0.5` as landing on `K` for the checkers) are not part
+of the stack, so statically a half-integer shift is a plain `Connectivity`. Its
+`gradient_to_staggered` example, `p(Staggered[I] + 1/2) - p(Staggered[I] - 1/2)`,
+is the coboundary of a 0-cochain, which is why it lands on the partner class.
+
+**One naming constraint.** That prototype spells the partner-swapping operation
+`dual()` / `Dual[X]`. In a complex the Hodge dual flips *every* axis bit (a
+primal k-cell pairs with a dual (n−k)-cell) while `Staggered[D]` flips one, so
+the two coincide only in one dimension. `dual` stays reserved for the full
+Hodge dual — the sense
+[[personal/egparedes/discretization-independent-fd-syntax|the surface-syntax note]]
+§6.5 uses for the primal/dual C↔D grid swap — and the per-axis operation keeps
+gt4py's existing name, `flip_staggered`.
+
+## 6. Alternatives considered
+
+**A `PEP 695` generic for `Staggered[D]`.** Rejected: the subscription would
+be a `typing` alias, not a class, failing `issubclass` and eve's `type[...]`
+validation and unable to carry a tag. The metaclass subscription builds a
+real class; the PEP 695 form is used only under `TYPE_CHECKING`.
+
+**A sibling root above `DimensionIndex`** — `AnyDimensionIndex` with
+`DimensionIndex` and `Staggered[D]` as siblings, which is where
+[[personal/havogt/dimension-generic-fields/dimension-generic-fields|generic dimensions]]
+puts the split. Gives the same static ban, but `Staggered[K]` then stops being
+a `DimensionIndex`, so every annotation and `issubclass` guard that must accept
+a staggered dimension has to widen, and the static and runtime lattices diverge
+unless the widening is mirrored at runtime. The `AnyCartesianAxisIndex` / `CartesianAxisIndex`
+levels sit below the root instead and cost nothing at those sites.
+
+**A structural discriminator instead of the axis levels** — bound `Staggered`'s
+parameter to a `Protocol` carrying `__gt_staggered__: ClassVar[Literal[False]]`
+that the staggered class overrides with `Literal[True]`. Rejected: it needs a
+suppressed incompatible-override, reports an opaque diagnostic, hangs a
+meaningless attribute on every dimension, and buys only the ban — there is no
+axis concept, so `C + 1` and `Staggered[C]` stay unchecked.
+
+**A second partner constructor** — `Staggered[D]` for `i - 1/2` and
+`StaggeredAbove[D]` for `i + 1/2`, instead of a per-axis alignment. Rejected: it
+gives three cell classes per axis where an axis has two, so
+`Field[Dims[Staggered[I], StaggeredAbove[I]]]` — the same physical axis twice —
+becomes expressible and needs a new `check_dims` rule; and it makes
+`flip_staggered` partial, since `flip_staggered(I)` would have two candidate
+answers, so `I + 0.5` could not compute its own codomain and neither
+`as_non_staggered` nor the typed `dual()` would be well defined. It also spells a
+per-*pair* fact at every use site, so two modules can disagree about one grid, and
+it duplicates the whole bracketed-tag apparatus (a second interned family, tag
+grammar, `copyreg` hook and codegen escape). Parameterizing the alignment, if it
+is done at all, is one class keyword on the declared axis — see
+[Open questions]([[personal/egparedes/connectivities-as-types/connectivities-as-types#open-questions--follow-ups).
+
+**Declaring both members of a pair** (`class ICell(CartesianAxisIndex, dual_of=IFace,
+offset=+0.5)`). The explicit form, rejected for the reason this note exists: it
+reintroduces a two-object agreement, loses the property that a partner needs no
+separate declaration, and loses the involution by construction.
+
+**`Staggered[D: AnyCartesianAxisIndex]`**, bounding on any cell class rather than on a
+declared axis. The semantically tempting reading, since a staggered dimension
+*is* an axis — but it re-admits `Staggered[Staggered[K]]`. The bound has to name
+the declared level.
+
+## 7. Open follow-ups
+
+Numbered as in the main note's *Open questions*.
+
+5. **Parameterizing the alignment.** The ADR 0026 convention is hard-coded, while
+   SGRID's `padding` attribute exists precisely because production codes use both
+   alignments
+   ([[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions appendix]]
+   §3). The antisymmetry above makes both conventions reachable by choosing which member of
+   the pair to declare, at a cosmetic cost in the derived member's tag; a per-axis
+   class keyword (`class X(CartesianAxisIndex, stagger=Align.ABOVE)`) would remove
+   even that. It would have to be **static, on the axis**: it changes the integer
+   correction `connectivity_for_cartesian_shift` bakes into the
+   `CartesianConnectivity`, hence the emitted stencil, so unlike periodicity and
+   extents it cannot be a grid property. Its footprint is one `ClassVar` plus `+1`
+   vs `+0` in that one function — the backends only ever see an integer offset
+   along an axis — against three costs: `a(Staggered[I] + 1/2)` stops being
+   readable without the declaration, the frontend and embedded shift test matrix
+   doubles, and Identity rule 4 bites, since dimensions fingerprint *by reference*
+   and flipping the keyword in place would not invalidate the ADR 0023 cache. That
+   last hole is pre-existing (`kind` has it too) and would argue for folding
+   declaration-time dimension attributes into the fingerprint. Not in this stack.
+
+7. **A cell `degree` on the axis.** Making the degree assignment static
+   (`degree=0|1`) would let a coboundary be typed generically
+   (`d⁰: Field[deg 0] -> Field[deg 1]`) and make the range invariant derivable
+   rather than declared. Left out for now: it duplicates what the absolute ranges
+   already say, creating exactly the cross-object agreement this note removes; it
+   does not fix the extent relation without periodicity, which cannot be static;
+   and nothing consumes it until an exterior-calculus surface exists (Proposal 1
+   of
+   [[personal/egparedes/discretization-independent-fd-syntax|the surface-syntax note]]).
+   Revisit if that surface lands — but note that a degree is *canonical* for a mesh
+   location and only *declarational* for a Cartesian axis, so it belongs on the
+   `LocationIndex` of the next item rather than here
+   ([[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions appendix]]
+   §4a).
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_typing.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_typing.md
new file mode 100644
index 0000000..debed3b
--- /dev/null
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_typing.md
@@ -0,0 +1,108 @@
+---
+title: "Connectivities as types — decisions made by running mypy and pyright"
+author: egparedes
+tags: [type-system, type-checking, local-dimensions, dependent-types, nominal-types]
+created: 2026-10-01
+status: draft
+---
+
+> **Appendix** to [[personal/egparedes/connectivities-as-types/connectivities-as-types|Connectivities as types]].
+> Every place in the design where the shape of a declaration was decided by what a
+> checker accepts rather than by taste: why `Local` is annotated nowhere, why an
+> adopted or shared `Local` must be a `TypeAlias`, what the `__add__` self-type
+> costs, and why `Local[C]` and `V2E.Local` cannot be reconciled. The probes are
+> [`typing_probe.py`](typing_probe.py) and
+> [`staggered_probe.py`](staggered_probe.py).
+
+## 1. The `__add__` self-type costs two suppressions
+
+The last row needs `__add__` declared with `cls: type[AnyCartesianAxisIndex]`.
+Both checkers bind that signature correctly at every call site and both reject it
+at the *definition* site, with different diagnostics — mypy `[misc]` ("self"
+parameter missing for a non-static method), pyright
+`reportGeneralTypeIssues` ("Type of parameter `cls` must be a supertype of its
+class `DimensionMeta`") — so it costs two separately-spelled suppressions. P4 of
+[`staggered_probe.py`](staggered_probe.py) pins this down; the same restriction
+is what
+[[personal/havogt/dimension-generic-fields/dimension-generic-fields|generic dimensions]]
+suppresses for its overload pairs.
+
+## 2. Why `Local` is annotated nowhere, and must be a `TypeAlias` when shared
+
+- **`Local` is annotated nowhere**, and that is load-bearing. An annotation on
+  the base (`Local: ClassVar[type[LocalDimensionIndex]]`) or on the metaclass
+  makes a declaration's `Local` a *variable* for the checkers, so
+  `Field[Dims[V, V2E.Local], float]` is rejected — by pyright for a nested
+  `Local` ("Variable not allowed in type expression"), by mypy for an adopted
+  or shared one ("not valid as a type"). A real nested `Local` on the base is
+  not an option either: pyright reports an incompatible override in every
+  declaration. With no annotation anywhere, all three spellings are types for
+  both checkers.
+  The cost is that `conn.Local` is not an attribute the checkers know for a
+  *generic* `conn`: library code reads it through
+  `common.local_dimension_of(conn)`, and code that must name a local dimension
+  generically uses a `TypeVar` bound to `LocalDimensionIndex`. This is checked
+  for both checkers in CI: the mypy cases in `typing_tests/test_next.yaml`, and
+  a pyright run over `typing_tests/pyright_probes.py` in the same nox session
+  (pyright is what catches the annotation regression; mypy accepts it).
+- A declaration can instead **adopt** a module-level local dimension, written
+  `Local: typing.TypeAlias = V2EDim`; the local keeps its own tag, which is then
+  the connectivity's `offset_tag`. This is also how the migration script
+  rewrites existing `FieldOffset`s without renaming anything. Adopting is *not*
+  side-effect free: the adopter becomes the local's `owner` and writes its
+  counts onto the module-level class, and ownership is first-come — the first
+  connectivity declared over a local dimension owns it, later ones share it and
+  are recorded in its `sharers`. A
+  declaration *redefined* under the same tag (a re-run notebook cell) takes
+  ownership over again rather than becoming a sharer, and the counts it repeats
+  are then checked against the local dimension's own `size=`, not against what
+  the stale owner wrote. `ConstList` cannot be adopted: it belongs to no
+  connectivity.
+- A connectivity can **share** another one's local dimension
+  (`class C2CE(NeighborConnectivity[C, CE]): Local: typing.TypeAlias =
+  C2E.Local`). ICON4Py's flattened sparse offsets (`C2CE`, `E2ECV`, `E2EC`,
+  `C2CEC`) need exactly this, because their results must combine with
+  `C2E`-shaped sparse fields. The
+  owner stays the first declaration over the local (here `C2E`); the sharer
+  must have the same domain (its codomain is free), any counts it repeats must
+  equal the owner's, and reductions over the shared axis take the neighbor
+  structure from any bound table over it (`connectivity_key_over`: the owner's
+  key if bound, else the smallest bound key over that local, which raises
+  `KeyError` if there is none).
+- **Write an adopted or shared `Local` as a `TypeAlias`.** `Local: TypeAlias =
+  C2E.Local` is what keeps mypy treating `C2CE.Local` as a type; with a plain
+  assignment it is "not valid as a type" there (pyright accepts either, but
+  widens the plain form to `LocalDimensionIndex`). With the alias, annotations
+  may name the local dimension through any of its spellings — `C2CE.Local`,
+  `C2E.Local`, `V2EDim` — and they are one type.
+
+## 3. Relation to `Local[V2E]`
+
+[[personal/havogt/dependent-local-dimensions/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). They **cannot be reconciled for a type checker**: making
+`Local.__class_getitem__` return `V2E.Local` unifies them at runtime only.
+[`typing_probe.py`](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.
+
+## 4. Alternatives these decided
+
+**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`](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]`.

From 5df95ffb1adb3a729795002f097d78bfad71dcd8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Gonz=C3=A1lez=20Paredes?= <enriqueg@cscs.ch>
Date: Thu, 1 Oct 2026 20:43:45 +0200
Subject: [PATCH 05/19] =?UTF-8?q?personal/egparedes:=20connectivities=20as?=
 =?UTF-8?q?=20types=20=E2=80=94=20a=20slide=20deck=20appendix?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`connectivities-as-types_slides.md`: twelve slides for the design review — the
four-string problem and which path uses which string, the class-based declaration,
identity, what a Python type can and cannot say, the dimension hierarchy, the four
checks that become static, why two axis levels, what it deletes, the PR stack, and
the open questions. Every slide links the section it compresses and the deck adds
no facts of its own, so drift degrades to staleness rather than contradiction; it
carries a visible "as of commit 21e6b8f" marker.

Vanilla Markdown, so one file serves as both a Quartz page and a real deck. No
change to `quartz.config.ts`, `quartz.layout.ts` or `deploy.yml`, no committed
artifact and no CI step.

Verified locally, both ways:
- `marp-cli` 4.5.1: 12 slides, 121,695-byte self-contained HTML with zero external
  references, and a 12-page 960x540 PDF 1.7 whose title and author come from the
  frontmatter. 3 tables and 3 code blocks render.
- Quartz 4.5.2 (the version `deploy.yml` clones from `v4`, commit `d25a6ea`), built
  against this repo's `content/` and config: 36 files processed, 270 emitted, exit
  0. Inside `<article>` the page has exactly 11 `<hr>`, 11 `<h2>` and 1 `<h1>` — so
  every `---` became a slide break rather than a setext heading — 0 leaked `<style>`
  and no `[[wikilink]]` text. All 10 anchors the deck points at exist in the built
  main page, and the staggering-appendix link resolves.

The render command needs `--no-stdin`: without it marp-cli waits on stdin and looks
like a hang. That is recorded in the deck itself, together with the note that a cold
`npx` run spends minutes downloading before it converts anything.
---
 .../connectivities-as-types.md                |   4 +
 .../connectivities-as-types_slides.md         | 196 ++++++++++++++++++
 2 files changed, 200 insertions(+)
 create mode 100644 content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md

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 b0bd1c0..d43894d 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
@@ -844,6 +844,10 @@ ICON4Py.
   reconciled. The two probes are its attachments.
 - [[personal/egparedes/connectivities-as-types/connectivities-as-types_alternatives|Alternatives considered]]:
   the alternatives rejected on grounds other than the axis levels.
+- [[personal/egparedes/connectivities-as-types/connectivities-as-types_slides|Slides: a walk-through deck]]:
+  a twelve-slide summary of this note for the design review, readable as a page and
+  renderable with `marp-cli`. It adds no facts and links the section each slide
+  compresses.
 - [[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),
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md
new file mode 100644
index 0000000..6e1f654
--- /dev/null
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md
@@ -0,0 +1,196 @@
+---
+title: "Connectivities as types — slides"
+author: egparedes
+tags: [type-system, connectivities, local-dimensions, offset-provider, dimensions, staggering, slides]
+created: 2026-10-01
+status: draft
+paginate: true
+---
+
+> **Appendix** to [Connectivities as types](connectivities-as-types).
+> A walk-through deck for the design review. It summarises that note as of commit
+> `21e6b8f` and adds no facts of its own — every slide links the section it
+> compresses, so when the two disagree the note wins. Render with:
+> `npx -y @marp-team/marp-cli@4 --no-stdin connectivities-as-types_slides.md --html -o /tmp/deck.html`
+> (add `--pdf` for a PDF, which needs a Chromium-family browser). `--no-stdin` is
+> required: without it marp-cli waits on stdin and looks like a hang. The first run
+> downloads marp-cli and may take several minutes; later runs take under a second.
+> The file also reads as an ordinary page here, scrolling rule to rule.
+
+# Connectivities as types
+
+One declaration for offset, local dimension and provider key
+
+ADR 0028 (dimensions) · ADR 0029 (connectivities) · GridTools/gt4py#2917
+
+---
+
+## Today: four strings must agree
+
+```python
+V2EDim = Dimension("V2E", kind=DimensionKind.LOCAL)                # (N3) local dim name
+V2E    = FieldOffset("V2E", source=Edge, target=(Vertex, V2EDim))  # (N1) tag, (N2) variable
+program(..., offset_provider={"V2E": table})                       # (N4) provider key
+```
+
+Four independently authored strings. None checked against the others at
+declaration time. A fifth constraint is hidden: the Python *variable* name.
+
+→ [Four strings, one dict lookup](connectivities-as-types#four-strings-one-dict-lookup)
+
+---
+
+## Which string wins depends on the path
+
+| Path | Operation | String used |
+| --- | --- | --- |
+| embedded | shift `a(V2E[1])` | N1 `FieldOffset.value` |
+| embedded | `neighbor_sum(axis=V2EDim)` | N3 `axis.value` |
+| compiled | shift | **N2 `foast.Name.id`** |
+| compiled | reduction | N3 `ListType.offset_type.value` |
+| compiled | sparse field argument | N3 `dim.value` |
+
+Confirmed by execution: embedded and compiled key the *same* program on
+*different* strings.
+
+→ [Four strings, one dict lookup](connectivities-as-types#four-strings-one-dict-lookup)
+
+---
+
+## Proposed: the connectivity is a class
+
+```python
+class V2E(NeighborConnectivity[V, E], max_neighbors=6, min_neighbors=5):
+    class Local(LocalDimensionIndex): ...
+
+neighbor_sum(a(V2E), axis=V2E.Local)
+program(a, out=out, offset_provider={V2E: v2e_table})
+```
+
+The class *contains* its local dimension and *is* its own provider key. Nothing
+is ever an instance of `V2E`; it holds no data.
+
+→ [Concepts](connectivities-as-types#concepts) · [Sketch](connectivities-as-types#sketch)
+
+---
+
+## Identity is the qualified Python name
+
+`tag = f"{cls.__module__}.{cls.__qualname__}"`
+
+- the static view (nominal types) and the runtime view (`is`) agree by construction
+- reconstruction from the IR is an **import**, the way `pickle` references a class
+- so `<locals>` dimensions are rejected, and a redefinition is a *different*
+  connectivity
+- the IR names a connectivity by its `offset_tag` = its local dimension's tag, so
+  shifts, reductions and sparse arguments find one table under **one** string
+
+→ [Identity](connectivities-as-types#identity-is-the-qualified-python-name)
+
+---
+
+## What a Python type can and cannot say
+
+The "true" type of a local index is `Fin<degree(table, v)>` — it depends on the
+table *value*. Python types cannot mention values.
+
+- **in the type**: *which* neighbor relation (`V2E.Local`), domain, codomain,
+  declared counts
+- **at bind time**: `check_neighbor_table` — dtype, skip value, actual width
+- **given up**: per-element valence
+
+That split is what lets DSL code be written, checked and compiled before any mesh
+is loaded, and one compiled program serve many meshes.
+
+→ [Binding model](connectivities-as-types#binding-model)
+
+---
+
+## Dimensions: four levels, one root
+
+```
+DimensionIndex                            # the root; every annotation says this
+├── AnyCartesianAxisIndex                 # a cell class of a Cartesian axis
+│   ├── CartesianAxisIndex                # ← declared; what users subclass
+│   └── Staggered[D: CartesianAxisIndex]  # derived
+├── LocalDimensionIndex                   # a neighbor index; not an axis
+└── (direct subclasses)                   # mesh locations V/E/C
+```
+
+Below the root, so nothing widens and `LocalDimensionIndex` does not move.
+
+→ [Cartesian axis dimensions](connectivities-as-types#cartesian-axis-dimensions)
+
+---
+
+## Four checks become static
+
+| Rejected | Today | With the axis levels |
+| --- | --- | --- |
+| `Staggered[Staggered[K]]` | runtime `TypeError` | static |
+| `Staggered[V2E.Local]` | runtime `TypeError` | static |
+| `Staggered[C]` (no half-cells on a mesh) | nothing rejects it | static |
+| `C + 1`, `V2E.Local + 1` | runtime `kind` check | static |
+
+Verified with mypy and pyright in `staggered_probe.py`.
+
+→ [Cartesian axis dimensions](connectivities-as-types#cartesian-axis-dimensions)
+
+---
+
+## Why two levels, not one
+
+An axis of a Cartesian grid is a 1-dimensional CW complex: exactly **two** cell
+classes. A declared axis and its `Staggered[·]` name those two; `Staggered` swaps
+them.
+
+So a staggered dimension *is itself* an axis — the asymmetry is **declarational**,
+not semantic. That is the level the bound must name, and it is why there is
+nothing to nest.
+
+In *n* dimensions the grid is the product complex, so `Dims[...]` is one
+staggering bit per axis — finer than a form degree.
+
+→ [Staggering appendix](connectivities-as-types_staggering)
+
+---
+
+## What it deletes
+
+`FieldOffset` · bare-name provider keys · the `_Staggered` name prefix ·
+`_CONST_DIM` as a magic name · `SparseTag` · `NamedIndex` · the dimension half of
+the mypy plugin · `DimensionKind.LOCAL` · the `V2EDim`-next-to-`V2E` convention
+
+Of ten cross-object identity constraints: **six dissolve**, three collapse into
+one bind-time check, one remains.
+
+→ [What it deletes](connectivities-as-types#what-it-deletes) ·
+[Effect per layer](connectivities-as-types#effect-per-layer)
+
+---
+
+## Where it stands
+
+| PR | Contents |
+| --- | --- |
+| A #2899 | dimensions as classes, `Staggered[D]`, ADR 0028 |
+| B #2907 | `NeighborConnectivity`, `LocalDimensionIndex`, ADR 0029 |
+| C #2910 | class-keyed providers, `FieldOffset` removed, migration script |
+| D #2912 | `MultiDimensionIndex`, typed embedded positions |
+
+ICON4Py: the script rewrites 4 files and reports 46 provider keys to decide.
+
+→ [Implementation](connectivities-as-types#implementation)
+
+---
+
+## Open, and worth arguing about
+
+- **naming** — convergence with the chain proposals is still open
+- **the mesh proposal** — does a `Mesh` bind the typed declarations?
+- **`kind`** — four jobs in one enum; it should shrink, not grow
+- **`__eq__` vs "equality is `is`"** — asserted in one place, overridden in another
+- **alignment** — `Staggered[D](i)` at `i − ½` is hard-coded; both conventions
+  exist in production
+
+→ [Open questions](connectivities-as-types#open-questions--follow-ups)

From 6a7fa94d5be317e51ba80f65182a324b11f3aa2b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Gonz=C3=A1lez=20Paredes?= <enriqueg@cscs.ch>
Date: Thu, 1 Oct 2026 21:21:39 +0200
Subject: [PATCH 06/19] =?UTF-8?q?personal/egparedes:=20connectivities=20as?=
 =?UTF-8?q?=20types=20=E2=80=94=20fix=20the=20deck's=20rendered=20layout?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Reviewing the rendered PDF page by page turned up four layout defects that only
show up once rendered:

- The appendix banner became slide 1 and pushed the title off the bottom edge.
  The title slide now leads, with a compact banner under the subtitle, and the
  render instructions move to a new closing slide where they read better anyway.
- Marp treats a source newline as a hard break, so hard-wrapping at 80 columns
  produced ragged lines throughout. Paragraphs, blockquotes, list items and the
  footer links are now one source line each.
- The "four checks become static" table overflowed, cutting off its footer link.
  Shortened to one line per row.
- The render command needs `--no-stdin`, without which marp-cli waits on stdin
  and looks like a hang. Recorded on the closing slide.

13 slides, verified page by page in the rendered PDF. Quartz still builds clean
(36 files, 270 emitted): inside `<article>` the page has 12 `<hr>`, 12 `<h2>` and
1 `<h1>`, no leaked `<style>`, no wikilink text, and all 11 anchors resolve in the
built main page.
---
 .../connectivities-as-types_slides.md         | 80 ++++++++-----------
 1 file changed, 35 insertions(+), 45 deletions(-)

diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md
index 6e1f654..5e3f253 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md
@@ -7,22 +7,14 @@ status: draft
 paginate: true
 ---
 
-> **Appendix** to [Connectivities as types](connectivities-as-types).
-> A walk-through deck for the design review. It summarises that note as of commit
-> `21e6b8f` and adds no facts of its own — every slide links the section it
-> compresses, so when the two disagree the note wins. Render with:
-> `npx -y @marp-team/marp-cli@4 --no-stdin connectivities-as-types_slides.md --html -o /tmp/deck.html`
-> (add `--pdf` for a PDF, which needs a Chromium-family browser). `--no-stdin` is
-> required: without it marp-cli waits on stdin and looks like a hang. The first run
-> downloads marp-cli and may take several minutes; later runs take under a second.
-> The file also reads as an ordinary page here, scrolling rule to rule.
-
 # Connectivities as types
 
 One declaration for offset, local dimension and provider key
 
 ADR 0028 (dimensions) · ADR 0029 (connectivities) · GridTools/gt4py#2917
 
+> **Appendix** to [Connectivities as types](connectivities-as-types), summarising that note as of commit `21e6b8f`. Every slide links the section it compresses and this deck adds no facts of its own, so where the two disagree the note wins. Rendering instructions are on the last slide.
+
 ---
 
 ## Today: four strings must agree
@@ -33,8 +25,7 @@ V2E    = FieldOffset("V2E", source=Edge, target=(Vertex, V2EDim))  # (N1) tag, (
 program(..., offset_provider={"V2E": table})                       # (N4) provider key
 ```
 
-Four independently authored strings. None checked against the others at
-declaration time. A fifth constraint is hidden: the Python *variable* name.
+Four independently authored strings. None checked against the others at declaration time. A fifth constraint is hidden: the Python *variable* name.
 
 → [Four strings, one dict lookup](connectivities-as-types#four-strings-one-dict-lookup)
 
@@ -50,8 +41,7 @@ declaration time. A fifth constraint is hidden: the Python *variable* name.
 | compiled | reduction | N3 `ListType.offset_type.value` |
 | compiled | sparse field argument | N3 `dim.value` |
 
-Confirmed by execution: embedded and compiled key the *same* program on
-*different* strings.
+Confirmed by execution: embedded and compiled key the *same* program on *different* strings.
 
 → [Four strings, one dict lookup](connectivities-as-types#four-strings-one-dict-lookup)
 
@@ -67,8 +57,7 @@ neighbor_sum(a(V2E), axis=V2E.Local)
 program(a, out=out, offset_provider={V2E: v2e_table})
 ```
 
-The class *contains* its local dimension and *is* its own provider key. Nothing
-is ever an instance of `V2E`; it holds no data.
+The class *contains* its local dimension and *is* its own provider key. Nothing is ever an instance of `V2E`; it holds no data.
 
 → [Concepts](connectivities-as-types#concepts) · [Sketch](connectivities-as-types#sketch)
 
@@ -80,10 +69,8 @@ is ever an instance of `V2E`; it holds no data.
 
 - the static view (nominal types) and the runtime view (`is`) agree by construction
 - reconstruction from the IR is an **import**, the way `pickle` references a class
-- so `<locals>` dimensions are rejected, and a redefinition is a *different*
-  connectivity
-- the IR names a connectivity by its `offset_tag` = its local dimension's tag, so
-  shifts, reductions and sparse arguments find one table under **one** string
+- so `<locals>` dimensions are rejected, and a redefinition is a *different* connectivity
+- the IR names a connectivity by its `offset_tag` = its local dimension's tag, so shifts, reductions and sparse arguments find one table under **one** string
 
 → [Identity](connectivities-as-types#identity-is-the-qualified-python-name)
 
@@ -91,16 +78,13 @@ is ever an instance of `V2E`; it holds no data.
 
 ## What a Python type can and cannot say
 
-The "true" type of a local index is `Fin<degree(table, v)>` — it depends on the
-table *value*. Python types cannot mention values.
+The "true" type of a local index is `Fin<degree(table, v)>` — it depends on the table *value*. Python types cannot mention values.
 
-- **in the type**: *which* neighbor relation (`V2E.Local`), domain, codomain,
-  declared counts
+- **in the type**: *which* neighbor relation (`V2E.Local`), domain, codomain, declared counts
 - **at bind time**: `check_neighbor_table` — dtype, skip value, actual width
 - **given up**: per-element valence
 
-That split is what lets DSL code be written, checked and compiled before any mesh
-is loaded, and one compiled program serve many meshes.
+That split is what lets DSL code be written, checked and compiled before any mesh is loaded, and one compiled program serve many meshes.
 
 → [Binding model](connectivities-as-types#binding-model)
 
@@ -129,10 +113,10 @@ Below the root, so nothing widens and `LocalDimensionIndex` does not move.
 | --- | --- | --- |
 | `Staggered[Staggered[K]]` | runtime `TypeError` | static |
 | `Staggered[V2E.Local]` | runtime `TypeError` | static |
-| `Staggered[C]` (no half-cells on a mesh) | nothing rejects it | static |
+| `Staggered[C]` | nothing rejects it | static |
 | `C + 1`, `V2E.Local + 1` | runtime `kind` check | static |
 
-Verified with mypy and pyright in `staggered_probe.py`.
+No half-cells on an unstructured mesh. Verified with mypy and pyright in `staggered_probe.py`.
 
 → [Cartesian axis dimensions](connectivities-as-types#cartesian-axis-dimensions)
 
@@ -140,16 +124,11 @@ Verified with mypy and pyright in `staggered_probe.py`.
 
 ## Why two levels, not one
 
-An axis of a Cartesian grid is a 1-dimensional CW complex: exactly **two** cell
-classes. A declared axis and its `Staggered[·]` name those two; `Staggered` swaps
-them.
+An axis of a Cartesian grid is a 1-dimensional CW complex: exactly **two** cell classes. A declared axis and its `Staggered[·]` name those two; `Staggered` swaps them.
 
-So a staggered dimension *is itself* an axis — the asymmetry is **declarational**,
-not semantic. That is the level the bound must name, and it is why there is
-nothing to nest.
+So a staggered dimension *is itself* an axis — the asymmetry is **declarational**, not semantic. That is the level the bound must name, and it is why there is nothing to nest.
 
-In *n* dimensions the grid is the product complex, so `Dims[...]` is one
-staggering bit per axis — finer than a form degree.
+In *n* dimensions the grid is the product complex, so `Dims[...]` is one staggering bit per axis — finer than a form degree.
 
 → [Staggering appendix](connectivities-as-types_staggering)
 
@@ -157,15 +136,11 @@ staggering bit per axis — finer than a form degree.
 
 ## What it deletes
 
-`FieldOffset` · bare-name provider keys · the `_Staggered` name prefix ·
-`_CONST_DIM` as a magic name · `SparseTag` · `NamedIndex` · the dimension half of
-the mypy plugin · `DimensionKind.LOCAL` · the `V2EDim`-next-to-`V2E` convention
+`FieldOffset` · bare-name provider keys · the `_Staggered` name prefix · `_CONST_DIM` as a magic name · `SparseTag` · `NamedIndex` · the dimension half of the mypy plugin · `DimensionKind.LOCAL` · the `V2EDim`-next-to-`V2E` convention
 
-Of ten cross-object identity constraints: **six dissolve**, three collapse into
-one bind-time check, one remains.
+Of ten cross-object identity constraints: **six dissolve**, three collapse into one bind-time check, one remains.
 
-→ [What it deletes](connectivities-as-types#what-it-deletes) ·
-[Effect per layer](connectivities-as-types#effect-per-layer)
+→ [What it deletes](connectivities-as-types#what-it-deletes) · [Effect per layer](connectivities-as-types#effect-per-layer)
 
 ---
 
@@ -190,7 +165,22 @@ ICON4Py: the script rewrites 4 files and reports 46 provider keys to decide.
 - **the mesh proposal** — does a `Mesh` bind the typed declarations?
 - **`kind`** — four jobs in one enum; it should shrink, not grow
 - **`__eq__` vs "equality is `is`"** — asserted in one place, overridden in another
-- **alignment** — `Staggered[D](i)` at `i − ½` is hard-coded; both conventions
-  exist in production
+- **alignment** — `Staggered[D](i)` at `i − ½` is hard-coded; both conventions exist in production
 
 → [Open questions](connectivities-as-types#open-questions--follow-ups)
+
+---
+
+## Rendering this deck
+
+```console
+npx -y @marp-team/marp-cli@4 --no-stdin \
+    connectivities-as-types_slides.md --html -o /tmp/deck.html
+```
+
+- **`--no-stdin` is required** — without it marp-cli waits on stdin and looks like a hang
+- add `--pdf` for a PDF; that path needs a Chromium-family browser
+- the first run downloads marp-cli and may take several minutes, later runs under a second
+- the file also reads as an ordinary page in the garden, scrolling rule to rule
+
+→ [Appendices](connectivities-as-types#appendices)

From 40f538fdc9f6aa7cd4176a751bae4c1cb490fd58 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Gonz=C3=A1lez=20Paredes?= <enriqueg@cscs.ch>
Date: Thu, 1 Oct 2026 21:36:48 +0200
Subject: [PATCH 07/19] =?UTF-8?q?personal/egparedes:=20connectivities=20as?=
 =?UTF-8?q?=20types=20=E2=80=94=20address=20the=20Copilot=20review?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Six inline comments, all valid. Two were regressions introduced when the
mega-cells and the Identity rules were condensed in the core/appendix split.

- `NeighborTableType` fallback: an undeclared table still *gets* a
  `NeighborTableType`; only its `connectivity` field falls back to the structural
  `ConnectivityType`, so `dtype`, `skip_value` and `max_neighbors` survive for
  compilation. The condensed prose had read as if the record itself were replaced.
- Identity rule 4: a dimension is fingerprinted by reference, so redefining one
  under the same name with a different `kind` does *not* invalidate artifacts —
  which is the hole open question 5 names. Only a connectivity declaration, which
  is fingerprinted additionally by domain, codomain, `Local` and counts, does. The
  condensation had made the claim general and so contradicted open question 5.
- `order_dimensions`: the proposed `(is_local, kind, base.tag)` key would move
  local dimensions from between horizontal and vertical to last, turning
  `(Cell, V2E.Local, K)` into `(Cell, K, V2E.Local)` and changing sparse-field
  layout. The note now says the existing rank is preserved and only the source of
  localness changes.
- The `Staggered[Staggered[K]] = K` paragraph now says explicitly that the
  involution is on cell *classes*, a different operation from composing two
  half-integer shifts.
- `min_neighbors` is not a `NeighborTableType` field; it is the optional count on
  the declaration's `Local`. Corrected in the conventions comparison table.
- The `start_index` suggestion was underspecified: a codomain is a dimension class
  and carries no range, `check_neighbor_table` gets only a declaration and a table
  or type, and the `table_types` path has no entries to inspect. Conventions §4b is
  retitled to *record the index origin* and lists the three prerequisites; open
  question 10 and the §6 round-trip claim are qualified to match.
---
 .../connectivities-as-types.md                | 38 ++++++++++++-------
 .../connectivities-as-types_conventions.md    | 31 ++++++++++-----
 2 files changed, 46 insertions(+), 23 deletions(-)

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 d43894d..e0d21b1 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
@@ -213,10 +213,12 @@ ahead-of-time compilation (`table_types`), never authored next to the declaratio
 A table alone cannot name its declaration — a sharer's table has the owner's domain
 dims and a different codomain — so the record is built from the provider key,
 taking whichever of the local dimension's `owner` or `sharers` the key names. A
-table bound under a name no declaration answers to (hand-written IR) gets the
-structural base `ConnectivityType`, which is also what `NeighborTable.__gt_type__()`
-returns and what types general connectivity values such as the index field of
-`as_offset`. It is what fingerprints a compiled variant: the owner's and a sharer's
+table bound under a name no declaration answers to (hand-written IR) still gets a
+`NeighborTableType`; what falls back is its `connectivity` field, which then holds
+the structural base `ConnectivityType` rather than a declaration, so `dtype`,
+`skip_value` and `max_neighbors` survive for compilation to consume. That
+structural type is also what `NeighborTable.__gt_type__()` returns and what types
+general connectivity values such as the index field of `as_offset`. It is what fingerprints a compiled variant: the owner's and a sharer's
 record over one table fingerprint differently.
 
 `ts.ShiftType` is what `V2E`, `V2E[1]`, `I + 1`, `K + 0.5` and `as_offset(K, f)`
@@ -378,9 +380,11 @@ stated as rules:
    **compiles it in the calling thread** instead of failing in a spawn worker.
 3. **No registry.** Classes pickle by reference. The one narrow `copyreg` hook is
    for `Staggered[D]`, whose bracketed qualname `save_global` cannot look up.
-4. **Fingerprints depend on qualified names**, so a redefinition under the same
-   name does not reuse artifacts and the ADR 0023 build cache invalidates on
-   module renames.
+4. **Fingerprints depend on qualified names.** A dimension is fingerprinted by
+   reference, so redefining one under the same name with a different `kind` does
+   *not* invalidate artifacts (open question 5). A connectivity declaration is
+   fingerprinted *additionally* by its domain, codomain, `Local` and counts, so
+   redefining one does. Either way the ADR 0023 cache invalidates on module renames.
 5. **Codegen names need injective mangling.** `codegen_name(tag)` is a prefix
    escape (`_`→`_u`, `.`→`_d`, `[`→`_l`, `]`→`_r`); the obvious alternative is
    not injective.
@@ -462,7 +466,9 @@ at most one `LOCAL` dimension; and `VERTICAL` names the scan axis and, by
 convention, the undecomposed one. The first and third are now class facts —
 `kind == LOCAL` iff `issubclass(d, LocalDimensionIndex)` — so **`LOCAL` leaves the
 enum**: `kind` becomes `HORIZONTAL | VERTICAL` and `order_dimensions` sorts by
-`(is_local, kind, base.tag)` with `is_local` read from the class (PR B, where
+the rank it uses today, with localness read from the class instead of from the
+enum — the horizontal/local/vertical order must not move, or sparse-field layout
+changes with it (PR B, where
 `LocalDimensionIndex` lands). What is left is the layout key and the "vertical"
 role, which belong to the field and to the program respectively — see
 [Open questions](#open-questions--follow-ups).
@@ -502,8 +508,9 @@ of [Cartesian axis dimensions](#cartesian-axis-dimensions).
   `Staggered[K]` stays a `DimensionIndex` and no annotation widens; verified in
   [`staggered_probe.py`](staggered_probe.py). Nothing stronger is claimed. The
   equation `Staggered[Staggered[K]] = K` is semantically right — `Staggered` is
-  an involution on the two cell classes — but Python typing has no type-level
-  reduction, so `Field[Dims[K]]` and a hypothetical
+  an involution on the two cell *classes*, a different operation from composing
+  two half-integer shifts (which lands on `K` one cell over, not on the same
+  index) — but Python typing has no type-level reduction, so `Field[Dims[K]]` and a hypothetical
   `Field[Dims[Staggered[Staggered[K]]]]` would be mutually incompatible nominal
   types. Making the nested form unrepresentable sidesteps the equation instead
   of asserting it.
@@ -793,9 +800,12 @@ equality with an interning registry; and static-only `max_neighbors` /
    identity story both depend on this being benign; it is not established here,
    and the ADR 0028 implementation should say which of the two rules wins.
 10. **The index origin of a bound table.** `NeighborTableType` records no index
-    origin, while UGRID standardizes `start_index` ∈ {0, 1}. `check_neighbor_table`
-    could validate entries against the codomain's absolute range instead of
-    `[0, size)` ([[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions appendix]] §4b).
+    origin, while UGRID standardizes `start_index` ∈ {0, 1}. Validating entries
+    against a codomain *range* is not a one-line change: a codomain is a dimension
+    class and carries no range, `check_neighbor_table` receives only a declaration
+    and a table or type, and its type-only path (`table_types`) has no entries to
+    inspect. It would need a target range supplied at binding time and a
+    value-carrying table ([[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions appendix]] §4b).
 
 ## Implementation
 
@@ -869,7 +879,7 @@ ICON4Py.
   staggering — why UGRID's locations are cell degrees while SGRID's are per-axis
   bit vectors, how SGRID's four `padding` values decode into single absolute
   ranges, and the enhancements that follow (a UGRID vocabulary for
-  `LocationIndex`, validating a bound table against its codomain's range,
+  `LocationIndex`, recording the index origin of a bound table,
   deriving incidence signs from a recorded node ordering).
 - [`staggered_probe.py`](staggered_probe.py): the mypy / pyright probes behind
   [Cartesian axis dimensions](#cartesian-axis-dimensions) — `Staggered[Staggered[I]]`,
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md
index c9713b5..703e60a 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md
@@ -80,7 +80,7 @@ enumerates as 2ⁿ location names, and it does not stop at three axes.
 | Convention feature | This design | Verdict |
 | --- | --- | --- |
 | Connectivities named by entity pair (`face_node_connectivity`) | `NeighborConnectivity[Domain, Codomain]` — `face_node_connectivity` ≡ `NeighborConnectivity[Face, Node]` | isomorphic. The `Domain`/`Codomain` naming matches UGRID's reading direction, where `source`/`target` did not |
-| `_FillValue` required wherever an entry may be absent — ragged valence, but also a missing boundary neighbour in `edge_face_connectivity` / `face_face_connectivity`; `nMaxMesh2_face_nodes` | `skip_value`, `max_neighbors`, `min_neighbors` on `NeighborTableType` | strictly more informative. ICON's icosahedron carries 12 pentagons among hexagons, so `V2E` is `min_neighbors=5, max_neighbors=6`; UGRID can only record max 6 plus fill. That is the sketch's example verbatim |
+| `_FillValue` required wherever an entry may be absent — ragged valence, but also a missing boundary neighbour in `edge_face_connectivity` / `face_face_connectivity`; `nMaxMesh2_face_nodes` | `skip_value` and `max_neighbors` on `NeighborTableType`, and the optional `min_neighbors` on the declaration's `Local` | strictly more informative. ICON's icosahedron carries 12 pentagons among hexagons, so `V2E` is `min_neighbors=5, max_neighbors=6`; UGRID can only record max 6 plus fill. That is the sketch's example verbatim |
 | `vertical_dimensions` uses **the same** padding syntax as `face_dimensions` | — | the vertical is just another axis pair. SGRID needs no "vertical kind", which supports the conclusion that `DimensionKind.VERTICAL` is a layout and scan artefact, not geometry (main note, open question 6) |
 | `face_dimensions` specifies a padding **per axis** | a per-axis alignment, never grid-wide | supports the shape of the alignment follow-up (open question 5): a class keyword on the axis |
 | 3D topology forbidden for layered grids; use 2D + `vertical_dimensions` | horizontal topology plus a separate vertical axis | validates the existing split |
@@ -160,16 +160,29 @@ answering it, and it gives `LocationIndex` content worth having: a typed
 `Node`/`Edge`/`Face`/`Volume` vocabulary with degrees makes a UGRID mesh bind by
 construction, and makes "a primary, non-local dimension" expressible.
 
-### (b) Validate a bound table against the codomain's range, not against `[0, size)`
+### (b) Record the index origin of a bound table
 
 UGRID standardizes `start_index` ∈ {0, 1} on every connectivity array, and
 ICON4Py's tables come from Fortran. `NeighborTableType` carries `dtype`,
-`skip_value` and `max_neighbors` but no index origin. Since a codomain dimension
-has an absolute range, `check_neighbor_table` can validate entries against
-`codomain`'s `UnitRange` rather than against `[0, size)`, and a 1-based table is
-then simply a codomain with range `[1, n+1)`. That makes `start_index` a
-non-issue at the cost of one comparison in one function, and it is the same
-absolute-range argument as §3(i).
+`skip_value` and `max_neighbors` but no index origin, so nothing in the design
+distinguishes a 0-based table from a 1-based one.
+
+Checking entries against a codomain *range* is the tempting fix, and it is the
+same absolute-range argument as §3(i) — but it is **not** a one-line change, and
+the note's open question 10 should say so. Three prerequisites are missing:
+
+- a **codomain is a dimension class** and carries no range; ranges live on a
+  field's `Domain`, not on the declaration;
+- `check_neighbor_table` is handed only a declaration and a table or type, so the
+  target range would have to be supplied at binding time, from the field or the
+  mesh;
+- its **type-only path** (`table_types`, for ahead-of-time compilation) has no
+  entries to inspect at all, so any entry-level check is unavailable there.
+
+The cheap, available step is therefore to *record* the origin — a `start_index`
+on `NeighborTableType`, or a documented 0-based requirement plus a rebase in the
+loader — and to treat range validation as a separate question that depends on a
+mesh concept.
 
 ### (c) Record the orientation guarantee so incidence signs become derivable
 
@@ -226,7 +239,7 @@ the data, not only in a side dict.
 
 Aligning on vocabulary rather than mechanism makes a UGRID/SGRID reader on the
 `gtx` side straightforward: entity classes and connectivity declarations come
-from the convention, `start_index` resolves into the codomain range (b), ragged
+from the convention, `start_index` is recorded rather than inferred (b), ragged
 valence into `min_neighbors`/`max_neighbors`/`skip_value`, SGRID `padding` into
 the two members' absolute ranges (§3), and SGRID `location` into a `Dims[...]`
 bit vector. That is downstream of the whole PR stack and is a goal, not a

From 80f9d04d6c7955b5ed38c4168f381ebcf3b93d71 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Gonz=C3=A1lez=20Paredes?= <enriqueg@cscs.ch>
Date: Thu, 1 Oct 2026 22:20:47 +0200
Subject: [PATCH 08/19] =?UTF-8?q?personal/egparedes:=20connectivities=20as?=
 =?UTF-8?q?=20types=20=E2=80=94=20second=20Copilot=20pass?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Five findings in code unchanged since the first review. All valid.

- **Three malformed links.** The core/appendix split rewrote same-file anchors
  into wikilinks by substituting the link *destination*, producing
  `[label]([[path#anchor)` — a Markdown link whose destination is an unclosed
  wikilink, reaching nothing. Two in the identity appendix, one in the staggering
  appendix, now proper `[[path#anchor|label]]`. My link checker matched neither
  `](#...)` nor `[[...]]` and so missed the hybrid; it now tests for it.
- **The degree/extent rationale was backwards.** Open question 7 claimed a static
  `degree` "duplicates what the ranges say" and "needs periodicity". Neither holds:
  a periodic axis gives both cell classes `[0, n)` under either assignment and halo
  padding makes the widths arbitrary, so degree is *not* inferable from extents; and
  a static degree needs no periodicity at all. It is *deriving extents* that needs
  the degree plus a periodicity and halo policy. The only surviving reason to leave
  it out is the absence of a consumer. Corrected here and in staggering appendix §7,
  and the appendix's "which one is wider is the degree assignment" now carries its
  bounded, halo-free precondition.
- **Incidence signs need three orderings, not one.** Conventions §4(c) claimed
  anticlockwise face-node order makes the signs derivable. That fixes the *face*
  orientation only: for face `(0, 1, 2)`, reversing edge `(0, 1)` flips its
  coefficient with `face_node_connectivity` unchanged. Deriving a sign needs the
  face ordering, each edge's own `edge_node_connectivity` ordering, and the
  `face_edge_connectivity` mapping — and even then only the topological `d`, never
  the metric `⋆`. The `C2V` orientation-marker suggestion is qualified accordingly.
- **The cross-link overstated popcount.** The surface-syntax note's paragraph said
  the cell degree is the number of set bits; that holds only when every declared
  axis indexes its 0-cells. ICON's full-level `KDim` indexes 1-cells, so deriving
  its partner lowers the degree. Qualified, so declared-versus-derived is not
  conflated with degree.
---
 .../connectivities-as-types.md                | 10 ++++---
 .../connectivities-as-types_conventions.md    | 27 +++++++++++++++----
 .../connectivities-as-types_identity.md       |  4 +--
 .../connectivities-as-types_staggering.md     | 19 ++++++++-----
 .../discretization-independent-fd-syntax.md   |  2 +-
 5 files changed, 44 insertions(+), 18 deletions(-)

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 e0d21b1..e8ce31f 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
@@ -781,9 +781,13 @@ equality with an interning registry; and static-only `max_neighbors` /
    the program, not of the dimension. Every candidate *addition* belongs to the
    grid, the program or the range, so `kind` should shrink rather than grow; see
    [[personal/egparedes/connectivities-as-types/connectivities-as-types_staggering|the staggering appendix]] §7.
-7. **A cell `degree` on the axis.** Left out: it duplicates what the absolute
-   ranges already say, needs periodicity (which cannot be static), and has no
-   consumer until an exterior-calculus surface exists. A degree is *canonical* for
+7. **A cell `degree` on the axis.** Left out because **nothing consumes it** until
+   an exterior-calculus surface exists; a static `degree=0|1` is itself perfectly
+   well defined and needs no periodicity. The ranges do *not* substitute for it: a
+   periodic axis gives both classes `[0, n)` under either assignment and halo
+   padding makes the widths arbitrary, so degree is not inferable from extents in
+   general. The dependency runs the other way — *deriving extents* needs the degree
+   plus a periodicity and halo policy. A degree is *canonical* for
    a mesh location and only *declarational* for an axis, so it belongs on the
    `LocationIndex` of the next item; see [[personal/egparedes/connectivities-as-types/connectivities-as-types_staggering|the staggering appendix]]
    and [[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions]] §4a.
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md
index 703e60a..db38c7d 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md
@@ -187,12 +187,29 @@ mesh concept.
 ### (c) Record the orientation guarantee so incidence signs become derivable
 
 UGRID says face corner nodes "should be specified in anticlockwise (also referred
-to as counterclockwise) direction as viewed from above". Where that holds, the
-incidence signs — the `d` of `div = ⋆d⋆` — are **derivable from
-`face_node_connectivity`** instead of supplied. Note the modal verb: the
+to as counterclockwise) direction as viewed from above". Note the modal verb: the
 convention *recommends* the ordering rather than mandating it, so a consumer
-cannot assume it — which is exactly why a gt4py-side declaration would have to
-record the guarantee rather than infer it. The main note explains why
+cannot assume it — which is why a gt4py-side declaration would have to record the
+guarantee rather than infer it.
+
+But recording that guarantee is **not sufficient** to derive the incidence signs —
+the `d` of `div = ⋆d⋆`. Anticlockwise face-node order fixes the orientation of the
+*face*, not of each globally indexed edge. For a face `(0, 1, 2)`, reversing edge
+`(0, 1)` to `(1, 0)` flips its incidence coefficient from `+1` to `−1` while
+`face_node_connectivity` is unchanged. Deriving a sign therefore needs three
+things, not one:
+
+- the face's node ordering (the anticlockwise guarantee);
+- **each edge's own node ordering** — `edge_node_connectivity`, which fixes the
+  edge field's sign convention;
+- the **face-to-edge mapping** relating the two, `face_edge_connectivity`.
+
+So an `orientation=` marker on a `C2V`-shaped declaration supplies one of the three
+and none of the metric factors — the `⋆` of
+[[personal/egparedes/discretization-independent-fd-syntax|the surface-syntax note]]
+§3.6. The honest claim is narrower than "derivable": with all three orderings
+recorded, the *topological* part `d` becomes computable, while `⋆` remains mesh
+geometry that has to be supplied. The main note explains why
 the Cartesian side needs no orientation data (a product of intervals is
 canonically oriented per axis) and points at ICON's `geofac_div` for the
 unstructured side, where the signs are materialized. UGRID shows the
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_identity.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_identity.md
index 21cdb20..46066e5 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_identity.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_identity.md
@@ -43,8 +43,8 @@ status: draft
 6. **Staggering is part of the dimension change.** The `_Staggered` name
    prefix needs the name→class lookup that type identity removes, so
    `Staggered[D]` is a real class and part of ADR 0028 (PR A), together with
-   the [Cartesian axis dimensions]([[personal/egparedes/connectivities-as-types/connectivities-as-types#cartesian-axis-dimensions) its parameter is bounded on; see
-   [`Staggered[D]`]([[personal/egparedes/connectivities-as-types/connectivities-as-types#staggeredd).
+   the [[personal/egparedes/connectivities-as-types/connectivities-as-types#cartesian-axis-dimensions|Cartesian axis dimensions]] its parameter is bounded on; see
+   [[personal/egparedes/connectivities-as-types/connectivities-as-types#staggeredd|`Staggered[D]`]].
 
 ## The `Staggered[D]` tag
 
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md
index ac9eb79..3a0cc7e 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md
@@ -100,7 +100,9 @@ a reference implementation and on boundary index ranges.
 
 **Extents are declared, never derived.** A path complex has `n` 0-cells and
 `n - 1` 1-cells; a cycle has `n` and `n`. So the two members of a pair do not in
-general have the same range, and *which one is wider is the degree assignment*:
+general have the same range, and for a bounded, halo-free complex *which one is
+wider is the degree assignment* (periodicity or halo padding destroys that
+correspondence — see §7):
 with `I` the 0-cells on `[0, n)`, the interior 1-cells are `[I(i-1), I(i)]` for
 `i` in `[1, n)`, and `Staggered[I](0)` is the first cell outside the complex —
 exactly where a halo cell goes; with `K` the 1-cells on `[0, n)` (ICON's layers),
@@ -189,7 +191,7 @@ per-*pair* fact at every use site, so two modules can disagree about one grid, a
 it duplicates the whole bracketed-tag apparatus (a second interned family, tag
 grammar, `copyreg` hook and codegen escape). Parameterizing the alignment, if it
 is done at all, is one class keyword on the declared axis — see
-[Open questions]([[personal/egparedes/connectivities-as-types/connectivities-as-types#open-questions--follow-ups).
+[[personal/egparedes/connectivities-as-types/connectivities-as-types#open-questions--follow-ups|Open questions]].
 
 **Declaring both members of a pair** (`class ICell(CartesianAxisIndex, dual_of=IFace,
 offset=+0.5)`). The explicit form, rejected for the reason this note exists: it
@@ -227,13 +229,16 @@ Numbered as in the main note's *Open questions*.
 7. **A cell `degree` on the axis.** Making the degree assignment static
    (`degree=0|1`) would let a coboundary be typed generically
    (`d⁰: Field[deg 0] -> Field[deg 1]`) and make the range invariant derivable
-   rather than declared. Left out for now: it duplicates what the absolute ranges
-   already say, creating exactly the cross-object agreement this note removes; it
-   does not fix the extent relation without periodicity, which cannot be static;
-   and nothing consumes it until an exterior-calculus surface exists (Proposal 1
+   rather than declared. Left out for now because **nothing consumes it** until an
+   exterior-calculus surface exists (Proposal 1
    of
    [[personal/egparedes/discretization-independent-fd-syntax|the surface-syntax note]]).
-   Revisit if that surface lands — but note that a degree is *canonical* for a mesh
+   Absolute ranges do **not** determine the
+   degree in general: a periodic axis gives both classes `[0, n)` under either
+   assignment, and halo padding makes the relative widths arbitrary. A static degree
+   needs no periodicity and would not be ill-defined — it is *deriving extents* that
+   needs the degree together with a periodicity and halo policy. Revisit if that
+   surface lands — but note that a degree is *canonical* for a mesh
    location and only *declarational* for a Cartesian axis, so it belongs on the
    `LocationIndex` of the next item rather than here
    ([[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions appendix]]
diff --git a/content/personal/egparedes/discretization-independent-fd-syntax.md b/content/personal/egparedes/discretization-independent-fd-syntax.md
index 0a271a3..cfd013c 100644
--- a/content/personal/egparedes/discretization-independent-fd-syntax.md
+++ b/content/personal/egparedes/discretization-independent-fd-syntax.md
@@ -130,7 +130,7 @@ Its companion in documentation is the **stencil molecule** — a figure that *on
 
 There is no analogous molecule for an unstructured operator: the "stencil" is a variable-valence patch, so unstructured papers draw a representative hexagon/triangle and rely on the connectivity-sum form instead.
 
-Per axis, the half-index pair is the two cell classes of a 1-dimensional CW complex — the 0-cells and 1-cells of a path, or of a cycle if the axis is periodic — and in more than one dimension the grid is their **product** complex, so a cell class is one staggering bit per axis and the cell degree is the number of set bits. That is the structure [[personal/egparedes/connectivities-as-types/connectivities-as-types|Connectivities as types]] encodes in the type system, as `Staggered[D]` over a declared axis dimension; the `HLoc`/`VLoc` location types of §7.1 sit above it, and a per-axis bit vector is strictly finer than a form degree (it keeps the two edge families of §6.4 apart, which `k = 1` alone does not).
+Per axis, the half-index pair is the two cell classes of a 1-dimensional CW complex — the 0-cells and 1-cells of a path, or of a cycle if the axis is periodic — and in more than one dimension the grid is their **product** complex, so a cell class is one staggering bit per axis. The cell degree is the number of set bits only when every declared axis indexes its 0-cells; a declared axis may index the 1-cells instead — ICON's full-level `KDim` does — and then deriving its partner lowers the degree rather than raising it, so declared-versus-derived status is not the same thing as degree. That is the structure [[personal/egparedes/connectivities-as-types/connectivities-as-types|Connectivities as types]] encodes in the type system, as `Staggered[D]` over a declared axis dimension; the `HLoc`/`VLoc` location types of §7.1 sit above it, and a per-axis bit vector is strictly finer than a form degree (it keeps the two edge families of §6.4 apart, which `k = 1` alone does not).
 
 ### 3.4 Connectivity-sum notation — *FV / mimetic FD on unstructured grids*
 

From 8e1a2123b66c2e616fcf21bb307fd1cb9ef6d7d5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Gonz=C3=A1lez=20Paredes?= <enriqueg@cscs.ch>
Date: Thu, 1 Oct 2026 23:37:42 +0200
Subject: [PATCH 09/19] =?UTF-8?q?personal/egparedes:=20connectivities=20as?=
 =?UTF-8?q?=20types=20=E2=80=94=20lead=20the=20deck=20with=20the=20render?=
 =?UTF-8?q?=20slide?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Move "Rendering this deck" from last to first, so a reader landing on the page
sees how to render it before the content — the role the `> **Appendix** to …`
banner plays in the sibling appendices. The title slide's pointer is updated from
"on the last slide" to "on the slide before this one".

Still 13 slides. Re-rendered and checked: slides 1 and 2 both fit, and the Quartz
page is unchanged structurally (12 `<hr>`, 12 `<h2>`, 1 `<h1>`, 3 tables, no leaked
`<style>`), with "Rendering this deck" now the first heading. All 14 deck links
still resolve.
---
 .../connectivities-as-types_slides.md         | 34 +++++++++----------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md
index 5e3f253..69da0f6 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md
@@ -7,13 +7,29 @@ status: draft
 paginate: true
 ---
 
+## Rendering this deck
+
+```console
+npx -y @marp-team/marp-cli@4 --no-stdin \
+    connectivities-as-types_slides.md --html -o /tmp/deck.html
+```
+
+- **`--no-stdin` is required** — without it marp-cli waits on stdin and looks like a hang
+- add `--pdf` for a PDF; that path needs a Chromium-family browser
+- the first run downloads marp-cli and may take several minutes, later runs under a second
+- the file also reads as an ordinary page in the garden, scrolling rule to rule
+
+→ [Appendices](connectivities-as-types#appendices)
+
+---
+
 # Connectivities as types
 
 One declaration for offset, local dimension and provider key
 
 ADR 0028 (dimensions) · ADR 0029 (connectivities) · GridTools/gt4py#2917
 
-> **Appendix** to [Connectivities as types](connectivities-as-types), summarising that note as of commit `21e6b8f`. Every slide links the section it compresses and this deck adds no facts of its own, so where the two disagree the note wins. Rendering instructions are on the last slide.
+> **Appendix** to [Connectivities as types](connectivities-as-types), summarising that note as of commit `21e6b8f`. Every slide links the section it compresses and this deck adds no facts of its own, so where the two disagree the note wins. Rendering instructions are on the slide before this one.
 
 ---
 
@@ -168,19 +184,3 @@ ICON4Py: the script rewrites 4 files and reports 46 provider keys to decide.
 - **alignment** — `Staggered[D](i)` at `i − ½` is hard-coded; both conventions exist in production
 
 → [Open questions](connectivities-as-types#open-questions--follow-ups)
-
----
-
-## Rendering this deck
-
-```console
-npx -y @marp-team/marp-cli@4 --no-stdin \
-    connectivities-as-types_slides.md --html -o /tmp/deck.html
-```
-
-- **`--no-stdin` is required** — without it marp-cli waits on stdin and looks like a hang
-- add `--pdf` for a PDF; that path needs a Chromium-family browser
-- the first run downloads marp-cli and may take several minutes, later runs under a second
-- the file also reads as an ordinary page in the garden, scrolling rule to rule
-
-→ [Appendices](connectivities-as-types#appendices)

From 96caa0e2fbaf8a465003d0dcfba81d6733f41d57 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Gonz=C3=A1lez=20Paredes?= <enriqueg@cscs.ch>
Date: Fri, 2 Oct 2026 00:02:24 +0200
Subject: [PATCH 10/19] =?UTF-8?q?personal/egparedes:=20connectivities=20as?=
 =?UTF-8?q?=20types=20=E2=80=94=20resolve=20the=20implementation's=20quest?=
 =?UTF-8?q?ions?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Answers to the gt4py implementation agent's seven questions, recorded where the
note was silent, ambiguous or wrong.

- **`kind` on a local is `None`**, annotated `ClassVar[DimensionKind | None]`, and
  `kind=` on a local declaration is a `TypeError`. `None` rather than `HORIZONTAL`
  so every `kind == HORIZONTAL` / `kind != VERTICAL` site in gtfn, nanobind and
  DaCe keeps its meaning instead of counting a sparse field's local axis as
  horizontal. Since `None` is not orderable against the enum, `order_dimensions`
  ranks horizontal/local/vertical explicitly rather than sorting on `kind`.
  `common.is_local_dimension` replaces the `kind is LOCAL` checks.
- **Index arithmetic is restricted statically *and* at runtime**, matching
  `Staggered[C]`: `__add__`/`__sub__` carry the self-type and also raise, and FOAST
  rejects `C + 1` / `as_offset(C, f)` with a `DSLError`. Hand-written iterator IR
  stays unchecked.
- **"ranges" in the sketch was wrong.** Only `+`/`-` and `as_offset` are restricted
  to an axis; comparison still builds a `Domain` on any dimension, which
  `concat_where` needs over `CellDim`/`EdgeDim`. Comment corrected.
- **`__eq__` versus `is` is decided**, not open: `DimensionMeta.__eq__` returns
  `NotImplemented` for a dimension operand so `I == J` falls back to `is` and is
  always a `bool`; `I == <int>` building a `Domain` is the one exception, and
  `Domain.__bool__` raises. The residual — an integer key colliding with a
  dimension-class key in one dict — is stated and accepted. Now Identity rule 8;
  open question 9 is retired and the old 10 renumbered.
- **The migration heuristic is specified** in staggering appendix §4 as an ordered
  rule, including `as_offset` use and a referenced staggered counterpart as axis
  evidence, and reporting rather than guessing on a conflict.
- `CartesianAxisIndex` and `AnyCartesianAxisIndex` are both exported from `gtx`.
- Identity rule 4 now states the fingerprint hole itself instead of deferring to
  open question 5, which only mentions it in passing.
---
 .../connectivities-as-types.md                | 72 ++++++++++++-------
 .../connectivities-as-types_conventions.md    |  2 +-
 .../connectivities-as-types_staggering.md     | 16 ++++-
 3 files changed, 62 insertions(+), 28 deletions(-)

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 e8ce31f..ac2b51a 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
@@ -254,7 +254,9 @@ type Dimension = type[DimensionIndex]          # PEP 695: `Dimension("I")` is no
 
 
 class AnyCartesianAxisIndex(DimensionIndex):   # either cell class of a Cartesian axis;
-    ...                                        #   `D + 1`, `as_offset`, ranges need this
+    ...                                        #   only `D ± n` and `as_offset` need it —
+    ...                                        #   `D == n` / `D < n` -> Domain stay on every
+    ...                                        #   dimension (`concat_where` over CellDim)
 
 
 class CartesianAxisIndex(AnyCartesianAxisIndex):
@@ -381,8 +383,10 @@ stated as rules:
 3. **No registry.** Classes pickle by reference. The one narrow `copyreg` hook is
    for `Staggered[D]`, whose bracketed qualname `save_global` cannot look up.
 4. **Fingerprints depend on qualified names.** A dimension is fingerprinted by
-   reference, so redefining one under the same name with a different `kind` does
-   *not* invalidate artifacts (open question 5). A connectivity declaration is
+   reference, so redefining one under the same name with a different `kind` or
+   `base` does *not* invalidate artifacts — a real hole, and the reason the
+   alignment follow-up (open question 5) cannot be a declaration-time attribute
+   without also folding such attributes into the fingerprint. A connectivity declaration is
    fingerprinted *additionally* by its domain, codomain, `Local` and counts, so
    redefining one does. Either way the ADR 0023 cache invalidates on module renames.
 5. **Codegen names need injective mangling.** `codegen_name(tag)` is a prefix
@@ -402,7 +406,16 @@ stated as rules:
    *sharing* another one's local dimension is named by its own tag, since the
    local tag already names the owner's table; for that case the backends have
    a fallback lookup, `connectivity_key_over` (see *The local dimension*).
-8. **Same-named declarations are different connectivities.** Two
+8. **Equality is identity for dimension operands.** `DimensionMeta.__eq__` returns
+   `NotImplemented` when the right operand is a dimension, so Python falls back to
+   `is` and `I == J` is always a `bool`. It builds a `Domain` only for an *integral*
+   right operand — `I == 5` — which is the one documented exception to "equality is
+   `is`", and `Domain.__bool__` raises, so a `Domain` can never be mistaken for a
+   truth value. The residual hazard is narrow and accepted: a dict holding both an
+   integer key and a dimension-class key whose hashes collide would reach
+   `bool(Domain)`. Class-keyed providers hold only classes and tag strings, and a
+   `str` compares unequal to a class, so they cannot. ADR 0028 records this.
+9. **Same-named declarations are different connectivities.** Two
    declarations with the same qualified name from different modules, or a
    redefinition, are simply different classes; no warning is issued, and
    `check_neighbor_table` hints "was the declaration redefined?" when a table
@@ -455,7 +468,14 @@ Four checks the tree performs at runtime, or not at all, become static:
 | `Staggered[C]` — no half-cells on an unstructured mesh | nothing rejects it | static, at the bound |
 | `C + 1`, `V2E.Local + 1` — index arithmetic off an axis | runtime `kind` check, or a late failure | static, via `DimensionMeta.__add__`'s self-type |
 
-The last row costs two definition-site suppressions, one per checker. P4 of
+The last row is enforced **both** statically and at runtime, as `Staggered[C]` is:
+`DimensionMeta.__add__` and `__sub__` carry the self-type
+`cls: type[AnyCartesianAxisIndex]` and also raise `TypeError` for anything else, and
+FOAST rejects `C + 1` and `as_offset(C, f)` in DSL code with a `DSLError`. Only
+`+`/`-` and `as_offset` are restricted — comparison still builds a `Domain` on any
+dimension, which `concat_where` needs over `CellDim`/`EdgeDim`. Hand-written
+iterator IR is unchecked, since it names dimensions by tag like the rest of the IR.
+The self-type costs two definition-site suppressions, one per checker; P4 of
 [`staggered_probe.py`](staggered_probe.py) pins it down and
 [[personal/egparedes/connectivities-as-types/connectivities-as-types_typing|the typing appendix]] records both diagnostics.
 
@@ -465,10 +485,18 @@ memory layout order (constraint F4); `order_dimensions` also uses it to enforce
 at most one `LOCAL` dimension; and `VERTICAL` names the scan axis and, by
 convention, the undecomposed one. The first and third are now class facts —
 `kind == LOCAL` iff `issubclass(d, LocalDimensionIndex)` — so **`LOCAL` leaves the
-enum**: `kind` becomes `HORIZONTAL | VERTICAL` and `order_dimensions` sorts by
-the rank it uses today, with localness read from the class instead of from the
-enum — the horizontal/local/vertical order must not move, or sparse-field layout
-changes with it (PR B, where
+enum**: `kind` becomes `HORIZONTAL | VERTICAL`, annotated
+`ClassVar[DimensionKind | None]`, and a local dimension's `kind` is `None` —
+passing `kind=` when declaring one is a `TypeError`. `None` rather than
+`HORIZONTAL` so that every existing `kind == HORIZONTAL` / `kind != VERTICAL`
+comparison in gtfn, the nanobind bindings and DaCe keeps its exact current
+meaning instead of silently counting a sparse field's local axis as horizontal.
+Because `None` is not orderable against the enum, `order_dimensions` computes the
+rank explicitly — horizontal, then local, then vertical — rather than sorting on
+`kind` directly; **the order must not move**, or sparse-field layout moves with
+it. A helper `common.is_local_dimension(dim)` replaces the `kind is LOCAL` checks,
+and the printed form (`Local[local]`) and the DaCe map variable
+(`i_<name>_gtx_localdim`) are derived from the class (PR B, where
 `LocalDimensionIndex` lands). What is left is the layout key and the "vertical"
 role, which belong to the field and to the program respectively — see
 [Open questions](#open-questions--follow-ups).
@@ -795,21 +823,13 @@ equality with an interning registry; and static-only `max_neighbors` /
    `DimensionIndex` subclasses, so "a primary, non-local dimension" is still not a
    type. UGRID supplies the vocabulary and the degrees
    ([[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions appendix]] §4a). Out of scope here.
-9. **`DimensionMeta.__eq__` versus "equality is `is`".** [Identity](#identity-is-the-qualified-python-name)
-   states that the runtime view of identity is `is`, while the sketch keeps
-   `__eq__` overridden so that `I == 5` builds a `Domain` (with
-   `__hash__ = type.__hash__`). A metaclass `__eq__` that does not return a bool
-   makes `I == J` not a comparison, and dict lookups on a hash collision would
-   call `bool(Domain)`. Class-keyed providers (`{V2E: table}`) and the `is`-based
-   identity story both depend on this being benign; it is not established here,
-   and the ADR 0028 implementation should say which of the two rules wins.
-10. **The index origin of a bound table.** `NeighborTableType` records no index
-    origin, while UGRID standardizes `start_index` ∈ {0, 1}. Validating entries
-    against a codomain *range* is not a one-line change: a codomain is a dimension
-    class and carries no range, `check_neighbor_table` receives only a declaration
-    and a table or type, and its type-only path (`table_types`) has no entries to
-    inspect. It would need a target range supplied at binding time and a
-    value-carrying table ([[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions appendix]] §4b).
+9. **The index origin of a bound table.** `NeighborTableType` records no index
+   origin, while UGRID standardizes `start_index` ∈ {0, 1}. Validating entries
+   against a codomain *range* is not a one-line change: a codomain is a dimension
+   class and carries no range, `check_neighbor_table` receives only a declaration
+   and a table or type, and its type-only path (`table_types`) has no entries to
+   inspect. It would need a target range supplied at binding time and a
+   value-carrying table ([[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions appendix]] §4b).
 
 ## Implementation
 
@@ -822,8 +842,8 @@ on its own, each based on the previous one:
 
 | PR | Branch | What |
 | --- | --- | --- |
-| A: GridTools/gt4py#2899 | `connectivities-as-types-2-dimension-classes` | `feat[next]`: a concrete dimension is a class identified by its qualified name (ADR 0028); `codegen_name`; `CartesianAxisIndex` / `AnyCartesianAxisIndex` and `Staggered[D: CartesianAxisIndex]`; interactive-`__main__` fallback; `NamedIndex` and the dimension half of the mypy plugin removed; `ConstList` with `size=1` replaces the `_CONST_DIM` aliases; `AxisLiteral` drops `kind`; printing IR never imports (`resolve_loaded`); offset tag = local dimension tag = provider key in the tree |
-| B: GridTools/gt4py#2907 | `connectivities-as-types-3-neighbor-connectivity` | `feat[next]`: `NeighborConnectivity[Domain, Codomain]`, `LocalDimensionIndex` (and `DimensionKind.LOCAL` removed, derived from the class), `check_neighbor_table`, `local_dimension_of`, declaration fingerprinting; usable in the DSL; shared local dimensions, in the declarations and in the backends (`connectivity_key_over`, DaCe `local_dimension_size`); `NeighborTableType` and `ts.ShiftType`; pyright in the typing nox session; ADR 0029 |
+| A: GridTools/gt4py#2899 | `connectivities-as-types-2-dimension-classes` | `feat[next]`: a concrete dimension is a class identified by its qualified name (ADR 0028); `codegen_name`; `CartesianAxisIndex` / `AnyCartesianAxisIndex` (both exported from `gtx`) and `Staggered[D: CartesianAxisIndex]`, with `__add__`/`__sub__` restricted to an axis statically and at runtime; interactive-`__main__` fallback; `NamedIndex` and the dimension half of the mypy plugin removed; `ConstList` with `size=1` replaces the `_CONST_DIM` aliases; `AxisLiteral` drops `kind`; printing IR never imports (`resolve_loaded`); offset tag = local dimension tag = provider key in the tree |
+| B: GridTools/gt4py#2907 | `connectivities-as-types-3-neighbor-connectivity` | `feat[next]`: `NeighborConnectivity[Domain, Codomain]`, `LocalDimensionIndex` (and `DimensionKind.LOCAL` removed: a local's `kind` is `None`, localness comes from `common.is_local_dimension`, and `order_dimensions` ranks horizontal/local/vertical explicitly), `check_neighbor_table`, `local_dimension_of`, declaration fingerprinting; usable in the DSL; shared local dimensions, in the declarations and in the backends (`connectivity_key_over`, DaCe `local_dimension_size`); `NeighborTableType` and `ts.ShiftType`; pyright in the typing nox session; ADR 0029 |
 | C: GridTools/gt4py#2910 | `connectivities-as-types-6-class-keyed-providers` | `feat[next]!`: the tree and docs declare connectivities as classes; class-keyed offset providers with `check_offset_provider` at every entry point; `FieldOffset` removed; `as_offset(dim, field)`; `table_types` replaces `offset_provider_type`; migration script |
 | D: GridTools/gt4py#2912 | `connectivities-as-types-8-typed-positions` | `refactor[next]`: `MultiDimensionIndex` and typed embedded positions |
 
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md
index db38c7d..add1474 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md
@@ -169,7 +169,7 @@ distinguishes a 0-based table from a 1-based one.
 
 Checking entries against a codomain *range* is the tempting fix, and it is the
 same absolute-range argument as §3(i) — but it is **not** a one-line change, and
-the note's open question 10 should say so. Three prerequisites are missing:
+the note's open question 9 should say so. Three prerequisites are missing:
 
 - a **codomain is a dimension class** and carries no range; ranges live on a
   field's `Domain`, not on the declaration;
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md
index 3a0cc7e..38fe389 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md
@@ -133,7 +133,21 @@ are both `HORIZONTAL` and only the first is an axis. That is why the migration
 cannot be inferred from the source — whether a dimension is an axis or a mesh
 location is a decision per declaration (about ten in ICON4Py's `dimension.py`;
 near-uniformly `CartesianAxisIndex` in `tests/next_tests`). The migration script
-rewrites what it can and reports the rest.
+decides per declaration, in this order:
+
+1. **`CartesianAxisIndex`** if the dimension is `kind=VERTICAL`; or is the
+   source/target of a *Cartesian* `FieldOffset` (source appears in target, no local
+   dimension); or is used with `as_offset`; or has a staggered counterpart
+   referenced anywhere (an `_Staggered`-prefixed name under the old encoding).
+2. **`DimensionIndex`** if it is the source or the target domain dimension of a
+   *neighbor* `FieldOffset` — a mesh location.
+3. Otherwise **`DimensionIndex`**, and the dimension is listed in the report as
+   "declare as `CartesianAxisIndex` if it is a Cartesian axis: index arithmetic,
+   `Staggered`". A structured horizontal axis with no Cartesian offset in the
+   source lands here, because nothing distinguishes it from a mesh location.
+
+A dimension matching both (1) and (2) is a **conflict**: the script reports it
+rather than choosing, since the two are mutually exclusive by construction.
 
 ## 5. Relation to `dimension-generic-fields`, and one naming constraint
 

From 7137baf56b85f054d3b5bd7f3dd63722703e31ae Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Gonz=C3=A1lez=20Paredes?= <enriqueg@cscs.ch>
Date: Fri, 2 Oct 2026 00:07:28 +0200
Subject: [PATCH 11/19] =?UTF-8?q?personal/egparedes:=20connectivities=20as?=
 =?UTF-8?q?=20types=20=E2=80=94=20renumber=20the=20ADRs=20to=200029=20and?=
 =?UTF-8?q?=200030?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

gt4py main merged #2808, which takes 0028 for "Plain Builders Instead of
Factories", so the stack's two ADRs shift up:

- ADR 0028 "Dimensions as nominal types" -> **ADR 0029**
  (`0029-Dimensions_As_Nominal_Types.md`), still PR A
- ADR 0029 "Connectivities as types" -> **ADR 0030**
  (`0030-Connectivities_As_Types.md`), still PR B

22 references updated across the note, the identity appendix and the slides, in
the order 0029->0030 then 0028->0029 so the two do not collide. ADR 0019, 0023 and
0026 are untouched, and no reference to ADR 0028 remains — it now means something
else.
---
 .../connectivities-as-types.md                | 32 +++++++++----------
 .../connectivities-as-types_identity.md       |  2 +-
 .../connectivities-as-types_slides.md         |  6 ++--
 3 files changed, 20 insertions(+), 20 deletions(-)

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 ac2b51a..24a9911 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
@@ -12,7 +12,7 @@ status: draft
 > `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's (ADR 0028) — is
+> own provider key, and whose identity — like every dimension's (ADR 0029) — is
 > its qualified Python name. In the IR it is named by its local dimension's
 > tag, so shifts, reductions and sparse arguments all find the table under one
 > string:
@@ -34,8 +34,8 @@ status: draft
 
 > **Implementation.** The design below is implemented on the stacked
 > GridTools/gt4py PRs listed in [Implementation](#implementation) (top branch
-> `connectivities-as-types-8-typed-positions`), with ADR 0028 (dimensions as
-> nominal types) and ADR 0029 (connectivities as types). The *Problem* section
+> `connectivities-as-types-8-typed-positions`), with ADR 0029 (dimensions as
+> nominal types) and ADR 0030 (connectivities as types). The *Problem* section
 > and the constraint catalogue in the appendix
 > [[personal/egparedes/connectivities-as-types/connectivities-as-types_research|Tag and name constraints — full catalogue]]
 > describe gt4py `main` (`b3c53fa7e`, v1.2.2), the tree the stack is based on.
@@ -56,7 +56,7 @@ status: draft
 > [[personal/havogt/dimension-generic-fields/dimension-generic-fields|Generic dimensions and statically
 > typed staggering]], whose Part II also proposed the `Staggered[D]` shape
 > used here. It **supersedes** [[shared/dimensions-as-types|Dimensions as
-> types]]: the dimension design below (ADR 0028) replaces that note's
+> types]]: the dimension design below (ADR 0029) replaces that note's
 > `(name, kind)` value identity and interning registry with type identity, and
 > is stated here in full. It overlaps with
 > [[personal/havogt/mesh-and-first-class-halos/mesh-and-first-class-halos|A mesh concept with
@@ -150,7 +150,7 @@ what is one idea — *a mapping between two index spaces, plus a name for it*.
 
 | Concept | Role | Replaces |
 | --- | --- | --- |
-| `DimensionIndex` | a dimension is a subclass, an index along it an instance (ADR 0028); the root — mesh locations, axes and local dimensions are all subclasses, so every `type[DimensionIndex]` annotation in the tree keeps its meaning | `Dimension` instances |
+| `DimensionIndex` | a dimension is a subclass, an index along it an instance (ADR 0029); the root — mesh locations, axes and local dimensions are all subclasses, so every `type[DimensionIndex]` annotation in the tree keeps its meaning | `Dimension` instances |
 | `CartesianAxisIndex(AnyCartesianAxisIndex)` | a **declared Cartesian axis**: an index space with integer index arithmetic and exactly one staggered partner (see [Cartesian axis dimensions](#cartesian-axis-dimensions)). `AnyCartesianAxisIndex` is either cell class of such an axis, declared or derived | — (new; today `kind != LOCAL` is the nearest approximation, and it does not separate a Cartesian axis from a mesh location) |
 | `Staggered[D: CartesianAxisIndex]` | the axis's derived partner, at the half-integer positions of `D`; a real, interned class (see [`Staggered[D]`](#staggeredd)) | the `_Staggered` name prefix |
 | `LocalDimensionIndex(DimensionIndex)` | a local dimension: **owned** (declared nested in, or adopted by, its connectivity), or **owner-less** (optionally with `size=n`, which sets `max_neighbors = min_neighbors = n`); carries the neighbor counts | `Dimension(..., kind=LOCAL)`, `_CONST_DIM` |
@@ -235,7 +235,7 @@ use for `a(V2E)`. The iterator-level `it_ts.OffsetLiteralType` /
 ### Sketch
 
 ```python
-# ── dimensions (ADR 0028) ─────────────────────────────────────────────────
+# ── dimensions (ADR 0029) ─────────────────────────────────────────────────
 class DimensionMeta(type):
     @property
     def tag(cls) -> Tag:                       # identity, and the IR spelling
@@ -282,7 +282,7 @@ Staggered[KDim]                                # KDim's derived partner;
                                                #   Staggered[Staggered[KDim]] is a type error
 
 
-# ── connectivities (ADR 0029) ─────────────────────────────────────────────
+# ── connectivities (ADR 0030) ─────────────────────────────────────────────
 class ConnectivityMeta(type):
     tag: Tag                                   # the declaration's qualified name
     offset_tag: Tag                            # how the IR names it, see "Identity"
@@ -394,7 +394,7 @@ stated as rules:
    not injective.
 6. **Staggering is part of the dimension change.** The `_Staggered` name prefix
    needs the name→class lookup that type identity removes, so `Staggered[D]` is a
-   real class and part of ADR 0028 (PR A), with its parameter bounded on a
+   real class and part of ADR 0029 (PR A), with its parameter bounded on a
    declared [Cartesian axis](#cartesian-axis-dimensions).
 
    Rules 3–6 in full — the hook, the fingerprint deconstructors, the exhaustive
@@ -414,7 +414,7 @@ stated as rules:
    truth value. The residual hazard is narrow and accepted: a dict holding both an
    integer key and a dimension-class key whose hashes collide would reach
    `bool(Domain)`. Class-keyed providers hold only classes and tag strings, and a
-   `str` compares unequal to a class, so they cannot. ADR 0028 records this.
+   `str` compares unequal to a class, so they cannot. ADR 0029 records this.
 9. **Same-named declarations are different connectivities.** Two
    declarations with the same qualified name from different modules, or a
    redefinition, are simply different classes; no warning is issued, and
@@ -652,7 +652,7 @@ tables assign different neighbors to the same domain element. The model:
   in the local dimension, is an `arg-type` error, probe P1b), 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 ADR 0028 exists to
+  both as *not valid as a type* — the very error class ADR 0029 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
@@ -765,12 +765,12 @@ equality with an interning registry; and static-only `max_neighbors` /
 ## Relation to gt4py ADRs
 
 - **ADR 0019 (Connectivities).** The part naming `FieldOffset` as the frontend
-  identifier is superseded by ADR 0029; the `Connectivity` / `NeighborTable` /
+  identifier is superseded by ADR 0030; the `Connectivity` / `NeighborTable` /
   `ConnectivityType` vocabulary is kept ([What stays](#what-stays-and-why)).
 - **ADR 0026 (Staggered dimensions).** Its encoding is superseded by
   `Staggered[D]` ([above](#staggeredd)); its semantics are unchanged, and
   [Cartesian axis dimensions](#cartesian-axis-dimensions) states the structure they encode.
-- **ADR 0028 (Dimensions as nominal types)** and **ADR 0029 (Connectivities
+- **ADR 0029 (Dimensions as nominal types)** and **ADR 0030 (Connectivities
   as types)** record this design in the gt4py tree.
 - **ADR 0023 (build cache).** Fingerprints depend on qualified names, so the
   cache invalidates on module renames (Identity, rule 4).
@@ -842,14 +842,14 @@ on its own, each based on the previous one:
 
 | PR | Branch | What |
 | --- | --- | --- |
-| A: GridTools/gt4py#2899 | `connectivities-as-types-2-dimension-classes` | `feat[next]`: a concrete dimension is a class identified by its qualified name (ADR 0028); `codegen_name`; `CartesianAxisIndex` / `AnyCartesianAxisIndex` (both exported from `gtx`) and `Staggered[D: CartesianAxisIndex]`, with `__add__`/`__sub__` restricted to an axis statically and at runtime; interactive-`__main__` fallback; `NamedIndex` and the dimension half of the mypy plugin removed; `ConstList` with `size=1` replaces the `_CONST_DIM` aliases; `AxisLiteral` drops `kind`; printing IR never imports (`resolve_loaded`); offset tag = local dimension tag = provider key in the tree |
-| B: GridTools/gt4py#2907 | `connectivities-as-types-3-neighbor-connectivity` | `feat[next]`: `NeighborConnectivity[Domain, Codomain]`, `LocalDimensionIndex` (and `DimensionKind.LOCAL` removed: a local's `kind` is `None`, localness comes from `common.is_local_dimension`, and `order_dimensions` ranks horizontal/local/vertical explicitly), `check_neighbor_table`, `local_dimension_of`, declaration fingerprinting; usable in the DSL; shared local dimensions, in the declarations and in the backends (`connectivity_key_over`, DaCe `local_dimension_size`); `NeighborTableType` and `ts.ShiftType`; pyright in the typing nox session; ADR 0029 |
+| A: GridTools/gt4py#2899 | `connectivities-as-types-2-dimension-classes` | `feat[next]`: a concrete dimension is a class identified by its qualified name (ADR 0029); `codegen_name`; `CartesianAxisIndex` / `AnyCartesianAxisIndex` (both exported from `gtx`) and `Staggered[D: CartesianAxisIndex]`, with `__add__`/`__sub__` restricted to an axis statically and at runtime; interactive-`__main__` fallback; `NamedIndex` and the dimension half of the mypy plugin removed; `ConstList` with `size=1` replaces the `_CONST_DIM` aliases; `AxisLiteral` drops `kind`; printing IR never imports (`resolve_loaded`); offset tag = local dimension tag = provider key in the tree |
+| B: GridTools/gt4py#2907 | `connectivities-as-types-3-neighbor-connectivity` | `feat[next]`: `NeighborConnectivity[Domain, Codomain]`, `LocalDimensionIndex` (and `DimensionKind.LOCAL` removed: a local's `kind` is `None`, localness comes from `common.is_local_dimension`, and `order_dimensions` ranks horizontal/local/vertical explicitly), `check_neighbor_table`, `local_dimension_of`, declaration fingerprinting; usable in the DSL; shared local dimensions, in the declarations and in the backends (`connectivity_key_over`, DaCe `local_dimension_size`); `NeighborTableType` and `ts.ShiftType`; pyright in the typing nox session; ADR 0030 |
 | C: GridTools/gt4py#2910 | `connectivities-as-types-6-class-keyed-providers` | `feat[next]!`: the tree and docs declare connectivities as classes; class-keyed offset providers with `check_offset_provider` at every entry point; `FieldOffset` removed; `as_offset(dim, field)`; `table_types` replaces `offset_provider_type`; migration script |
 | D: GridTools/gt4py#2912 | `connectivities-as-types-8-typed-positions` | `refactor[next]`: `MultiDimensionIndex` and typed embedded positions |
 
 The four PRs form GitHub stack GridTools/gt4py#2917. `NeighborTableType`,
-`TableTypes` and `ts.ShiftType` land in B, `table_types` in C; ADR 0028 and
-ADR 0029 are in A and B respectively.
+`TableTypes` and `ts.ShiftType` land in B, `table_types` in C; ADR 0029 and
+ADR 0030 are in A and B respectively.
 
 **ICON4Py migration.** `scripts/python/migrate_connectivities.py` (PR C)
 rewrites `Dimension(...)` and `FieldOffset(...)` declarations (connectivities
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_identity.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_identity.md
index 46066e5..7233728 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_identity.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_identity.md
@@ -42,7 +42,7 @@ status: draft
    to length 4.
 6. **Staggering is part of the dimension change.** The `_Staggered` name
    prefix needs the name→class lookup that type identity removes, so
-   `Staggered[D]` is a real class and part of ADR 0028 (PR A), together with
+   `Staggered[D]` is a real class and part of ADR 0029 (PR A), together with
    the [[personal/egparedes/connectivities-as-types/connectivities-as-types#cartesian-axis-dimensions|Cartesian axis dimensions]] its parameter is bounded on; see
    [[personal/egparedes/connectivities-as-types/connectivities-as-types#staggeredd|`Staggered[D]`]].
 
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md
index 69da0f6..dcaa2c6 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md
@@ -27,7 +27,7 @@ npx -y @marp-team/marp-cli@4 --no-stdin \
 
 One declaration for offset, local dimension and provider key
 
-ADR 0028 (dimensions) · ADR 0029 (connectivities) · GridTools/gt4py#2917
+ADR 0029 (dimensions) · ADR 0030 (connectivities) · GridTools/gt4py#2917
 
 > **Appendix** to [Connectivities as types](connectivities-as-types), summarising that note as of commit `21e6b8f`. Every slide links the section it compresses and this deck adds no facts of its own, so where the two disagree the note wins. Rendering instructions are on the slide before this one.
 
@@ -164,8 +164,8 @@ Of ten cross-object identity constraints: **six dissolve**, three collapse into
 
 | PR | Contents |
 | --- | --- |
-| A #2899 | dimensions as classes, `Staggered[D]`, ADR 0028 |
-| B #2907 | `NeighborConnectivity`, `LocalDimensionIndex`, ADR 0029 |
+| A #2899 | dimensions as classes, `Staggered[D]`, ADR 0029 |
+| B #2907 | `NeighborConnectivity`, `LocalDimensionIndex`, ADR 0030 |
 | C #2910 | class-keyed providers, `FieldOffset` removed, migration script |
 | D #2912 | `MultiDimensionIndex`, typed embedded positions |
 

From 8292eff020a941937f46a45e6b706c1c6c277fa1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Gonz=C3=A1lez=20Paredes?= <enriqueg@cscs.ch>
Date: Fri, 2 Oct 2026 00:39:33 +0200
Subject: [PATCH 12/19] =?UTF-8?q?personal/egparedes:=20connectivities=20as?=
 =?UTF-8?q?=20types=20=E2=80=94=20sync=20with=20the=20implemented=20stack?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Aligns the note with what the four branches now implement.

- The migration rule in staggering appendix §4 matches the script: axis evidence is
  `kind=VERTICAL`, the source of a Cartesian `FieldOffset`, the first argument of
  `as_offset`/`flip_staggered`, **index arithmetic `D ± <number>` in the source**
  (v1.2.2 could already write `KDim + 1`), or a `"_Staggered<value>"` string
  constant; mesh-location evidence is a neighbor `FieldOffset`'s source or target
  domain dimension; a conflict is declared `DimensionIndex` and reported.
- ICON4Py at the same snapshot, from a fresh run: `KDim` classified as a
  `CartesianAxisIndex`, the three horizontal locations as `DimensionIndex`, all 15
  locals as `LocalDimensionIndex`, 0 undecided and 0 conflicts. The reported
  `isinstance(..., Dimension)` figure becomes 5 sites in 2 modules, superseding the
  earlier 10-in-5, and the new category of 6 `DimensionKind.LOCAL` uses in 5
  modules is recorded.
- `as_offset` is restricted to an `AnyCartesianAxisIndex`, so a staggered partner is
  still accepted; `DSLError` in a field operator, `TypeError` in embedded. Noted as
  landing in PR C rather than A.
- `Staggered[K]`'s only base is `Staggered`, which derives from
  `AnyCartesianAxisIndex` — it is an axis by inheritance, not by direct base.
- Implementation rows record the artifacts that now pin these claims: the mypy
  typing case `cartesian_axis_levels` (A) and pyright with
  `reportUnnecessaryTypeIgnoreComment: error` (B).

Held pending clarification: the three places that say `AxisLiteral` drops its
stored `kind`, which the implementation report contradicts.
---
 .../connectivities-as-types.md                | 28 ++++++++++++-------
 .../connectivities-as-types_staggering.md     | 28 ++++++++++---------
 2 files changed, 33 insertions(+), 23 deletions(-)

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 24a9911..646942d 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
@@ -471,7 +471,10 @@ Four checks the tree performs at runtime, or not at all, become static:
 The last row is enforced **both** statically and at runtime, as `Staggered[C]` is:
 `DimensionMeta.__add__` and `__sub__` carry the self-type
 `cls: type[AnyCartesianAxisIndex]` and also raise `TypeError` for anything else, and
-FOAST rejects `C + 1` and `as_offset(C, f)` in DSL code with a `DSLError`. Only
+FOAST rejects `C + 1` in DSL code with a `DSLError`. `as_offset(dim, field)` is
+restricted the same way, typed `dim: type[AnyCartesianAxisIndex]` so that a
+staggered partner is still accepted, raising a `DSLError` in a field operator and a
+`TypeError` in embedded execution (PR C, where `as_offset(dim, field)` lands). Only
 `+`/`-` and `as_offset` are restricted — comparison still builds a `Domain` on any
 dimension, which `concat_where` needs over `CellDim`/`EdgeDim`. Hand-written
 iterator IR is unchecked, since it names dimensions by tag like the rest of the IR.
@@ -516,7 +519,8 @@ of [Cartesian axis dimensions](#cartesian-axis-dimensions).
 - **Runtime representation.** `Staggered[K]` is a real, interned class:
   `Staggered` has a metaclass whose `__getitem__` builds one class per base
   and caches it by base identity (with `setdefault`, so concurrent
-  compilation threads see one class). Its base is `AnyCartesianAxisIndex`, and it is
+  compilation threads see one class). `Staggered[K]`'s only base is `Staggered`,
+  which derives from `AnyCartesianAxisIndex` — so it is an axis by inheritance and
   deliberately *not* a subclass of `K`, so a `Field[Dims[Staggered[K]]]` is
   rejected where a `Field[Dims[K]]` is required; it has `base = K` and `K`'s
   kind. Staggering anything that is not a declared `CartesianAxisIndex` — a local
@@ -842,9 +846,9 @@ on its own, each based on the previous one:
 
 | PR | Branch | What |
 | --- | --- | --- |
-| A: GridTools/gt4py#2899 | `connectivities-as-types-2-dimension-classes` | `feat[next]`: a concrete dimension is a class identified by its qualified name (ADR 0029); `codegen_name`; `CartesianAxisIndex` / `AnyCartesianAxisIndex` (both exported from `gtx`) and `Staggered[D: CartesianAxisIndex]`, with `__add__`/`__sub__` restricted to an axis statically and at runtime; interactive-`__main__` fallback; `NamedIndex` and the dimension half of the mypy plugin removed; `ConstList` with `size=1` replaces the `_CONST_DIM` aliases; `AxisLiteral` drops `kind`; printing IR never imports (`resolve_loaded`); offset tag = local dimension tag = provider key in the tree |
-| B: GridTools/gt4py#2907 | `connectivities-as-types-3-neighbor-connectivity` | `feat[next]`: `NeighborConnectivity[Domain, Codomain]`, `LocalDimensionIndex` (and `DimensionKind.LOCAL` removed: a local's `kind` is `None`, localness comes from `common.is_local_dimension`, and `order_dimensions` ranks horizontal/local/vertical explicitly), `check_neighbor_table`, `local_dimension_of`, declaration fingerprinting; usable in the DSL; shared local dimensions, in the declarations and in the backends (`connectivity_key_over`, DaCe `local_dimension_size`); `NeighborTableType` and `ts.ShiftType`; pyright in the typing nox session; ADR 0030 |
-| C: GridTools/gt4py#2910 | `connectivities-as-types-6-class-keyed-providers` | `feat[next]!`: the tree and docs declare connectivities as classes; class-keyed offset providers with `check_offset_provider` at every entry point; `FieldOffset` removed; `as_offset(dim, field)`; `table_types` replaces `offset_provider_type`; migration script |
+| A: GridTools/gt4py#2899 | `connectivities-as-types-2-dimension-classes` | `feat[next]`: a concrete dimension is a class identified by its qualified name (ADR 0029); `codegen_name`; `CartesianAxisIndex` / `AnyCartesianAxisIndex` (both exported from `gtx`) and `Staggered[D: CartesianAxisIndex]`, with `__add__`/`__sub__` restricted to an axis statically and at runtime; interactive-`__main__` fallback; `NamedIndex` and the dimension half of the mypy plugin removed; mypy typing case `cartesian_axis_levels`; `ConstList` with `size=1` replaces the `_CONST_DIM` aliases; `AxisLiteral` drops `kind`; printing IR never imports (`resolve_loaded`); offset tag = local dimension tag = provider key in the tree |
+| B: GridTools/gt4py#2907 | `connectivities-as-types-3-neighbor-connectivity` | `feat[next]`: `NeighborConnectivity[Domain, Codomain]`, `LocalDimensionIndex` (and `DimensionKind.LOCAL` removed: a local's `kind` is `None`, localness comes from `common.is_local_dimension`, and `order_dimensions` ranks horizontal/local/vertical explicitly), `check_neighbor_table`, `local_dimension_of`, declaration fingerprinting; usable in the DSL; shared local dimensions, in the declarations and in the backends (`connectivity_key_over`, DaCe `local_dimension_size`); `NeighborTableType` and `ts.ShiftType`; pyright in the typing nox session, with `reportUnnecessaryTypeIgnoreComment: error` so a rejection that stops firing fails the run; ADR 0030 |
+| C: GridTools/gt4py#2910 | `connectivities-as-types-6-class-keyed-providers` | `feat[next]!`: the tree and docs declare connectivities as classes; class-keyed offset providers with `check_offset_provider` at every entry point; `FieldOffset` removed; `as_offset(dim, field)` restricted to an `AnyCartesianAxisIndex`; `table_types` replaces `offset_provider_type`; migration script |
 | D: GridTools/gt4py#2912 | `connectivities-as-types-8-typed-positions` | `refactor[next]`: `MultiDimensionIndex` and typed embedded positions |
 
 The four PRs form GitHub stack GridTools/gt4py#2917. `NeighborTableType`,
@@ -856,11 +860,15 @@ rewrites `Dimension(...)` and `FieldOffset(...)` declarations (connectivities
 adopt their existing local dimensions, so `C2EDim` etc. keep working and
 `C2CE` becomes a sharer), removes Cartesian offsets and rewrites their uses
 (`Koff[1]` → `KDim + 1`, `as_offset(KDim, ...)`, imports), and reports what
-it cannot decide from the source. At ICON4Py `89b4967` (2026-09-21) the
-script rewrites 4 files (`dimension.py` and 3 stencil modules) and reports 46
-connectivity provider keys, 2 removable Cartesian provider entries and 10
-`isinstance(..., Dimension)` sites in 5 modules. Declaring counts is left to
-ICON4Py.
+it cannot decide from the source. At ICON4Py `89b4967` (2026-09-21) the script
+rewrites 4 files (`dimension.py` and 3 stencil modules) and classifies every
+dimension with no undecided cases and no conflicts: `KDim` as a
+`CartesianAxisIndex`, `EdgeDim`/`CellDim`/`VertexDim` as `DimensionIndex`, and all
+15 `*Dim` locals including `LsqUnkDim` as `LocalDimensionIndex`. It reports 46
+connectivity provider keys, 2 removable Cartesian provider entries, 5
+`isinstance(..., Dimension)` sites in 2 modules, and 6 `DimensionKind.LOCAL` uses
+in 5 modules to be replaced by `common.is_local_dimension`. Declaring counts is
+left to ICON4Py.
 
 ## Appendices
 
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md
index 38fe389..16e3fb6 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md
@@ -135,19 +135,21 @@ location is a decision per declaration (about ten in ICON4Py's `dimension.py`;
 near-uniformly `CartesianAxisIndex` in `tests/next_tests`). The migration script
 decides per declaration, in this order:
 
-1. **`CartesianAxisIndex`** if the dimension is `kind=VERTICAL`; or is the
-   source/target of a *Cartesian* `FieldOffset` (source appears in target, no local
-   dimension); or is used with `as_offset`; or has a staggered counterpart
-   referenced anywhere (an `_Staggered`-prefixed name under the old encoding).
-2. **`DimensionIndex`** if it is the source or the target domain dimension of a
-   *neighbor* `FieldOffset` — a mesh location.
-3. Otherwise **`DimensionIndex`**, and the dimension is listed in the report as
-   "declare as `CartesianAxisIndex` if it is a Cartesian axis: index arithmetic,
-   `Staggered`". A structured horizontal axis with no Cartesian offset in the
-   source lands here, because nothing distinguishes it from a mesh location.
-
-A dimension matching both (1) and (2) is a **conflict**: the script reports it
-rather than choosing, since the two are mutually exclusive by construction.
+1. **`CartesianAxisIndex`** on any of this axis evidence: `kind=VERTICAL`; the
+   source of a *Cartesian* `FieldOffset`; the first argument of `as_offset(...)` or
+   `flip_staggered(...)`; **index arithmetic `D ± <number>` in the source**, which
+   v1.2.2 code could already write as `KDim + 1`; or a string constant
+   `"_Staggered<old Dimension value>"`, the old encoding of a staggered partner.
+2. **`DimensionIndex`** on mesh-location evidence: the source or the target domain
+   dimension of a *neighbor* `FieldOffset`.
+3. Otherwise **`DimensionIndex`**, reported as "declare it as `CartesianAxisIndex`
+   if it is a Cartesian axis (index arithmetic, `Staggered`)". A structured
+   horizontal axis with no Cartesian offset in the source lands here, because
+   nothing in the source distinguishes it from a mesh location.
+
+A dimension carrying **both** kinds of evidence is a conflict: the script declares
+it `DimensionIndex` and reports it for a hand decision rather than choosing, since
+the two are mutually exclusive by construction.
 
 ## 5. Relation to `dimension-generic-fields`, and one naming constraint
 

From 7eb0d0213a82cade4b9a3a2c69391f5ce4106e23 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Gonz=C3=A1lez=20Paredes?= <enriqueg@cscs.ch>
Date: Fri, 2 Oct 2026 00:40:06 +0200
Subject: [PATCH 13/19] =?UTF-8?q?personal/egparedes:=20connectivities=20as?=
 =?UTF-8?q?=20types=20=E2=80=94=20refresh=20the=20deck's=20as-of=20marker?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The deck summarises the note as of 8292eff, the commit that syncs it with the
implemented stack.
---
 .../connectivities-as-types/connectivities-as-types_slides.md   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md
index dcaa2c6..7d5ea75 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md
@@ -29,7 +29,7 @@ One declaration for offset, local dimension and provider key
 
 ADR 0029 (dimensions) · ADR 0030 (connectivities) · GridTools/gt4py#2917
 
-> **Appendix** to [Connectivities as types](connectivities-as-types), summarising that note as of commit `21e6b8f`. Every slide links the section it compresses and this deck adds no facts of its own, so where the two disagree the note wins. Rendering instructions are on the slide before this one.
+> **Appendix** to [Connectivities as types](connectivities-as-types), summarising that note as of commit `8292eff`. Every slide links the section it compresses and this deck adds no facts of its own, so where the two disagree the note wins. Rendering instructions are on the slide before this one.
 
 ---
 

From 606429ad8a2ce1a8f198daea9294f528f5bd047a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Gonz=C3=A1lez=20Paredes?= <enriqueg@cscs.ch>
Date: Fri, 2 Oct 2026 00:44:28 +0200
Subject: [PATCH 14/19] =?UTF-8?q?personal/egparedes:=20connectivities=20as?=
 =?UTF-8?q?=20types=20=E2=80=94=20the=20kind=20fingerprint=20hole=20is=20c?=
 =?UTF-8?q?losed?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- `AxisLiteral` keeps storing only the tag, as the note said; `kind` and `dim` are
  read-only properties off the resolved class, and the derived `kind` is optional
  because a local dimension's is `None`. Recorded in Identity rule 1 and the
  identity appendix; A10 is unaffected.
- **Identity rule 4 rewritten.** A dimension is now deconstructed as its
  by-reference name *and* its `kind`, so redefining one under the same name with
  another kind does invalidate artifacts, and a staggered dimension goes through
  its base. `base` cannot be flipped in place at all, since `Staggered[K]` is
  interned by base identity and its tag embeds the base tag. The axis level is
  deliberately not fingerprinted: it changes what is accepted, never what is
  emitted.
- Open question 5 and staggering appendix §7 lose the "fingerprint hole" objection
  to an alignment keyword. The cost is now that the keyword would have to join
  `kind` in the dimension fingerprint — a pattern rule 4 establishes rather than an
  open hole.
---
 .../connectivities-as-types.md                | 24 ++++++++++++-------
 .../connectivities-as-types_identity.md       |  4 +++-
 .../connectivities-as-types_staggering.md     |  8 +++----
 3 files changed, 22 insertions(+), 14 deletions(-)

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 646942d..0106eaa 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
@@ -372,7 +372,8 @@ stated as rules:
    longest importable module prefix and walks the rest as attributes, the way
    `pickle` references a class, so a nested `V2E.Local` resolves naturally and a
    redefined declaration resolves to the new class. `AxisLiteral` stores only the
-   tag. Memoization, `resolve_loaded` and the `Staggered[D]` grammar: [[personal/egparedes/connectivities-as-types/connectivities-as-types_identity|the identity appendix]].
+   tag; its `kind` and `dim` are read-only properties off the resolved class, and
+   `kind` is optional because a local dimension's is `None`. Memoization, `resolve_loaded` and the `Staggered[D]` grammar: [[personal/egparedes/connectivities-as-types/connectivities-as-types_identity|the identity appendix]].
 2. **Types reaching the IR must be importable.** `<locals>` in a qualname is
    rejected at class creation (for dimensions and connectivities); pickle's
    own `save_global` stays the authoritative check. Interactive `__main__`
@@ -382,13 +383,16 @@ stated as rules:
    **compiles it in the calling thread** instead of failing in a spawn worker.
 3. **No registry.** Classes pickle by reference. The one narrow `copyreg` hook is
    for `Staggered[D]`, whose bracketed qualname `save_global` cannot look up.
-4. **Fingerprints depend on qualified names.** A dimension is fingerprinted by
-   reference, so redefining one under the same name with a different `kind` or
-   `base` does *not* invalidate artifacts — a real hole, and the reason the
-   alignment follow-up (open question 5) cannot be a declaration-time attribute
-   without also folding such attributes into the fingerprint. A connectivity declaration is
-   fingerprinted *additionally* by its domain, codomain, `Local` and counts, so
-   redefining one does. Either way the ADR 0023 cache invalidates on module renames.
+4. **Fingerprints depend on qualified names, plus `kind`.** A dimension is
+   deconstructed as its by-reference name *and* its `kind`, so redefining one under
+   the same name with another kind does invalidate artifacts; a staggered dimension
+   is fingerprinted through its base. `base` cannot be flipped in place at all —
+   `Staggered[K]` is interned by base identity and its tag embeds the base tag, so a
+   different base is a different class. The axis level
+   (`CartesianAxisIndex` versus `DimensionIndex`) is deliberately *not*
+   fingerprinted: it changes what is accepted, never what is emitted. A connectivity
+   declaration is fingerprinted *additionally* by its domain, codomain, `Local` and
+   counts. Either way the ADR 0023 cache invalidates on module renames.
 5. **Codegen names need injective mangling.** `codegen_name(tag)` is a prefix
    escape (`_`→`_u`, `.`→`_d`, `[`→`_l`, `]`→`_r`); the obvious alternative is
    not injective.
@@ -806,7 +810,9 @@ equality with an interning registry; and static-only `max_neighbors` /
    remove the one cosmetic cost of choosing which member of a pair to declare. It
    has to be static — it changes the integer correction
    `connectivity_for_cartesian_shift` bakes in, hence the emitted stencil — and it
-   hits the rule-4 fingerprint hole. See [[personal/egparedes/connectivities-as-types/connectivities-as-types_staggering|the staggering appendix]].
+   would have to join `kind` in the dimension fingerprint, which rule 4 now
+   establishes as a pattern rather than an obstacle. See
+   [[personal/egparedes/connectivities-as-types/connectivities-as-types_staggering|the staggering appendix]].
    Not in this stack.
 6. **`kind`'s remaining two jobs.** Once `LOCAL` leaves the enum, `kind` is a
    layout sort key and a name for the scan axis — properties of the field and of
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_identity.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_identity.md
index 7233728..cf8606a 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_identity.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_identity.md
@@ -19,7 +19,9 @@ status: draft
    class. Only where the module path ends is memoized: the attribute walk is
    repeated, so a declaration redefined under the same name (a re-run
    notebook cell) resolves to the new class. `AxisLiteral` stores only the tag
-   and derives `kind` and `dim` from it (the `TODO` at `iterator/ir.py:93`);
+   and derives `kind` and `dim` from it as read-only properties (the `TODO` at
+   `iterator/ir.py:93`); the derived `kind` is optional, since a local
+   dimension's is `None`;
    printing IR never imports (`resolve_loaded`). `Staggered[D]` tags use the
    small grammar `<owner tag>[<base tag>]`, resolved by subscripting the owner.
 
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md
index 16e3fb6..b432f6c 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md
@@ -237,10 +237,10 @@ Numbered as in the main note's *Open questions*.
    vs `+0` in that one function — the backends only ever see an integer offset
    along an axis — against three costs: `a(Staggered[I] + 1/2)` stops being
    readable without the declaration, the frontend and embedded shift test matrix
-   doubles, and Identity rule 4 bites, since dimensions fingerprint *by reference*
-   and flipping the keyword in place would not invalidate the ADR 0023 cache. That
-   last hole is pre-existing (`kind` has it too) and would argue for folding
-   declaration-time dimension attributes into the fingerprint. Not in this stack.
+   doubles, and the keyword would have to be folded into the dimension fingerprint.
+   That last cost is now a known quantity rather than an open hole: Identity rule 4
+   fingerprints a dimension's `kind` alongside its by-reference name, so an
+   alignment keyword would follow the same pattern. Not in this stack.
 
 7. **A cell `degree` on the axis.** Making the degree assignment static
    (`degree=0|1`) would let a coboundary be typed generically

From 45831649f7bf4a2858fa7eb2cfe6958ff7ee98bc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Gonz=C3=A1lez=20Paredes?= <enriqueg@cscs.ch>
Date: Fri, 2 Oct 2026 04:17:44 +0200
Subject: [PATCH 15/19] =?UTF-8?q?personal/egparedes:=20connectivities=20as?=
 =?UTF-8?q?=20types=20=E2=80=94=20split=20the=20two=20N2=20leak=20sites?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Verified against gt4py `main` at `b3c53fa7e`: `foast_to_gtir.py:305` is
`im.shift(offset_name.id, ...)`, the shift lowering, while `:331` is
`im.as_fieldop_neighbors(str(offset_name), ...)`, the neighbors lowering. The
Problem table cited both under "shift", which the research appendix already
contradicted by placing `:325-331` in the reduction path.

Both leak N2, so the claim was right and the attribution was not: the compiled
reduction path leaks the Python variable name into `as_fieldop_neighbors` and
*then* reads N3 in `unroll_reduce`. The reduction row now records both strings.
---
 .../connectivities-as-types/connectivities-as-types.md        | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

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 0106eaa..c13306c 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
@@ -97,8 +97,8 @@ path and the operation:
 | --- | --- | --- | --- |
 | 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 | shift | **N2 `foast.Name.id`** | `ffront/foast_to_gtir.py:305` (`im.shift(offset_name.id, ...)`) |
+| compiled | reduction | **N2 `foast.Name.id`**, then N3 `ListType.offset_type.value` | `ffront/foast_to_gtir.py:331` (`im.as_fieldop_neighbors(str(offset_name), ...)`); `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: embedded and compiled

From 560d613408852dce9f7a0a604e97bf93f3fc4808 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Gonz=C3=A1lez=20Paredes?= <enriqueg@cscs.ch>
Date: Fri, 2 Oct 2026 07:27:27 +0200
Subject: [PATCH 16/19] =?UTF-8?q?personal/egparedes:=20connectivities=20as?=
 =?UTF-8?q?=20types=20=E2=80=94=20fix=20the=20core/appendix=20drift?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

An independent review found 14 items, almost all drift introduced when the note
was split into appendices and then revised: the last two commits each corrected
the core and left a stale copy of the same fact behind a link.

Factual:
- The identity appendix's rule 4 still read "fingerprinted by reference" with no
  `kind` — the version `606429a` was written to retire — while being the page the
  core points at for that rule "in full". Rewritten to match.
- Open question 6 had lost its argument entirely: the split dropped the layout-is-a-
  field-property / F4 / `order_dimensions`-wants-an-order / vertical-is-a-role
  reasoning, leaving only the conclusion and a pointer to a section that never
  carried it. Restored verbatim from `94d1726` as staggering appendix §7 item 6, and
  the core now also links the conventions appendix §4d, which is literally titled
  "External evidence for open question 6".
- The deck's reduction row omitted the N2 leak that `4583164` had just added to the
  core, losing the point that N2 leaks on both compiled paths.
- The deck presented `__eq__` versus `is` as open on its closing slide; `96caa0e`
  settled it as Identity rule 8. Replaced with a genuinely open item.
- The deck double-counted: "four strings … a fifth constraint is hidden", when the
  hidden one is N2, already inside the four.
- Three counts were wrong: "twelve-slide" (thirteen), "eleven alternatives" (eight,
  plus two in the typing appendix and six in the staggering appendix), and "about
  ten" axis-vs-location decisions in ICON4Py's `dimension.py` (four, per the
  measured run).
- `GridTools/gt4py#2917` 404s while #2916 and #2918 resolve, so the stack reference
  is dead; dropped in favour of the per-PR table.

Structural:
- Two conventions-appendix citations attributed to "the main note" text that lives
  in the staggering appendix.
- The typing appendix opened on "The last row", with no table in that file.
- "Three levels" / "four levels" for a hierarchy whose new classes are siblings;
  the core and slide 8 now say three new classes.
- The open-questions list says which four items are actually open.
- The core's three named alternatives now carry a why-clause each, so the section is
  decidable without opening an appendix.

Nits: `updated` date, probe stamps to mypy 2.4.0 (re-verified: both probes report
exactly their documented sets), probes grouped at the end of the appendix list,
plain-text cross-references in the alternatives appendix made into wikilinks, the
provider-key sentence given a referent, and the deck's as-of marker replaced by a
branch reference rather than a SHA that goes stale on every push.
---
 .../connectivities-as-types.md                | 57 ++++++++++++-------
 .../connectivities-as-types_alternatives.md   |  5 +-
 .../connectivities-as-types_conventions.md    | 10 ++--
 .../connectivities-as-types_identity.md       | 15 +++--
 .../connectivities-as-types_slides.md         | 10 ++--
 .../connectivities-as-types_staggering.md     | 16 ++++++
 .../connectivities-as-types_typing.md         |  2 +-
 .../staggered_probe.py                        |  2 +-
 .../connectivities-as-types/typing_probe.py   |  2 +-
 9 files changed, 78 insertions(+), 41 deletions(-)

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 c13306c..659733e 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
@@ -3,7 +3,7 @@ title: "Connectivities as types: one declaration for offset, local dimension and
 author: egparedes
 tags: [type-system, type-checking, dimensions, local-dimensions, connectivities, offset-provider, unstructured, neighbor-sum, reduction, frontend, foast, gtir, embedded, gtfn, dace, nominal-types, dependent-types, metaclass, serialization, fingerprint, staggering, axis-dimensions, cw-complex, exterior-calculus, domain, dimension-kind, ugrid, sgrid, migration, adr, tech-debt, shared-local-dimensions, implemented]
 created: 2026-09-17
-updated: 2026-10-01
+updated: 2026-10-02
 status: draft
 ---
 
@@ -449,7 +449,7 @@ declared rather than derived, and the per-declaration axis-versus-mesh-location
 decision are in [[personal/egparedes/connectivities-as-types/connectivities-as-types_staggering|the staggering appendix]]; its external
 corroboration is in [[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|the conventions appendix]].
 
-Hence three levels, all *below* `DimensionIndex`, so that no
+Hence three new classes, all *below* `DimensionIndex`, so that no
 `type[DimensionIndex]` annotation in the tree changes and `LocalDimensionIndex`
 keeps its position:
 
@@ -640,9 +640,9 @@ tables assign different neighbors to the same domain element. The model:
   additionally requires all tables over one local dimension to agree on width
   and skip-value presence and — where a program is compiled — on the skip
   positions of the concrete tables, compared on the device the tables live on.
-  A key that names the *connectivity* instead of the declaration (`{V2E.tag:
-  table}`, which is the IR name of a declaration only when it shares another's
-  local dimension) is rejected with a pointer to `{V2E: table}`. A string key that is
+  A key that names a declaration by its own tag rather than by its
+  `offset_tag` (`{V2E.tag: table}`, which is the IR name of a declaration only when
+  it shares another's local dimension) is rejected with a pointer to `{V2E: table}`. A string key that is
   not a qualified name at all is remembered as such, so it costs one import
   attempt in total rather than one per call.
 - The class never holds data; the table crosses process boundaries as it did.
@@ -763,12 +763,22 @@ dimension, `as_offset(KDim, field)`.
 
 ## Alternatives considered
 
-Eleven alternatives are recorded in [[personal/egparedes/connectivities-as-types/connectivities-as-types_alternatives|the alternatives appendix]],
-and the six concerning the axis levels and `Staggered[D]` in
-[[personal/egparedes/connectivities-as-types/connectivities-as-types_staggering|the staggering appendix]]. The three a reviewer is most likely
-to raise: keep every concept and fix only which string wins; `(name, kind)` value
-equality with an interning registry; and static-only `max_neighbors` /
-`min_neighbors`.
+Eight alternatives are recorded in [[personal/egparedes/connectivities-as-types/connectivities-as-types_alternatives|the alternatives appendix]],
+two more on the spelling of `Local` in [[personal/egparedes/connectivities-as-types/connectivities-as-types_typing|the typing appendix]] §4, and the
+six concerning the axis levels and `Staggered[D]` in
+[[personal/egparedes/connectivities-as-types/connectivities-as-types_staggering|the staggering appendix]] §6. The three a reviewer is most likely to
+raise, with why each loses:
+
+- **Keep every concept and fix only which string wins.** It enforces the tangle
+  instead of removing it; no concept goes away.
+- **`(name, kind)` value equality with an interning registry.** It decouples the
+  Python type's identity from the IR's, so it needs a registry, a `copyreg` hook and
+  a custom fingerprint deconstructor to paper over the gap — and still cannot give a
+  nested `V2E.Local` a unique name.
+- **Static-only `max_neighbors` / `min_neighbors`.** Counts are not known statically:
+  `fvm_nabla_setup.py` sizes `V2E` from the atlas mesh and ICON's skip values are
+  configuration-dependent, so a static count forces duplicate classes or always-on
+  skip handling.
 
 ## Relation to gt4py ADRs
 
@@ -785,6 +795,10 @@ equality with an interning registry; and static-only `max_neighbors` /
 
 ## Open questions / follow-ups
 
+Items **1, 2, 5 and 6** are genuinely open and are what this note puts to a
+reviewer. Items 3, 4, 7, 8 and 9 are recorded as settled or deliberately out of
+scope, with the reasoning, so that a later reader does not reopen them.
+
 1. **Naming.** `NeighborConnectivity[Domain, Codomain]`, `Local`,
    `max_neighbors` / `min_neighbors`, and `offset_tag` for the IR name.
    Convergence with
@@ -817,8 +831,11 @@ equality with an interning registry; and static-only `max_neighbors` /
 6. **`kind`'s remaining two jobs.** Once `LOCAL` leaves the enum, `kind` is a
    layout sort key and a name for the scan axis — properties of the field and of
    the program, not of the dimension. Every candidate *addition* belongs to the
-   grid, the program or the range, so `kind` should shrink rather than grow; see
-   [[personal/egparedes/connectivities-as-types/connectivities-as-types_staggering|the staggering appendix]] §7.
+   grid, the program or the range, so `kind` should shrink rather than grow. The
+   argument is in [[personal/egparedes/connectivities-as-types/connectivities-as-types_staggering|the staggering appendix]] §7, and SGRID's
+   treatment of the vertical is external evidence for it
+   ([[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions#d-external-evidence-for-open-question-6|conventions appendix]]
+   §4d).
 7. **A cell `degree` on the axis.** Left out because **nothing consumes it** until
    an exterior-calculus surface exists; a static `degree=0|1` is itself perfectly
    well defined and needs no periodicity. The ranges do *not* substitute for it: a
@@ -857,7 +874,7 @@ on its own, each based on the previous one:
 | C: GridTools/gt4py#2910 | `connectivities-as-types-6-class-keyed-providers` | `feat[next]!`: the tree and docs declare connectivities as classes; class-keyed offset providers with `check_offset_provider` at every entry point; `FieldOffset` removed; `as_offset(dim, field)` restricted to an `AnyCartesianAxisIndex`; `table_types` replaces `offset_provider_type`; migration script |
 | D: GridTools/gt4py#2912 | `connectivities-as-types-8-typed-positions` | `refactor[next]`: `MultiDimensionIndex` and typed embedded positions |
 
-The four PRs form GitHub stack GridTools/gt4py#2917. `NeighborTableType`,
+`NeighborTableType`,
 `TableTypes` and `ts.ShiftType` land in B, `table_types` in C; ADR 0029 and
 ADR 0030 are in A and B respectively.
 
@@ -893,7 +910,7 @@ left to ICON4Py.
 - [[personal/egparedes/connectivities-as-types/connectivities-as-types_alternatives|Alternatives considered]]:
   the alternatives rejected on grounds other than the axis levels.
 - [[personal/egparedes/connectivities-as-types/connectivities-as-types_slides|Slides: a walk-through deck]]:
-  a twelve-slide summary of this note for the design review, readable as a page and
+  a thirteen-slide summary of this note for the design review, readable as a page and
   renderable with `marp-cli`. It adds no facts and links the section each slide
   compresses.
 - [[personal/egparedes/connectivities-as-types/connectivities-as-types_research|Tag and name constraints — full catalogue]]:
@@ -907,11 +924,6 @@ left to ICON4Py.
   local slots vs. incidences) on a small mesh, and a mapping of each concept
   onto this design — what is kept statically, what moves to the bind-time
   check, and what is given up.
-- [`typing_probe.py`](typing_probe.py): the mypy /
-  pyright probes behind the `Local` decisions (explicit nested class works,
-  also when only the local dimension differs; generated `ClassVar` form and
-  `Local[C]` reconciliation do not). Last run with mypy 2.3.1 and pyright
-  1.1.414.
 - [[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|Alignment with the UGRID and SGRID conventions]]:
   an audit against the two community conventions for mesh topology and grid
   staggering — why UGRID's locations are cell degrees while SGRID's are per-axis
@@ -919,6 +931,11 @@ left to ICON4Py.
   ranges, and the enhancements that follow (a UGRID vocabulary for
   `LocationIndex`, recording the index origin of a bound table,
   deriving incidence signs from a recorded node ordering).
+- [`typing_probe.py`](typing_probe.py): the mypy /
+  pyright probes behind the `Local` decisions (explicit nested class works,
+  also when only the local dimension differs; generated `ClassVar` form and
+  `Local[C]` reconciliation do not). Last run with mypy 2.4.0 and pyright
+  1.1.414.
 - [`staggered_probe.py`](staggered_probe.py): the mypy / pyright probes behind
   [Cartesian axis dimensions](#cartesian-axis-dimensions) — `Staggered[Staggered[I]]`,
   `Staggered[V2E.Local]` and `Staggered[C]` are `[type-var]` errors, while
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_alternatives.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_alternatives.md
index e16fe2d..d950e1c 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_alternatives.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_alternatives.md
@@ -32,7 +32,7 @@ Keeps independently declared same-named dimensions interchangeable and
 avoids the importability rule. Rejected 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 *Identity*.
+`V2E.Local` a unique name without further convention. See [[personal/egparedes/connectivities-as-types/connectivities-as-types#identity-is-the-qualified-python-name|Identity]].
 
 **Integer type parameters for `max_neighbors`** (`LocalDimensionIndex[F: int, M: int]`).
 Would need `Literal[6]` type arguments and `Final[F]` over a `TypeVar`;
@@ -50,8 +50,7 @@ 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.
-
+Declared counts stay available as a constraint; see [[personal/egparedes/connectivities-as-types/connectivities-as-types#binding-model|Binding model]].
 
 **Owner-less local axes as non-LOCAL dimensions.** Rejected: they would
 become domain dimensions with a range in every program domain and lose the
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md
index add1474..24eb261 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md
@@ -126,9 +126,9 @@ netCDF *dimensions* are 0-based but SGRID *labels* need not be. What a `UnitRang
 still adds is that the origin travels with the dimension in one object rather than
 in a separate coordinate variable, and that halo depth is unbounded.
 
-**(ii) `padding: low` is this note's halo remark, standardized.** The main note
-observes that `Staggered[I](0)` "is the first cell outside the complex — exactly
-where a halo cell goes". That is `low`: equal length, one extra value stored at
+**(ii) `padding: low` is this note's halo remark, standardized.**
+[[personal/egparedes/connectivities-as-types/connectivities-as-types_staggering|The staggering appendix]] §3 observes that `Staggered[I](0)` "is the
+first cell outside the complex — exactly where a halo cell goes". That is `low`: equal length, one extra value stored at
 the low end.
 
 **(iii) Both alignments are standardized and in production, which strengthens
@@ -209,8 +209,8 @@ and none of the metric factors — the `⋆` of
 [[personal/egparedes/discretization-independent-fd-syntax|the surface-syntax note]]
 §3.6. The honest claim is narrower than "derivable": with all three orderings
 recorded, the *topological* part `d` becomes computable, while `⋆` remains mesh
-geometry that has to be supplied. The main note explains why
-the Cartesian side needs no orientation data (a product of intervals is
+geometry that has to be supplied. [[personal/egparedes/connectivities-as-types/connectivities-as-types_staggering|The staggering appendix]] §1
+explains why the Cartesian side needs no orientation data (a product of intervals is
 canonically oriented per axis) and points at ICON's `geofac_div` for the
 unstructured side, where the signs are materialized. UGRID shows the
 unstructured side can be canonical too if a declaration records the ordering
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_identity.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_identity.md
index cf8606a..7d8ef22 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_identity.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_identity.md
@@ -30,11 +30,16 @@ status: draft
 3. **No registry.** Classes pickle by reference. One narrow `copyreg` hook
    exists, for `Staggered[D]`, whose bracketed qualname `save_global` cannot
    look up; it reduces to the base dimension and re-interns.
-4. **Fingerprints depend on qualified names.** Dimensions are fingerprinted by
-   reference (`Staggered[D]` through its base); a connectivity declaration
-   additionally by its domain, codomain, `Local` and counts, so a redefinition
-   under the same name does not reuse artifacts. Consequently the ADR 0023
-   build cache invalidates on module renames.
+4. **Fingerprints depend on qualified names, plus `kind`.** A dimension is
+   deconstructed as its by-reference name *and* its declaration-time `kind`, which
+   decides a field's layout order and the scan axis — so a dimension redefined under
+   the same name with another kind does *not* reuse artifacts. `Staggered[D]` goes
+   through its base and inherits this; its base cannot be flipped in place, since
+   the class is interned by base identity and its tag embeds the base tag. The axis
+   level (`CartesianAxisIndex` versus `DimensionIndex`) is deliberately *not*
+   fingerprinted: it changes what is accepted, never what is emitted. A connectivity
+   declaration is fingerprinted *additionally* by its domain, codomain, `Local` and
+   counts. Consequently the ADR 0023 build cache invalidates on module renames.
 5. **Codegen names need injective mangling.** `codegen_name(tag)` is a prefix
    escape — `_`→`_u`, `.`→`_d`, `[`→`_l`, `]`→`_r` — used by gtfn, DaCe, the
    roundtrip backend and the nanobind bindings; its inverse
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md
index 7d5ea75..2d77d0a 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md
@@ -29,7 +29,7 @@ One declaration for offset, local dimension and provider key
 
 ADR 0029 (dimensions) · ADR 0030 (connectivities) · GridTools/gt4py#2917
 
-> **Appendix** to [Connectivities as types](connectivities-as-types), summarising that note as of commit `8292eff`. Every slide links the section it compresses and this deck adds no facts of its own, so where the two disagree the note wins. Rendering instructions are on the slide before this one.
+> **Appendix** to [Connectivities as types](connectivities-as-types), summarising the note on this branch; where the two disagree the note is authoritative. Every slide links the section it compresses, and the deck adds no facts of its own. Rendering instructions are on the slide before this one.
 
 ---
 
@@ -41,7 +41,7 @@ V2E    = FieldOffset("V2E", source=Edge, target=(Vertex, V2EDim))  # (N1) tag, (
 program(..., offset_provider={"V2E": table})                       # (N4) provider key
 ```
 
-Four independently authored strings. None checked against the others at declaration time. A fifth constraint is hidden: the Python *variable* name.
+Four independently authored strings, none checked against the others at declaration time. One of them is hidden: N2, the Python *variable* name the `FieldOffset` happens to be bound to.
 
 → [Four strings, one dict lookup](connectivities-as-types#four-strings-one-dict-lookup)
 
@@ -54,7 +54,7 @@ Four independently authored strings. None checked against the others at declarat
 | embedded | shift `a(V2E[1])` | N1 `FieldOffset.value` |
 | embedded | `neighbor_sum(axis=V2EDim)` | N3 `axis.value` |
 | compiled | shift | **N2 `foast.Name.id`** |
-| compiled | reduction | N3 `ListType.offset_type.value` |
+| compiled | reduction | **N2 `foast.Name.id`**, then N3 `ListType.offset_type.value` |
 | compiled | sparse field argument | N3 `dim.value` |
 
 Confirmed by execution: embedded and compiled key the *same* program on *different* strings.
@@ -106,7 +106,7 @@ That split is what lets DSL code be written, checked and compiled before any mes
 
 ---
 
-## Dimensions: four levels, one root
+## Dimensions: three new classes under one root
 
 ```
 DimensionIndex                            # the root; every annotation says this
@@ -180,7 +180,7 @@ ICON4Py: the script rewrites 4 files and reports 46 provider keys to decide.
 - **naming** — convergence with the chain proposals is still open
 - **the mesh proposal** — does a `Mesh` bind the typed declarations?
 - **`kind`** — four jobs in one enum; it should shrink, not grow
-- **`__eq__` vs "equality is `is`"** — asserted in one place, overridden in another
+- **the index origin of a bound table** — UGRID standardizes `start_index`; validating against a codomain range needs a target range the API has not got
 - **alignment** — `Staggered[D](i)` at `i − ½` is hard-coded; both conventions exist in production
 
 → [Open questions](connectivities-as-types#open-questions--follow-ups)
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md
index b432f6c..d506703 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md
@@ -242,6 +242,22 @@ Numbered as in the main note's *Open questions*.
    fingerprints a dimension's `kind` alongside its by-reference name, so an
    alignment keyword would follow the same pattern. Not in this stack.
 
+6. **`kind`'s remaining two jobs.** Once `LOCAL` leaves the enum, `kind` is a
+   layout sort key and a name for the scan axis. Layout is a property of the field,
+   not of the dimension, and that coupling is why dimension *names* currently
+   determine memory layout (F4); what `order_dimensions` actually wants is an
+   *order* — innermost to outermost, `I, J, K` for a box, `(CellDim, KDim)` for
+   ICON — which a per-grid dimension ordering would supply and which would retire
+   F4. "Vertical" is a role, not a geometry: in a Cartesian box the three axes are
+   alike, and what singles out `K` is that the numerics is sequential along it and
+   that it is not decomposed, properties of the program and of the decomposition.
+   [[personal/havogt/scan-redesign/scan-redesign|Scan redesign]] already takes the
+   scan range from the output domain rather than from `kind`, and SGRID describes
+   vertical staggering with the *same* `padding` syntax as horizontal, so it needs
+   no vertical kind at all. Every candidate
+   *addition* to `kind` — periodic, distributed, sequential, cell degree — likewise
+   belongs to the grid, the program or the range, so `kind` should shrink rather
+   than grow.
 7. **A cell `degree` on the axis.** Making the degree assignment static
    (`degree=0|1`) would let a coboundary be typed generically
    (`d⁰: Field[deg 0] -> Field[deg 1]`) and make the range invariant derivable
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_typing.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_typing.md
index debed3b..0f8a752 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_typing.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_typing.md
@@ -16,7 +16,7 @@ status: draft
 
 ## 1. The `__add__` self-type costs two suppressions
 
-The last row needs `__add__` declared with `cls: type[AnyCartesianAxisIndex]`.
+The last row of [[personal/egparedes/connectivities-as-types/connectivities-as-types#cartesian-axis-dimensions|the core's *four checks become static* table]] — `C + 1` and `V2E.Local + 1` — needs `__add__` declared with `cls: type[AnyCartesianAxisIndex]`.
 Both checkers bind that signature correctly at every call site and both reject it
 at the *definition* site, with different diagnostics — mypy `[misc]` ("self"
 parameter missing for a non-static method), pyright
diff --git a/content/personal/egparedes/connectivities-as-types/staggered_probe.py b/content/personal/egparedes/connectivities-as-types/staggered_probe.py
index f7ee4cd..2cb5be1 100644
--- a/content/personal/egparedes/connectivities-as-types/staggered_probe.py
+++ b/content/personal/egparedes/connectivities-as-types/staggered_probe.py
@@ -18,7 +18,7 @@
 `LocalDimensionIndex` is a real subclass of `DimensionIndex` so that eve's
 `type[...]` validation is unaffected — see the main note.
 
-Last run: mypy 2.3.1 and pyright 1.1.414 (2026-10-01). Both report exactly the
+Last run: mypy 2.4.0 and pyright 1.1.414 (2026-10-01). Both report exactly the
 eleven `EXPECT-ERROR` lines and nothing else — mypy 12 diagnostics (two for the
 `Doubly` alias), pyright 11 — so every `must be ACCEPTED` line holds.
 """
diff --git a/content/personal/egparedes/connectivities-as-types/typing_probe.py b/content/personal/egparedes/connectivities-as-types/typing_probe.py
index 425efea..06d6c93 100644
--- a/content/personal/egparedes/connectivities-as-types/typing_probe.py
+++ b/content/personal/egparedes/connectivities-as-types/typing_probe.py
@@ -17,7 +17,7 @@
 
 `StaticMultiLevelMapping` is a stand-in that stores the table on the class, which the
 design rejects (see "Data on the class" in the main note); only the probes at the
-end matter. Last run: mypy 2.3.1 and pyright 1.1.414 (2026-09-23; re-checked
+end matter. Last run: mypy 2.4.0 and pyright 1.1.414 (2026-09-23; re-checked
 2026-10-01).
 """
 

From cd631ffc11d41a75410211a6832a351364c52b4c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Gonz=C3=A1lez=20Paredes?= <enriqueg@cscs.ch>
Date: Fri, 2 Oct 2026 07:38:05 +0200
Subject: [PATCH 17/19] =?UTF-8?q?personal/egparedes:=20connectivities=20as?=
 =?UTF-8?q?=20types=20=E2=80=94=20three=20fixes=20the=20last=20commit=20mi?=
 =?UTF-8?q?ssed?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A second review pass found that one of the fixes `560d613` claimed had never been
written, one landed only in the core, and one created a fresh contradiction.

- **"about ten" was never changed.** `560d613`'s message says it became "four", but
  the only hunk it applied to the staggering appendix was the open-question-6
  insertion; the number stood untouched, still contradicting the note's own measured
  run. It is now four, with the reason the other 15 declarations do not raise the
  question.
- **`GridTools/gt4py#2917` was removed from the core but left on the deck's title
  slide.** It 404s while #2916 and #2918 resolve; slide 12 already carries the
  per-PR table, so nothing is lost by dropping it.
- **Open question 9 is open.** `560d613` added a lead sentence calling items 3, 4, 7,
  8 and 9 settled, and in the same commit put item 9 on the deck's "Open, and worth
  arguging about" slide. Item 9 is the half that was misclassified: unlike item 8 it
  carries no out-of-scope marker, and the conventions appendix §4b treats it as live
  ("the note's open question 9 should say so"). The open set is now 1, 2, 5, 6 and 9.

Nits: the restored open-question-6 text said scan-redesign "already takes" the scan
range from the output domain, which reads as endorsement of something that note
lists as P1 and wants to replace — reworded to say the range does not come from the
dimension either way; item 7's "the next item" now names the main note's item 8;
§7's list spacing made consistent; the typing appendix no longer italicises the
deck's slide title as if quoting the core.
---
 .../connectivities-as-types.md                  |  6 +++---
 .../connectivities-as-types_slides.md           |  4 ++--
 .../connectivities-as-types_staggering.md       | 17 ++++++++++-------
 .../connectivities-as-types_typing.md           |  2 +-
 4 files changed, 16 insertions(+), 13 deletions(-)

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 659733e..2dd5a8e 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
@@ -795,9 +795,9 @@ raise, with why each loses:
 
 ## Open questions / follow-ups
 
-Items **1, 2, 5 and 6** are genuinely open and are what this note puts to a
-reviewer. Items 3, 4, 7, 8 and 9 are recorded as settled or deliberately out of
-scope, with the reasoning, so that a later reader does not reopen them.
+Items **1, 2, 5, 6 and 9** are genuinely open and are what this note puts to a
+reviewer. Items 3, 4, 7 and 8 are recorded as settled or deliberately out of scope,
+with the reasoning, so that a later reader does not reopen them.
 
 1. **Naming.** `NeighborConnectivity[Domain, Codomain]`, `Local`,
    `max_neighbors` / `min_neighbors`, and `offset_tag` for the IR name.
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md
index 2d77d0a..cc8e75e 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_slides.md
@@ -27,9 +27,9 @@ npx -y @marp-team/marp-cli@4 --no-stdin \
 
 One declaration for offset, local dimension and provider key
 
-ADR 0029 (dimensions) · ADR 0030 (connectivities) · GridTools/gt4py#2917
+ADR 0029 (dimensions) · ADR 0030 (connectivities)
 
-> **Appendix** to [Connectivities as types](connectivities-as-types), summarising the note on this branch; where the two disagree the note is authoritative. Every slide links the section it compresses, and the deck adds no facts of its own. Rendering instructions are on the slide before this one.
+> **Appendix** to [Connectivities as types](connectivities-as-types), summarising the note it is published alongside; where the two disagree the note is authoritative. Every slide links the section it compresses, and the deck adds no facts of its own. Rendering instructions are on the slide before this one.
 
 ---
 
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md
index d506703..91e2a7a 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md
@@ -131,7 +131,8 @@ the two are independent.
 The class level also draws a distinction `kind` never did: `IDim` and `CellDim`
 are both `HORIZONTAL` and only the first is an axis. That is why the migration
 cannot be inferred from the source — whether a dimension is an axis or a mesh
-location is a decision per declaration (about ten in ICON4Py's `dimension.py`;
+location is a decision per declaration (four in ICON4Py's `dimension.py`, whose
+other 15 `*Dim` declarations are local and so do not raise the question;
 near-uniformly `CartesianAxisIndex` in `tests/next_tests`). The migration script
 decides per declaration, in this order:
 
@@ -251,13 +252,15 @@ Numbered as in the main note's *Open questions*.
    F4. "Vertical" is a role, not a geometry: in a Cartesian box the three axes are
    alike, and what singles out `K` is that the numerics is sequential along it and
    that it is not decomposed, properties of the program and of the decomposition.
-   [[personal/havogt/scan-redesign/scan-redesign|Scan redesign]] already takes the
-   scan range from the output domain rather than from `kind`, and SGRID describes
-   vertical staggering with the *same* `padding` syntax as horizontal, so it needs
-   no vertical kind at all. Every candidate
-   *addition* to `kind` — periodic, distributed, sequential, cell degree — likewise
+   [[personal/havogt/scan-redesign/scan-redesign|Scan redesign]] takes the scan range
+   from the output domain and never appeals to `kind` — it lists that implicit range
+   as P1, something to replace with an explicit one, but either way the range does
+   not come from the dimension. SGRID likewise describes vertical staggering with the
+   *same* `padding` syntax as horizontal, so it needs no vertical kind at all. Every
+   candidate *addition* to `kind` — periodic, distributed, sequential, cell degree —
    belongs to the grid, the program or the range, so `kind` should shrink rather
    than grow.
+
 7. **A cell `degree` on the axis.** Making the degree assignment static
    (`degree=0|1`) would let a coboundary be typed generically
    (`d⁰: Field[deg 0] -> Field[deg 1]`) and make the range invariant derivable
@@ -272,6 +275,6 @@ Numbered as in the main note's *Open questions*.
    needs the degree together with a periodicity and halo policy. Revisit if that
    surface lands — but note that a degree is *canonical* for a mesh
    location and only *declarational* for a Cartesian axis, so it belongs on the
-   `LocationIndex` of the next item rather than here
+   `LocationIndex` of the main note's item 8 rather than here
    ([[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions appendix]]
    §4a).
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_typing.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_typing.md
index 0f8a752..77b8438 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_typing.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_typing.md
@@ -16,7 +16,7 @@ status: draft
 
 ## 1. The `__add__` self-type costs two suppressions
 
-The last row of [[personal/egparedes/connectivities-as-types/connectivities-as-types#cartesian-axis-dimensions|the core's *four checks become static* table]] — `C + 1` and `V2E.Local + 1` — needs `__add__` declared with `cls: type[AnyCartesianAxisIndex]`.
+The last row of [[personal/egparedes/connectivities-as-types/connectivities-as-types#cartesian-axis-dimensions|the core's table of checks that become static]] — `C + 1` and `V2E.Local + 1` — needs `__add__` declared with `cls: type[AnyCartesianAxisIndex]`.
 Both checkers bind that signature correctly at every call site and both reject it
 at the *definition* site, with different diagnostics — mypy `[misc]` ("self"
 parameter missing for a non-static method), pyright

From d0a07927d5ec789672bf437f02c347ef6f3140bf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Gonz=C3=A1lez=20Paredes?= <enriqueg@cscs.ch>
Date: Fri, 2 Oct 2026 07:48:40 +0200
Subject: [PATCH 18/19] =?UTF-8?q?personal/egparedes:=20connectivities=20as?=
 =?UTF-8?q?=20types=20=E2=80=94=20cosmetic=20nits=20from=20the=20review?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Non-blocking items from the approving pass:

- `staggered_probe.py` quoted "four checks become static" as the note's wording;
  that string is the deck's slide title. The previous commit fixed exactly this in
  the typing appendix and left it in the probe. Now matches the note's own label.
- The restored open-question-6 text made Scan redesign the grammatical agent of
  behaviour it describes and wants to replace. Reworded so today's behaviour is the
  subject and the proposal's P1 is attributed to it.
- Reflowed an awkward source wrap in staggering appendix item 7.
---
 .../connectivities-as-types_staggering.md                | 9 ++++-----
 .../egparedes/connectivities-as-types/staggered_probe.py | 4 ++--
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md
index 91e2a7a..50eb4dc 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_staggering.md
@@ -252,9 +252,9 @@ Numbered as in the main note's *Open questions*.
    F4. "Vertical" is a role, not a geometry: in a Cartesian box the three axes are
    alike, and what singles out `K` is that the numerics is sequential along it and
    that it is not decomposed, properties of the program and of the decomposition.
-   [[personal/havogt/scan-redesign/scan-redesign|Scan redesign]] takes the scan range
-   from the output domain and never appeals to `kind` — it lists that implicit range
-   as P1, something to replace with an explicit one, but either way the range does
+   Today the scan range comes from the output domain and never from `kind`;
+   [[personal/havogt/scan-redesign/scan-redesign|Scan redesign]] lists that implicit
+   range as its P1 and replaces it with an explicit one — either way the range does
    not come from the dimension. SGRID likewise describes vertical staggering with the
    *same* `padding` syntax as horizontal, so it needs no vertical kind at all. Every
    candidate *addition* to `kind` — periodic, distributed, sequential, cell degree —
@@ -265,8 +265,7 @@ Numbered as in the main note's *Open questions*.
    (`degree=0|1`) would let a coboundary be typed generically
    (`d⁰: Field[deg 0] -> Field[deg 1]`) and make the range invariant derivable
    rather than declared. Left out for now because **nothing consumes it** until an
-   exterior-calculus surface exists (Proposal 1
-   of
+   exterior-calculus surface exists (Proposal 1 of
    [[personal/egparedes/discretization-independent-fd-syntax|the surface-syntax note]]).
    Absolute ranges do **not** determine the
    degree in general: a periodic axis gives both classes `[0, n)` under either
diff --git a/content/personal/egparedes/connectivities-as-types/staggered_probe.py b/content/personal/egparedes/connectivities-as-types/staggered_probe.py
index 2cb5be1..90ff2dc 100644
--- a/content/personal/egparedes/connectivities-as-types/staggered_probe.py
+++ b/content/personal/egparedes/connectivities-as-types/staggered_probe.py
@@ -8,8 +8,8 @@
 point of placing the two axis levels *below* `DimensionIndex` rather than above
 it: a staggered dimension stays a `DimensionIndex`, so no `type[DimensionIndex]`
 annotation in the gt4py tree widens, and `LocalDimensionIndex` keeps its
-position. P4 covers the fourth row of the note's "four checks become static"
-table — index arithmetic restricted to an axis by a self-type on
+position. P4 covers the fourth row of the note's table of checks that become
+static — index arithmetic restricted to an axis by a self-type on
 `DimensionMeta.__add__` — including the two definition-site suppressions that
 restriction costs (see the comment on `DimensionMeta`).
 

From 99c39899995d1fdf4341efee588644f7dabe1745 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Enrique=20Gonz=C3=A1lez=20Paredes?= <enriqueg@cscs.ch>
Date: Fri, 2 Oct 2026 08:23:50 +0200
Subject: [PATCH 19/19] =?UTF-8?q?personal/egparedes:=20connectivities=20as?=
 =?UTF-8?q?=20types=20=E2=80=94=20record=20the=200-based=20table=20assumpt?=
 =?UTF-8?q?ion?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The implementation reports it made no decision on the index origin: the stack
assumes 0-based tables, `NeighborTableType` carries no `start_index`, the loader
performs no rebase, and nothing validates entries against a codomain range.

Open question 9 now states that assumption instead of only noting the absent
field, which changes what is being asked: not whether to validate, but whether to
*record* an assumption the stack currently ships silently. Validation stays
described as the separate, larger change it is. The question stays open at the
implementation's request — recording the origin is egparedes's call, not the
stack's.

Conventions appendix §4b asked open question 9 to say this; it now does, so the
cross-reference reads as satisfied rather than pending. PR A's row says
`AxisLiteral` stores only its tag and derives `kind`/`dim`, rather than the
shorthand "drops `kind`" that was once read as dropping the accessor too.
---
 .../connectivities-as-types.md                | 20 +++++++++++--------
 .../connectivities-as-types_conventions.md    |  4 ++--
 2 files changed, 14 insertions(+), 10 deletions(-)

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 2dd5a8e..4213f5e 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
@@ -850,13 +850,17 @@ with the reasoning, so that a later reader does not reopen them.
    `DimensionIndex` subclasses, so "a primary, non-local dimension" is still not a
    type. UGRID supplies the vocabulary and the degrees
    ([[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions appendix]] §4a). Out of scope here.
-9. **The index origin of a bound table.** `NeighborTableType` records no index
-   origin, while UGRID standardizes `start_index` ∈ {0, 1}. Validating entries
-   against a codomain *range* is not a one-line change: a codomain is a dimension
-   class and carries no range, `check_neighbor_table` receives only a declaration
-   and a table or type, and its type-only path (`table_types`) has no entries to
-   inspect. It would need a target range supplied at binding time and a
-   value-carrying table ([[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions appendix]] §4b).
+9. **The index origin of a bound table.** The stack assumes **0-based** tables and
+   says so nowhere: `NeighborTableType` carries no `start_index`, the loader performs
+   no rebase, and nothing validates entries against a codomain range. UGRID, by
+   contrast, standardizes `start_index` ∈ {0, 1}, and ICON4Py's tables come from
+   Fortran. So the open question is not whether to validate but whether to *record*
+   the assumption — a `start_index` field, or a documented 0-based requirement plus a
+   rebase in the loader. Validating against a codomain *range* is a separate and
+   larger change: a codomain is a dimension class and carries no range,
+   `check_neighbor_table` receives only a declaration and a table or type, and its
+   type-only path (`table_types`) has no entries to inspect. That would need a target
+   range supplied at binding time and a value-carrying table ([[personal/egparedes/connectivities-as-types/connectivities-as-types_conventions|conventions appendix]] §4b).
 
 ## Implementation
 
@@ -869,7 +873,7 @@ on its own, each based on the previous one:
 
 | PR | Branch | What |
 | --- | --- | --- |
-| A: GridTools/gt4py#2899 | `connectivities-as-types-2-dimension-classes` | `feat[next]`: a concrete dimension is a class identified by its qualified name (ADR 0029); `codegen_name`; `CartesianAxisIndex` / `AnyCartesianAxisIndex` (both exported from `gtx`) and `Staggered[D: CartesianAxisIndex]`, with `__add__`/`__sub__` restricted to an axis statically and at runtime; interactive-`__main__` fallback; `NamedIndex` and the dimension half of the mypy plugin removed; mypy typing case `cartesian_axis_levels`; `ConstList` with `size=1` replaces the `_CONST_DIM` aliases; `AxisLiteral` drops `kind`; printing IR never imports (`resolve_loaded`); offset tag = local dimension tag = provider key in the tree |
+| A: GridTools/gt4py#2899 | `connectivities-as-types-2-dimension-classes` | `feat[next]`: a concrete dimension is a class identified by its qualified name (ADR 0029); `codegen_name`; `CartesianAxisIndex` / `AnyCartesianAxisIndex` (both exported from `gtx`) and `Staggered[D: CartesianAxisIndex]`, with `__add__`/`__sub__` restricted to an axis statically and at runtime; interactive-`__main__` fallback; `NamedIndex` and the dimension half of the mypy plugin removed; mypy typing case `cartesian_axis_levels`; `ConstList` with `size=1` replaces the `_CONST_DIM` aliases; `AxisLiteral` stores only its tag, deriving `kind` and `dim`; printing IR never imports (`resolve_loaded`); offset tag = local dimension tag = provider key in the tree |
 | B: GridTools/gt4py#2907 | `connectivities-as-types-3-neighbor-connectivity` | `feat[next]`: `NeighborConnectivity[Domain, Codomain]`, `LocalDimensionIndex` (and `DimensionKind.LOCAL` removed: a local's `kind` is `None`, localness comes from `common.is_local_dimension`, and `order_dimensions` ranks horizontal/local/vertical explicitly), `check_neighbor_table`, `local_dimension_of`, declaration fingerprinting; usable in the DSL; shared local dimensions, in the declarations and in the backends (`connectivity_key_over`, DaCe `local_dimension_size`); `NeighborTableType` and `ts.ShiftType`; pyright in the typing nox session, with `reportUnnecessaryTypeIgnoreComment: error` so a rejection that stops firing fails the run; ADR 0030 |
 | C: GridTools/gt4py#2910 | `connectivities-as-types-6-class-keyed-providers` | `feat[next]!`: the tree and docs declare connectivities as classes; class-keyed offset providers with `check_offset_provider` at every entry point; `FieldOffset` removed; `as_offset(dim, field)` restricted to an `AnyCartesianAxisIndex`; `table_types` replaces `offset_provider_type`; migration script |
 | D: GridTools/gt4py#2912 | `connectivities-as-types-8-typed-positions` | `refactor[next]`: `MultiDimensionIndex` and typed embedded positions |
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md
index 24eb261..3e6edb8 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_conventions.md
@@ -168,8 +168,8 @@ ICON4Py's tables come from Fortran. `NeighborTableType` carries `dtype`,
 distinguishes a 0-based table from a 1-based one.
 
 Checking entries against a codomain *range* is the tempting fix, and it is the
-same absolute-range argument as §3(i) — but it is **not** a one-line change, and
-the note's open question 9 should say so. Three prerequisites are missing:
+same absolute-range argument as §3(i) — but it is **not** a one-line change, as
+the note's open question 9 now records. Three prerequisites are missing:
 
 - a **codomain is a dimension class** and carries no range; ranges live on a
   field's `Domain`, not on the declaration;